int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { // Initialize the ORB. CORBA::ORB_var orb = CORBA::ORB_init(argc, argv); // Create a MessengerServer object. MessengerServer * server = new MessengerServer (orb.in()); ACE_Auto_Ptr<MessengerServer> safe_ptr (server); // Parse arguments to determine how we should shutdown. if (server->parse_args (argc, argv) != 0) return 1; //Get reference to the RootPOA. CORBA::Object_var obj = orb->resolve_initial_references( "RootPOA" ); PortableServer::POA_var poa = PortableServer::POA::_narrow( obj.in() ); // Activate the POAManager. PortableServer::POAManager_var mgr = poa->the_POAManager(); mgr->activate(); // Create a servant. Messenger_i messenger_servant (orb.in()); // Register the servant with the RootPOA, obtain its object // reference, stringify it, and write it to a file. PortableServer::ObjectId_var oid = poa->activate_object( &messenger_servant ); CORBA::Object_var messenger_obj = poa->id_to_reference( oid.in() ); CORBA::String_var str = orb->object_to_string( messenger_obj.in() ); std::ofstream iorFile(ACE_TEXT_ALWAYS_CHAR (ior_output_file.c_str ())); iorFile << str.in() << std::endl; iorFile.close(); std::cout << "IOR written to file " << ACE_TEXT_ALWAYS_CHAR (ior_output_file.c_str ()) << std::endl; switch (s_method) { // shutdown on client invocation case MessengerServer::s_client_call: std::cout << "Will shutdown on client invocation." << std::endl; server->run (); break; // shutdown after some iterations through loop case MessengerServer::s_polling_loop: server->poll (loop_iterations); break; // schedule a timer to shutdown case MessengerServer::s_timer: server->schedule_shutdown_timer (timeout); server->run (); break; // shutdown on console input case MessengerServer::s_console_input: server->shutdown_on_console_input (); server->run (); break; // use CORBA::ORB::run() with time value case MessengerServer::s_run_time_value: server->run (timeout); break; } } catch(const CORBA::Exception& ex) { std::cerr << "CORBA exception: " << ex << std::endl; return 1; } return 0; }
pid_t ACE_OS::fork_exec (ACE_TCHAR *argv[]) { # if defined (ACE_WIN32) ACE_TCHAR *buf = 0; ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> safe_ptr (buf); if (ACE_OS::argv_to_string (argv, buf) != -1) { PROCESS_INFORMATION process_info; # if !defined (ACE_HAS_WINCE) ACE_TEXT_STARTUPINFO startup_info; ACE_OS::memset ((void *) &startup_info, 0, sizeof startup_info); startup_info.cb = sizeof startup_info; if (ACE_TEXT_CreateProcess (0, buf, 0, // No process attributes. 0, // No thread attributes. TRUE, // Allow handle inheritance. 0, // Don't create a new console window. 0, // No environment. 0, // No current directory. &startup_info, &process_info)) # else if (ACE_TEXT_CreateProcess (0, buf, 0, // No process attributes. 0, // No thread attributes. FALSE, // Can's inherit handles on CE 0, // Don't create a new console window. 0, // No environment. 0, // No current directory. 0, // Can't use startup info on CE &process_info)) # endif /* ! ACE_HAS_WINCE */ { // Free resources allocated in kernel. ACE_OS::close (process_info.hThread); ACE_OS::close (process_info.hProcess); // Return new process id. return process_info.dwProcessId; } } // CreateProcess failed. return -1; # else pid_t const result = ACE_OS::fork (); # if defined (ACE_USES_WCHAR) // Wide-char builds need to convert the command-line args to // narrow char strings for execv (). char **cargv = 0; int arg_count; # endif /* ACE_HAS_WCHAR */ switch (result) { case -1: // Error. return -1; case 0: // Child process. # if defined (ACE_USES_WCHAR) for (arg_count = 0; argv[arg_count] != 0; ++arg_count) ; ++arg_count; // Need a 0-pointer end-of-array marker ACE_NEW_NORETURN (cargv, char*[arg_count]); if (cargv == 0) ACE_OS::exit (errno); --arg_count; // Back to 0-indexed cargv[arg_count] = 0; while (--arg_count >= 0) cargv[arg_count] = ACE_Wide_To_Ascii::convert (argv[arg_count]); // Don't worry about freeing the cargv or the strings it points to. // Either the process will be replaced, or we'll exit. if (ACE_OS::execv (cargv[0], cargv) == -1) ACE_OS::exit (errno); # else if (ACE_OS::execv (argv[0], argv) == -1) { // The OS layer should not print stuff out // ACE_ERROR ((LM_ERROR, // "%p Exec failed\n")); // If the execv fails, this child needs to exit. ACE_OS::exit (errno); } # endif /* ACE_HAS_WCHAR */ default: // Server process. The fork succeeded. return result; } # endif /* ACE_WIN32 */ }