int
main (int argc, char *argv[])
{
ACE_Service_Config loggerd;
Event_Handler handler;
ACE_Sig_Adapter shutdown_handler ((ACE_Sig_Handler_Ex) ACE_Reactor::end_event_loop);
if (ACE_Event_Handler::register_stdin_handler (&handler,
ACE_Reactor::instance (),
ACE_Thread_Manager::instance ()) == -1)
ACE_ERROR ((LM_ERROR,
"%p\n",
"register_stdin_handler"));
if (loggerd.open (argc,
argv,
ACE_DEFAULT_LOGGER_KEY,
// Don't ignore static services!
0) == -1 && errno != ENOENT)
ACE_ERROR ((LM_ERROR,
"%p\n%a",
"open",
1));
else if (ACE_Reactor::instance ()->register_handler
(SIGINT, &shutdown_handler) == -1)
ACE_ERROR ((LM_ERROR,
"%p\n%a",
"register_handler",
1));
// Perform logging service until we receive SIGINT.
ACE_Reactor::run_event_loop ();
return 0;
}
void test_shutdown_handler() {
shutdown_handler(SIGALRM);
mu_assert(shutdown_requested == 0, "test_shutdown_handler: shutdown_requested should be 0 after unhandled signals");
shutdown_handler(SIGHUP);
mu_assert(shutdown_requested == 1, "test_shutdown_handler: shutdown_requested should be 1 after SIGHUP");
shutdown_requested = 0;
shutdown_handler(SIGTERM);
mu_assert(shutdown_requested == 1, "test_shutdown_handler: shutdown_requested should be 1 after SIGTERM");
shutdown_requested = 0;
shutdown_handler(SIGINT);
mu_assert(shutdown_requested == 1, "test_shutdown_handler: shutdown_requested should be 1 after SIGINT");
shutdown_requested = 0;
}
void
ipmi_emu_shutdown(emu_data_t *emu)
{
misc_data_t *data = ipmi_emu_get_user_data(emu);
console_info_t *con;
if (data->sys->console_fd != -1)
close(data->sys->console_fd);
con = data->consoles;
while (con) {
data->os_hnd->remove_fd_to_wait_for(data->os_hnd, con->conid);
close(con->outfd);
con = con->next;
}
if (!nostdio)
tcsetattr(0, TCSADRAIN, &old_termios);
fcntl(0, F_SETFL, old_flags);
tcdrain(0);
shutdown_handler(0);
exit(0);
}
void* eventloop(void* socket) {
Msg msg;
while (1) {
msg_recv(socket, &msg);
switch (msg.header.msg_type) {
case msg_execute_request:
execute_handler(socket, &msg);
break;
case msg_complete_request:
complete_handler(socket, &msg);
break;
case msg_kernel_info_request:
kernel_info_handler(socket, &msg);
break;
case msg_connect_request:
connect_handler(socket, &msg);
break;
case msg_shutdown_request:
shutdown_handler(socket, &msg);
break;
case msg_object_info_request:
object_info_handler(socket, &msg);
break;
case msg_history_request:
history_handler(socket, &msg);
break;
default:
fprintf(stderr, "error: unsupported message type: %s", dump_msg_type(msg.header.msg_type));
exit(1);
}
}
pthread_exit(NULL);
return NULL;
}
/* Need to make this a function main called from a GO main wrapper */
int
ipmi_sim_main(int argc, const char *argv[])
{
sys_data_t sysinfo;
misc_data_t data;
int err, rv = 1;
int i;
poptContext poptCtx;
struct timeval tv;
console_info_t stdio_console;
struct sigaction act;
os_hnd_fd_id_t *conid;
lmc_data_t *mc;
int print_version = 0;
poptCtx = poptGetContext(argv[0], argc, argv, poptOpts, 0);
while ((i = poptGetNextOpt(poptCtx)) >= 0) {
switch (i) {
case 'd':
debug++;
break;
case 'n':
nostdio = 1;
break;
case 'v':
print_version = 1;
break;
}
}
poptFreeContext(poptCtx);
printf("IPMI Simulator version %s\n", PVERSION);
data.os_hnd = ipmi_posix_setup_os_handler();
if (!data.os_hnd) {
fprintf(stderr, "Unable to allocate OS handler\n");
exit(1);
}
err = os_handler_alloc_waiter_factory(data.os_hnd, 0, 0,
&data.waiter_factory);
if (err) {
fprintf(stderr, "Unable to allocate waiter factory: 0x%x\n", err);
exit(1);
}
err = data.os_hnd->alloc_timer(data.os_hnd, &data.timer);
if (err) {
fprintf(stderr, "Unable to allocate timer: 0x%x\n", err);
exit(1);
}
sysinfo_init(&sysinfo);
sysinfo.info = &data;
sysinfo.alloc = balloc;
sysinfo.free = bfree;
sysinfo.get_monotonic_time = ipmi_get_monotonic_time;
sysinfo.get_real_time = ipmi_get_real_time;
sysinfo.alloc_timer = ipmi_alloc_timer;
sysinfo.start_timer = ipmi_start_timer;
sysinfo.stop_timer = ipmi_stop_timer;
sysinfo.free_timer = ipmi_free_timer;
sysinfo.add_io_hnd = ipmi_add_io_hnd;
sysinfo.io_set_hnds = ipmi_io_set_hnds;
sysinfo.io_set_enables = ipmi_io_set_enables;
sysinfo.remove_io_hnd = ipmi_remove_io_hnd;
sysinfo.gen_rand = sys_gen_rand;
sysinfo.debug = debug;
sysinfo.log = sim_log;
sysinfo.csmi_send = smi_send;
sysinfo.clog = sim_chan_log;
sysinfo.calloc = ialloc;
sysinfo.cfree = ifree;
sysinfo.lan_channel_init = lan_channel_init;
sysinfo.ser_channel_init = ser_channel_init;
data.sys = &sysinfo;
err = pipe(sigpipeh);
if (err) {
perror("Creating signal handling pipe");
exit(1);
}
act.sa_handler = handle_sigchld;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
err = sigaction(SIGCHLD, &act, NULL);
if (err) {
perror("setting up sigchld sigaction");
exit(1);
}
err = data.os_hnd->add_fd_to_wait_for(data.os_hnd, sigpipeh[0],
sigchld_ready, &data,
NULL, &conid);
if (err) {
fprintf(stderr, "Unable to sigchld pipe wait: 0x%x\n", err);
exit(1);
}
data.emu = ipmi_emu_alloc(&data, sleeper, &sysinfo);
/* Set this up for console I/O, even if we don't use it. */
stdio_console.data = &data;
stdio_console.outfd = 1;
stdio_console.pos = 0;
stdio_console.echo = 1;
stdio_console.shutdown_on_close = 1;
stdio_console.telnet = 0;
stdio_console.tn_pos = 0;
if (nostdio) {
stdio_console.out.printf = dummy_printf;
stdio_console.out.data = &stdio_console;
} else {
stdio_console.out.printf = emu_printf;
stdio_console.out.data = &stdio_console;
}
stdio_console.next = NULL;
stdio_console.prev = NULL;
data.consoles = &stdio_console;
err = ipmi_mc_alloc_unconfigured(&sysinfo, 0x20, &mc);
if (err) {
if (err == ENOMEM)
fprintf(stderr, "Out of memory allocation BMC MC\n");
exit(1);
}
sysinfo.mc = mc;
sysinfo.chan_set = ipmi_mc_get_channelset(mc);
sysinfo.startcmd = ipmi_mc_get_startcmdinfo(mc);
sysinfo.cpef = ipmi_mc_get_pef(mc);
sysinfo.cusers = ipmi_mc_get_users(mc);
sysinfo.sol = ipmi_mc_get_sol(mc);
if (read_config(&sysinfo, config_file, print_version))
exit(1);
if (print_version)
exit(0);
if (!sysinfo.name) {
fprintf(stderr, "name not set in config file\n");
exit(1);
}
err = persist_init("ipmi_sim", sysinfo.name, statedir);
if (err) {
fprintf(stderr, "Unable to initialize persistence: %s\n",
strerror(err));
exit(1);
}
read_persist_users(&sysinfo);
err = sol_init(&sysinfo);
if (err) {
fprintf(stderr, "Unable to initialize SOL: %s\n",
strerror(err));
goto out;
}
err = read_sol_config(&sysinfo);
if (err) {
fprintf(stderr, "Unable to read SOL configs: %s\n",
strerror(err));
goto out;
}
err = load_dynamic_libs(&sysinfo, 0);
if (err)
goto out;
if (!command_file) {
FILE *tf;
command_file = malloc(strlen(BASE_CONF_STR) + 6 + strlen(sysinfo.name));
if (!command_file) {
fprintf(stderr, "Out of memory\n");
goto out;
}
strcpy(command_file, BASE_CONF_STR);
strcat(command_file, "/");
strcat(command_file, sysinfo.name);
strcat(command_file, ".emu");
tf = fopen(command_file, "r");
if (!tf) {
free(command_file);
command_file = NULL;
} else {
fclose(tf);
}
}
if (command_file)
read_command_file(&stdio_console.out, data.emu, command_file);
if (command_string)
ipmi_emu_cmd(&stdio_console.out, data.emu, command_string);
if (!sysinfo.bmc_ipmb || !sysinfo.ipmb_addrs[sysinfo.bmc_ipmb]) {
sysinfo.log(&sysinfo, SETUP_ERROR, NULL,
"No bmc_ipmb specified or configured.");
goto out;
}
sysinfo.console_fd = -1;
if (sysinfo.console_addr_len) {
int nfd;
int val;
nfd = socket(sysinfo.console_addr.s_ipsock.s_addr.sa_family,
SOCK_STREAM, IPPROTO_TCP);
if (nfd == -1) {
perror("Console socket open");
goto out;
}
err = bind(nfd, (struct sockaddr *) &sysinfo.console_addr,
sysinfo.console_addr_len);
if (err) {
perror("bind to console socket");
goto out;
}
err = listen(nfd, 1);
if (err == -1) {
perror("listen to console socket");
goto out;
}
val = 1;
err = setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR,
(char *)&val, sizeof(val));
if (err) {
perror("console setsockopt reuseaddr");
goto out;
}
sysinfo.console_fd = nfd;
err = data.os_hnd->add_fd_to_wait_for(data.os_hnd, nfd,
console_bind_ready, &data,
NULL, &conid);
if (err) {
fprintf(stderr, "Unable to add console wait: 0x%x\n", err);
goto out;
}
}
if (!nostdio) {
init_term();
err = write(1, "> ", 2);
err = data.os_hnd->add_fd_to_wait_for(data.os_hnd, 0,
user_data_ready, &stdio_console,
NULL, &stdio_console.conid);
if (err) {
fprintf(stderr, "Unable to add input wait: 0x%x\n", err);
goto out;
}
}
post_init_dynamic_libs(&sysinfo);
act.sa_handler = shutdown_handler;
act.sa_flags = SA_RESETHAND;
for (i = 0; shutdown_sigs[i]; i++) {
err = sigaction(shutdown_sigs[i], &act, NULL);
if (err) {
fprintf(stderr, "Unable to register shutdown signal %d: %s\n",
shutdown_sigs[i], strerror(errno));
}
}
tv.tv_sec = 1;
tv.tv_usec = 0;
err = data.os_hnd->start_timer(data.os_hnd, data.timer, &tv, tick, &data);
if (err) {
fprintf(stderr, "Unable to start timer: 0x%x\n", err);
goto out;
}
data.os_hnd->operation_loop(data.os_hnd);
rv = 0;
out:
shutdown_handler(0);
exit(rv);
}
int main(int argc, char* argv[])
{
int pid;
Msg myMsg;
int sender_pid;
initialize();
if (Register(FILE_SERVER)) {
perror("Register server process error!");
}
if (argc>1) {
pid = Fork();
if (pid==0) {
Exec(argv[1],argv+1);
}
}
while (1) {
if ((sender_pid=Receive(&myMsg))==ERROR) {
// perror("error receiving message!");
continue;
}
switch (myMsg.type) {
case OPEN:
open_handler(&myMsg,sender_pid);break;
/*
case CLOSE:
close_handler(&myMsg,sender_pid);break;
*/
case CREATE:
create_handler(&myMsg,sender_pid);break;
case READ:
read_handler(&myMsg,sender_pid);break;
case WRITE:
write_handler(&myMsg,sender_pid);break;
/*
case SEEK:
seek_handler(&myMsg,sender_pid);break;
*/
case LINK:
link_handler(&myMsg,sender_pid);break;
case UNLINK:
unlink_handler(&myMsg,sender_pid);break;
case SYMLINK:
symlink_handler(&myMsg,sender_pid);break;
case READLINK:
readlink_handler(&myMsg,sender_pid);break;
case MKDIR:
mkdir_handler(&myMsg,sender_pid);break;
case RMDIR:
rmdir_handler(&myMsg,sender_pid);break;
case CHDIR:
chdir_handler(&myMsg,sender_pid);break;
case STAT:
stat_handler(&myMsg,sender_pid);break;
case SYNC:
sync_handler(&myMsg);break;
case SHUTDOWN:
shutdown_handler(&myMsg,sender_pid);break;
default:
perror("message type error!");
break;
}
if (Reply(&myMsg,sender_pid)==ERROR) fprintf(stderr, "Error replying to pid %d\n",sender_pid);
}
terminate();
return 0;
}
int
main (int argc, char *argv[])
{
try
{
orb = CORBA::ORB_init (argc, argv, "");
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
poa_manager->activate();
Hello *hello_impl;
ACE_NEW_RETURN (hello_impl,
Hello (shutdown_handler),
1);
PortableServer::ServantBase_var owner_transfer(hello_impl);
Test::Hello_var hello =
hello_impl->_this ();
ACE_DEBUG ((LM_DEBUG, "getting proxy reference\n"));
CORBA::Object_var obj =
orb->string_to_object (lorica_ior);
#if 0
Security::QOP qop = Security::SecQOPNoProtection;
CORBA::Any no_protection;
no_protection <<= qop;
// Create the Security::QOPPolicy.
CORBA::Policy_var policy =
orb->create_policy (Security::SecQOPPolicy,
no_protection);
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] = CORBA::Policy::_duplicate (policy.in ());
// Create an object reference that uses plain IIOP (i.e. no
// protection).
obj =
obj->_set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
#endif
ACE_DEBUG ((LM_DEBUG, "narrowing proxy reference\n"));
mapper = Lorica::ReferenceMapper::_narrow(obj.in());
if (CORBA::is_nil(mapper.in()))
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot get reference to Lorica "
"reference mapper\n"),1);
#if 1
obj = register_with_proxy (hello.in());
#else
obj = mapper->as_server (hello.in(),"Hello",
Lorica::ServerAgent::_nil());
#endif
ACE_DEBUG ((LM_DEBUG,"register_with_proxy() returned\n"));
if (CORBA::is_nil (obj.in()))
ACE_ERROR_RETURN ((LM_ERROR,
"Lorica reference mapper returned a nil "
"mapped reference.\n"),1);
mapped_hello = Test::Hello::_narrow(obj.in());
if (CORBA::is_nil(mapped_hello.in()))
ACE_ERROR_RETURN ((LM_ERROR,
"Lorica reference mapper returned an "
"incorrectly typed reference\n"),1);
CORBA::String_var orig_ior =
orb->object_to_string (hello.in ());
CORBA::String_var mapped_ior =
orb->object_to_string (mapped_hello.in());
if (ACE_OS::strcmp (orig_ior.in(), mapped_ior.in()) == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Lorica reference mapper returned "
"the original reference unmapped.\n"),1);
ACE_DEBUG ((LM_DEBUG,"writing original IOR to file %s\n",orig_file));
ACE_DEBUG ((LM_DEBUG,"writing mapped IOR to file %s\n",mapped_file));
ACE_DEBUG ((LM_DEBUG,"Size of orig IOR = %d, size of mapped = %d\n",
ACE_OS::strlen(orig_ior.in()),
ACE_OS::strlen(mapped_ior.in())));
FILE *output_file= ACE_OS::fopen (mapped_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s\n",
mapped_file),
1);
ACE_OS::fprintf (output_file, "%s", mapped_ior.in());
ACE_OS::fclose (output_file);
output_file= ACE_OS::fopen (orig_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s\n",
orig_file),
1);
ACE_OS::fprintf (output_file, "%s", orig_ior.in());
ACE_OS::fclose (output_file);
if (linger)
orb->run();
else
shutdown_handler();
// No need to run the ORB the test only requires modifying an IOR
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
