void
ssh_userauth2(const char *local_user, const char *server_user, char *host,
Sensitive *sensitive)
{
Authctxt authctxt;
int type;
if (options.challenge_response_authentication)
options.kbd_interactive_authentication = 1;
packet_start(SSH2_MSG_SERVICE_REQUEST);
packet_put_cstring("ssh-userauth");
packet_send();
debug("SSH2_MSG_SERVICE_REQUEST sent");
packet_write_wait();
type = packet_read();
if (type != SSH2_MSG_SERVICE_ACCEPT)
fatal("Server denied authentication request: %d", type);
if (packet_remaining() > 0) {
char *reply = packet_get_string(NULL);
debug2("service_accept: %s", reply);
xfree(reply);
} else {
debug2("buggy server: service_accept w/o service");
}
packet_check_eom();
debug("SSH2_MSG_SERVICE_ACCEPT received");
if (options.preferred_authentications == NULL)
options.preferred_authentications = authmethods_get();
/* setup authentication context */
memset(&authctxt, 0, sizeof(authctxt));
authctxt.agent = ssh_get_authentication_connection();
authctxt.server_user = server_user;
authctxt.local_user = local_user;
authctxt.host = host;
authctxt.service = "ssh-connection"; /* service name */
authctxt.success = 0;
authctxt.method = authmethod_lookup("none");
authctxt.authlist = NULL;
authctxt.sensitive = sensitive;
authctxt.info_req_seen = 0;
if (authctxt.method == NULL)
fatal("ssh_userauth2: internal error: cannot send userauth none request");
/* initial userauth request */
userauth_none(&authctxt);
dispatch_init(&input_userauth_error);
dispatch_set(SSH2_MSG_USERAUTH_SUCCESS, &input_userauth_success);
dispatch_set(SSH2_MSG_USERAUTH_FAILURE, &input_userauth_failure);
dispatch_set(SSH2_MSG_USERAUTH_BANNER, &input_userauth_banner);
dispatch_run(DISPATCH_BLOCK, &authctxt.success, &authctxt); /* loop until success */
if (authctxt.agent != NULL)
ssh_close_authentication_connection(authctxt.agent);
debug("Authentication succeeded (%s).", authctxt.method->name);
}
Authctxt *
do_authentication2(void)
{
Authctxt *authctxt = authctxt_new();
x_authctxt = authctxt; /*XXX*/
#ifdef HAVE_BSM
fatal_add_cleanup(audit_failed_login_cleanup, authctxt);
#endif /* HAVE_BSM */
/* challenge-response is implemented via keyboard interactive */
if (options.challenge_response_authentication)
options.kbd_interactive_authentication = 1;
if (options.pam_authentication_via_kbd_int)
options.kbd_interactive_authentication = 1;
if (use_privsep)
options.pam_authentication_via_kbd_int = 0;
dispatch_init(&dispatch_protocol_error);
dispatch_set(SSH2_MSG_SERVICE_REQUEST, &input_service_request);
dispatch_run(DISPATCH_BLOCK, &authctxt->success, authctxt);
return (authctxt);
}
/*
* loop until authctxt->success == TRUE
*/
void
do_authentication2(Authctxt *authctxt)
{
dispatch_init(&dispatch_protocol_error);
dispatch_set(SSH2_MSG_SERVICE_REQUEST, &input_service_request);
dispatch_run(DISPATCH_BLOCK, &authctxt->success, authctxt);
}
int main(const int argc, const char **argv){
if (argc < 3){
std::cerr << "Error: too few arguments." << std::endl;
return 1;
}
const int64_t SIZE = std::stoull(argv[1]);
const int64_t NUM_THREADS = std::stoull(argv[2]);
if (SIZE < 10 || NUM_THREADS < 1){
std::cerr << "Error: Invalid aruments " << SIZE << " and " << NUM_THREADS << std::endl;
return 1;
}
dispatch_init();
std::cout << "Creating matricies..." << std::endl;
std::cout << "Size: " << SIZE << ", Threads: " << NUM_THREADS << std::endl;
const double createStart = getRealTime();
Matrix *mat1 = createMatrix(SIZE);
Matrix *mat2 = createMatrix(SIZE);
Matrix *mat3 = createMatrix(SIZE);
initMatrix(mat1);
initMatrix(mat2);
const double createEnd = getRealTime();
const double createElapsed = createEnd - createStart;
std::cout << "Matricies created. Took " << createElapsed << " seconds." << std::endl;
std::cout << "Multiplying..." << std::endl;
const double multiplyStart = getRealTime();
multiplyParallel(mat1, mat2, mat3, NUM_THREADS);
const double multiplyEnd = getRealTime();
const double multiplyElapsed = multiplyEnd - multiplyStart;
std::cout << "Multiply finished. Took " << multiplyElapsed << " seconds." << std::endl;
destroyMatrix(mat1);
destroyMatrix(mat2);
destroyMatrix(mat3);
disaptch_release();
return 0;
}
/**
* @brief Creates the main user program as a main task
* and sets it to run.
*
* This function is only called when the user program is
* first run.
*
*/
void sched_init(task_t* main_task)
{
main_task->lambda = (void *)0xa0000000;
main_task->data = 0;
main_task->stack_pos = (void *)0xa3000000;
main_task->C = 1;
main_task->T = 1;
tcb_init(main_task, &system_tcb[FIRST_MAIN_PRIO], FIRST_MAIN_PRIO);
runqueue_add(&system_tcb[FIRST_MAIN_PRIO], FIRST_MAIN_PRIO);
dispatch_init(&system_tcb[FIRST_MAIN_PRIO]);
}
void CPPLIB( exc_setup ) // SETUP DISPATCH, EXCEPTION RECORDS
( DISPATCH_EXC* disp // - dispatch record
, THROW_RO* throw_ro // - throw r/o block
, rboolean is_zero // - true ==> thrown object is zero constant
, _RTCTL* rt_ctl // - R/T control
, void* object // - thrown object
, FsExcRec* rec ) // - exception record
{
dispatch_init( disp, throw_ro, is_zero, rt_ctl );
initFsExcRec( object, rec, disp );
}
void register_cmd_internal(void) {
dispatch_init(&internal);
LVal cmds=0;
cmds=add_command(cmds,"tar" ,NULL,cmd_tar,0,1);
cmds=add_command(cmds,"download",NULL,cmd_download,0,1);
cmds=add_command(cmds,"uname",NULL,cmd_uname,0,1);
cmds=add_command(cmds,"which",NULL,cmd_which,0,1);
cmds=add_command(cmds,"impl",NULL,cmd_impl,0,1);
cmds=add_command(cmds,"version",NULL,cmd_internal_version,0,1);
cmds=add_command(cmds,"core-extention",NULL,cmd_internal_core_extention,0,1);
internal.command=cmds;
}
int main(void)
{
bsp_init();
dispatch_init();
on_ready();
while(1)
{
HCI_Process();
dispatch();
loop();
}
}
/**@brief Function for the application main entry.
*/
int main(void)
{
uint32_t err_code;
load_app();
gpio_init();
ble_stack_init();
device_manager_init();
juma_init();
// initialize Bluetooth Stack parameters.
gap_params_init();
advertising_init();
services_init();
dispatch_init();
flash_init();
if (app) {
device_current_statue_set(DEVICE_STATUE_APP);
data_storage_init();
on_ready();
} else {
device_current_statue_set(DEVICE_STATUE_OTA);
ble_device_set_name("OTA Mode");
ota_init();
ble_device_set_advertising_interval(200);
ble_device_start_advertising();
}
// Enter main loop.
for (;;)
{
watchDog_sys_SDK_dog1_RR();
if(0 != enter_ota_mode_statue)
{
enter_ota_process(NULL);
}
else
{
dispatch();
}
serial_get();
// Switch to a low power state until an event is available for the application
err_code = sd_app_evt_wait();
APP_ERROR_CHECK(err_code);
}
}
static void
server_init_dispatch_13(void)
{
debug("server_init_dispatch_13");
dispatch_init(NULL);
dispatch_set(SSH_CMSG_EOF, &server_input_eof);
dispatch_set(SSH_CMSG_STDIN_DATA, &server_input_stdin_data);
dispatch_set(SSH_CMSG_WINDOW_SIZE, &server_input_window_size);
dispatch_set(SSH_MSG_CHANNEL_CLOSE, &channel_input_close);
dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION, &channel_input_close_confirmation);
dispatch_set(SSH_MSG_CHANNEL_DATA, &channel_input_data);
dispatch_set(SSH_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);
dispatch_set(SSH_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);
dispatch_set(SSH_MSG_PORT_OPEN, &channel_input_port_open);
}
Authctxt *
do_authentication2(void)
{
Authctxt *authctxt = authctxt_new();
x_authctxt = authctxt; /*XXX*/
#ifdef HAVE_BSM
fatal_add_cleanup(audit_failed_login_cleanup, authctxt);
#endif /* HAVE_BSM */
dispatch_init(&dispatch_protocol_error);
dispatch_set(SSH2_MSG_SERVICE_REQUEST, &input_service_request);
dispatch_run(DISPATCH_BLOCK, &authctxt->success, authctxt);
return (authctxt);
}
int main(void) {
halInit();
chSysInit();
chRegSetThreadName("main");
LocalStatus = &M2RStatus;
/*sbp_state_init(&sbp_state);*/
rockblock_init();
dispatch_init();
chThdCreateStatic(waThreadHB, sizeof(waThreadHB), LOWPRIO,
ThreadHeartbeat, NULL);
/* Configure and enable the watchdog timer, stopped in debug halt */
DBGMCU->APB1FZ |= DBGMCU_APB1_FZ_DBG_IWDG_STOP;
IWDG->KR = 0x5555;
IWDG->PR = 3;
IWDG->KR = 0xCCCC;
m2serial_shell = m2r_shell_run;
M2SerialSD = &SD2;
chThdCreateStatic(waM2Serial, sizeof(waM2Serial), HIGHPRIO,
m2serial_thread, NULL);
chThdCreateStatic(waM2Status, sizeof(waM2Status), HIGHPRIO,
m2status_thread, NULL);
chThdCreateStatic(waThreadUblox, sizeof(waThreadUblox), NORMALPRIO,
ublox_thread, NULL);
chThdCreateStatic(waThreadRadio, sizeof(waThreadRadio), NORMALPRIO,
radio_thread, NULL);
chThdCreateStatic(waDispatch, sizeof(waDispatch), NORMALPRIO,
dispatch_thread, NULL);
chThdSetPriority(LOWPRIO);
chThdSleep(TIME_INFINITE);
return 0;
}
static void
server_init_dispatch_20(void)
{
debug("server_init_dispatch_20");
dispatch_init(&dispatch_protocol_error);
dispatch_set(SSH2_MSG_CHANNEL_CLOSE, &channel_input_oclose);
dispatch_set(SSH2_MSG_CHANNEL_DATA, &channel_input_data);
dispatch_set(SSH2_MSG_CHANNEL_EOF, &channel_input_ieof);
dispatch_set(SSH2_MSG_CHANNEL_EXTENDED_DATA, &channel_input_extended_data);
dispatch_set(SSH2_MSG_CHANNEL_OPEN, &server_input_channel_open);
dispatch_set(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);
dispatch_set(SSH2_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);
dispatch_set(SSH2_MSG_CHANNEL_REQUEST, &server_input_channel_req);
dispatch_set(SSH2_MSG_CHANNEL_WINDOW_ADJUST, &channel_input_window_adjust);
dispatch_set(SSH2_MSG_GLOBAL_REQUEST, &server_input_global_request);
/* client_alive */
dispatch_set(SSH2_MSG_CHANNEL_FAILURE, &server_input_channel_failure);
/* rekeying */
dispatch_set(SSH2_MSG_KEXINIT, &kex_input_kexinit);
}
int main ( int argc, char *argv[] )
{
// Call sys_init with the created modules
int SYS_INIT_ERR;
int SHELL_ERR;
int DATE_ERR;
date_rec* tdf_date;
// Initialize system date
DATE_ERR = sys_set_date(tdf_date);
SYS_INIT_ERR = sys_init (MODULE_R3);
// Setting up registers for dispatch...
dispatch_init();
// Call the shell
SHELL_ERR = shell();
// Fin
return 0;
}
/**
* @brief Allocate user-stacks and initializes the kernel contexts of the
* given threads.
*
* This function assumes that:
* - num_tasks < number of tasks allowed on the system.
* - the tasks have already been deemed schedulable and have been appropriately
* scheduled. In particular, this means that the task list is sorted in order
* of priority -- higher priority tasks come first.
*
* @param tasks A list of scheduled task descriptors.
* @param size The number of tasks is the list.
*/
void allocate_tasks(task_t** tasks, size_t num_tasks)
{
size_t i = 1;
for(; i <= num_tasks; i++)
{
tcb_t *task_tcb = &(system_tcb[i]);
task_tcb->native_prio = i;
task_tcb->cur_prio = i;
// Context
sched_context_t *ctx = &(task_tcb->context);
ctx->r4 = (uint32_t) (tasks[i-1]->lambda);
ctx->r5 = (uint32_t) (tasks[i-1]->data);
ctx->r6 = (uint32_t) (tasks[i-1]->stack_pos);
ctx->r8 = global_data;
ctx->sp = ((char *)(task_tcb->kstack) + OS_KSTACK_SIZE);
// Easy way to launch task fo first time
ctx->lr = (void *)launch_task;
task_tcb->holds_lock = 0;
task_tcb->sleep_queue = (tcb_t *)0;
}
initialize_idle();
runqueue_init();
runqueue_add(&(system_tcb[IDLE_PRIO]), IDLE_PRIO);
for(i=1; i <= num_tasks; i++)
{
runqueue_add(&(system_tcb[i]), i);
}
// Set current tcb as IDLE
dispatch_init(&(system_tcb[IDLE_PRIO]));
}
int main(const int argc, const char * argv[]) {
watch_t w;
watch_init(&w);
watch_callback_t wc = {
.data = NULL,
.func = NULL,
};
watch_add(&w, "/dev/mqueue", IN_CREATE | IN_ATTRIB, &wc);
dispatch_t d;
dispatch_init(&d);
dispatch_callback_t dc = {
.data = NULL,
.func = callback,
};
dispatch_add(&d, watch_fileno(&w), EPOLLIN, &dc);
dispatch_wait(&d);
return 0;
}
int main() {
static unsigned char alloc_buffer[4096*(1+1+4+1+32+1+256)];
char json_buffer[4096];
char print_buffer[4096];
int ret;
int readlen;
int json_offset;
void * root_node;
void * findlist;
void * memdb_template ;
BYTE uuid[DIGEST_SIZE];
int i;
MSG_HEAD * msg_head;
pthread_t cube_thread;
char * baseconfig[] =
{
"typelist.json",
"subtypelist.json",
"msghead.json",
"login_struct.json",
"headrecord.json",
NULL
};
alloc_init(alloc_buffer);
struct_deal_init();
memdb_init();
// test namelist reading start
for(i=0; baseconfig[i]!=NULL; i++)
{
ret=read_json_file(baseconfig[i]);
if(ret<0)
return ret;
printf("read %d elem from file %s!\n",ret,baseconfig[i]);
}
void * record;
// test struct desc reading start
msgfunc_init();
void * message;
void * policy;
dispatch_init(NULL);
policy=dispatch_policy_create();
if(policy==NULL)
{
printf("create policy failed!\n");
return -EINVAL;
}
ret=read_dispatch_file("dispatch_policy.json");
// routine_start();
// sleep(100000);
return 0;
}
int
main(int argc, char * argv[])
{
/* State variables. */
int * socks_s;
int sock_t;
struct wire_requestqueue * Q_t;
struct dispatch_state * dstate;
/* Command-line parameters. */
intmax_t opt_n = 0;
char * opt_p = NULL;
char * opt_t = NULL;
ADDRLIST opt_s;
char * opt_s_1 = NULL;
/* Working variables. */
size_t opt_s_size;
struct sock_addr ** sas;
size_t i;
const char * ch;
WARNP_INIT;
/* We have no addresses to listen on yet. */
if ((opt_s = addrlist_init(0)) == NULL) {
warnp("addrlist_init");
exit(1);
}
/* Parse the command line. */
while ((ch = GETOPT(argc, argv)) != NULL) {
GETOPT_SWITCH(ch) {
GETOPT_OPTARG("-n"):
if (opt_n != 0)
usage();
if (PARSENUM(&opt_n, optarg, 0, 65535)) {
warn0("Invalid option: -n %s", optarg);
usage();
}
break;
GETOPT_OPTARG("-p"):
if (opt_p != NULL)
usage();
if ((opt_p = strdup(optarg)) == NULL)
OPT_EPARSE(ch, optarg);
break;
GETOPT_OPTARG("-s"):
/* Keep a copy of the path for pidfile generation. */
if ((opt_s_1 == NULL) &&
((opt_s_1 = strdup(optarg)) == NULL))
OPT_EPARSE(ch, optarg);
/* Attempt to resolve to a list of addresses. */
if ((sas = sock_resolve(optarg)) == NULL) {
warnp("Cannot resolve address: %s", optarg);
exit(1);
}
if (sas[0] == NULL) {
warn0("No addresses found for %s", optarg);
exit(1);
}
/* Push pointers to addresses onto the list. */
for (i = 0; sas[i] != NULL; i++) {
if (addrlist_append(opt_s, &sas[i], 1))
OPT_EPARSE(ch, optarg);
}
/* Free the array (but keep the addresses). */
free(sas);
break;
GETOPT_OPTARG("-t"):
if (opt_t != NULL)
usage();
if ((opt_t = strdup(optarg)) == NULL)
OPT_EPARSE(ch, optarg);
break;
GETOPT_OPT("--version"):
fprintf(stderr, "kivaloo-mux @VERSION@\n");
exit(0);
GETOPT_MISSING_ARG:
warn0("Missing argument to %s\n", ch);
usage();
GETOPT_DEFAULT:
warn0("illegal option -- %s\n", ch);
usage();
}
}
argc -= optind;
argv += optind;
/* We should have processed all the arguments. */
if (argc != 0)
usage();
/* Sanity-check options. */
if ((opt_s_size = addrlist_getsize(opt_s)) == 0)
usage();
if (opt_t == NULL)
usage();
/* Resolve target address. */
if ((sas = sock_resolve(opt_t)) == NULL) {
warnp("Error resolving socket address: %s", opt_t);
exit(1);
}
if (sas[0] == NULL) {
warn0("No addresses found for %s", opt_t);
exit(1);
}
/* Connect to the target. */
if ((sock_t = sock_connect(sas)) == -1)
exit(1);
/* Free the target address(es). */
sock_addr_freelist(sas);
/* Create a queue of requests to the target. */
if ((Q_t = wire_requestqueue_init(sock_t)) == NULL) {
warnp("Cannot create request queue");
exit(1);
}
/* Allocate array of source sockets. */
if ((socks_s = malloc(opt_s_size * sizeof(int))) == NULL) {
warnp("malloc");
exit(1);
}
/* Create listening sockets. */
for (i = 0; i < opt_s_size; i++) {
if ((socks_s[i] =
sock_listener(*addrlist_get(opt_s, i))) == -1)
exit(1);
}
/* Initialize the dispatcher. */
if ((dstate = dispatch_init(socks_s, opt_s_size,
Q_t, opt_n ? (size_t)opt_n : SIZE_MAX)) == NULL) {
warnp("Failed to initialize dispatcher");
exit(1);
}
/* Daemonize and write pid. */
if (opt_p == NULL) {
if (asprintf(&opt_p, "%s.pid", opt_s_1) == -1) {
warnp("asprintf");
exit(1);
}
}
if (daemonize(opt_p)) {
warnp("Failed to daemonize");
exit(1);
}
/* Loop until the dispatcher is finished. */
do {
if (events_run()) {
warnp("Error running event loop");
exit(1);
}
} while (dispatch_alive(dstate));
/* Clean up the dispatcher. */
dispatch_done(dstate);
/* Shut down the request queue. */
wire_requestqueue_destroy(Q_t);
wire_requestqueue_free(Q_t);
/* Close sockets. */
for (i = 0; i < opt_s_size; i++)
close(socks_s[i]);
free(socks_s);
close(sock_t);
/* Free source socket addresses. */
for (i = 0; i < addrlist_getsize(opt_s); i++)
sock_addr_free(*addrlist_get(opt_s, i));
addrlist_free(opt_s);
/* Shut down the event subsystem. */
events_shutdown();
/* Free option strings. */
free(opt_p);
free(opt_s_1);
free(opt_t);
/* Success! */
return (0);
}
int main(int argc,char **argv)
{
struct tcloud_connector_hub * hub;
struct tcloud_connector * temp_conn;
int ret;
int retval;
void * message_box;
int i,j;
int argv_offset;
char namebuffer[DIGEST_SIZE*4];
char * sys_plugin;
char * app_plugin;
char * base_define;
char * cube_output;
char json_buffer[4096];
char print_buffer[4096];
int readlen;
int json_offset;
void * memdb_template ;
BYTE uuid[DIGEST_SIZE];
void * main_proc; // point to the main proc's subject struct
void * conn_proc; // point to the conn proc's subject struct
void * router_proc; // point to the conn proc's subject struct
char local_uuid[DIGEST_SIZE*2];
FILE * fp;
char audit_text[4096];
char buffer[4096];
void * root_node;
void * temp_node;
PROC_INIT plugin_proc;
char * baseconfig[] =
{
"namelist.json",
"dispatchnamelist.json",
"typelist.json",
"subtypelist.json",
"baseflag.json",
"memdb.json",
"msghead.json",
"msgrecord.json",
"expandrecord.json",
"base_msg.json",
"dispatchrecord.json",
"exmoduledefine.json",
"sys_conn.json",
NULL
};
struct start_para start_para;
start_para.argc=argc;
start_para.argv=argv;
int fd =open(msgaudit_file,O_CREAT|O_RDWR|O_TRUNC,0666);
close(fd);
audit_file_init();
sys_plugin=getenv("CUBE_SYS_PLUGIN");
// alloc_init(alloc_buffer);
struct_deal_init();
memdb_init();
base_define=getenv("CUBE_BASE_DEFINE");
for(i=0;baseconfig[i]!=NULL;i++)
{
Strcpy(namebuffer,base_define);
Strcat(namebuffer,"/");
Strcat(namebuffer,baseconfig[i]);
ret=read_json_file(namebuffer);
if(ret<0)
return ret;
print_cubeaudit("read %d elem from file %s!\n",ret,namebuffer);
}
msgfunc_init();
dispatch_init();
channel_init();
ex_module_list_init();
// init system
system("mkdir lib");
// init the main proc struct
struct lib_para_struct * lib_para=NULL;
fd=open(sys_config_file,O_RDONLY);
if(fd>0)
{
ret=read_json_node(fd,&root_node);
if(ret<0)
return ret;
close(fd);
ret=read_sys_cfg(&lib_para,root_node,NULL);
if(ret<0)
return ret;
}
fd=open(main_config_file,O_RDONLY);
if(fd<0)
return -EINVAL;
ret=read_json_node(fd,&root_node);
if(ret<0)
return ret;
close(fd);
ret=read_main_cfg(lib_para,root_node);
if(ret<0)
return ret;
ret=get_local_uuid(local_uuid);
digest_to_uuid(local_uuid,buffer);
buffer[64]=0;
print_cubeaudit("this machine's local uuid is %s\n",buffer);
proc_share_data_setvalue("uuid",local_uuid);
// init all the proc database
usleep(time_val.tv_usec);
// init the connect proc
Strcpy(namebuffer,sys_plugin);
Strcat(namebuffer,"/");
Strcat(namebuffer,connector_plugin_file);
plugin_proc.init =main_read_func(namebuffer,"proc_conn_init");
if(plugin_proc.init==NULL)
return -EINVAL;
plugin_proc.start =main_read_func(namebuffer,"proc_conn_start");
if(plugin_proc.start==NULL)
return -EINVAL;
plugin_proc.name=dup_str("connector_proc",0);
plugin_proc.type=MOD_TYPE_CONN;
ret=ex_module_create("connector_proc",MOD_TYPE_CONN,NULL,&conn_proc);
if(ret<0)
return ret;
ex_module_setinitfunc(conn_proc,plugin_proc.init);
ex_module_setstartfunc(conn_proc,plugin_proc.start);
ex_module_init(conn_proc,connector_config_file);
add_ex_module(conn_proc);
// init the router proc
Strcpy(namebuffer,sys_plugin);
Strcat(namebuffer,"/");
Strcat(namebuffer,router_plugin_file);
plugin_proc.init =main_read_func(namebuffer,"proc_router_init");
if(plugin_proc.init==NULL)
return -EINVAL;
plugin_proc.start =main_read_func(namebuffer,"proc_router_start");
if(plugin_proc.start==NULL)
return -EINVAL;
plugin_proc.name=dup_str("router_proc",0);
plugin_proc.type=MOD_TYPE_ROUTER;
ret=ex_module_create("router_proc",MOD_TYPE_MONITOR,NULL,&router_proc);
if(ret<0)
return ret;
ex_module_setinitfunc(router_proc,plugin_proc.init);
ex_module_setstartfunc(router_proc,plugin_proc.start);
struct router_init_para
{
char * router_file;
char * aspect_file;
} router_init;
router_init.router_file=router_config_file;
router_init.aspect_file=aspect_config_file;
ex_module_init(router_proc,&router_init);
print_cubeaudit("prepare the router proc\n");
ret=add_ex_module(router_proc);
if(ret<0)
return ret;
// loop to init all the plugin's
void * ex_module;
fd=open(plugin_config_file,O_RDONLY);
if(fd>0)
{
while(read_json_node(fd,&root_node)>0)
{
ret=read_plugin_cfg(&ex_module,root_node);
if(ret>=0)
add_ex_module(ex_module);
}
}
/*
}
*/
usleep(time_val.tv_usec);
print_cubeaudit("prepare the conn proc\n");
ret=ex_module_start(conn_proc,NULL);
if(ret<0)
return ret;
// second loop: start all the monitor process
ret=get_first_ex_module(&ex_module);
if(ret<0)
return ret;
int active_module_no=0;
while(ex_module!=NULL)
{
if((ex_module_gettype(ex_module) == MOD_TYPE_MONITOR)
||(ex_module_gettype(ex_module) == MOD_TYPE_PORT))
{
ret=ex_module_start(ex_module,NULL);
if(ret<0)
return ret;
print_cubeaudit("monitor ex_modulec %s started successfully!\n",ex_module_getname(ex_module));
}
else if(ex_module_gettype(ex_module) == MOD_TYPE_START)
{
ret=ex_module_start(ex_module,&start_para);
if(ret<0)
return ret;
print_cubeaudit("start ex_module %s started successfully!\n",ex_module_getname(ex_module));
}
ret= get_next_ex_module(&ex_module);
active_module_no++;
if(ret<0)
return ret;
}
if(active_module_no==0)
return 0;
proc_share_data_setstate(PROC_LOCAL_START);
// third loop: test if any module exit
int * thread_retval;
thread_retval=malloc(sizeof(int)*active_module_no);
if(thread_retval==NULL)
return NULL;
/*
i=0;
while(1)
{
usleep(time_val.tv_usec);
ret=get_first_ex_module(&ex_module);
if(ret<0)
return ret;
while(ex_module!=NULL)
{
if(ex_module_tryjoin(ex_module,&thread_retval[i++])==0)
{
print_cubeaudit("monitor ex_modulec %s exited successfully!\n",ex_module_getname(ex_module));
return thread_retval[i-1];
}
ret= get_next_ex_module(&ex_module);
}
i=0;
}
*/
// third loop: join all the non_system module
ret=get_first_ex_module(&ex_module);
if(ret<0)
return ret;
i=0;
while(ex_module!=NULL)
{
if((ex_module_gettype(ex_module) == MOD_TYPE_MONITOR)
||(ex_module_gettype(ex_module) == MOD_TYPE_PORT)
||(ex_module_gettype(ex_module) == MOD_TYPE_START))
{
if(Strcmp(ex_module_getname(ex_module),"router_proc")!=0)
{
ret=ex_module_join(ex_module,&thread_retval[i++]);
if(ret<0)
{
print_cubeerr("%s module exit!\n",ex_module_getname(ex_module));
return ret;
}
print_cubeaudit("%s module exit!\n",ex_module_getname(ex_module));
}
}
ret= get_next_ex_module(&ex_module);
if(ret<0)
return ret;
}
printf("thread return value %d!\n",thread_retval[0]);
return ret;
}
int main() {
static unsigned char alloc_buffer[4096*(1+1+4+1+32+1+256)];
char json_buffer[4096];
char print_buffer[4096];
int ret;
int readlen;
int json_offset;
void * root_node;
void * findlist;
void * memdb_template ;
BYTE uuid[DIGEST_SIZE];
int i;
MSG_HEAD * msg_head;
pthread_t cube_thread;
char * baseconfig[] =
{
"namelist.json",
"dispatchnamelist.json",
"typelist.json",
"subtypelist.json",
"msghead.json",
"msgrecord.json",
"expandrecord.json",
"base_msg.json",
"dispatchrecord.json",
NULL
};
// alloc_init(alloc_buffer);
struct_deal_init();
memdb_init();
// test namelist reading start
for(i=0;baseconfig[i]!=NULL;i++)
{
ret=read_json_file(baseconfig[i]);
if(ret<0)
return ret;
printf("read %d elem from file %s!\n",ret,baseconfig[i]);
}
void * record;
// test struct desc reading start
msgfunc_init();
dispatch_init();
void * message;
void * policy;
ret=read_dispatch_file("dispatch_policy.json");
message=message_create(DTYPE_MESSAGE,SUBTYPE_BASE_MSG,NULL);
struct basic_message * base_msg;
base_msg=Talloc0(sizeof(*base_msg));
if(base_msg==NULL)
return -ENOMEM;
base_msg->message=dup_str("hello",0);
message_add_record(message,base_msg);
ret=message_output_json(message,json_buffer);
if(ret<0)
{
printf("message output json failed!\n");
return ret;
}
printf("%s\n",json_buffer);
ret=dispatch_policy_getfirst(&policy);
while(policy!=NULL)
{
ret=dispatch_match_message(policy,message);
if(ret==0)
{
printf("this message match the policy!\n");
break;
}
ret=dispatch_policy_getnext(&policy);
}
if(policy!=NULL)
{
router_set_local_route(message,policy);
ret=message_output_json(message,json_buffer);
if(ret<0)
{
printf("message output json failed!\n");
return ret;
}
printf("%s\n",json_buffer);
}
// routine_start();
// sleep(100000);
return 0;
}
int main(int argc, const char** argv)
{
argv0 = argv[0];
bool print_stats = false;
U.start();
// Set up smsh related error codes
if (! (w_error_t::insert(
"ss_m shell",
smsh_error_list, SSH_MAX_ERROR - SSH_MIN_ERROR - 1))) {
abort();
}
/*
* The following section of code sets up all the various options
* for the program. The following steps are performed:
- determine the name of the program
- setup an option group for the program
- initialize the ssm options
- scan default option configuration files ($HOME/.shoreconfig .shoreconfig)
- process any options found on the command line
- use getopt() to process smsh specific flags on the command line
- check that all required options are set before initializing sm
*/
// set prog_name to the file name of the program
const char* prog_name = strrchr(argv[0], '/');
if (prog_name == NULL) {
prog_name = argv[0];
} else {
prog_name += 1; /* skip the '/' */
if (prog_name[0] == '\0') {
prog_name = argv[0];
}
}
/*
* Set up and option group (list of options) for use by
* all layers of the system. Level "smsh" indicates
* that the program is a a part to the smsh test suite.
* Level "server" indicates
* the type of program (the smsh server program). The third
* level is the program name itself.
*/
option_group_t options(3);
W_COERCE(options.add_class_level("smsh"));
W_COERCE(options.add_class_level("server"));
W_COERCE(options.add_class_level(prog_name));
/*
* Set up and smsh option for the name of the tcl library directory
* and the name of the .smshrc file.
*/
option_t* smsh_libdir;
option_t* smsh_smshrc;
W_COERCE(options.add_option("smsh_libdir", "directory name", NULL,
"directory for smsh tcl libraries",
true, option_t::set_value_charstr, smsh_libdir));
W_COERCE(options.add_option("smsh_smshrc", "rc file name", ".smshrc",
"full path name of the .smshrc file",
false, option_t::set_value_charstr, smsh_smshrc));
// have the sm add its options to the group
W_COERCE(ss_m::setup_options(&options));
/*
* Scan the default configuration files: $HOME/.shoreconfig, .shoreconfig. Note
* That OS errors are ignored since it is not an error
* for this file to not be found.
*/
rc_t rc;
{
char opt_file[ss_m::max_devname+1];
for(int file_num = 0; file_num < 2 && !rc.is_error(); file_num++) {
// scan default option files
w_ostrstream err_stream;
const char* config = ".shoreconfig";
if (file_num == 0) {
if (!getenv("HOME")) {
// ignore it ...
// cerr << "Error: environment variable $HOME is not set" << endl;
// rc = RC(SSH_FAILURE);
break;
}
if (sizeof(opt_file) <= strlen(getenv("HOME")) + strlen("/") + strlen(config) + 1) {
cerr << "Error: environment variable $HOME is too long" << endl;
rc = RC(SSH_FAILURE);
break;
}
strcpy(opt_file, getenv("HOME"));
strcat(opt_file, "/");
strcat(opt_file, config);
} else {
w_assert3(file_num == 1);
strcpy(opt_file, "./");
strcat(opt_file, config);
}
{
option_file_scan_t opt_scan(opt_file, &options);
rc = opt_scan.scan(true, err_stream);
err_stream << ends;
if (rc.is_error()) {
// ignore OS error messages
if (rc.err_num() == fcOS) {
rc = RCOK;
} else {
// this error message is kind of gross but is
// sufficient for now
cerr << "Error in reading option file: " << opt_file << endl;
//cerr << "\t" << w_error_t::error_string(rc.err_num()) << endl;
cerr << "\t" << err_stream.c_str() << endl;
}
}
}
}
}
/*
* Assuming there has been no error so far, the command line
* is processed for any options in the option group "options".
*/
if (!rc.is_error()) {
// parse command line
w_ostrstream err_stream;
rc = options.parse_command_line(argv, argc, 2, &err_stream);
err_stream << ends;
if (rc.is_error()) {
cerr << "Error on command line " << endl;
cerr << "\t" << w_error_t::error_string(rc.err_num()) << endl;
cerr << "\t" << err_stream.c_str() << endl;
print_usage(cerr, prog_name, false, options);
}
}
/*
* Assuming there has been no error so far, the command line
* is processed for any smsh specific flags.
*/
int option;
//if (!rc)
{ // do even if error so that smsh -h can be recognized
bool verbose_opt = false; // print verbose option values
while ((option = getopt(argc, (char * const*) argv, "Cf:hLOsTvV")) != -1) {
switch (option) {
case 'T':
extern bool logtrace;
logtrace = true;
break;
case 'O':
// Force use of old sort
cout << "Force use of old sort implementation." <<endl;
newsort = false;
break;
case 'C':
// force compression of btrees
force_compress = true;
break;
case 's':
print_stats = true;
break;
case 'f':
f_arg = optarg;
break;
case 'L':
// use log warning callback
log_warn_callback = true;
break;
case 'h':
// print a help message describing options and flags
print_usage(cerr, prog_name, true, options);
// free rc structure to avoid complaints on exit
W_IGNORE(rc);
goto done;
break;
case 'v':
verbose_opt = true;
break;
case 'V':
verbose = true;
break;
default:
cerr << "unknown flag: " << option << endl;
rc = RC(SSH_COMMAND_LINE);
}
}
if (verbose_opt) {
options.print_values(false, cerr);
}
}
/*
* Assuming no error so far, check that all required options
* in option_group_t options are set.
*/
if (!rc.is_error()) {
// check required options
w_ostrstream err_stream;
rc = options.check_required(&err_stream);
err_stream << ends;
if (rc.is_error()) {
cerr << "These required options are not set:" << endl;
cerr << err_stream.c_str() << endl;
print_usage(cerr, prog_name, false, options);
}
}
/*
* If there have been any problems so far, then exit
*/
if (rc.is_error()) {
// free the rc error structure to avoid complaints on exit
W_IGNORE(rc);
goto errordone;
}
/*
* At this point, all options and flags have been properly
* set. What follows is initialization for the rest of
* the program. The ssm will be started by a tcl_thread.
*/
// setup table of sm commands - doesn't involve the Tcl_Interp
dispatch_init();
// set up the linked variables
// either these should be read-only or
// they need to be made thread-safe. We can assume for smsh they
// are for all purposes read-only, since only the mama thread sets
// them in the scripts.
linked.sm_page_sz = ss_m::page_sz;
linked.sm_max_exts = ss_m::max_exts;
linked.sm_max_vols = ss_m::max_vols;
linked.sm_max_servers = ss_m::max_servers;
linked.sm_max_keycomp = ss_m::max_keycomp;
linked.sm_max_dir_cache = ss_m::max_dir_cache;
linked.sm_max_rec_len = ss_m::max_rec_len;
linked.sm_srvid_map_sz = ss_m::srvid_map_sz;
linked.verbose_flag = verbose?1:0;
linked.verbose2_flag = verbose2?1:0;
linked.instrument_flag = instrument?1:0;
linked.compress_flag = force_compress?1:0;
linked.log_warn_callback_flag = log_warn_callback?1:0;
{
int tty = isatty(0);
interactive = tty && f_arg;
}
// Create the main tcl_thread
{
tcl_thread_t* tcl_thread = NULL;
bool ok = true;
if(ok) {
if (f_arg) {
TCL_AV char* av[2];
av[0] = TCL_AV1 "source";
av[1] = f_arg;
// smsh -f <file>
tcl_thread = new tcl_thread_t(2, av,
smsh_libdir->value(),
smsh_smshrc->value()
);
} else {
// interactive
/*
cerr << __func__ << " " << __LINE__ << " " << __FILE__
<< " INTERACTIVE libdir " << smsh_libdir->value()
<< " msshrc " << smsh_smshrc->value()
<< endl;
*/
tcl_thread = new tcl_thread_t(0, 0,
smsh_libdir->value(),
smsh_smshrc->value()
);
}
assert(tcl_thread);
W_COERCE( tcl_thread->fork() );
W_COERCE( tcl_thread->join() );
delete tcl_thread;
}
}
// Shutdown TCL and have it deallocate resources still held!
Tcl_Finalize();
U.stop(1); // 1 iteration
if(print_stats)
{
cout << "Thread stats" <<endl;
sthread_t::dump_stats(cout);
cout << endl;
cout << "Unix stats for parent:" <<endl;
cout << U << endl << endl;
}
cout << flush;
done:
clean_up_shell();
fprintf(stderr, "%d tcl threads ran\n", num_tcl_threads_ttl);
return 0;
errordone:
clean_up_shell();
return 1;
}
