MonolithicDeploymentDescription MDD_Handler::mono_deployment_description( const Deployment::MonolithicDeploymentDescription &src) { DANCE_TRACE("mono_deployment_description - reverse"); //Get the name and instantiate the mdd XMLSchema::string < ACE_TCHAR > name ( ACE_TEXT_CHAR_TO_TCHAR (src.name)); MonolithicDeploymentDescription mdd (name); //Get the source(s) from the IDL and store them size_t total = src.source.length(); for(size_t i = 0; i < total; i++) { XMLSchema::string< ACE_TCHAR > curr ( ACE_TEXT_CHAR_TO_TCHAR(src.source[i])); //mdd.add_source(curr); } //Get the artifactRef(s) from the IDL and store them total = src.artifactRef.length(); for(size_t j = 0; j < total; j++) { ACE_TString tmp; ADD_Handler::IDREF.find_ref(src.artifactRef[j], tmp); IdRef idref; idref.idref (tmp.c_str ()); //mdd.add_artifact (idref); } //Get the execParameter(s) from the IDL and store them total = src.execParameter.length(); for(size_t k = 0; k < total; k++) { //mdd.add_execParameter (Property_Handler:: //get_property (src.execParameter[k])); } //Get the deployRequirement(s) from the IDL and store them total = src.deployRequirement.length(); for(size_t l = 0; l < total; l++) { //mdd.add_deployRequirement(Req_Handler:: //get_requirement (src.deployRequirement[l])); } // Generate a UUID to use for the IDREF. ACE_Utils::UUID uuid; ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid); ACE_TString mdd_id (ACE_TEXT ("_")); mdd_id += ACE_TEXT_CHAR_TO_TCHAR (uuid.to_string ()->c_str ()); XMLSchema::ID< ACE_TCHAR > xml_id (mdd_id.c_str ()); // Bind the ref and set it in the IDD MDD_Handler::IDREF.bind_next_available (mdd_id); mdd.id (xml_id); return mdd; }
void ImR_Activator_i::start_server(const char* name, const char* cmdline, const char* dir, const ImplementationRepository::EnvironmentList & env) { bool unique = false; if (ACE_OS::strlen (name) > unique_prefix_len && ACE_OS::strncmp (name, unique_prefix, unique_prefix_len) == 0) { unique = true; name += unique_prefix_len; } // if (debug_ > 1) ORBSVCS_DEBUG((LM_DEBUG, "ImR Activator: Starting %C <%C>...\n", (unique ? "unique server" : "server"), name)); pid_t pid; if (unique && this->still_running_i (name, pid)) { // if (debug_ > 1) ORBSVCS_DEBUG((LM_DEBUG, "ImR Activator: Unique instance already running %d\n", static_cast<int> (pid))); char reason[32]; ACE_OS::snprintf (reason,32,"pid:%d",static_cast<int> (pid)); throw ImplementationRepository::CannotActivate( CORBA::string_dup (reason)); } ACE_TString cmdline_tstr(ACE_TEXT_CHAR_TO_TCHAR(cmdline)); size_t cmdline_buf_len = cmdline_tstr.length(); if (debug_ > 1) ORBSVCS_DEBUG((LM_DEBUG, "\tcommand line : len=%d <%s>\n\tdirectory : <%C>\n", cmdline_buf_len, cmdline_tstr.c_str(), dir) ); ACE_Process_Options proc_opts ( 1, cmdline_buf_len + 1, this->env_buf_len_, this->max_env_vars_); proc_opts.command_line (ACE_TEXT_CHAR_TO_TCHAR(cmdline)); proc_opts.working_directory (dir); // Win32 does not support the CLOSE_ON_EXEC semantics for sockets // the way unix does, so in order to avoid having the child process // hold the listen socket open, we force the child to inherit no // handles. This includes stdin, stdout, logs, etc. proc_opts.handle_inheritance (0); // We always enable the unicode environmet buffer on Windows. This works // around a 32kb environment buffer limitation. This must come before any of // the setenv() calls, since the first of those will copy the current // process's environment. proc_opts.enable_unicode_environment (); // Guard against possible signal reflection which can happen on very heavily // loaded systems. Detaching the child process avoids that possibility but at // the cost of required explicit child termination prior to activator shutdown if (this->detach_child_) { proc_opts.setgroup (0); } proc_opts.setenv (ACE_TEXT ("TAO_USE_IMR"), ACE_TEXT ("1")); if (!CORBA::is_nil (this->locator_.in ())) { CORBA::String_var ior = orb_->object_to_string (locator_.in ()); proc_opts.setenv (ACE_TEXT ("ImplRepoServiceIOR"), ACE_TEXT_CHAR_TO_TCHAR (ior.in ())); } for (CORBA::ULong i = 0; i < env.length (); ++i) { proc_opts.setenv (ACE_TEXT_CHAR_TO_TCHAR (env[i].name.in ()), ACE_TEXT_CHAR_TO_TCHAR (env[i].value.in ())); } pid = this->process_mgr_.spawn (proc_opts, this); if (pid == ACE_INVALID_PID) { ORBSVCS_ERROR ((LM_ERROR, "ImR Activator: Cannot start server <%C> using <%C>\n", name, cmdline)); throw ImplementationRepository::CannotActivate( CORBA::string_dup ( "Process Creation Failed")); } else { if (debug_ > 1) { ORBSVCS_DEBUG((LM_DEBUG, "ImR Activator: register death handler for process %d\n", static_cast<int> (pid))); } this->process_map_.rebind (pid, name); if (unique) { this->running_server_list_.insert (name); } if (!CORBA::is_nil (this->locator_.in ())) { if (this->notify_imr_) { if (debug_ > 1) { ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) ImR Activator: Notifying ImR that ") ACE_TEXT ("<%C> has started.\n"), name)); } this->locator_->spawn_pid (name, pid); } } } if (debug_ > 0) { ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) ImR Activator: Successfully started <%C>, pid=%d\n"), name, static_cast<int> (pid))); } }
int Activator_Options::load_registry_options () { #if defined (ACE_WIN32) HKEY key = 0; // Create or open the parameters key LONG err = ACE_TEXT_RegOpenKeyEx (SERVICE_REG_ROOT, SERVICE_REG_PATH, 0, KEY_READ, &key ); if (err != ERROR_SUCCESS) { // If there aren't any saved parameters, then that's ok. return 0; } char tmpstr[4096]; DWORD sz = sizeof (tmpstr); DWORD type = 0; err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("ORBInitOptions"), 0, &type, (LPBYTE) tmpstr, &sz); if (err == ERROR_SUCCESS) { ACE_ASSERT (type == REG_SZ); tmpstr[sz - 1] = '\0'; this->cmdline_ = tmpstr; } sz = sizeof(tmpstr); err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("IORFile"), 0, &type, (LPBYTE) tmpstr, &sz); if (err == ERROR_SUCCESS) { ACE_ASSERT (type == REG_SZ); tmpstr[sz - 1] = '\0'; this->ior_output_file_ = ACE_TEXT_CHAR_TO_TCHAR(tmpstr); } sz = sizeof(debug_); err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("DebugLevel"), 0, &type, (LPBYTE) &this->debug_ , &sz); if (err == ERROR_SUCCESS) { ACE_ASSERT (type == REG_DWORD); } sz = sizeof(tmpstr); err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("Name"), 0, &type, (LPBYTE) tmpstr, &sz); if (err == ERROR_SUCCESS) { ACE_ASSERT (type == REG_SZ); tmpstr[sz - 1] = '\0'; this->name_ = tmpstr; } DWORD tmpint = 0; sz = sizeof(tmpint); err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("NotifyImR"), 0, &type, (LPBYTE) &tmpint , &sz); if (err == ERROR_SUCCESS) { ACE_ASSERT (type == REG_DWORD); } this->notify_imr_ = tmpint != 0; err = ACE_TEXT_RegQueryValueEx(key, ACE_TEXT("EnvBufLen"), 0, &type, (LPBYTE) &tmpint , &sz); if (err == ERROR_SUCCESS) { ACE_ASSERT(type == REG_DWORD); } this->env_buf_len_ = tmpint; err = ACE_TEXT_RegQueryValueEx(key, ACE_TEXT("MaxEnvArgs"), 0, &type, (LPBYTE) &tmpint , &sz); if (err == ERROR_SUCCESS) { ACE_ASSERT(type == REG_DWORD); } this->max_env_vars_ = tmpint; err = ::RegCloseKey (key); ACE_ASSERT(err == ERROR_SUCCESS); #endif /* ACE_WIN32 */ return 0; }
// Print a usage message and exit. void DRV_usage (void) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%s: usage: %s [flag | file]*\n"), ACE_TEXT_CHAR_TO_TCHAR (idl_global->prog_name ()), ACE_TEXT_CHAR_TO_TCHAR (idl_global->prog_name ()))); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Legal flags:\n"))); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -A...\t\t\tlocal implementation-specific escape\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -Cw\t\t\tWarning if identifier spellings differ ") ACE_TEXT ("only in case (default is error)\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -Ce\t\t\tError if identifier spellings differ ") ACE_TEXT ("only in case (default)\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -ae\t\t\tError if anonymous type is seen ") ACE_TEXT ("(default)\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -aw\t\t\tWarning if anonymous type is seen ") ACE_TEXT ("(default is error)\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -as\t\t\tSilences the anonymous type diagnostic ") ACE_TEXT ("(default is error)\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -d\t\t\tOutputs (to stdout) a dump of the AST\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -Dname[=value]\t\tdefines name for preprocessor\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -E\t\t\truns preprocessor only, prints on stdout\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -Idir\t\t\tincludes dir in search path for preprocessor\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -t\t\t\tTemporary directory to be used") ACE_TEXT (" by the IDL compiler.\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -u\t\t\tprints usage message and exits\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -Uname\t\t\tundefines name for preprocessor\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -v\t\t\ttraces compilation stages\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -V\t\t\tprints version info then exits\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -w\t\t\tsuppresses IDL compiler warning messages\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -Wp,<arg1,...,argn>\tpasses args to preprocessor\n") )); ACE_DEBUG (( LM_DEBUG, ACE_TEXT (" -Yp,path\t\tdefines location of preprocessor\n") )); be_util::usage (); }
int HTTP_Handler::svc (void) { static char buf[BUFSIZ]; int count = 0; ACE_DEBUG ((LM_DEBUG, "[%t] sending request --\n%s", this->request_)); this->peer ().send_n (this->request_, this->request_size_); // Read in characters until encounter \r\n\r\n int done = 0; char *contentlength; do { while (((count += this->peer ().recv_n (buf + count, 1)) > 0) && ((u_int) count < sizeof (buf))) { buf[count] = '\0'; if (count < 2) continue; done = ACE_OS::strcmp (buf + count - 4, "\n\n") == 0; if (done) break; if (count < 4) continue; done = ACE_OS::strcmp (buf + count - 4, "\r\n\r\n") == 0; if (done) break; } if (!done) { char *last = ACE_OS::strrchr (buf, '\n'); last[0] = '\0'; if ((contentlength = ACE_OS::strstr (buf, "\nContent-length:")) || (contentlength = ACE_OS::strstr (buf, "\nContent-Length:"))) done = 1; else { last[0] = '\n'; count = ACE_OS::strlen (last); ACE_OS::memmove (buf, last, count + 1); } } else { contentlength = ACE_OS::strstr (buf, "\nContent-length:"); if (!contentlength) contentlength = ACE_OS::strstr (buf, "\nContent-Length:"); } } while (!done); // ASSERT (contentlength != 0) int size = 0; if (contentlength && (::sscanf (contentlength, "\nContent-%*[lL]ength: %d ", &size) == 1)) { this->response_size_ = size; ACE_Filecache_Handle afh (ACE_TEXT_CHAR_TO_TCHAR (this->filename_), this->response_size_); this->peer ().recv_n (afh.address (), this->response_size_); ACE_DEBUG ((LM_DEBUG, " ``%s'' is now cached.\n", this->filename_)); } else { // Maybe we should do something more clever here, such as extend // ACE_Filecache_Handle to allow the creation of cache objects // whose size is unknown? // Another possibility is to write the contents out to a file, // and then cache it. // Perhaps make ACE_Filecache_Handle more savvy, and allow a // constructor which accepts a PEER as a parameter. ACE_DEBUG ((LM_DEBUG, "HTTP_Handler, no content-length header!\n")); } return 0; }
int ACE_SOCK_Dgram_Mcast::unsubscribe_ifs (const ACE_INET_Addr &mcast_addr, const ACE_TCHAR *net_if) { ACE_TRACE ("ACE_SOCK_Dgram_Mcast::unsubscribe_ifs"); if (ACE_BIT_ENABLED (this->opts_, OPT_NULLIFACE_ALL) && net_if == 0) { #if defined (__linux__) && defined (ACE_HAS_IPV6) if (mcast_addr.get_type () == AF_INET6) { struct if_nameindex *intf; intf = ACE_OS::if_nameindex (); if (intf == 0) return -1; size_t nr_unsubscribed = 0; int index = 0; while (intf[index].if_index != 0 || intf[index].if_name != 0) { if (this->leave (mcast_addr, ACE_TEXT_CHAR_TO_TCHAR(intf[index].if_name)) == 0) ++nr_unsubscribed; ++index; } ACE_OS::if_freenameindex (intf); if (nr_unsubscribed == 0) { errno = ENODEV; return -1; } return 1; } else { // Unsubscribe on all local multicast-capable network interfaces, by // doing recursive calls with specific interfaces. ACE_INET_Addr *if_addrs = 0; size_t if_cnt; // NOTE - <get_ip_interfaces> doesn't always get all of the // interfaces. In particular, it may not get a PPP interface. This // is a limitation of the way <get_ip_interfaces> works with // old versions of MSVC. The reliable way of getting the interface // list is available only with MSVC 5 and newer. if (ACE::get_ip_interfaces (if_cnt, if_addrs) != 0) return -1; size_t nr_unsubscribed = 0; if (if_cnt < 2) { if (this->leave (mcast_addr, ACE_LIB_TEXT ("0.0.0.0")) == 0) ++nr_unsubscribed; } else { while (if_cnt > 0) { --if_cnt; // Convert to 0-based for indexing, next loop check if (if_addrs[if_cnt].get_ip_address () == INADDR_LOOPBACK) continue; if (this->leave (mcast_addr, ACE_TEXT_CHAR_TO_TCHAR (if_addrs[if_cnt].get_host_addr ())) == 0) ++nr_unsubscribed; } } delete [] if_addrs; if (nr_unsubscribed == 0) { errno = ENODEV; return -1; } return 1; } #else // Unsubscribe on all local multicast-capable network interfaces, by // doing recursive calls with specific interfaces. ACE_INET_Addr *if_addrs = 0; size_t if_cnt; // NOTE - <get_ip_interfaces> doesn't always get all of the // interfaces. In particular, it may not get a PPP interface. This // is a limitation of the way <get_ip_interfaces> works with // old versions of MSVC. The reliable way of getting the interface list // is available only with MSVC 5 and newer. if (ACE::get_ip_interfaces (if_cnt, if_addrs) != 0) return -1; size_t nr_unsubscribed = 0; if (if_cnt < 2) { if (this->leave (mcast_addr, ACE_LIB_TEXT ("0.0.0.0")) == 0) ++nr_unsubscribed; } else { while (if_cnt > 0) { --if_cnt; // Convert to 0-based for indexing, next loop check if (if_addrs[if_cnt].get_ip_address () == INADDR_LOOPBACK) continue; if (this->leave (mcast_addr, ACE_TEXT_CHAR_TO_TCHAR (if_addrs[if_cnt].get_host_addr ())) == 0) ++nr_unsubscribed; } } delete [] if_addrs; if (nr_unsubscribed == 0) { errno = ENODEV; return -1; } return 1; #endif /* __linux__ && ACE_HAS_IPV6 */ } return 0; }
int run_main (int argc, ACE_TCHAR *argv[]) { #if defined (ACE_LACKS_FORK) ACE_UNUSED_ARG (argc); ACE_UNUSED_ARG (argv); ACE_START_TEST (ACE_TEXT ("Process_Mutex_Test")); ACE_ERROR ((LM_INFO, ACE_TEXT ("fork is not supported on this platform\n"))); ACE_END_TEST; #else /* ! ACE_LACKS_FORK */ parse_args (argc, argv); // Child process code. if (child_process) { ACE_APPEND_LOG ("Process_Mutex_Test-children"); acquire_release (); ACE_END_LOG; } else { ACE_START_TEST (ACE_TEXT ("Process_Mutex_Test")); ACE_INIT_LOG ("Process_Mutex_Test-children"); ACE_Process_Options options; if (release_mutex == 0) options.command_line (ACE_TEXT (".") ACE_DIRECTORY_SEPARATOR_STR ACE_TEXT ("Process_Mutex_Test") ACE_PLATFORM_EXE_SUFFIX ACE_TEXT (" -c -n %s -d"), ACE_TEXT_CHAR_TO_TCHAR (mutex_name)); else options.command_line (ACE_TEXT (".") ACE_DIRECTORY_SEPARATOR_STR ACE_TEXT ("Process_Mutex_Test") ACE_PLATFORM_EXE_SUFFIX ACE_TEXT (" -c -n %s"), ACE_TEXT_CHAR_TO_TCHAR (mutex_name)); // Spawn <n_processes> child processes that will contend for the // lock. ACE_Process children[n_processes]; size_t i; for (i = 0; i < n_processes; i++) { // Spawn the child process. int result = children[i].spawn (options); ACE_ASSERT (result != -1); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Parent spawned child process with pid = %d.\n"), children[i].getpid ())); // Give the newly spawned child process a chance to start... // David Levine thinks this sleep() is required because // calling ::waitpid () before a fork'ed child has actually // been created may be a problem on some platforms. It's // not enough for fork() to have returned to the parent. ACE_OS::sleep (1); } for (i = 0; i < n_processes; i++) { ACE_exitcode child_status; // Wait for the child processes we created to exit. ACE_ASSERT (children[i].wait (&child_status) != -1); if (child_status == 0) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Child %d finished ok\n"), children[i].getpid ())); else ACE_ERROR ((LM_ERROR, ACE_TEXT ("Child %d finished with status %d\n"), children[i].getpid (), child_status)); } ACE_END_TEST; } #endif /* ! ACE_LACKS_FORK */ return 0; }
int run_main (int argc, ACE_TCHAR *argv[]) { ACE_UNUSED_ARG (argc); ACE_UNUSED_ARG (argv); ACE_START_TEST (ACE_TEXT ("Multihomed_INET_Addr_Test_IPV6")); int status = 0; // Innocent until proven guilty #if defined (ACE_HAS_IPV6) // loop variables size_t i, j; sockaddr_in6 *pointer6; const ACE_TCHAR *primary_ipv6 = ACE_TEXT("3ffe::123:4567:89ab:cdef"); const ACE_TCHAR *secondary_ipv6[] = { ACE_IPV6_LOCALHOST, ACE_TEXT("fe80::0123:4567:89ab:cdef"), ACE_TEXT("fec0::0123:4567:89ab:cdef"), ACE_TEXT("3ffe::1:0123:4567:89ab:cdef"), ACE_TEXT("2002:3e02:5473::") }; // The port will always be this u_short port = 80; // ... and as you can see, there are 5 of them const size_t num_secondaries = 5; // Test subject ACE_Multihomed_INET_Addr addr; // Array of INET_Addrs that will repeatedly be passed into the // get_secondary_addresses accessor of Multihomed_INET_Addr ACE_INET_Addr in_out[5]; // Array of INET_Addrs against which the above array will be tested. ACE_INET_Addr stay_out[5]; // Array of sockaddrs that will repeatedly be passed into the // get_addresses accessor of Multihomed_INET_Addr const size_t num_sockaddrs = 6; sockaddr_in6 in_out_sockaddr6[num_sockaddrs]; for (i = 0; i <= num_secondaries; ++i) { /**** Test set (u_short, const char[], int, int, const char *([]), size_t) ****/ addr.set(port, primary_ipv6, 1, AF_INET6, secondary_ipv6, i); // Check the port number if (addr.get_port_number() != port) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed second get_port_number check\n") ACE_TEXT ("%d != %d\n"), addr.get_port_number(), port)); status = 1; } // Check the primary address if (0 != ACE_OS::strcmp (ACE_TEXT_CHAR_TO_TCHAR(addr.get_host_addr()), primary_ipv6)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%s failed get_host_addr() check\n") ACE_TEXT ("%s != %s\n"), primary_ipv6, addr.get_host_addr (), primary_ipv6)); status = 1; } // Check that the test subject reports the correct number of // secondary addresses. size_t returned_num_secondaries = addr.get_num_secondary_addresses(); if (returned_num_secondaries == i) { // Initialize the stay_out array with the secondary addresses for (j = 0; j < i; ++j) { stay_out[j].set(port, secondary_ipv6[j]); } // Pass the in_out array to the accessor addr.get_secondary_addresses(in_out, i); // Check that the in_out array matches stay_out array for (j = 0; j < i; ++j) { if (in_out[j] != stay_out[j]) { ACE_TCHAR in_out_string[100]; ACE_TCHAR stay_out_string[100]; in_out[j].addr_to_string(in_out_string, 100); stay_out[j].addr_to_string(stay_out_string, 100); ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed get_secondary_addresses check\n") ACE_TEXT ("%s != %s\n"), in_out_string, stay_out_string)); status = 1; } } // Pass the in_out_sockaddr array to the accessor addr.get_addresses(in_out_sockaddr6, i + 1); // Check that the primary address in the in_out_sockaddr array // matches the primary address reported by the superclass if (ACE_OS::memcmp(in_out_sockaddr6, addr.get_addr(), sizeof(sockaddr_in6))) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed second get_addresses check ") ACE_TEXT ("(for primary address)\n"))); status = 1; } // Check that the secondary addresses in the in_out_sockaddr // array match the stay_out array for (j = 1, pointer6 = &in_out_sockaddr6[1]; j < i + 1; ++j, ++pointer6) { if (ACE_OS::memcmp(pointer6, stay_out[j-1].get_addr(), sizeof(sockaddr_in6))) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed get_addresses check ") ACE_TEXT ("(for secondary addresses)\n"))); status = 1; } } } else { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed get_num_secondary_addresses check\n") ACE_TEXT ("%d != %d\n"), returned_num_secondaries, i)); status = 1; } } #endif /* ACE_HAS_IPV6 */ ACE_END_TEST; return status; }
void Config_Handler_Impl::install_instance (const Deployment::DeploymentPlan &plan, uint32_t instanceRef, CORBA::Any &) { DANCEX11_LOG_TRACE ("Config_Handler_Impl::install_instance"); if (plan.instance ().size () <= instanceRef) { DANCEX11_LOG_ERROR ("Config_Handler_Impl::install_instance - " << "Invalid instance reference " << instanceRef << " provided " << "to install_instance"); throw Deployment::PlanError (plan.UUID (), "Invalid instance reference"); } Deployment::InstanceDeploymentDescription const &idd = plan.instance ()[instanceRef]; if (plan.implementation ().size () <= idd.implementationRef ()) { DANCEX11_LOG_ERROR ("Config_Handler_Impl::install_instance - " << "Invalid implementation reference " << idd.implementationRef () << " provided " << "to install_instance"); throw ::Deployment::PlanError (plan.UUID (), "Invalid Implementation reference"); } Deployment::MonolithicDeploymentDescription const &mdd = plan.implementation ()[idd.implementationRef ()]; DANCEX11_LOG_DEBUG ("Config_Handler_Impl::install_instance - " << "Starting installation of instance <" << idd.name () << ">"); std::string entrypoint; if (!DAnCE::Utility::get_property_value (DAnCE::DANCE_PLUGIN_ENTRYPT, mdd.execParameter (), entrypoint)) { DANCEX11_LOG_ERROR ("Config_Handler_Impl::install_instance - " << "No entrypoint found for plug-in initialization"); throw ::Deployment::StartError (idd.name (), "No entrypoint found for plug-in initialization\n"); } std::string artifact; if (!DAnCE::Utility::get_property_value (DAnCE::DANCE_PLUGIN_ARTIFACT, mdd.execParameter (), artifact)) { DANCEX11_LOG_ERROR ("Config_Handler_Impl::install_instance - " << "No artifact found for plug-in initialization"); throw ::Deployment::StartError (idd.name (), "No artifact found for plug-in initialization\n"); } uint32_t open_mode = ACE_DEFAULT_SHLIB_MODE; if (!DAnCE::Utility::get_property_value (DAnCE::DANCE_PLUGIN_OPENMODE, mdd.execParameter (), open_mode)) { DANCEX11_LOG_ERROR ("Config_Handler_Impl::install_instance - " << "No open mode found for plug-in initialization"); throw ::Deployment::StartError (idd.name (), "No open mode found for plug-in initialization\n"); } PLUGIN_MANAGER::instance ()->register_configuration_plugin ( ACE_TEXT_CHAR_TO_TCHAR (artifact.c_str ()), ACE_TEXT_CHAR_TO_TCHAR (entrypoint.c_str ()), open_mode); }
// Check that the ACE_Based_Pointer_Repository can be accessed // from a Windows DLL // (see http://bugzilla.dre.vanderbilt.edu/show_bug.cgi?id=1991) int singleton_test (void) { void* baddr1 = ACE_BASED_POINTER_REPOSITORY::instance(); void* baddr2 = ACE_BASED_POINTER_REPOSITORY::instance(); if (baddr1 != baddr2) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("ACE_Based_Pointer_Repository is not a singleton\n")), -1); } // Protection against this test being run on platforms not supporting Dlls. #if defined(ACE_HAS_DYNAMIC_LINKING) ACE_TString dll_file; const char *subdir_env = ACE_OS::getenv ("ACE_EXE_SUB_DIR"); if (subdir_env) { dll_file = ACE_TEXT_CHAR_TO_TCHAR (subdir_env); dll_file += ACE_DIRECTORY_SEPARATOR_STR; } dll_file += OBJ_PREFIX ACE_TEXT ("Based_Pointer_Test_Lib") OBJ_SUFFIX; // If DLL causes multiple instances of singleton // then the ACE_Cleanup object registered // with the ACE_Object_manager will no longer be valid, // at exit time if the library is unloaded. Override // the default close on destruct. ACE_DLL dll; int retval = dll.open (dll_file.c_str (), ACE_DEFAULT_SHLIB_MODE, 0); if (retval != 0) { ACE_TCHAR *dll_error = dll.error (); ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Error in DLL Open: %s\n"), dll_error ? dll_error : ACE_TEXT ("unknown error")), -1); } #if defined (ACE_OPENVMS) // with OPENVMS symbol names > 31 cause us trouble with dlsym() void* foo = dll.symbol (ACE_TEXT ("get_based_pointer_repo_inst")); #else void* foo = dll.symbol (ACE_TEXT ("get_based_pointer_repository_instance")); #endif // Cast the void* to function* with a long as intermediate. ptrdiff_t tmp = reinterpret_cast<ptrdiff_t> (foo); Get_Bp_Repository_Inst get_bp_repository_inst = reinterpret_cast<Get_Bp_Repository_Inst> (tmp); if (get_bp_repository_inst == 0) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), dll.error ()), -1); void* baddr_dll = get_bp_repository_inst (); dll.close (); if (baddr_dll != baddr1) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("ACE_Based_Pointer_Repository is not a ") ACE_TEXT ("singleton in DLL <%@> <%@>\n"), baddr_dll, baddr1), -1); } #endif /* ACE_HAS_DYNAMIC_LINKING */ return 0; }
void Directory::scan_dir(const ACE_TString& relative, DDS_Dirent& dir, unsigned int overflow_index) { ACE_TString path = physical_dirname_ + relative; add_slash(path); while (DDS_DIRENT* ent = dir.read()) { if (ent->d_name[0] == ACE_TEXT('.') && (!ent->d_name[1] || (ent->d_name[1] == ACE_TEXT('.') && !ent->d_name[2]))) { continue; // skip '.' and '..' } ACE_TString file = path + ent->d_name; if (is_dir(file.c_str())) { ACE_TString phys(relative); add_slash(phys); phys += ent->d_name; if (ACE_OS::strncmp(ent->d_name, ACE_TEXT("_overflow."), 10) == 0) { unsigned int n = ACE_OS::atoi(ent->d_name + 10); DDS_Dirent overflow(file.c_str()); scan_dir(ent->d_name, overflow, n); } else if (ACE_OS::strlen(ent->d_name) <= FSS_MAX_FILE_NAME_ENCODED) { dirs_[b32h_decode(ent->d_name)] = phys; ++overflow_[overflow_index]; } else { CwdGuard cg(file); std::ifstream fn("_fullname"); std::string fullname; if (!std::getline(fn, fullname)) { throw std::runtime_error("Can't read .../_fullname"); } ACE_TString full_t(ACE_TEXT_CHAR_TO_TCHAR(fullname.c_str())); dirs_[full_t] = phys; ++overflow_[overflow_index]; String_Index_t idx = phys.rfind(ACE_TEXT('.')); if (idx == ACE_TString::npos) { throw std::runtime_error("Badly formatted long dir name"); } ACE_TString prefix(phys.c_str(), idx); unsigned int serial = ACE_OS::atoi(&phys[idx + 1]); unsigned int& counter = long_names_[prefix]; if (serial >= counter) counter = serial + 1; } } else { // regular file if (ent->d_name[0] != ACE_TEXT('_')) { files_[b32h_decode(ent->d_name)] = ent->d_name; ++overflow_[overflow_index]; } } } }
/*static*/ Directory::Ptr Directory::create(const char* dirname) { return new Directory(ACE_TEXT_CHAR_TO_TCHAR(dirname), ACE_TEXT(""), 0); }
int ACE_SOCK_Dgram_Mcast::subscribe_ifs (const ACE_INET_Addr &mcast_addr, const ACE_TCHAR *net_if, int reuse_addr) { ACE_TRACE ("ACE_SOCK_Dgram_Mcast::subscribe_ifs"); if (ACE_BIT_ENABLED (this->opts_, OPT_NULLIFACE_ALL) && net_if == 0) { int family = mcast_addr.get_type (); size_t nr_subscribed = 0; #if defined (ACE_HAS_GETIFADDRS) // Take advantage of the BSD getifaddrs function that simplifies // access to connected interfaces. struct ifaddrs *ifap = 0; struct ifaddrs *p_if = 0; if (::getifaddrs (&ifap) != 0) return -1; // Not every interface is for IP, and not all are up and multicast. for (p_if = ifap; p_if != 0; p_if = p_if->ifa_next) { // Some OSes can return interfaces with no ifa_addr if the // interface has no assigned address. // If there is an address but it's not the family we want, ignore it. if (p_if->ifa_addr == 0 || p_if->ifa_addr->sa_family != family) continue; // Check to see if it's up and supports multicast. unsigned int wanted = IFF_UP | IFF_MULTICAST; if ((p_if->ifa_flags & wanted) != wanted) continue; // Sometimes the kernel returns 0.0.0.0 as the interface // address, skip those... if (p_if->ifa_addr->sa_family == PF_INET) { struct sockaddr_in *addr = reinterpret_cast<sockaddr_in *> (p_if->ifa_addr); if (addr->sin_addr.s_addr == INADDR_ANY) continue; } # if defined (ACE_HAS_IPV6) else if (p_if->ifa_addr->sa_family == AF_INET6) { struct sockaddr_in6 *addr = reinterpret_cast<sockaddr_in6 *> (p_if->ifa_addr); // Skip the ANY address if (IN6_IS_ADDR_UNSPECIFIED(&addr->sin6_addr)) continue; } # endif /* ACE_HAS_IPV6 */ // Ok, now join on this interface. if (this->join (mcast_addr, reuse_addr, ACE_TEXT_CHAR_TO_TCHAR(p_if->ifa_name)) == 0) ++nr_subscribed; } ::freeifaddrs (ifap); # elif defined (ACE_WIN32) IP_ADAPTER_ADDRESSES tmp_addrs; // Initial call to determine actual memory size needed DWORD dwRetVal; ULONG bufLen = 0; // Note... GetAdaptersAddresses returns different bufLen values depending // on how many multicast joins there are on the system. To avoid this, // specify that we don't want to know about multicast addresses. This // does not avoid multicastable interfaces and makes the size-check // more reliable across varying conditions. DWORD flags = GAA_FLAG_SKIP_MULTICAST; if ((dwRetVal = ::GetAdaptersAddresses (family, flags, 0, &tmp_addrs, &bufLen)) != ERROR_BUFFER_OVERFLOW) { errno = dwRetVal; return -1; // With output bufferlength 0 this can't be right. } // Get required output buffer and retrieve info for real. PIP_ADAPTER_ADDRESSES pAddrs; char *buf; ACE_NEW_RETURN (buf, char[bufLen], -1); pAddrs = reinterpret_cast<PIP_ADAPTER_ADDRESSES> (buf); if ((dwRetVal = ::GetAdaptersAddresses (family, flags, 0, pAddrs, &bufLen)) != NO_ERROR) { delete[] buf; // clean up errno = dwRetVal; return -1; } for (; pAddrs; pAddrs = pAddrs->Next) { if (pAddrs->OperStatus != IfOperStatusUp) continue; // The ACE_SOCK_Dgram::make_multicast_ifaddr (IPv4), called by join(), // can only deal with a dotted-decimal address, not an interface name. if (family == AF_INET) { ACE_INET_Addr intf_addr ((sockaddr_in*)(pAddrs->FirstUnicastAddress->Address.lpSockaddr), pAddrs->FirstUnicastAddress->Address.iSockaddrLength); char intf_addr_str[INET_ADDRSTRLEN]; intf_addr.get_host_addr (intf_addr_str, sizeof (intf_addr_str)); if (this->join (mcast_addr, reuse_addr, ACE_TEXT_CHAR_TO_TCHAR(intf_addr_str)) == 0) ++nr_subscribed; } else { if (this->join (mcast_addr, reuse_addr, ACE_TEXT_CHAR_TO_TCHAR(pAddrs->AdapterName)) == 0) ++nr_subscribed; } } delete[] buf; // clean up # else // Subscribe on all local multicast-capable network interfaces, by // doing recursive calls with specific interfaces. ACE_INET_Addr *if_addrs = 0; size_t if_cnt; if (ACE::get_ip_interfaces (if_cnt, if_addrs) != 0) return -1; if (if_cnt < 2) { if (this->join (mcast_addr, reuse_addr, ACE_TEXT ("0.0.0.0")) == 0) ++nr_subscribed; } else { // Iterate through all the interfaces, figure out which ones // offer multicast service, and subscribe to them. while (if_cnt > 0) { --if_cnt; // Convert to 0-based for indexing, next loop check. if (if_addrs[if_cnt].get_type () != family || if_addrs[if_cnt].is_loopback ()) continue; char addr_buf[INET6_ADDRSTRLEN]; if (this->join (mcast_addr, reuse_addr, ACE_TEXT_CHAR_TO_TCHAR (if_addrs[if_cnt].get_host_addr (addr_buf, INET6_ADDRSTRLEN))) == 0) ++nr_subscribed; } } delete [] if_addrs; # endif /* ACE_WIN32 */ if (nr_subscribed == 0) { errno = ENODEV; return -1; } return 1; }
int run_parent (bool inherit_files) { int status = 0; ACE_TCHAR t[] = ACE_TEXT ("ace_testXXXXXX"); // Create tempfile. This will be tested for inheritance. ACE_TCHAR tempfile[MAXPATHLEN + 1]; if (ACE::get_temp_dir (tempfile, MAXPATHLEN - sizeof (t)) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Could not get temp dir\n"))); ACE_OS::strcat (tempfile, t); ACE_HANDLE file_handle = ACE_OS::mkstemp (tempfile); if (file_handle == ACE_INVALID_HANDLE) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Could not get temp filename\n"))); status = 1; } // Build child options ACE_TString exe_sub_dir; const char *subdir_env = ACE_OS::getenv ("ACE_EXE_SUB_DIR"); if (subdir_env) { exe_sub_dir = ACE_TEXT_CHAR_TO_TCHAR (subdir_env); exe_sub_dir += ACE_DIRECTORY_SEPARATOR_STR; } ACE_Process_Options options; options.command_line (ACE_TEXT (".") ACE_DIRECTORY_SEPARATOR_STR ACE_TEXT ("%sProcess_Test") ACE_PLATFORM_EXE_SUFFIX ACE_TEXT (" -c -h %d -f %s"), exe_sub_dir.c_str(), (int)inherit_files, tempfile); options.handle_inheritance (inherit_files); /* ! */ // Spawn child ACE_Process child; pid_t result = child.spawn (options); if (result == -1) { status = errno; ACE_ERROR ((LM_ERROR, ACE_TEXT ("Parent could NOT spawn child process\n"))); } else ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Parent spawned child process with pid = %d.\n"), child.getpid ())); ACE_exitcode child_status; result = child.wait (&child_status); if (result == -1) { status = errno; ACE_ERROR ((LM_ERROR, ACE_TEXT ("Could NOT wait on child process\n"))); } else if (child_status == 0) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Child %d finished ok\n"), child.getpid ())); else { status = child_status; ACE_ERROR ((LM_ERROR, ACE_TEXT ("Child %d finished with status %d\n"), child.getpid (), child_status)); } return status; }
void Lorica::Proxy::configure(Config & config, const std::string &def_ior_file ) throw (InitError) { try { // This should be OK even if multiple copies of Proxy // get created as they all create the same ORB instance // and therefore the single ORB instance will get shutdown. Lorica::Proxy::this_ = this; std::auto_ptr<ACE_ARGV> arguments(config.get_orb_options()); // Create proxy ORB. int argc = arguments->argc(); if (Lorica_debug_level > 2) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%T) %N:%l - passing %d args to ORB_init:\n"), argc)); for (int i = 0; i < argc; i++) ACE_DEBUG((LM_DEBUG, ACE_TEXT("%N:%l - %s\n"), arguments->argv()[i])); } orb_ = CORBA::ORB_init(argc, arguments->argv()); // test if we have any security functionality ACE_Service_Repository * repo = orb_->orb_core()->configuration()-> current_service_repository(); config.secure_available(repo->find("SSLIOP_Factory") == 0); int attempts = 3; CORBA::Object_var obj = CORBA::Object::_nil(); resolve_again: try { obj = orb_->resolve_initial_references("RootPOA"); } catch (CORBA::Exception & ex) { if (attempts--) { ACE_DEBUG((LM_INFO, ACE_TEXT("(%T) %N:%l - Exception trying to resolve initial references\n"))); ACE_OS::sleep(10); goto resolve_again; } ACE_DEBUG((LM_ERROR, ACE_TEXT("(%T) %N:%l - %s\n"), ex._info().c_str())); throw InitError(); } root_poa_ = PortableServer::POA::_narrow(obj.in()); if (CORBA::is_nil(root_poa_.in())) { ACE_ERROR((LM_ERROR, "(%T) %N:%l - could not get root POA\n")); throw InitError(); } pmf_ = root_poa_->the_POAManagerFactory(); if (CORBA::is_nil(pmf_.in())) { ACE_ERROR((LM_ERROR, "(%T) %N:%l - could not get PMF\n")); throw InitError(); } obj = orb_->resolve_initial_references("IORTable"); iorTable_ = IORTable::Table::_narrow(obj.in()); if (CORBA::is_nil(iorTable_.in())) { ACE_ERROR((LM_ERROR, "(%T) %N:%l - could not get IORTable\n")); throw InitError(); } CORBA::PolicyList policies; EndpointPolicy::EndpointList list; CORBA::Any policy_value; // Create external POA manager Config::Endpoints ex_points = config.get_endpoints(true); policies.length(1); list.length(ex_points.size()); if (Lorica_debug_level > 2) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%T) %N:%l - setting up External POA manager with %d endpoints\n"), ex_points.size())); } for (size_t count = 0; count < ex_points.size(); count++) { std::string inter = ex_points[count].hostname_; if (!ex_points[count].alias_.empty()) inter = ex_points[count].alias_; list[count] = new IIOPEndpointValue_i(inter.c_str(), ex_points[count].port_); } policy_value <<= list; policies[0] = orb_->create_policy(EndpointPolicy::ENDPOINT_POLICY_TYPE, policy_value); outside_pm_ = pmf_->create_POAManager("OutsidePOAManager", policies); // Create internal POA manager. Config::Endpoints in_points = config.get_endpoints(false); policies.length(1); list.length(in_points.size()); if (Lorica_debug_level > 2) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%T) %N:%l - setting up Internal POA manager with %d endpoints\n"), in_points.size())); } for (size_t count = 0; count < in_points.size(); count++) { std::string inter = in_points[count].hostname_; if (!in_points[count].alias_.empty()) inter = in_points[count].alias_; list[count] = new IIOPEndpointValue_i(inter.c_str(), in_points[count].port_); } policy_value <<= list; policies[0] = orb_->create_policy(EndpointPolicy::ENDPOINT_POLICY_TYPE, policy_value); inside_pm_ = pmf_->create_POAManager("InsidePOAManager", policies); if (Lorica_debug_level > 2) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%T) %N:%l - creating admin POA with internal POA manager\n"))); } policies.length(0); admin_poa_ = root_poa_->create_POA("adminPOA", inside_pm_.in(), policies); try { ReferenceMapper_i *refMapper = new ReferenceMapper_i(orb_.in(), iorTable_.in(), config.secure_available()); PortableServer::ServantBase_var refMapperServant = refMapper; PortableServer::ObjectId_var oid = admin_poa_->activate_object(refMapperServant.in()); obj = admin_poa_->id_to_reference(oid.in()); // refMapper->allow_insecure_access (obj.in()); } catch (CORBA::Exception & ex) { ACE_DEBUG((LM_ERROR, ACE_TEXT("(%T) %N:%l - %s\n"), ex._info().c_str())); throw InitError(); } ReferenceMapper_var refMapper_obj = ReferenceMapper::_narrow(obj.in()); CORBA::String_var ior = orb_->object_to_string(refMapper_obj.in()); iorTable_->bind(Lorica::ReferenceMapper::IOR_TABLE_KEY, ior.in()); this->ior_file_ = config.get_value("IOR_FILE", def_ior_file); FILE *output_file = ACE_OS::fopen (ACE_TEXT_CHAR_TO_TCHAR (this->ior_file_.c_str()), ACE_TEXT("w")); if (!output_file) { ACE_ERROR((LM_ERROR, "(%T) %N:%l - cannot open output file for writing IOR: %s\n", this->ior_file_.c_str())); throw InitError(); } ACE_OS::fprintf(output_file, "%s", ior.in()); ACE_OS::fclose(output_file); if (!setup_shutdown_handler()) { ACE_ERROR ((LM_ERROR, "(%T) %N:%l - could not set up shutdown handler\n")); throw InitError(); } // Initialize the mapper registry Lorica_MapperRegistry *mreg = ACE_Dynamic_Service<Lorica_MapperRegistry>::instance (this->orb_->orb_core()->configuration(),"MapperRegistry"); std::string ne_ids = config.null_eval_type_ids(); if (!ne_ids.empty()) { if (Lorica_debug_level > 2) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%T) %N:%l - adding type ids for null ") ACE_TEXT("evaluator: %s\n"), ne_ids.c_str())); } size_t space = ne_ids.find(' '); size_t start = 0; while (space != std::string::npos) { mreg->add_null_mapper_type(ne_ids.substr(start,space - start)); start = space+1; space = ne_ids.find(' ',start); } mreg->add_null_mapper_type(ne_ids.substr(start)); } else if (config.null_eval_any()) { if (Lorica_debug_level > 2) ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%T) %N:%l - creating default null mapper\n"))); mreg->create_default_null_mapper(); } if (config.generic_evaluator()) { if (Lorica_debug_level > 0) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%T) %N:%l - loading generic evaluator\n"))); } #ifdef ACE_WIN32 this->orb_->orb_core()->configuration()->process_directive (ACE_TEXT_ALWAYS_CHAR (ACE_DYNAMIC_SERVICE_DIRECTIVE("Lorica_GenericLoader", "lorica_GenericEvaluator", "_make_Lorica_GenericLoader", "") ) ); #else Lorica::GenericMapper *gen_eval = new Lorica::GenericMapper(debug_, *mreg); mreg->add_proxy_mapper(gen_eval); #endif } // add generic or other mappers... mreg->init_mappers(this->outside_pm_, this->inside_pm_, this->orb_, config.secure_available()); // last thing to do, put both POAs in the active state. outside_pm_->activate(); inside_pm_->activate(); } catch (CORBA::Exception & ex) { ACE_DEBUG((LM_ERROR, ACE_TEXT("(%T) %N:%l - %s\n"), ex._info().c_str())); throw InitError(); } catch (...) { ACE_ERROR((LM_ERROR, "%N:%l - Caught an otherwise unknown exception\n")); throw InitError(); } }
ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (const ACE_ANTI_TCHAR* output) { *this << ACE_TEXT_CHAR_TO_TCHAR(output); return *this; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { int status = 0; try { ACE_DEBUG((LM_INFO,"(%P|%t) %T subscriber main\n")); ::DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv); // let the Service_Participant (in above line) strip out -DCPSxxx parameters // and then get application specific parameters. status = parse_args (argc, argv); if (status) return status; ::DDS::DomainParticipant_var dp = dpf->create_participant(TEST_DOMAIN, PARTICIPANT_QOS_DEFAULT, ::DDS::DomainParticipantListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (dp.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: create_participant failed.\n"))); return 1 ; } // Register the type supports ::profilingTest::testMsgTypeSupport_var ts = new ::profilingTest::testMsgTypeSupportImpl(); if (::DDS::RETCODE_OK != ts->register_type(dp.in (), TEST_TYPE)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) ERROR: Failed to register the testMsgTypeSupport."))); return 1; } ::DDS::TopicQos topic_qos; dp->get_default_topic_qos(topic_qos); topic_qos.resource_limits.max_samples_per_instance = MAX_SAMPLES_PER_INSTANCE; topic_qos.resource_limits.max_instances = MAX_INSTANCES; topic_qos.resource_limits.max_samples = MAX_SAMPLES; topic_qos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS; topic_qos.reliability.max_blocking_time.sec = max_mili_sec_blocking / 1000; topic_qos.reliability.max_blocking_time.nanosec = (max_mili_sec_blocking % 1000) * 1000*1000; topic_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS; ::DDS::Topic_var topic = dp->create_topic (TEST_TOPIC, TEST_TYPE, topic_qos, ::DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (topic.in ())) { return 1 ; } ::DDS::TopicDescription_var description = dp->lookup_topicdescription(TEST_TOPIC); if (CORBA::is_nil (description.in() )) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: lookup_topicdescription failed.\n")), 1); } // Create the subscriber ::DDS::Subscriber_var sub = dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT, ::DDS::SubscriberListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (sub.in() )) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: create_subscriber failed.\n")), 1); } // Initialize the transport if (0 != ::init_reader_tranport() ) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: init_transport failed!\n")), 1); } // Attach the subscriber to the transport. ::OpenDDS::DCPS::SubscriberImpl* sub_impl = dynamic_cast< ::OpenDDS::DCPS::SubscriberImpl*>(sub.in()); if (0 == sub_impl) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Failed to obtain servant ::OpenDDS::DCPS::SubscriberImpl\n")), 1); } OpenDDS::DCPS::AttachStatus attach_status = sub_impl->attach_transport(reader_transport_impl.in()); if (attach_status != OpenDDS::DCPS::ATTACH_OK) { // We failed to attach to the transport for some reason. std::string status_str; switch (attach_status) { case OpenDDS::DCPS::ATTACH_BAD_TRANSPORT: status_str = "ATTACH_BAD_TRANSPORT"; break; case OpenDDS::DCPS::ATTACH_ERROR: status_str = "ATTACH_ERROR"; break; case OpenDDS::DCPS::ATTACH_INCOMPATIBLE_QOS: status_str = "ATTACH_INCOMPATIBLE_QOS"; break; default: status_str = "Unknown Status"; break; } ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Failed to attach to the transport. ") ACE_TEXT("AttachStatus == %s\n"), ACE_TEXT_CHAR_TO_TCHAR(status_str.c_str())), 1); } // Create the Datareader ::DDS::DataReaderQos dr_qos; sub->get_default_datareader_qos (dr_qos); sub->copy_from_topic_qos (dr_qos, topic_qos); dr_qos.liveliness.lease_duration.sec = 2 ; dr_qos.liveliness.lease_duration.nanosec = 0 ; DataReaderListenerImpl* dr_listener_impl = new DataReaderListenerImpl(num_datawriters, NUM_SAMPLES, DATA_SIZE, RECVS_BTWN_READS, USE_ZERO_COPY_READ); DDS::DataReaderListener_var dr_listener = dr_listener_impl; if (CORBA::is_nil (dr_listener.in())) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: get listener reference failed.\n")), 1); } ::DDS::DataReader_var the_dr = sub->create_datareader(description.in() , dr_qos, dr_listener.in(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (the_dr.in() )) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: create_datareader failed.\n")), 1); } while (! dr_listener_impl->is_finished ()) { ACE_OS::sleep(2); } // clean up subscriber objects sub->delete_contained_entities() ; dp->delete_subscriber(sub.in()); dp->delete_topic(topic.in ()); dpf->delete_participant(dp.in ()); TheTransportFactory->release(); TheServiceParticipant->shutdown (); reader_transport_impl = 0; //reader_config = 0; } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught in main.cpp:"); return 1; } return status; }
int ACE_Service_Manager::handle_input (ACE_HANDLE) { ACE_TRACE ("ACE_Service_Manager::handle_input"); // Try to find out if the implementation of the reactor that we are // using requires us to reset the event association for the newly // created handle. This is because the newly created handle will // inherit the properties of the listen handle, including its event // associations. int reset_new_handle = ACE_Reactor::instance ()->uses_event_associations (); if (this->acceptor_.accept (this->client_stream_, // stream 0, // remote address 0, // timeout 1, // restart reset_new_handle // reset new handler ) == -1) return -1; if (this->debug_) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("client_stream fd = %d\n"), this->client_stream_.get_handle ())); ACE_INET_Addr sa; if (this->client_stream_.get_remote_addr (sa) == -1) return -1; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("accepted from host %s at port %d\n"), ACE_TEXT_CHAR_TO_TCHAR (sa.get_host_name ()), sa.get_port_number ())); } ACE_TCHAR request[BUFSIZ]; ACE_TCHAR* offset = request; ssize_t remaining = sizeof (request); // Read service request from client. ssize_t result; // Keep looping until we actually get the request. Note that Win32 // sets the socket into non-blocking mode, so we may need to loop if // the system is heavily loaded. Read bytes into the buffer until a // '\n' or '\r' is found in the buffer, otherwise the buffer // contains an incomplete string. int error; do { result = client_stream_.recv (offset, remaining); error = errno; if (result == 0 && error != EWOULDBLOCK) remaining = 0; if (result >= 0) { if ((remaining -= result) <= 0) { ACE_DEBUG ((LM_ERROR, ACE_TEXT ("Request buffer overflow.\n"))); result = 0; break; } offset += result; *offset = 0; if (ACE_OS::strchr (request, '\r') != 0 || ACE_OS::strchr (request, '\n') != 0) remaining = 0; } } while (result == -1 && error == EWOULDBLOCK || remaining > 0); switch (result) { case -1: if (this->debug_) ACE_DEBUG ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("recv"))); break; case 0: return 0; /* NOTREACHED */ default: { ACE_Event_Handler *old_signal_handler = 0; ACE_Reactor::instance ()->register_handler (SIGPIPE, this, 0, &old_signal_handler); this->process_request (request); // Restore existing SIGPIPE handler ACE_Reactor::instance ()->register_handler (SIGPIPE, old_signal_handler); } } if (this->client_stream_.close () == -1 && this->debug_) ACE_DEBUG ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("close"))); return 0; }
int run_main (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("Svc_Handler_Test")); { size_t max_buffer_size = BUFSIZ; size_t iterations = 10; if (argc > 1) max_buffer_size = ACE_OS::atoi (argv[1]); if (argc > 2) iterations = ACE_OS::atoi (argv[2]); ACE_FILE_Connector connector; ACE_FILE_IO file_io; // Create a temporary filename. ACE_FILE_Addr file (ACE_sap_any_cast (ACE_FILE_Addr &)); // Open up the temp file. if (connector.connect (file_io, file) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("connect failed for %p\n"), file.get_path_name ()), 1); #if (!defined (ACE_WIN32) \ || (defined (ACE_HAS_WINNT4) && ACE_HAS_WINNT4 == 1)) && \ !defined (VXWORKS) # define TEST_CAN_UNLINK_IN_ADVANCE #endif // Create the service handler and assign it <file_io> as its data // sink. SVC_HANDLER svc_handler (0, 0, 0, max_buffer_size, 0); svc_handler.peer () = file_io; // Run the test. run_test (svc_handler, iterations); file_io.close (); // Open up the temp file. if (connector.connect (file_io, file) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("connect failed for %p\n"), file.get_path_name ()), 1); char buf[ACE_MAXLOGMSGLEN + 1]; ACE_LOG_MSG->clr_flags (ACE_Log_Msg::VERBOSE_LITE); ACE_FILE_Info info; file_io.get_info (info); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT("file size = %d\n"), info.size_)); for (ssize_t n_bytes; (n_bytes = file_io.recv (buf, ACE_MAXLOGMSGLEN)) > 0; ) { buf[n_bytes] = '\0'; ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT("%s"), ACE_TEXT_CHAR_TO_TCHAR(buf))); } ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT("\n"))); file_io.close (); if (file_io.unlink () == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("unlink failed for %p\n"), file.get_path_name ()), 1); } ACE_END_TEST; return 0; }
int ACE_SOCK_Dgram_Mcast::subscribe_ifs (const ACE_INET_Addr &mcast_addr, const ACE_TCHAR *net_if, int reuse_addr) { ACE_TRACE ("ACE_SOCK_Dgram_Mcast::subscribe_ifs"); if (ACE_BIT_ENABLED (this->opts_, OPT_NULLIFACE_ALL) && net_if == 0) { #if defined (__linux__) && defined (ACE_HAS_IPV6) if (mcast_addr.get_type () == AF_INET6) { struct if_nameindex *intf; intf = ACE_OS::if_nameindex (); if (intf == 0) return -1; size_t nr_subscribed = 0; int index = 0; while (intf[index].if_index != 0 || intf[index].if_name != 0) { if (this->join (mcast_addr, reuse_addr, ACE_TEXT_CHAR_TO_TCHAR(intf[index].if_name)) == 0) ++nr_subscribed; ++index; } ACE_OS::if_freenameindex (intf); if (nr_subscribed == 0) { errno = ENODEV; return -1; } return 1; } else { // Subscribe on all local multicast-capable network interfaces, by // doing recursive calls with specific interfaces. ACE_INET_Addr *if_addrs = 0; size_t if_cnt; if (ACE::get_ip_interfaces (if_cnt, if_addrs) != 0) return -1; size_t nr_subscribed = 0; if (if_cnt < 2) { if (this->subscribe (mcast_addr, reuse_addr, ACE_LIB_TEXT ("0.0.0.0")) == 0) ++nr_subscribed; } else { // Iterate through all the interfaces, figure out which ones // offer multicast service, and subscribe to them. while (if_cnt > 0) { --if_cnt; // Convert to 0-based for indexing, next loop check. if (if_addrs[if_cnt].get_ip_address () == INADDR_LOOPBACK) continue; if (this->subscribe (mcast_addr, reuse_addr, ACE_TEXT_CHAR_TO_TCHAR (if_addrs[if_cnt].get_host_addr ())) == 0) ++nr_subscribed; } } delete [] if_addrs; if (nr_subscribed == 0) { errno = ENODEV; return -1; } // 1 indicates a "short-circuit" return. This handles the // recursive behavior of checking all the interfaces. return 1; } #else // Subscribe on all local multicast-capable network interfaces, by // doing recursive calls with specific interfaces. ACE_INET_Addr *if_addrs = 0; size_t if_cnt; if (ACE::get_ip_interfaces (if_cnt, if_addrs) != 0) return -1; size_t nr_subscribed = 0; if (if_cnt < 2) { if (this->subscribe (mcast_addr, reuse_addr, ACE_LIB_TEXT ("0.0.0.0")) == 0) ++nr_subscribed; } else { // Iterate through all the interfaces, figure out which ones // offer multicast service, and subscribe to them. while (if_cnt > 0) { --if_cnt; // Convert to 0-based for indexing, next loop check. if (if_addrs[if_cnt].get_ip_address () == INADDR_LOOPBACK) continue; if (this->subscribe (mcast_addr, reuse_addr, ACE_TEXT_CHAR_TO_TCHAR (if_addrs[if_cnt].get_host_addr ())) == 0) ++nr_subscribed; } } delete [] if_addrs; if (nr_subscribed == 0) { errno = ENODEV; return -1; } // 1 indicates a "short-circuit" return. This handles the // recursive behavior of checking all the interfaces. return 1; #endif /* __linux__ && ACE_HAS_IPV6 */ } #if defined (__linux__) && defined (ACE_HAS_IPV6) if (mcast_addr.get_type () == AF_INET6) { if (this->make_multicast_ifaddr6 (0, mcast_addr, net_if) == -1) return -1; } else { // Validate passed multicast addr and iface specifications. if (this->make_multicast_ifaddr (0, mcast_addr, net_if) == -1) return -1; } #else // Validate passed multicast addr and iface specifications. if (this->make_multicast_ifaddr (0, mcast_addr, net_if) == -1) return -1; #endif /* __linux__ && ACE_HAS_IPV6 */ return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv []) { DANCE_DISABLE_TRACE (); int retval = 0; try { DAnCE::Logger_Service * dlf = ACE_Dynamic_Service<DAnCE::Logger_Service>::instance ( "DAnCE_Logger"); if (dlf) { dlf->init (argc, argv); } DANCE_DEBUG (DANCE_LOG_EVENT_TRACE, (LM_TRACE, DLINFO ACE_TEXT("PlanLauncher - initializing ORB\n"))); // Need an ORB for the Config handlers CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if (!parse_args (argc, argv)) { return -1; } auto_ptr<Deployment::DeploymentPlan> plan; if (!cdr_encoded_) { plan.reset (DAnCE::Convert_Plan::read_xml_plan ( ACE_TEXT_CHAR_TO_TCHAR (input_filename))); } else { plan.reset (DAnCE::Convert_Plan::read_cdr_plan ( ACE_TEXT_CHAR_TO_TCHAR (input_filename))); } if (plan.get () == 0) { DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("Split_Plan - ") ACE_TEXT ("Unable to convert provided plan into IDL"\ "representation\n"))); return 0; } if (split_type == 'N') { DAnCE::Split_Plan<DAnCE::Node_Splitter> split; split.split_plan (*plan); for (DAnCE::Split_Plan<DAnCE::Node_Splitter>::TSubPlanIterator iter_plans = split.plans ().begin(); iter_plans != split.plans ().end(); ++iter_plans) { ACE_CString label ((*iter_plans).int_id_.label.in ()); DANCE_DEBUG (DANCE_LOG_EVENT_TRACE, (LM_DEBUG, DLINFO ACE_TEXT ("Split_Plan - ") ACE_TEXT ("Writing sub plan : %C\n"), label.c_str ())); ACE_CString name ((*iter_plans).ext_id_); name += "-"; name += input_filename; DAnCE::Convert_Plan::write_cdr_plan ( ACE_TEXT_CHAR_TO_TCHAR (name.c_str ()), (*iter_plans).int_id_); } } else { DAnCE::Split_Plan<DAnCE::Locality_Splitter> split; split.split_plan (*plan); for (DAnCE::Split_Plan<DAnCE::Locality_Splitter>::TSubPlanIterator iter_plans = split.plans ().begin(); iter_plans != split.plans ().end(); ++iter_plans) { ACE_CString label ((*iter_plans).int_id_.label.in ()); DANCE_DEBUG (DANCE_LOG_EVENT_TRACE, (LM_DEBUG, DLINFO ACE_TEXT ("Split_Plan - ") ACE_TEXT ("Writing sub plan : %C\n"), label.c_str ())); ACE_CString name ((*iter_plans).ext_id_); name += "-"; name += input_filename; DAnCE::Convert_Plan::write_cdr_plan ( ACE_TEXT_CHAR_TO_TCHAR (name.c_str ()), (*iter_plans).int_id_); } } } catch (const CORBA::Exception &ex) { ex._tao_print_exception ("Split_Plan"); retval = -1; } catch (...) { DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, ACE_TEXT ("Split_Plan - error: unknown c++ exception\n"))); retval = -1; } return retval; }
// Win32, unnamed synchronization objects are acceptable. ACE::unique_name (this, this->name_, ACE_UNIQUE_NAME_LEN); return this->name_; } ACE_Process_Mutex::ACE_Process_Mutex (const char *name, void *arg, mode_t mode) #if defined (_ACE_USE_SV_SEM) : lock_ (name ? name : ACE_TEXT_ALWAYS_CHAR (this->unique_name ()), ACE_SV_Semaphore_Complex::ACE_CREATE, 1, 1, mode) #else : lock_ (USYNC_PROCESS, name ? ACE_TEXT_CHAR_TO_TCHAR (name) : this->unique_name (), (ACE_mutexattr_t *) arg, mode) #endif /* _ACE_USE_SV_SEM */ { #if defined (_ACE_USE_SV_SEM) ACE_UNUSED_ARG (arg); #endif /* !_ACE_USE_SV_SEM */ } #if defined (ACE_HAS_WCHAR) ACE_Process_Mutex::ACE_Process_Mutex (const wchar_t *name, void *arg, mode_t mode) #if defined (_ACE_USE_SV_SEM) : lock_ (name ?
int Dump_Restore::handle_input (ACE_HANDLE) { char option[BUFSIZ]; char buf1[BUFSIZ]; u_short port; if (::scanf ("%s", option) <= 0) { ACE_DEBUG ((LM_ERROR, ACE_TEXT ("try again\n"))); return 0; } switch (option[0]) { case 'P' : case 'p' : set_proc_local (); break; case 'N' : case 'n' : set_node_local (); break; case 'H' : case 'h' : if (::scanf ("%s %hu", buf1, &port) <= 0) break; set_host (ACE_TEXT_CHAR_TO_TCHAR (buf1), port); break; case 'F': case 'f': if (::scanf ("%s", filename_) <= 0) break; if (this->infile_) ACE_OS::fclose (this->infile_); this->infile_ = ACE_OS::fopen(filename_, ACE_TEXT("r")); break; case 'B' : case 'b' : populate (Dump_Restore::BIND); break; case 'U' : case 'u' : populate (Dump_Restore::UNBIND); break; case 'R' : case 'r' : populate (Dump_Restore::REBIND); break; case 'D': case 'd': if (::scanf ("%s", dump_filename_) <= 0) break; this->dump (); break; case 'Q' : case 'q' : quit (); break; default : ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Unrecognized command.\n"))); } display_menu (); return 0; }
int Logging_Handler::handle_input (ACE_HANDLE) { ACE_Log_Record log_record; // We need to use the old two-read trick here since TCP sockets // don't support framing natively. Allocate a message block for the // payload; initially at least large enough to hold the header, but // needs some room for alignment. ACE_Message_Block *payload_p = 0; ACE_Message_Block *header_p = 0; ACE_NEW_RETURN (header_p, ACE_Message_Block (ACE_DEFAULT_CDR_BUFSIZE), -1); auto_ptr <ACE_Message_Block> header (header_p); // Align the Message Block for a CDR stream ACE_CDR::mb_align (header.get ()); ACE_CDR::Boolean byte_order; ACE_CDR::ULong length; ssize_t count = ACE::recv_n (this->peer ().get_handle (), header->wr_ptr (), 8); switch (count) { // Handle shutdown and error cases. default: case -1: case 0: ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("server logging daemon closing down\n"))); return -1; /* NOTREACHED */ case 8: // Just fall through in this case.. break; } header->wr_ptr (8); // Reflect addition of 8 bytes. // Create a CDR stream to parse the 8-byte header. ACE_InputCDR header_cdr (header.get ()); // Extract the byte-order and use helper methods to disambiguate // octet, booleans, and chars. header_cdr >> ACE_InputCDR::to_boolean (byte_order); // Set the byte-order on the stream... header_cdr.reset_byte_order (byte_order); // Extract the length header_cdr >> length; ACE_NEW_RETURN (payload_p, ACE_Message_Block (length), -1); auto_ptr <ACE_Message_Block> payload (payload_p); // Ensure there's sufficient room for log record payload. ACE_CDR::grow (payload.get (), 8 + ACE_CDR::MAX_ALIGNMENT + length); // Use <recv_n> to obtain the contents. if (ACE::recv_n (this->peer ().get_handle (), payload->wr_ptr (), length) <= 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("recv_n()"))); return -1; } payload->wr_ptr (length); // Reflect additional bytes ACE_InputCDR payload_cdr (payload.get ()); payload_cdr.reset_byte_order (byte_order); payload_cdr >> log_record; // Finally extract the <ACE_log_record>. log_record.length (length); log_record.print (ACE_TEXT_CHAR_TO_TCHAR (this->peer_name_), 1, stderr); return 0; }
static void * server (void *arg) { ACE_SOCK_Acceptor *peer_acceptor = (ACE_SOCK_Acceptor *) arg; ACE_SOCK_Stream sock_str; ACE_INET_Addr cli_addr; ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT); // Accept the connection over which the stream tests will run. // Don't lock up if client doesn't connect if (peer_acceptor->accept (sock_str, &cli_addr, &timeout) == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("accept"))); Test_Result = 1; return 0; } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) client %s connected from %d\n"), ACE_TEXT_CHAR_TO_TCHAR(cli_addr.get_host_name ()), cli_addr.get_port_number ())); //******************* TEST 1 ****************************** // // Do a iovec recvv - the client should send 255 bytes, which we // will be detected and read into a ACE-allocated buffer. Use a 5 // second timeout to give the client a chance to send it all. ACE_OS::sleep (5); u_char buffer[255]; ssize_t len; int i; len = sock_str.recv (buffer, 255); if (len == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("Test 1, recvv failed"))); Test_Result = 1; } ACE_ASSERT (len == 255); for (i = 0; i < 255; i++) if (buffer[i] != i) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) Test 1, rcvd byte %d is %d, not %d\n"), i, buffer[i], i)); Test_Result = 1; } //******************* TEST 2 ****************************** // // Send the buffer back, using send (size_t n, ...) in 3 pieces. len = sock_str.send (6, buffer, 42, &buffer[42], 189, &buffer[231], 24); ACE_ASSERT (len == 255); sock_str.close(); return 0; }
// Parse arguments on command line void DRV_parse_args (long ac, char **av) { ACE_CString buffer; char *s = 0; long i; bool has_space = false; FE_store_env_include_paths (); DRV_cpp_init (); idl_global->set_prog_name (av[0]); for (i = 1; i < ac; i++) { if (av[i][0] == '-') { idl_global->append_idl_flag (av[i]); switch (av[i][1]) { case 0: // One or more letters expected after the dash. ACE_ERROR (( LM_ERROR, ACE_TEXT ("IDL: Space between dash and option ") ACE_TEXT ("letters not allowed\n") )); ++i; idl_global->set_err_count (idl_global->err_count () + 1); break; case 'A': if (av[i][2] == '\0') { if (i < ac - 1) { s = av[i + 1]; ++i; } else { ACE_ERROR (( LM_ERROR, ACE_TEXT ("IDL: incorrect use of ") ACE_TEXT ("the -A option\n") )); idl_global->set_compile_flags ( idl_global->compile_flags () | IDL_CF_ONLY_USAGE ); break; } } else { s = av[i] + 2; } ACE_OS::strcat (idl_global->local_escapes (), s); ACE_OS::strcat (idl_global->local_escapes (), " "); break; case 'a': if (av[i][2] == 'e') { idl_global->anon_type_diagnostic ( IDL_GlobalData::ANON_TYPE_ERROR); } else if (av[i][2] == 'w') { idl_global->anon_type_diagnostic ( IDL_GlobalData::ANON_TYPE_WARNING); } else if (av[i][2] == 's') { idl_global->anon_type_diagnostic ( IDL_GlobalData::ANON_TYPE_SILENT); } else { ACE_ERROR (( LM_ERROR, ACE_TEXT ("IDL: I don't understand") ACE_TEXT (" the '%s' option\n"), ACE_TEXT_CHAR_TO_TCHAR (av[i]) )); } break; // Temp directory for the IDL compiler to keep its files. case 't': if ((av[i][2] == '\0') && (i < ac - 1)) { idl_global->append_idl_flag (av[i + 1]); idl_global->temp_dir (av[i + 1]); ++i; } else { ACE_ERROR (( LM_ERROR, ACE_TEXT ("IDL: I don't understand") ACE_TEXT (" the '%s' option\n"), ACE_TEXT_CHAR_TO_TCHAR (av[i]) )); idl_global->set_compile_flags ( idl_global->compile_flags () | IDL_CF_ONLY_USAGE ); } break; case 'D': case 'U': case 'I': if (av[i][2] == '\0') { if (i < ac - 1) { idl_global->append_idl_flag (av[i + 1]); has_space = FE_Utils::hasspace (av[i + 1]); // If the include path has a space, we need to // add literal "s. ACE_CString arg = av[i]; arg += (has_space ? "\"" : ""); arg += av[i + 1]; arg += (has_space ? "\"" : ""); DRV_cpp_putarg (arg.c_str ()); idl_global->add_include_path (arg.substr (2).c_str (), false); ++i; } else { ACE_ERROR (( LM_ERROR, ACE_TEXT ("IDL: I don't understand") ACE_TEXT (" the '%s' option\n"), ACE_TEXT_CHAR_TO_TCHAR (av[i]) )); idl_global->set_compile_flags ( idl_global->compile_flags () | IDL_CF_ONLY_USAGE ); break; } } else { has_space = FE_Utils::hasspace (av[i]); // If the include path has a space, we need to // add literal "s. ACE_CString arg (av[i], 2); arg += (has_space ? "\"" : ""); arg += av[i] + 2; arg += (has_space? "\"" : ""); idl_global->add_include_path (arg.substr (2).c_str (), false); DRV_cpp_putarg (arg.c_str ()); } break; case 'E': idl_global->set_compile_flags (idl_global->compile_flags () | IDL_CF_ONLY_PREPROC); break; case 'V': idl_global->set_compile_flags (idl_global->compile_flags () | IDL_CF_VERSION); break; case 'W': if (av[i][2] == '\0') { if (i < ac - 1) { s = av[i + 1]; ++i; } else { ACE_ERROR (( LM_ERROR, ACE_TEXT ("IDL: I don't understand") ACE_TEXT (" the '%s' option\n"), ACE_TEXT_CHAR_TO_TCHAR (av[i]) )); idl_global->set_compile_flags ( idl_global->compile_flags () | IDL_CF_ONLY_USAGE ); break; } } else { s = av[i] + 2; } switch (*s) { default: ACE_ERROR (( LM_ERROR, ACE_TEXT ("IDL: Incorrect use of -W option\n") )); idl_global->set_compile_flags ( idl_global->compile_flags () | IDL_CF_ONLY_USAGE ); break; case 'p': if (*(s + 1) == ',') { DRV_prep_cpp_arg (s + 2); } break; case 'b': if (*(s + 1) == ',') { be_util::prep_be_arg (s + 2); } break; } break; case 'Y': if (av[i][2] == '\0') { if (i < ac - 1) { s = av[i + 1]; ++i; } else { ACE_ERROR (( LM_ERROR, ACE_TEXT ("IDL: I don't understand") ACE_TEXT (" the '%s' option\n"), ACE_TEXT_CHAR_TO_TCHAR (av[i]) )); idl_global->set_compile_flags ( idl_global->compile_flags () | IDL_CF_ONLY_USAGE ); break; } } else { s = av[i] + 2; } switch (*s) { case 'p': if (*(s + 1) == ',') { idl_global->set_cpp_location (s + 2); DRV_cpp_new_location (s + 2); } else { ACE_ERROR (( LM_ERROR, ACE_TEXT ("IDL: I don't understand") ACE_TEXT (" the '-Y' option\n") )); idl_global->set_compile_flags ( idl_global->compile_flags () | IDL_CF_ONLY_USAGE ); } break; default: ACE_ERROR (( LM_ERROR, ACE_TEXT ("IDL: I dont' understand the use of") ACE_TEXT (" %s with the '-Y' option\n"), ACE_TEXT_CHAR_TO_TCHAR (s) )); idl_global->set_compile_flags ( idl_global->compile_flags () | IDL_CF_ONLY_USAGE ); break; } break; case 'd': idl_global->set_compile_flags (idl_global->compile_flags () | IDL_CF_DUMP_AST); break; case 'u': idl_global->set_compile_flags (idl_global->compile_flags () | IDL_CF_ONLY_USAGE); break; case 'v': idl_global->set_compile_flags (idl_global->compile_flags () | IDL_CF_INFORMATIVE); break; case 'w': idl_global->set_compile_flags (idl_global->compile_flags () | IDL_CF_NOWARNINGS); break; case 'C': // If identifiers in the same scope differ only by case... if (av[i][2] == 'e') { // ...report an error. idl_global->case_diff_error (true); } else if (av[i][2] == 'w') { // ...report a warning (default for now) idl_global->case_diff_error (false); } else { ACE_ERROR (( LM_ERROR, ACE_TEXT ("IDL: I don't understand the '%s' option\n"), ACE_TEXT_CHAR_TO_TCHAR (av[i]) )); idl_global->set_compile_flags ( idl_global->compile_flags () | IDL_CF_ONLY_USAGE ); } break; default: be_global->parse_args (i, av); break; } // End of switch (av[i][1]) } // End of IF (av[i][0] == '-') else { DRV_push_file (av[i]); } } // End of FOR (i = 1; i < ac; i++) be_util::arg_post_proc (); // Make sure the output directory is valid. if (idl_global->temp_dir () == 0) { ACE_TCHAR tmpdir[MAXPATHLEN + 1]; if (ACE::get_temp_dir (tmpdir, MAXPATHLEN) == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Temporary path too long, ") ACE_TEXT ("defaulting to current directory\n"))); ACE_OS::strcpy (tmpdir, ACE_TEXT (".")); } #if defined(ACE_MVS) if (ACE_OS::access (tmpdir, F_OK) == -1 || ACE_OS::access (tmpdir, R_OK) == -1 || ACE_OS::access (tmpdir, W_OK) == -1) #else if (ACE_OS::access (tmpdir, F_OK | R_OK | W_OK) == -1) #endif /* ACE_MVS */ { ACE_ERROR (( LM_ERROR, ACE_TEXT ("Can't access temporary directory (%s),") ACE_TEXT (" using current directory for temp files.\n"), tmpdir )); ACE_OS::strcpy (tmpdir, ACE_TEXT (".")); #if defined(ACE_MVS) if (ACE_OS::access (tmpdir, F_OK) == -1 || ACE_OS::access (tmpdir, R_OK) == -1 || ACE_OS::access (tmpdir, W_OK) == -1) #else if (ACE_OS::access (tmpdir, F_OK | R_OK | W_OK) == -1) #endif /* ACE_MVS */ { ACE_ERROR ((LM_ERROR, "Error: Can't access temporary directory %s\n", tmpdir)); throw Bailout (); } } idl_global->temp_dir (ACE_TEXT_ALWAYS_CHAR (tmpdir)); } DRV_cpp_post_init (); }
static void * client (void *arg) { ACE_INET_Addr *remote_addr = reinterpret_cast<ACE_INET_Addr *> (arg); ACE_INET_Addr server_addr (remote_addr->get_port_number (), ACE_LOCALHOST); ACE_SOCK_Stream cli_stream; ACE_SOCK_Connector con; ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Connecting to port %d\n"), server_addr.get_port_number())); // Initiate connection with server; don't wait forever if (con.connect (cli_stream, server_addr, &timeout) == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("connection failed"))); Test_Result = 1; return 0; } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) connected to %s\n"), ACE_TEXT_CHAR_TO_TCHAR(server_addr.get_host_name ()))); //******************* TEST 1 ****************************** // // Send the 255 byte buffer in 5 chunks. The // server will verify that the correct data is sent, and that there // is no more and no less. u_char buffer[255]; size_t i; // The server will verify that this data pattern gets there intact. for (i = 0; i < sizeof buffer; ++i) buffer[i] = static_cast<u_char> (i); ACE_TCHAR const test_file[] = ACE_TEXT ("Sendfile_Test_File"); ACE_HANDLE in_fd = ACE_OS::open (test_file, O_CREAT | O_RDWR | O_TRUNC, ACE_DEFAULT_FILE_PERMS); ACE_ASSERT (in_fd != ACE_INVALID_HANDLE); ACE_OS::unlink (test_file); ssize_t const byte_count = ACE_OS::write (in_fd, buffer, sizeof (buffer)); ACE_ASSERT (byte_count == static_cast<ssize_t> (sizeof (buffer))); off_t offset = 0; ssize_t len = ACE_OS::sendfile (cli_stream.get_handle (), in_fd, &offset, byte_count); if (len == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("Test 1, sendfile failed"))); Test_Result = 1; goto cleanup; } else ACE_ASSERT (len == 255); //******************* TEST 2 ****************************** // // The same data is coming back - receive it using recv (size_t n, // ...) and compare it to the original data. u_char buffer2[255]; // Give it a chance to get here ACE_OS::sleep (2); len = cli_stream.recv (4, buffer2, 150, &buffer2[150], 105); if (len != 255) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p; len is %d, but should be 255!\n"), len)); } ACE_ASSERT (len == 255); for (i = 0; i < 255; i++) if (buffer2[i] != buffer[i]) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) Test 2, rcvd byte %d is %d, not %d\n"), i, buffer2[i], buffer[i])); Test_Result = 1; } cleanup: cli_stream.close (); (void) ACE_OS::close (in_fd); return 0; }
int ACE_SOCK_Dgram_Mcast::subscribe_ifs (const ACE_INET_Addr &mcast_addr, const ACE_TCHAR *net_if, int reuse_addr) { ACE_TRACE ("ACE_SOCK_Dgram_Mcast::subscribe_ifs"); if (ACE_BIT_ENABLED (this->opts_, OPT_NULLIFACE_ALL) && net_if == 0) { #if defined (ACE_HAS_IPV6) if (mcast_addr.get_type () == AF_INET6) { size_t nr_subscribed = 0; # if defined(__linux__) struct if_nameindex *intf; intf = ACE_OS::if_nameindex (); if (intf == 0) return -1; int index = 0; while (intf[index].if_index != 0 || intf[index].if_name != 0) { if (this->join (mcast_addr, reuse_addr, ACE_TEXT_CHAR_TO_TCHAR(intf[index].if_name)) == 0) ++nr_subscribed; ++index; } ACE_OS::if_freenameindex (intf); # elif defined (ACE_WIN32) IP_ADAPTER_ADDRESSES tmp_addrs; // Initial call to determine actual memory size needed DWORD dwRetVal; ULONG bufLen = 0; if ((dwRetVal = ::GetAdaptersAddresses (AF_INET6, 0, 0, &tmp_addrs, &bufLen)) != ERROR_BUFFER_OVERFLOW) return -1; // With output bufferlength 0 this can't be right. // Get required output buffer and retrieve info for real. PIP_ADAPTER_ADDRESSES pAddrs; char *buf; ACE_NEW_RETURN (buf, char[bufLen], -1); pAddrs = reinterpret_cast<PIP_ADAPTER_ADDRESSES> (buf); if ((dwRetVal = ::GetAdaptersAddresses (AF_INET6, 0, 0, pAddrs, &bufLen)) != NO_ERROR) { delete[] buf; // clean up return -1; } while (pAddrs) { if (this->join (mcast_addr, reuse_addr, ACE_TEXT_CHAR_TO_TCHAR(pAddrs->AdapterName)) == 0) ++nr_subscribed; pAddrs = pAddrs->Next; } delete[] buf; // clean up # endif /* ACE_WIN32 */ if (nr_subscribed == 0) { errno = ENODEV; return -1; } return 1; } else {
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { // Initialize the ORB CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); // Parse the command-line arguments to get the IOR parse_args (argc, argv); // If ior_input_file exists, Read the file, and get the IOR // else, it must have been specified on the command line if (ior_input_file != 0) { ACE_HANDLE input_file = ACE_OS::open (ior_input_file, 0); if (input_file == ACE_INVALID_HANDLE) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open input file for reading IOR: %s\n", ior_input_file), -1); ACE_Read_Buffer ior_buffer (input_file); char *data = ior_buffer.read (); if (data == 0) ACE_ERROR_RETURN ((LM_ERROR, "Unable to read ior\n"), -1); ior = ACE_OS::strdup (ACE_TEXT_CHAR_TO_TCHAR(data)); ior_buffer.alloc ()->free (data); ACE_OS::close (input_file); } // Get the object reference with the IOR CORBA::Object_var object = orb->string_to_object (ior); CORBA::String_var string; // Narrow the object reference A_var a = A::_narrow (object.in ()); // Narrow the object reference intB_var b = intB::_narrow (a.in ()); // Narrow the object reference C_var c = C::_narrow (a.in ()); // Narrow the object reference D_var d = D::_narrow (c.in ()); string = a->method1 (); ACE_DEBUG ((LM_DEBUG, "%C\n", string.in ())); string = b->method1 (); ACE_DEBUG ((LM_DEBUG, "%C\n", string.in ())); string = b->method2 (); ACE_DEBUG ((LM_DEBUG, "%C\n", string.in ())); string = c->method1 (); ACE_DEBUG ((LM_DEBUG, "%C\n", string.in ())); string = c->method3 (); ACE_DEBUG ((LM_DEBUG, "%C\n", string.in ())); string = d->method1 (); ACE_DEBUG ((LM_DEBUG, "%C\n", string.in ())); string = d->method2 (); ACE_DEBUG ((LM_DEBUG, "%C\n", string.in ())); string = d->method3 (); ACE_DEBUG ((LM_DEBUG, "%C\n", string.in ())); string = d->method4 (); ACE_DEBUG ((LM_DEBUG, "%C\n", string.in ())); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("client"); return 1; } return 0; }