void __noprof kernel_main_thread(void *data)
{
struct thread *me = CURRENT();
struct thread_queue tmp_q;
tq_init(&tmp_q);
tq_insert_head(me, &tmp_q);
bug_on(!scheduler_enqueue(&tmp_q));
mach_running();
kprintf("Initializing vfs core... ");
fs_init();
kprintf("Done.\n");
call_late_init();
run_tests();
load_init();
for (;;) {
scheduler_yield();
arch_idle();
}
bug();
}
int main() {
bool newreadings;
bool buttonschanged;
load_init();
initsystem();
watchdog_init();
initserial();
timer_init();
display_init();
initfan();
adc_init();
buttons_init();
enableInterrupts();
protocol_onbooted();
while (1) {
watchdog_kick();
newreadings = adc_updatereadings();
if (newreadings) {
checkstate();
}
buttonschanged = buttons_check();
if (newreadings || buttonschanged) {
protocol_sendstate();
display_update();
}
protocol_checkcommand();
}
}
void settings_load_late(session_t *sp)
{
/* FIXME: This needs to be updated for the transcoder */
uint32_t my_ssrc;
struct utsname u;
char hostfmt[] = "RAT v" RAT_VERSION " %s %s (%s)";
char *field, username[32] = "";
load_init(); /* Initial settings come from the common prefs file... */
/*
* We check to see it SDES items are set first. If they are
* then presumeably it has come from the command line and
* so it should override saved settings.
*/
my_ssrc = rtp_my_ssrc(sp->rtp_session[0]);
if (settings_username(username, sizeof(username) - 1) == FALSE) {
sprintf(username, "Unknown");
}
field = setting_load_str("rtpName", username);
if (rtp_get_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_NAME) == NULL) {
debug_msg("username %s %s\n", field, username);
rtp_set_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_NAME, field, strlen(field));
}
field = setting_load_str("rtpEmail", "");
if (rtp_get_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_EMAIL) == NULL) {
rtp_set_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_EMAIL, field, strlen(field));
}
field = setting_load_str("rtpPhone", "");
if (rtp_get_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_PHONE) == NULL) {
rtp_set_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_PHONE, field, strlen(field));
}
field = setting_load_str("rtpLoc", "");
if (rtp_get_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_LOC) == NULL) {
rtp_set_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_LOC, field, strlen(field));
}
field = setting_load_str("rtpNote", "");
if (rtp_get_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_NOTE) == NULL) {
rtp_set_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_NOTE, field, strlen(field));
}
field = (char*)xmalloc(3 * 256 + sizeof(hostfmt));
uname(&u);
sprintf(field, hostfmt, u.sysname, u.release, u.machine);
rtp_set_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_TOOL, field, strlen(field));
xfree(field);
/* This is evil [csp] */
field = xstrdup(" rattest");
field[0] = 3;
rtp_set_sdes(sp->rtp_session[0], my_ssrc, RTCP_SDES_PRIV, field, strlen(field));
xfree(field);
init_part_two(); /* Switch to pulling settings from the RAT specific prefs file... */
load_done();
}
void main()
{
int c;
load_init();
load_w();
while ( (c = getchar()) != EOF )
{
ungetc( c, stdin );
load_inside();
input();
calc();
save_inside();
output();
}
}
JPEG_NODE *jpeg_create_link(PFBDEV pfbdev, JPEG_NODE *jpeg_head, const char *path)
{
FILE_NODE *jpeg_file_head = NULL;
jpeg_file_head = load_init(jpeg_file_head, ".jpg", path);
while (jpeg_file_head != NULL)
{
jpeg_head = jpeg_link_add(pfbdev, jpeg_head, jpeg_file_head->flname);
jpeg_file_head = jpeg_file_head->next;
}
load_destroy(jpeg_file_head);
return jpeg_head;
}
uintptr_t load_setupProg(int binFd,A_UNUSED uintptr_t a,A_UNUSED uintptr_t b,A_UNUSED size_t c,
int argc,char **argv) {
#else
uintptr_t load_setupProg(int binFd,int argc,char **argv) {
#endif
sSharedLib *prog;
uintptr_t entryPoint;
/* create entry for program */
prog = (sSharedLib*)malloc(sizeof(sSharedLib));
if(!prog)
load_error("Not enough mem!");
prog->isDSO = false;
prog->relocated = false;
prog->initialized = false;
prog->dynstrtbl = NULL;
prog->dyn = NULL;
prog->name = "-Main-";
prog->deps = NULL;
appendto(&libs,prog);
/* load program including shared libraries into linked list */
load_doLoad(binFd,prog);
/* load segments into memory */
entryPoint = load_addSegments();
#if PRINT_LOADADDR
for(sSharedLib *l = libs; l != NULL; l = l->next) {
uintptr_t addr;
lookup_byName(NULL,"_start",&addr);
debugf("[%d] Loaded %s @ %p .. %p (text @ %p) with deps: ",
getpid(),l->name,l->loadAddr,l->loadAddr + l->textSize,addr);
for(sDep *dl = l->deps; dl != NULL; dl = dl->next)
debugf("%s ",dl->lib->name);
debugf("\n");
}
#endif
/* relocate everything we need so that the program can start */
load_reloc();
/* call global constructors */
load_init(argc,argv);
return entryPoint;
}
void bootloader_main(void) {
/* Init hardware */
hw_init();
/* Initialize elf-loader environment */
init_elf_loader();
/* Load the nano kernel. Doing this will install exception vectors */
boot_printf("Boot: loading nano kernel ...\n");
nano_init_t * nano_init = (nano_init_t *)load_nano(); //We have to rederive this as an executable cap
nano_init = (nano_init_t*)cheri_setoffset(cheri_getpcc(),cheri_getoffset(nano_init));
/* TODO: we could have some boot exception vectors if we want exception handling in boot. */
/* These should be in ROM as a part of the boot image (i.e. make a couple more dedicated sections */
cp0_status_bev_set(0);
boot_printf("Boot: loading kernel ...\n");
size_t entry = load_kernel();
boot_printf("Boot: loading init ...\n");
boot_info_t *bi = load_init();
size_t invalid_length = bi->init_end;
capability phy_start = cheri_setbounds(cheri_setoffset(cheri_getdefault(), MIPS_KSEG0), invalid_length);
/* Do we actually need this? */
//boot_printf("Invalidating %p length %lx:\n", phy_start, invalid_length);
//caches_invalidate(phy_start, invalid_length);
register_t mem_size = bi->init_end - bi->nano_end;
/* Jumps to the nano kernel init. This will completely destroy boot and so we can never return here.
* All registers will be cleared apart from a specified few. mem_size of memory will be left unmanaged and the
* rest will be returned as a reservation. The third argument is an extra argument to the kernel */
boot_printf("Jumping to nano kernel...\n");
BOOT_PRINT_CAP(nano_init);
nano_init(mem_size, entry, bi->init_begin - bi->kernel_begin, bi->init_entry);
}
void main()
{
ginit();
load_init();
int c;
//double data;
while ( (c = getchar()) != EOF )
{
ungetc( c, stdin );
draw();
px++;
if ( px > 639 )
{
cleardevice();
px = 0;
}
}
save_init();
//closegraph();
}
sexp run_main (int argc, char **argv) {
#if SEXP_USE_MODULES
char *impmod;
#endif
char *arg;
const char *prefix=NULL, *suffix=NULL, *main_symbol=NULL, *main_module=NULL;
sexp_sint_t i, j, c, quit=0, print=0, init_loaded=0, mods_loaded=0,
fold_case=SEXP_DEFAULT_FOLD_CASE_SYMS, nonblocking=0;
sexp_uint_t heap_size=0, heap_max_size=SEXP_MAXIMUM_HEAP_SIZE;
sexp out=SEXP_FALSE, ctx=NULL, ls;
sexp_gc_var4(tmp, sym, args, env);
args = SEXP_NULL;
env = NULL;
/* SRFI 22: invoke `main` procedure by default if the interpreter is */
/* invoked as `scheme-r7rs`. */
arg = strrchr(argv[0], '/');
if (strncmp((arg == NULL ? argv[0] : arg + 1), "scheme-r7rs", strlen("scheme-r7rs")) == 0) {
main_symbol = "main";
/* skip option parsing since we can't pass `--` before the name of script */
/* to avoid misinterpret the name as options when the interpreter is */
/* executed via `#!/usr/env/bin scheme-r7rs` shebang. */
i = 1;
goto done_options;
}
/* parse options */
for (i=1; i < argc && argv[i][0] == '-'; i++) {
switch ((c=argv[i][1])) {
case 'D':
init_context();
arg = (argv[i][2] == '\0') ? argv[++i] : argv[i]+2;
sym = sexp_intern(ctx, arg, -1);
ls = sexp_global(ctx, SEXP_G_FEATURES);
if (sexp_pairp(ls)) {
for (; sexp_pairp(sexp_cdr(ls)); ls=sexp_cdr(ls))
;
sexp_cdr(ls) = sexp_cons(ctx, sym, SEXP_NULL);
}
break;
case 'e':
case 'p':
mods_loaded = 1;
load_init(0);
print = (argv[i][1] == 'p');
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
check_nonull_arg('e', arg);
tmp = check_exception(ctx, sexp_eval_string(ctx, arg, -1, env));
if (print) {
if (! sexp_oportp(out))
out = sexp_eval_string(ctx, "(current-output-port)", -1, env);
sexp_write(ctx, tmp, out);
sexp_write_char(ctx, '\n', out);
}
quit = 1;
break;
case 'l':
mods_loaded = 1;
load_init(0);
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
check_nonull_arg('l', arg);
check_exception(ctx, sexp_load_module_file(ctx, arg, env));
break;
case 'x':
prefix = sexp_environment_prefix;
suffix = sexp_environment_suffix;
case 'm':
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
if (c == 'x') {
if (strcmp(arg, "chibi.primitive") == 0) {
goto load_primitive;
} else if (strcmp(arg, "scheme.small") == 0) {
load_init(0);
break;
}
} else {
prefix = sexp_import_prefix;
suffix = sexp_import_suffix;
}
mods_loaded = 1;
load_init(c == 'x');
#if SEXP_USE_MODULES
check_nonull_arg(c, arg);
impmod = make_import(prefix, arg, suffix);
tmp = check_exception(ctx, sexp_eval_string(ctx, impmod, -1, (c=='x' ? sexp_global(ctx, SEXP_G_META_ENV) : env)));
free(impmod);
if (c == 'x') {
sexp_set_parameter(ctx, sexp_global(ctx, SEXP_G_META_ENV), sexp_global(ctx, SEXP_G_INTERACTION_ENV_SYMBOL), tmp);
sexp_context_env(ctx) = env = tmp;
sexp_add_import_binding(ctx, env);
tmp = sexp_param_ref(ctx, env, sexp_global(ctx, SEXP_G_CUR_OUT_SYMBOL));
if (tmp != NULL && !sexp_oportp(tmp)) {
sexp_load_standard_ports(ctx, env, stdin, stdout, stderr, 0);
}
}
#endif
break;
load_primitive:
case 'Q':
init_context();
mods_loaded = 1;
if (! init_loaded++)
sexp_load_standard_ports(ctx, env, stdin, stdout, stderr, 0);
handle_noarg();
break;
case 'q':
argv[i--] = (char*)"-xchibi";
break;
case 'A':
init_context();
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
check_nonull_arg('A', arg);
sexp_add_module_directory(ctx, tmp=sexp_c_string(ctx,arg,-1), SEXP_TRUE);
break;
case 'I':
init_context();
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
check_nonull_arg('I', arg);
sexp_add_module_directory(ctx, tmp=sexp_c_string(ctx,arg,-1), SEXP_FALSE);
break;
#if SEXP_USE_GREEN_THREADS
case 'b':
nonblocking = 1;
break;
#endif
case '-':
if (argv[i][2] == '\0') {
i++;
goto done_options;
}
sexp_usage(1);
case 'h':
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
check_nonull_arg('h', arg);
#if ! SEXP_USE_BOEHM
heap_size = strtoul(arg, &arg, 0);
if (sexp_isalpha((unsigned char)*arg)) heap_size *= multiplier(*arg++);
if (*arg == '/') {
heap_max_size = strtoul(arg+1, &arg, 0);
if (sexp_isalpha((unsigned char)*arg)) heap_max_size *= multiplier(*arg++);
}
#endif
break;
#if SEXP_USE_IMAGE_LOADING
case 'i':
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
if (ctx) {
fprintf(stderr, "-:i <file>: image files must be loaded first\n");
exit_failure();
}
ctx = sexp_load_image(arg, 0, heap_size, heap_max_size);
if (!ctx || !sexp_contextp(ctx)) {
fprintf(stderr, "-:i <file>: couldn't open image file for reading: %s\n", arg);
fprintf(stderr, " %s\n", sexp_load_image_err());
ctx = NULL;
} else {
env = sexp_load_standard_params(ctx, sexp_context_env(ctx), nonblocking);
init_loaded++;
}
break;
case 'd':
if (! init_loaded++) {
init_context();
env = sexp_load_standard_env(ctx, env, SEXP_SEVEN);
}
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
if (sexp_save_image(ctx, arg) != SEXP_TRUE) {
fprintf(stderr, "-d <file>: couldn't save image to file: %s\n", arg);
fprintf(stderr, " %s\n", sexp_load_image_err());
exit_failure();
}
quit = 1;
break;
#endif
case 'V':
load_init(1);
if (! sexp_oportp(out))
out = sexp_eval_string(ctx, "(current-output-port)", -1, env);
sexp_write_string(ctx, sexp_version_string, out);
tmp = sexp_env_ref(ctx, env, sym=sexp_intern(ctx, "*features*", -1), SEXP_NULL);
sexp_write(ctx, tmp, out);
sexp_newline(ctx, out);
return SEXP_TRUE;
#if SEXP_USE_FOLD_CASE_SYMS
case 'f':
fold_case = 1;
init_context();
sexp_global(ctx, SEXP_G_FOLD_CASE_P) = SEXP_TRUE;
handle_noarg();
break;
#endif
case 'R':
main_module = argv[i][2] != '\0' ? argv[i]+2 :
(i+1 < argc && argv[i+1][0] != '-') ? argv[++i] : "chibi.repl";
if (main_symbol == NULL) main_symbol = "main";
break;
case 'r':
main_symbol = argv[i][2] == '\0' ? "main" : argv[i]+2;
break;
case 's':
init_context(); sexp_global(ctx, SEXP_G_STRICT_P) = SEXP_TRUE;
handle_noarg();
break;
case 'T':
init_context(); sexp_global(ctx, SEXP_G_NO_TAIL_CALLS_P) = SEXP_TRUE;
handle_noarg();
break;
case 't':
mods_loaded = 1;
load_init(1);
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
#if SEXP_USE_MODULES
check_nonull_arg('t', arg);
suffix = strrchr(arg, '.');
sym = sexp_intern(ctx, suffix + 1, -1);
*(char*)suffix = '\0';
impmod = make_import(sexp_trace_prefix, arg, sexp_trace_suffix);
tmp = check_exception(ctx, sexp_eval_string(ctx, impmod, -1, sexp_meta_env(ctx)));
if (!(tmp && sexp_envp(tmp))) {
fprintf(stderr, "couldn't find library to trace: %s\n", impmod);
} else if (!((sym = sexp_env_cell(ctx, tmp, sym, 0)))) {
fprintf(stderr, "couldn't find binding to trace: %s in %s\n", suffix + 1, impmod);
} else {
sym = sexp_list1(ctx, sym);
tmp = check_exception(ctx, sexp_eval_string(ctx, "(environment '(chibi trace))", -1, sexp_meta_env(ctx)));
tmp = sexp_env_ref(ctx, tmp, sexp_intern(ctx, "trace-cell", -1), 0);
if (tmp && sexp_procedurep(tmp))
check_exception(ctx, sexp_apply(ctx, tmp, sym));
}
free(impmod);
#endif
break;
default:
fprintf(stderr, "unknown option: %s\n", argv[i]);
/* ... FALLTHROUGH ... */
case '?':
sexp_usage(1);
}
}
done_options:
if (!quit || main_symbol != NULL) {
init_context();
/* build argument list */
if (i < argc)
for (j=argc-1; j>=i; j--)
args = sexp_cons(ctx, tmp=sexp_c_string(ctx,argv[j],-1), args);
if (i >= argc || main_symbol != NULL)
args = sexp_cons(ctx, tmp=sexp_c_string(ctx,argv[0],-1), args);
load_init(i < argc || main_symbol != NULL);
sexp_set_parameter(ctx, sexp_meta_env(ctx), sym=sexp_intern(ctx, sexp_argv_symbol, -1), args);
if (i >= argc && main_symbol == NULL) {
/* no script or main, run interactively */
repl(ctx, env);
} else {
#if SEXP_USE_MODULES
/* load the module or script */
if (main_module != NULL) {
impmod = make_import("(load-module '(", main_module, "))");
env = check_exception(ctx, sexp_eval_string(ctx, impmod, -1, sexp_meta_env(ctx)));
if (sexp_vectorp(env)) env = sexp_vector_ref(env, SEXP_ONE);
free(impmod);
check_exception(ctx, env);
if (!sexp_envp(env)) {
fprintf(stderr, "couldn't find module: %s\n", main_module);
exit_failure();
}
} else
#endif
if (i < argc) { /* script usage */
#if SEXP_USE_MODULES
/* reset the environment to have only the `import' and */
/* `cond-expand' bindings */
if (!mods_loaded) {
env = sexp_make_env(ctx);
sexp_set_parameter(ctx, sexp_meta_env(ctx),
sexp_global(ctx, SEXP_G_INTERACTION_ENV_SYMBOL), env);
sexp_context_env(ctx) = env;
sym = sexp_intern(ctx, "repl-import", -1);
tmp = sexp_env_ref(ctx, sexp_meta_env(ctx), sym, SEXP_VOID);
sym = sexp_intern(ctx, "import", -1);
check_exception(ctx, sexp_env_define(ctx, env, sym, tmp));
sym = sexp_intern(ctx, "cond-expand", -1);
tmp = sexp_env_cell(ctx, sexp_meta_env(ctx), sym, 0);
#if SEXP_USE_RENAME_BINDINGS
sexp_env_rename(ctx, env, sym, tmp);
#endif
sexp_env_define(ctx, env, sym, sexp_cdr(tmp));
}
#endif
sexp_context_tracep(ctx) = 1;
tmp = sexp_env_bindings(env);
#if SEXP_USE_MODULES
/* use scheme load if possible for better stack traces */
sym = sexp_intern(ctx, "load", -1);
tmp = sexp_env_ref(ctx, sexp_meta_env(ctx), sym, SEXP_FALSE);
if (sexp_procedurep(tmp)) {
sym = sexp_c_string(ctx, argv[i], -1);
sym = sexp_list2(ctx, sym, env);
tmp = check_exception(ctx, sexp_apply(ctx, tmp, sym));
} else
#endif
tmp = check_exception(ctx, sexp_load(ctx, sym=sexp_c_string(ctx, argv[i], -1), env));
#if SEXP_USE_WARN_UNDEFS
sexp_warn_undefs(ctx, env, tmp, SEXP_VOID);
#endif
#ifdef EMSCRIPTEN
if (sexp_applicablep(tmp)) {
sexp_resume_ctx = ctx;
sexp_resume_proc = tmp;
sexp_preserve_object(ctx, sexp_resume_proc);
emscripten_exit_with_live_runtime();
}
#endif
}
/* SRFI-22: run main if specified */
if (main_symbol) {
sym = sexp_intern(ctx, main_symbol, -1);
tmp = sexp_env_ref(ctx, env, sym, SEXP_FALSE);
if (sexp_procedurep(tmp)) {
args = sexp_list1(ctx, sexp_cdr(args));
check_exception(ctx, sexp_apply(ctx, tmp, args));
} else {
fprintf(stderr, "couldn't find main binding: %s in %s\n", main_symbol, main_module ? main_module : argv[i]);
}
}
}
}
sexp_gc_release4(ctx);
if (sexp_destroy_context(ctx) == SEXP_FALSE) {
fprintf(stderr, "destroy_context error\n");
return SEXP_FALSE;
}
return SEXP_TRUE;
}
void xyzsh_init(enum eAppType app_type, BOOL no_runtime_script)
{
setenv("XYZSH_VERSION", "1.5.8", 1);
setenv("XYZSH_DOCDIR", DOCDIR, 1);
setenv("XYZSH_DATAROOTDIR", DOCDIR, 1);
setenv("XYZSH_EXT_PATH", EXTDIR, 1);
setenv("XYZSH_SYSCONFDIR", SYSCONFDIR, 1);
char* home = getenv("HOME");
if(home) {
char home_library[PATH_MAX];
snprintf(home_library, PATH_MAX, "%s/.xyzsh/lib/", home);
char* ld_library_path = getenv("LD_LIBRARY_PATH");
if(ld_library_path) {
char ld_library_path2[512];
snprintf(ld_library_path2, 512, "%s:%s:%s", ld_library_path, EXTDIR, home_library);
setenv("LD_LIBRARY_PATH", ld_library_path2, 1);
}
else {
char ld_library_path2[512];
snprintf(ld_library_path2, 512, "%s:%s", EXTDIR, home_library);
setenv("LD_LIBRARY_PATH", ld_library_path2, 1);
}
}
else {
char* ld_library_path = getenv("LD_LIBRARY_PATH");
if(ld_library_path) {
char ld_library_path2[512];
snprintf(ld_library_path2, 512, "%s:%s", ld_library_path, EXTDIR);
setenv("LD_LIBRARY_PATH", ld_library_path2, 1);
}
else {
char ld_library_path2[512];
snprintf(ld_library_path2, 512, "%s", EXTDIR);
setenv("LD_LIBRARY_PATH", ld_library_path2, 1);
}
}
setlocale(LC_ALL, "");
stack_init(1);;
stack_start_stack();
gErrMsg = STRING_NEW_STACK("");
gXyzshSigInt = FALSE;
gXyzshSigUser = FALSE;
gXyzshSigTstp = FALSE;
gXyzshSigCont = FALSE;
xyzsh_set_signal_other = NULL;
gc_init(1);
run_init(app_type);
load_init();
xyzsh_editline_init();
gDirStack = VECTOR_NEW_GC(10, FALSE);
uobject_put(gXyzshObject, "_dir_stack", gDirStack);
char* term_env = getenv("TERM");
if(term_env != NULL && strcmp(term_env, "") != 0) {
mcurses_init();
}
if(!xyzsh_rehash("init", 0)) {
fprintf(stderr, "run time error\n");
fprintf(stderr, "%s", string_c_str(gErrMsg));
exit(1);
}
if(!no_runtime_script) {
xyzsh_read_rc();
}
else {
xyzsh_read_rc_mini();
}
}
int main(void) {
// Winsock data
WSADATA wsaData;
// Connection info:
// address of server and sockets
// struct sockaddr_in sin;
SOCKET newclient;
// info for initializing server:
// id : server literal name
// address: ip:port
struct init_context ic;
// threads for finding new peers and handling clients
pthread_t cmd_td;
pthread_t listen_td;
pthread_t client_td[MAX_CLIENTS];
// data pipes for threads
data_pipe cmd_pipe;
data_pipe listen_pipe;
data_pipe client_pipes[MAX_CLIENTS];
int quit = 0;
char msg[1024];
int len = 0;
int numclients = 0;
// load init file for session info
memset(&ic, 0, sizeof ic);
if (!load_init( "server.init", &ic) ) {
printf("Init file failed to load\n");
goto srv_loaderror;
}
// start winsock
if (WSAStartup(MAKEWORD(2,0), &wsaData) != 0) {
fprintf(stderr, "WSAStartup failed.\n");
goto srv_loaderror;
}
// initialize listen thread pipe
if ( data_pipe_init( &listen_pipe ) == 0) {
goto srv_listenpipeiniterror;
}
// put server address in pipe and start listen thread
data_pipe_put( &listen_pipe, ic.listen_port, strlen(ic.listen_port) );
pthread_create(&listen_td, NULL, listen_thread, (void *)&listen_pipe);
data_pipe_sync( &listen_pipe );
// initialize cmdline thread pipe
if ( data_pipe_init( &cmd_pipe ) == 0) {
goto srv_cmdpipeiniterror;
}
// start cmd line thread
pthread_create(&cmd_td, NULL, cmd_thread, (void *)&cmd_pipe);
// start game
init();
myship->state = SHIP_INACTIVE;
// main loop
while(!quit) {
//poll cmd pipe
if (data_pipe_geta( &cmd_pipe, (void *)msg, NULL) == 1) {
printf("cmd: %s\n", msg);
quit = 1;
}
// update game state
update();
// poll listen pipe
if (numclients < MAX_CLIENTS &&
data_pipe_geta( &listen_pipe, (void *)msg, &len) == 1) {
newclient = *((SOCKET *)msg);
if (newclient < 0) {
printf("listen thread error: %s\n", gai_strerror(newclient));
} else {
printf("listen: %d\n", newclient);
}
if (len == sizeof(SOCKET)) {
if ( data_pipe_init( &client_pipes[numclients] ) != 0) {
data_pipe_put( &client_pipes[numclients], (void *)&newclient, sizeof newclient );
pthread_create(&client_td[numclients], NULL, session_loop, (void *)&client_pipes[numclients]);
data_pipe_put( &client_pipes[numclients], (void *)&numclients, sizeof numclients );
data_pipe_sync( &client_pipes[numclients] );
numclients++;
}
}
}
}
pthread_join( cmd_td, NULL );
data_pipe_destroy( &cmd_pipe );
srv_cmdpipeiniterror:
pthread_cancel( listen_td );
data_pipe_destroy( &listen_pipe );
srv_listenpipeiniterror:
WSACleanup();
srv_loaderror:
return 0;
}
void settings_load_early(session_t *sp)
{
/* FIXME: This needs to be updated for the transcoder */
char *name, *param, *primary_codec, *port, *silence;
int freq, chan, mute;
uint32_t i, n, success, device_exists;
const cc_details_t *ccd;
const audio_device_details_t *add = NULL;
const audio_port_details_t *apd = NULL;
const converter_details_t *cod = NULL;
const repair_details_t *r = NULL;
codec_id_t cid;
load_init(); /* Initial settings come from the common prefs file... */
init_part_two(); /* Switch to pulling settings from the RAT specific prefs file... */
if (sp->mode == AUDIO_TOOL) {
name = setting_load_str("audioDevice", "No Audio Device");
} else {
name = (char *) xmalloc(20);
sprintf(name, "Transcoder Port %d", sp->id+1);
}
/* User may not have a (valid) audio device entry in the */
/* settings file, or have "No Audio Device" there. In */
/* either case try to use first available device, if */
/* it's in use we'll fallback to dummy device anyway. */
device_exists = FALSE;
n = (int)audio_get_device_count();
for(i = 0; i < n; i++) {
add = audio_get_device_details(i);
if (strcmp(add->name, name) == 0) {
device_exists = TRUE;
break;
}
}
if (strcmp(name, "No Audio Device") == 0 || device_exists == FALSE) {
add = audio_get_device_details(0);
}
audio_device_register_change_device(sp, add->descriptor);
freq = setting_load_int("audioFrequency", 8000);
chan = setting_load_int("audioChannelsIn", 1);
primary_codec = setting_load_str("audioPrimary", "GSM");
cid = codec_get_matching(primary_codec, (uint16_t)freq, (uint16_t)chan);
if (codec_id_is_valid(cid) == FALSE) {
/* Codec name is garbage...should only happen on upgrades */
cid = codec_get_matching("GSM", (uint16_t)freq, (uint16_t)chan);
}
audio_device_register_change_primary(sp, cid);
audio_device_reconfigure(sp);
port = setting_load_str("audioOutputPort", "Headphone");
n = audio_get_oport_count(sp->audio_device);
for(i = 0; i < n; i++) {
apd = audio_get_oport_details(sp->audio_device, i);
if (!strcasecmp(port, apd->name)) {
break;
}
}
audio_set_oport(sp->audio_device, apd->port);
port = setting_load_str("audioInputPort", "Microphone");
n = audio_get_iport_count(sp->audio_device);
for(i = 0; i < n; i++) {
apd = audio_get_iport_details(sp->audio_device, i);
if (!strcasecmp(port, apd->name)) {
break;
}
}
audio_set_iport(sp->audio_device, apd->port);
audio_set_ogain(sp->audio_device, setting_load_int("audioOutputGain", 75));
audio_set_igain(sp->audio_device, setting_load_int("audioInputGain", 75));
tx_igain_update(sp->tb);
name = setting_load_str("audioChannelCoding", "None");
param = setting_load_str("audioChannelParameters", "None");
do {
n = channel_get_coder_count();
for (i = 0; i < n; i++ ) {
ccd = channel_get_coder_details(i);
if (strcmp(ccd->name, name) == 0) {
if (sp->channel_coder) {
channel_encoder_destroy(&sp->channel_coder);
}
channel_encoder_create(ccd->descriptor, &sp->channel_coder);
break;
}
}
success = channel_encoder_set_parameters(sp->channel_coder, param);
if (success == 0) {
/* Could not set parameters for channel coder, fall back to "None" */
name = "None";
param = "";
}
} while (success == 0);
channel_encoder_set_units_per_packet(sp->channel_coder, (uint16_t) setting_load_int("audioUnits", 1));
/* Set default repair to be first available */
r = repair_get_details(0);
sp->repair = r->id;
name = setting_load_str("audioRepair", "Pattern-Match");
n = (int)repair_get_count();
for(i = 0; i < n; i++) {
r = repair_get_details((uint16_t)i);
if (strcasecmp(r->name, name) == 0) {
sp->repair = r->id;
break;
}
}
/* Set default converter to be first available */
cod = converter_get_details(0);
sp->converter = cod->id;
name = setting_load_str("audioAutoConvert", "High Quality");
n = (int)converter_get_count();
/* If converter setting name matches then override existing choice */
for(i = 0; i < n; i++) {
cod = converter_get_details(i);
if (strcasecmp(cod->name, name) == 0) {
sp->converter = cod->id;
break;
}
}
silence = setting_load_str("audioSilence", "Automatic");
sp->silence_detection = sd_name_to_type(silence);
sp->manual_sd_thresh = setting_load_int("audioSilenceManualThresh", 100);
if (sp->manual_sd) {
manual_sd_set_thresh(sp->manual_sd, sp->manual_sd_thresh);
}
sp->limit_playout = setting_load_int("audioLimitPlayout", 0);
sp->min_playout = setting_load_int("audioMinPlayout", 0);
sp->max_playout = setting_load_int("audioMaxPlayout", 2000);
sp->lecture = setting_load_int("audioLecture", 0);
sp->agc_on = setting_load_int("audioAGC", 0);
sp->loopback_gain = setting_load_int("audioLoopback", 0);
audio_loopback(sp->audio_device, sp->loopback_gain);
sp->echo_suppress = setting_load_int("audioEchoSuppress", 0);
sp->meter = setting_load_int("audioPowermeters", 1);
sp->rtp_promiscuous_mode = setting_load_int("rtpPromiscuousMode", 0);
sp->rtp_wait_for_rtcp = setting_load_int("rtpWaitForRTCP", 1);
/* Ignore saved render_3d setting. Break initial device config stuff. V.fiddly to fix. */
/* sp->render_3d = setting_load_int("audio3dRendering", 0); */
mute = setting_load_int("audioInputMute", sp->mode==TRANSCODER?0:1);
if (mute && tx_is_sending(sp->tb)) {
tx_stop(sp->tb);
} else if (mute == 0 && tx_is_sending(sp->tb) == 0) {
tx_start(sp->tb);
}
setting_load_int("audioOutputMute", 1);
xmemchk();
load_done();
}
void
init()
{
struct ext_mem_format *ptr_exts; // structure-pointer to structure
struct ext_mem_format temp_struc; // temporary structure
struct inode ino_kern;
struct ext_mem_format ext_mem_strucs[50]; // 386 usable RAM list format
usec_t ino_sec;
ubyte_t num_servs; // number of servers to read to memory
uint_t tot_mem, counter, counter1; // counters
byte *ptr_mem=(byte *)ext_mem_strucs; // byte-pointer to structure
/*
* Get absolute sector for first ivector.
* It is stored in a global variable.
*/
sosfs_ivec_first();
/* read kernel's and server's inode sector */
ino_sec = sosfs_iget("/boot/kernel");
/* if error */
if (ino_sec == -1) {
low_putstr("Inode not found\n");
while (1);
}
/* read kernel's inode */
sosfs_read_raw(ino_sec, &ino_kern);
/* zero out the vector */
for (tot_mem=0; tot_mem<512; tot_mem++)
buffer[tot_mem]=0;
/*
* Copy arguments from real-mode to protected-mode.
* The monitor program wishes to pass the arguments to the kernel.
* This is done by a little hack that uses an interrupt instruction
* passing a buffer to copy from real-mode to protected-mode using
* BIOS.
*/
kargs_init();
/*
* Get total amount of RAM.
* The most reliable way to know the system's memory-mapping
* is by using the BIOS; we use int $0x15 function 0xe820.
*/
low_tot_ram(ext_mem_strucs);
/* point to memory-map vector */
ptr_exts=ext_mem_strucs;
/*
* Traverse the structures until magic number found.
* Our interrupt handler set a magic number after the last
* entry returned by the BIOS handler.
*/
kprintf("\n");
kprintf("BIOS-provided physical-memory mappings\n");
kprintf("======================================================\n");
while (ptr_exts->acpi_ext != 0x12345) {
/* if we must ignore the entry, so we do */
if (ptr_exts->reg_len == 0)
continue;
/* print type of memory to terminal */
switch (ptr_exts->reg_type) {
case 1:
kprintf("Usable RAM at ");
if (ptr_exts->base_addr[0] != 0) {
zero_mem(ptr_exts);
put_list(ptr_exts);
}
break;
case 2:
kprintf("Reserved/unusable RAM at ");
break;
case 3:
case 4:
case 5:
kprintf("ACPI RAM at ");
break;
}
/*
* Create a temporary structure and copy the entire structure
* to it.
* Print the address range.
*/
temp_struc = *ptr_exts; // copy structure
temp_struc.reg_len[0] += temp_struc.base_addr[0];
kprintf("%x-", &temp_struc);
kprintf("%x", temp_struc.reg_len);
kprintf("\n");
for (tot_mem=0; tot_mem<512; tot_mem++)
buffer[tot_mem]=0;
ptr_exts++; // advance one structure
}
kprintf("======================================================\n");
/*
* Set up initial memory mappings.
* Load user-level servers to predefined physical memory and
* identically map them. Map the monitor program and the kernel
* also to identical physical addresses. Also map those programs'
* heaps.
*/
load_init();
heap_init();
/* list returned by BIOS might be unsorted */
sort_free_list();
/* machine-dependent format to machine-independent format */
dep_2_indep_list(ptr_list);
mmap_init();
enable_paging();
SOS_init();
}
void run_main (int argc, char **argv) {
char *arg, *impmod, *p;
sexp out=SEXP_FALSE, env=NULL, ctx=NULL;
sexp_sint_t i, j, len, quit=0, print=0, init_loaded=0, fold_case=SEXP_DEFAULT_FOLD_CASE_SYMS;
sexp_uint_t heap_size=0, heap_max_size=SEXP_MAXIMUM_HEAP_SIZE;
sexp_gc_var2(tmp, args);
args = SEXP_NULL;
/* parse options */
for (i=1; i < argc && argv[i][0] == '-'; i++) {
switch (argv[i][1]) {
case 'e':
case 'p':
load_init();
print = (argv[i][1] == 'p');
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
check_nonull_arg('e', arg);
tmp = check_exception(ctx, sexp_eval_string(ctx, arg, -1, env));
if (print) {
if (! sexp_oportp(out))
out = sexp_eval_string(ctx, "(current-output-port)", -1, env);
sexp_write(ctx, tmp, out);
sexp_write_char(ctx, '\n', out);
}
quit = 1;
break;
case 'l':
load_init();
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
check_nonull_arg('l', arg);
check_exception(ctx, sexp_load_module_file(ctx, arg, env));
break;
case 'm':
load_init();
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
check_nonull_arg('m', arg);
len = strlen(arg)+strlen(sexp_import_prefix)+strlen(sexp_import_suffix);
impmod = (char*) malloc(len+1);
strcpy(impmod, sexp_import_prefix);
strcpy(impmod+strlen(sexp_import_prefix), arg);
strcpy(impmod+len-+strlen(sexp_import_suffix), sexp_import_suffix);
impmod[len] = '\0';
for (p=impmod; *p; p++)
if (*p == '.') *p=' ';
check_exception(ctx, sexp_eval_string(ctx, impmod, -1, env));
free(impmod);
break;
case 'q':
init_context();
if (! init_loaded++)
sexp_load_standard_ports(ctx, env, stdin, stdout, stderr, 0);
break;
case 'A':
init_context();
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
check_nonull_arg('A', arg);
sexp_add_module_directory(ctx, tmp=sexp_c_string(ctx,arg,-1), SEXP_TRUE);
break;
case 'I':
init_context();
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
check_nonull_arg('I', arg);
sexp_add_module_directory(ctx, tmp=sexp_c_string(ctx,arg,-1), SEXP_FALSE);
break;
case '-':
i++;
goto done_options;
case 'h':
arg = ((argv[i][2] == '\0') ? argv[++i] : argv[i]+2);
check_nonull_arg('h', arg);
heap_size = strtoul(arg, &arg, 0);
if (sexp_isalpha(*arg)) heap_size *= multiplier(*arg++);
if (*arg == '/') {
heap_max_size = strtoul(arg+1, &arg, 0);
if (sexp_isalpha(*arg)) heap_max_size *= multiplier(*arg++);
}
break;
case 'V':
load_init();
if (! sexp_oportp(out))
out = sexp_eval_string(ctx, "(current-output-port)", -1, env);
sexp_write_string(ctx, sexp_version_string, out);
tmp = sexp_env_ref(env, sexp_intern(ctx, "*features*", -1), SEXP_NULL);
sexp_write(ctx, tmp, out);
sexp_newline(ctx, out);
return;
#if SEXP_USE_FOLD_CASE_SYMS
case 'f':
fold_case = 1;
if (ctx) sexp_global(ctx, SEXP_G_FOLD_CASE_P) = SEXP_TRUE;
break;
#endif
default:
fprintf(stderr, "unknown option: %s\n", argv[i]);
exit_failure();
}
}
done_options:
if (! quit) {
load_init();
if (i < argc)
for (j=argc-1; j>i; j--)
args = sexp_cons(ctx, tmp=sexp_c_string(ctx,argv[j],-1), args);
else
args = sexp_cons(ctx, tmp=sexp_c_string(ctx,argv[0],-1), args);
sexp_env_define(ctx, env, sexp_intern(ctx, sexp_argv_symbol, -1), args);
sexp_eval_string(ctx, sexp_argv_proc, -1, env);
if (i < argc) { /* script usage */
sexp_context_tracep(ctx) = 1;
check_exception(ctx, sexp_load(ctx, tmp=sexp_c_string(ctx, argv[i], -1), env));
tmp = sexp_intern(ctx, "main", -1);
tmp = sexp_env_ref(env, tmp, SEXP_FALSE);
if (sexp_procedurep(tmp)) {
args = sexp_list1(ctx, args);
check_exception(ctx, sexp_apply(ctx, tmp, args));
}
} else {
repl(ctx, env);
}
}
sexp_gc_release2(ctx);
sexp_destroy_context(ctx);
}
