std::string GetStringDefault(const char* name, const std::string &def) { ACE_TString val; return GetValueHelper(name, val) ? val.c_str() : def; };
bool XML_Saver::open(const ACE_TString & base_name, size_t backup_count) { this->base_name_ = base_name; this->backup_count_ = backup_count; if (base_name == ACE_TEXT("cout")) { this->output_ = stdout; this->close_out_ = false; } else if (base_name == ACE_TEXT("cerr")) { this->output_ = stderr; this->close_out_ = false; } else { ACE_TString file_name = base_name; file_name += ACE_TEXT(".new"); this->output_ = ACE_OS::fopen (file_name.c_str(), ACE_TEXT("wb")); if (this->output_) { this->close_out_ = true; } else { ORBSVCS_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) XML_Saver unable to open %s\n"), base_name.c_str())); } } if (this->output_ != 0) { FILE * const out = this->output_; ACE_OS::fprintf (out, "<?xml version=\"1.0\"?>\n"); try { bool changed = true; NVPList attrs; ACE_Time_Value const now = ACE_High_Res_Timer::gettimeofday(); ACE_UINT64 nowus = now.usec(); static const ACE_UINT64 USECSPERSEC = 1000 * 1000; ACE_UINT64 const tmpus = now.sec(); nowus += tmpus * USECSPERSEC; ACE_TCHAR nowusstr[128]; ACE_OS::sprintf(nowusstr, ACE_UINT64_FORMAT_SPECIFIER, nowus); attrs.push_back(NVP("version", "1.0")); if (this->timestamp_) { attrs.push_back(NVP("timestamp", ACE_TEXT_ALWAYS_CHAR(nowusstr))); } this->begin_object(0, "notification_service", attrs, changed); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ( ACE_TEXT ( "(%P|%t) XML_Saver Unknown exception\n")); if (this->close_out_ && this->output_ != 0) { (void) ACE_OS::fclose (this->output_); } this->output_ = 0; } } return this->output_ != 0; }
float GetFloatDefault(const char* name, float def) { ACE_TString val; return GetValueHelper(name, val) ? (float)atof(val.c_str()) : def; };
int ACE_DLL_Handle::open (const ACE_TCHAR *dll_name, int open_mode, ACE_SHLIB_HANDLE handle, ERROR_STACK *errors) { ACE_TRACE ("ACE_DLL_Handle::open"); ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0)); if (this->dll_name_) { // Once dll_name_ has been set, it can't be changed.. if (ACE_OS::strcmp (this->dll_name_, dll_name) != 0) { if (ACE::debug ()) ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("ACE (%P|%t) DLL_Handle::open: error, ") ACE_TEXT ("tried to reopen %s with name %s\n"), this->dll_name_, dll_name)); return -1; } } else this->dll_name_ = ACE::strnew (dll_name); if (!this->open_called_) this->open_called_ = 1; // If it hasn't been loaded yet, go ahead and do that now. if (this->handle_ == ACE_SHLIB_INVALID_HANDLE) { if (handle) this->handle_ = handle; else { /* ** Get the set of names to try loading. We need to do this to ** properly support the ability for a user to specify a simple, ** unadorned name (for example, "ACE") that will work across ** platforms. We apply platform specifics to get a name that will ** work (e.g. libACE, ACEd.dll, ACE.dll, etc.) We rely on the ** underlying dlopen() implementation to "Do The Right Thing" in ** terms of using relative paths, LD_LIBRARY_PATH, system security ** rules, etc. except when ACE_MUST_HELP_DLOPEN_SEARCH_PATH is set. ** If it is set, then ACE::ldfind() scans the configured path ** looking for a match on the name and prefix/suffix applications. ** NOTE: having ACE scan for a file and then pass a fully-qualified ** pathname to dlopen() is a potential security hole; therefore, ** do not use ACE_MUST_HELP_DLOPEN_SEARCH_PATH unless necessary ** and only after considering the risks. */ ACE_Array<ACE_TString> dll_names; dll_names.max_size (10); // Decent guess to avoid realloc later #if defined (ACE_MUST_HELP_DLOPEN_SEARCH_PATH) // Find out where the library is ACE_TCHAR dll_pathname[MAXPATHLEN + 1]; // Transform the pathname into the appropriate dynamic link library // by searching the ACE_LD_SEARCH_PATH. ACE::ldfind (dll_name, dll_pathname, (sizeof dll_pathname / sizeof (ACE_TCHAR))); ACE_TString dll_str (dll_pathname); dll_names.size (1); dll_names.set (dll_str, 0); #else this->get_dll_names (dll_name, dll_names); #endif ACE_Array_Iterator<ACE_TString> name_iter (dll_names); ACE_TString *name = 0; while (name_iter.next (name)) { // The ACE_SHLIB_HANDLE object is obtained. this->handle_ = ACE_OS::dlopen (name->c_str (), open_mode); if (ACE::debug ()) { ACE_TString err; ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE (%P|%t) DLL_Handle::open ") ACE_TEXT ("(\"%s\", 0x%x) -> %s: %s\n"), name->c_str (), open_mode, ((this->handle_ != ACE_SHLIB_INVALID_HANDLE) ? ACE_TEXT ("succeeded") : ACE_TEXT ("failed")), this->error (err).c_str())); } if (this->handle_ != ACE_SHLIB_INVALID_HANDLE) // Good one? break; // If errno is ENOENT we just skip over this one, // anything else - like an undefined symbol, for // instance must be flagged here or the next error will // mask it. // @TODO: If we've found our DLL _and_ it's // broken, should we continue at all? if ((errno != 0) && (errno != ENOENT) && (errors || ACE::debug ())) { ACE_TString errtmp; if (errors) { errors->push (this->error (errtmp)); } if (ACE::debug ()) { if (!errors) this->error (errtmp); ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("ACE (%P|%t) DLL_Handle::open ") ACE_TEXT ("(\'%s\') failed, errno=") ACE_TEXT ("%d: <%s>\n"), name->c_str (), ACE_ERRNO_GET, errtmp.c_str ())); } } #if defined (AIX) // AIX often puts the shared library file (most often named // shr.o) inside an archive library. If this is an archive // library name, then try appending [shr.o] and retry. if (ACE_TString::npos != name->strstr (ACE_TEXT (".a"))) { ACE_TCHAR aix_pathname[MAXPATHLEN + 1]; ACE_OS::strncpy (aix_pathname, name->c_str (), name->length ()); aix_pathname[name->length ()] = '\0'; ACE_OS::strcat (aix_pathname, ACE_TEXT ("(shr.o)")); open_mode |= RTLD_MEMBER; if (ACE::debug ()) { ACE_TString err; ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE (%P|%t) DLL_Handle::open ") ACE_TEXT ("(\"%s\", 0x%x) -> %s: %s\n"), aix_pathname, open_mode, (this->handle_ != ACE_SHLIB_INVALID_HANDLE ? ACE_TEXT ("succeeded") : ACE_TEXT ("failed")), this->error(err).c_str())); } this->handle_ = ACE_OS::dlopen (aix_pathname, open_mode); if (this->handle_ != ACE_SHLIB_INVALID_HANDLE) break; // If errno is ENOENT we just skip over this one, anything // else - like an undefined symbol, for instance // must be flagged here or the next error will mask it. // // @TODO: If we've found our DLL _and_ it's broken, // should we continue at all? if ((errno != 0) && (errno != ENOENT) && (errors || ACE::debug ())) { ACE_TString errtmp; if (errors) { errors->push (this->error (errtmp)); } if (ACE::debug ()) { if (!errors) this->error (errtmp); ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("ACE (%P|%t) DLL_Handle::open ") ACE_TEXT ("(\'%s\') failed, errno=") ACE_TEXT ("%d: <%s>\n"), name->c_str (), ACE_ERRNO_GET, errtmp.c_str ())); } } } #endif /* AIX */ name_iter.advance (); } if (this->handle_ == ACE_SHLIB_INVALID_HANDLE) { if (errors || ACE::debug ()) { ACE_TString errtmp; if (errors) { errors->push (this->error (errtmp)); } if (ACE::debug ()) { if (!errors) this->error (errtmp); ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("ACE (%P|%t) DLL_Handle::open (\"%s\"): ") ACE_TEXT ("Invalid handle error: %s\n"), this->dll_name_, errtmp.c_str ())); } } return -1; } } } ++this->refcount_; if (ACE::debug ()) ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE (%P|%t) DLL_Handle::open - %s (%d), refcount=%d\n"), this->dll_name_, this->handle_, this->refcount_)); return 0; }
int ACE_Ini_ImpExp::export_section (const ACE_Configuration_Section_Key& section, const ACE_TString& path, FILE* out) { // don't export the root if (path.length ()) { // Write out the section header ACE_TString header = ACE_TEXT ("["); header += path; header += ACE_TEXT ("]\n"); if (ACE_OS::fputs (header.fast_rep (), out) < 0) return -1; // Write out each value int index = 0; ACE_TString name; ACE_Configuration::VALUETYPE type; ACE_TString line; ACE_TCHAR int_value[32]; ACE_TCHAR bin_value[3]; void* binary_data; size_t binary_length; ACE_TString string_value; while (!config_.enumerate_values (section, index, name, type)) { line = name + ACE_TEXT ("="); switch (type) { case ACE_Configuration::INTEGER: { u_int value; if (config_.get_integer_value (section, name.fast_rep (), value)) return -2; ACE_OS::sprintf (int_value, ACE_TEXT ("%08x"), value); line += int_value; break; } case ACE_Configuration::STRING: { if (config_.get_string_value (section, name.fast_rep (), string_value)) return -2; line += string_value; break; } #ifdef _WIN32 case ACE_Configuration::INVALID: break; // JDO added break. Otherwise INVALID is processed // like BINARY. If that's correct, please remove the // break and these comments #endif case ACE_Configuration::BINARY: { // not supported yet - maybe use BASE64 codeing? if (config_.get_binary_value (section, name.fast_rep (), binary_data, binary_length)) return -2; line += ACE_TEXT ("\""); unsigned char* ptr = (unsigned char*)binary_data; while (binary_length) { if (ptr != binary_data) { line += ACE_TEXT (","); } ACE_OS::sprintf (bin_value, ACE_TEXT ("%02x"), *ptr); line += bin_value; --binary_length; ++ptr; } line += ACE_TEXT ("\""); delete [] (char *) binary_data; break; } default: return -3; }// end switch on type line += ACE_TEXT ("\n"); if (ACE_OS::fputs (line.fast_rep (), out) < 0) return -4; ++index; }// end while enumerating values } // Export all sub sections int index = 0; ACE_TString name; ACE_Configuration_Section_Key sub_key; ACE_TString sub_section; while (!config_.enumerate_sections (section, index, name)) { ACE_TString sub_section (path); if (path.length ()) sub_section += ACE_TEXT ("\\"); sub_section += name; if (config_.open_section (section, name.fast_rep (), 0, sub_key)) return -5; if (export_section (sub_key, sub_section.fast_rep (), out)) return -6; ++index; } return 0; }
static void writer (void) { ACE_RW_Process_Mutex mutex (mutex_name.c_str ()); // Make sure the constructor succeeded if (ACE_LOG_MSG->op_status () != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Writer, mutex %s %p\n"), mutex_name.c_str (), ACE_TEXT ("ctor"))); return; } ACE_SOCK_Dgram sock; ACE_INET_Addr parent; parent.set (reporting_port, ACE_LOCALHOST, 1, AF_INET); ACE_TCHAR me_str[80]; parent.addr_to_string (me_str, 80); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Sending reports to %s\n"), me_str)); if (sock.open (ACE_Addr::sap_any, PF_INET) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("UDP open"))); Range_Report report; report.child_ = 0; // We're the writer ACE_Time_Value start (ACE_Time_Value::zero), stop (ACE_Time_Value::zero); // Grab the lock if (-1 == mutex.acquire_write ()) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Writer first %p\n"), ACE_TEXT ("acquire_write"))); else { start = ACE_OS::gettimeofday (); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Writer acquired first time\n"))); } // Now sleep, making the readers wait for the lock. Then release the lock, // sleep, and reacquire the lock. ACE_OS::sleep (2); stop = ACE_OS::gettimeofday (); if (-1 == mutex.release ()) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Writer %p\n"), ACE_TEXT ("first release"))); else ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Writer released first time\n"))); report.range_.set (start, stop); ssize_t bytes = sock.send (&report, sizeof (report), parent); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Writer sent %b byte report\n"), bytes)); ACE_OS::sleep (1); // Ensure we don't immediately grab the lock back start = stop = ACE_Time_Value::zero; if (-1 == mutex.acquire_write ()) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Writer second %p\n"), ACE_TEXT ("acquire_write"))); else { start = ACE_OS::gettimeofday (); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Writer acquired second time\n"))); } ACE_OS::sleep (2); stop = ACE_OS::gettimeofday (); if (-1 == mutex.release ()) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Writer %p\n"), ACE_TEXT ("second release"))); else ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Writer released second time\n"))); report.range_.set (start, stop); bytes = sock.send (&report, sizeof (report), parent); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Writer sent %b byte report\n"), bytes)); sock.close (); return; }
// Print an context with <name> and <parent> static void print_context (ACE_Registry::Naming_Context &parent, const ACE_TString &name, u_long indentation) { // Set indentation indent (indentation); cout << name << endl; ACE_Registry::Naming_Context child_context; // Find child context int result = parent.resolve_context (name, child_context, KEY_READ); if (result != 0) ACE_ERROR ((LM_ERROR, "%s %s\n", "ACE_Registry::Naming_Context::resolve_context failed for:", name.c_str ())); else { // Print contents of the child result = ::print_naming_context (child_context, indentation + INDENTATION_LEVEL); if (result != 0) ACE_ERROR ((LM_ERROR, "%p\n", "print_naming_context failed")); } }
int SimpleDataWriter::run(SimplePublisher* publisher) { DBG_ENTRY("SimpleDataWriter","run"); VDBG((LM_DEBUG, "(%P|%t) DBG: " "Build the DataSampleElementList to contain one element - " "our 'Hello World' string.\n")); // We just send one message. // This is what goes in the "Data Block". ACE_TString data = "Hello World!"; // Now we can create the DataSampleHeader struct and set its fields. TAO::DCPS::DataSampleHeader header; // The +1 makes the null terminator ('/0') get placed into the block. header.message_length_ = data.length() + 1; header.message_id_ = 1; header.sequence_ = 0; // TMB - Compiler no longer likes the next line... source_timestamp_ is gone. //header.source_timestamp_ = ACE_OS::gettimeofday().msec(); header.publication_id_ = this->pub_id_; // The DataSampleHeader is what goes in the "Header Block". ACE_Message_Block* header_block = new ACE_Message_Block (header.max_marshaled_size()); header_block << header; // The +1 makes the null terminator ('/0') get placed into the block. ACE_Message_Block* data_block = new ACE_Message_Block(data.length() + 1); data_block->copy(data.c_str()); // Chain the "Data Block" to the "Header Block" header_block->cont(data_block); // Create the DataSampleListElement now. TAO::DCPS::DataSampleListElementAllocator allocator(3); TAO::DCPS::TransportSendElementAllocator trans_allocator(3, sizeof (TAO::DCPS::TransportSendElement)); TAO::DCPS::DataSampleListElement* element; ACE_NEW_MALLOC_RETURN(element, static_cast<TAO::DCPS::DataSampleListElement*> (allocator.malloc(sizeof (TAO::DCPS::DataSampleListElement))), TAO::DCPS::DataSampleListElement(this->pub_id_, this, 0, &trans_allocator), 1); // The Sample Element will hold on to the chain of blocks (header + data). element->sample_ = header_block; // Set up the DataSampleList TAO::DCPS::DataSampleList samples; samples.head_ = element; samples.tail_ = element; samples.size_ = 1; VDBG((LM_DEBUG, "(%P|%t) DBG: " "Ask the publisher to send the DataSampleList (samples).\n")); publisher->send_samples(samples); VDBG((LM_DEBUG, "(%P|%t) DBG: " "The Publisher has finished sending the samples.\n")); return 0; }
CORBA::ExtValueDef::ExtFullValueDescription * TAO_ExtValueDef_i::describe_ext_value_i ( ) { CORBA::ExtValueDef::ExtFullValueDescription *fv_desc = 0; ACE_NEW_RETURN (fv_desc, CORBA::ExtValueDef::ExtFullValueDescription, 0); CORBA::ExtValueDef::ExtFullValueDescription_var retval = fv_desc; ACE_TString holder; this->repo_->config ()->get_string_value (this->section_key_, "name", holder); fv_desc->name = holder.fast_rep (); this->repo_->config ()->get_string_value (this->section_key_, "id", holder); fv_desc->id = holder.fast_rep (); CORBA::ULong val = 0; this->repo_->config ()->get_integer_value (this->section_key_, "is_abstract", val); fv_desc->is_abstract = static_cast<CORBA::Boolean> (val); this->repo_->config ()->get_integer_value (this->section_key_, "is_custom", val); fv_desc->is_custom = static_cast<CORBA::Boolean> (val); this->repo_->config ()->get_string_value (this->section_key_, "container_id", holder); fv_desc->defined_in = holder.fast_rep (); this->repo_->config ()->get_string_value (this->section_key_, "version", holder); fv_desc->version = holder.fast_rep (); // Operations. fv_desc->operations.length (0); ACE_Configuration_Section_Key ops_key; int status = this->repo_->config ()->open_section (this->section_key_, "ops", 0, ops_key); CORBA::ULong count = 0; CORBA::ULong param_count = 0; char *stringified = 0; CORBA::ULong i = 0; CORBA::ULong j = 0; TAO_IDLType_i *idl_type = 0; CORBA::Object_var obj; ACE_Configuration_Section_Key params_key, excepts_key, except_def_key; if (status == 0) { this->repo_->config ()->get_integer_value (ops_key, "count", count); fv_desc->operations.length (count); ACE_Configuration_Section_Key op_key, result_key, contexts_key; for (i = 0; i < count; ++i) { stringified = TAO_IFR_Service_Utils::int_to_string (i); this->repo_->config ()->open_section (ops_key, stringified, 0, op_key); this->repo_->config ()->get_string_value (op_key, "name", holder); fv_desc->operations[i].name = holder.fast_rep (); this->repo_->config ()->get_string_value (op_key, "id", holder); fv_desc->operations[i].id = holder.fast_rep (); this->repo_->config ()->get_string_value (this->section_key_, "id", holder); fv_desc->operations[i].defined_in = holder.fast_rep (); this->repo_->config ()->get_string_value (op_key, "result", holder); idl_type = TAO_IFR_Service_Utils::path_to_idltype (holder, this->repo_); fv_desc->operations[i].result = idl_type->type_i (); this->repo_->config ()->get_integer_value (op_key, "mode", val); fv_desc->operations[i].mode = static_cast<CORBA::OperationMode> (val); CORBA::TCKind kind = fv_desc->operations[i].result->kind (); if (fv_desc->operations[i].mode == CORBA::OP_ONEWAY && kind != CORBA::tk_void) { throw CORBA::BAD_PARAM ( CORBA::OMGVMCID | 31, CORBA::COMPLETED_NO); } // Operation contexts. TAO_IFR_Strseq_Utils<CORBA::ContextIdSeq>::fill_string_seq ( "contexts", this->repo_->config (), op_key, fv_desc->operations[i].contexts ); // Operation parameters. fv_desc->operations[i].parameters.length (0); status = this->repo_->config ()->open_section (op_key, "params", 0, params_key); if (status == 0) { ACE_Configuration_Section_Key param_key; this->repo_->config ()->get_integer_value (params_key, "count", param_count); fv_desc->operations[i].parameters.length (param_count); for (j = 0; j < param_count; ++j) { stringified = TAO_IFR_Service_Utils::int_to_string (j); this->repo_->config ()->open_section (params_key, stringified, 0, param_key); this->repo_->config ()->get_string_value (param_key, "name", holder); fv_desc->operations[i].parameters[j].name = holder.fast_rep (); this->repo_->config ()->get_string_value (param_key, "type_path", holder); idl_type = TAO_IFR_Service_Utils::path_to_idltype (holder, this->repo_); fv_desc->operations[i].parameters[j].type = idl_type->type_i (); obj = TAO_IFR_Service_Utils::path_to_ir_object ( holder, this->repo_ ); fv_desc->operations[i].parameters[j].type_def = CORBA::IDLType::_narrow (obj.in ()); this->repo_->config ()->get_integer_value (param_key, "mode", val); fv_desc->operations[i].parameters[j].mode = static_cast<CORBA::ParameterMode> (val); } } // Operation exceptions. status = this->repo_->config ()->open_section (op_key, "excepts", 0, excepts_key); fv_desc->operations[i].exceptions.length (0); if (status == 0) { CORBA::ULong excep_count = 0; this->repo_->config ()->get_integer_value (excepts_key, "count", excep_count); fv_desc->operations[i].exceptions.length (excep_count); ACE_Configuration_Section_Key except_def_key; for (j = 0; j < excep_count; ++j) { stringified = TAO_IFR_Service_Utils::int_to_string (j); this->repo_->config ()->get_string_value (excepts_key, stringified, holder); this->repo_->config ()->expand_path ( this->repo_->root_key (), holder, except_def_key, 0 ); this->repo_->config ()->get_string_value (except_def_key, "name", holder); fv_desc->operations[i].exceptions[j].name = holder.fast_rep (); this->repo_->config ()->get_string_value (except_def_key, "id", holder); fv_desc->operations[i].exceptions[j].id = holder.fast_rep (); this->repo_->config ()->get_string_value (except_def_key, "container_id", holder); fv_desc->operations[i].exceptions[j].defined_in = holder.fast_rep (); this->repo_->config ()->get_string_value (except_def_key, "version", holder); fv_desc->operations[i].exceptions[j].version = holder.fast_rep (); TAO_ExceptionDef_i impl (this->repo_); impl.section_key (except_def_key); fv_desc->operations[i].exceptions[j].type = impl.type_i (); } } } } // Attributes.. fv_desc->attributes.length (0); ACE_Configuration_Section_Key attrs_key; status = this->repo_->config ()->open_section (this->section_key_, "attrs", 0, attrs_key); if (status == 0) { this->repo_->config ()->get_integer_value (attrs_key, "count", count); fv_desc->attributes.length (count); ACE_Configuration_Section_Key attr_key, attr_def_key; for (i = 0; i < count; ++i) { stringified = TAO_IFR_Service_Utils::int_to_string (i); this->repo_->config ()->open_section (attrs_key, stringified, 0, attr_key); this->repo_->config ()->get_string_value (attr_key, "name", holder); fv_desc->attributes[i].name = holder.fast_rep (); this->repo_->config ()->get_string_value (attr_key, "id", holder); fv_desc->attributes[i].id = holder.fast_rep (); this->repo_->config ()->get_string_value (attr_key, "version", holder); fv_desc->attributes[i].version = holder.fast_rep (); this->repo_->config ()->get_integer_value (attr_key, "mode", val); fv_desc->attributes[i].mode = static_cast<CORBA::AttributeMode> (val); this->repo_->config ()->get_string_value (attr_key, "type_path", holder); // Use the type path for 'defined_in' and 'type'. idl_type = TAO_IFR_Service_Utils::path_to_idltype (holder, this->repo_); fv_desc->attributes[i].type = idl_type->type_i (); this->repo_->config ()->expand_path (this->repo_->root_key (), holder, attr_def_key, 0); this->repo_->config ()->get_string_value (attr_def_key, "container_id", holder); fv_desc->attributes[i].defined_in = holder.fast_rep (); this->fill_exceptions (fv_desc->attributes[i].get_exceptions, attr_key, "get_excepts"); this->fill_exceptions (fv_desc->attributes[i].put_exceptions, attr_key, "put_excepts"); } } // Members.. fv_desc->members.length (0); ACE_Configuration_Section_Key members_key; status = this->repo_->config ()->open_section (this->section_key_, "members", 0, members_key); if (status == 0) { this->repo_->config ()->get_integer_value (members_key, "count", count); fv_desc->members.length (count); ACE_Configuration_Section_Key member_key, member_def_key; for (i = 0; i < count; ++i) { stringified = TAO_IFR_Service_Utils::int_to_string (i); this->repo_->config ()->open_section (members_key, stringified, 0, member_key); this->repo_->config ()->get_string_value (member_key, "name", holder); fv_desc->members[i].name = holder.fast_rep (); this->repo_->config ()->get_string_value (member_key, "id", holder); fv_desc->members[i].id = holder.fast_rep (); this->repo_->config ()->get_string_value (member_key, "container_id", holder); fv_desc->members[i].defined_in = holder.fast_rep (); this->repo_->config ()->get_string_value (member_key, "version", holder); fv_desc->members[i].version = holder.fast_rep (); this->repo_->config ()->get_integer_value (member_key, "access", val); fv_desc->members[i].access = static_cast<CORBA::Visibility> (val); // Use type path for 'type' and 'type_def', this->repo_->config ()->get_string_value (member_key, "type_path", holder); idl_type = TAO_IFR_Service_Utils::path_to_idltype (holder, this->repo_); fv_desc->members[i].type = idl_type->type_i (); obj = TAO_IFR_Service_Utils::path_to_ir_object (holder, this->repo_); fv_desc->members[i].type_def = CORBA::IDLType::_narrow (obj.in ()); } } // Initializers fv_desc->initializers.length (0); ACE_Configuration_Section_Key initializers_key; status = this->repo_->config ()->open_section (this->section_key_, "initializers", 0, initializers_key); if (status == 0) { this->repo_->config ()->get_integer_value (initializers_key, "count", count); fv_desc->initializers.length (count); ACE_Configuration_Section_Key initializer_key, params_key, arg_key, excepts_key; for (i = 0; i < count; ++i) { stringified = TAO_IFR_Service_Utils::int_to_string (i); this->repo_->config ()->open_section (initializers_key, stringified, 0, initializer_key); this->repo_->config ()->get_string_value (initializer_key, "name", holder); fv_desc->initializers[i].name = holder.fast_rep (); fv_desc->initializers[i].members.length (0); status = this->repo_->config ()->open_section (initializer_key, "params", 0, params_key); if (status == 0) { this->repo_->config ()->get_integer_value (params_key, "count", param_count); fv_desc->initializers[i].members.length (param_count); for (j = 0; j < param_count; ++j) { stringified = TAO_IFR_Service_Utils::int_to_string (j); this->repo_->config ()->open_section (params_key, stringified, 0, arg_key); this->repo_->config ()->get_string_value (arg_key, "arg_name", holder); fv_desc->initializers[i].members[j].name = holder.fast_rep (); this->repo_->config ()->get_string_value (arg_key, "arg_path", holder); TAO_IDLType_i *impl = TAO_IFR_Service_Utils::path_to_idltype (holder, this->repo_); fv_desc->initializers[i].members[j].type = impl->type_i (); obj = TAO_IFR_Service_Utils::path_to_ir_object ( holder, this->repo_ ); fv_desc->initializers[i].members[j].type_def = CORBA::IDLType::_narrow (obj.in ()); } } this->fill_exceptions (fv_desc->initializers[i].exceptions, initializer_key, "excepts"); } } TAO_IFR_Strseq_Utils<CORBA::RepositoryIdSeq>::fill_string_seq ( "supported", this->repo_->config (), this->section_key_, fv_desc->supported_interfaces ); TAO_IFR_Strseq_Utils<CORBA::RepositoryIdSeq>::fill_string_seq ( "abstract_bases", this->repo_->config (), this->section_key_, fv_desc->abstract_base_values ); this->repo_->config ()->get_integer_value (this->section_key_, "is_truncatable", val); fv_desc->is_truncatable = static_cast<CORBA::Boolean> (val); status = this->repo_->config ()->get_string_value (this->section_key_, "base_value", holder); if (status == 0) { ACE_Configuration_Section_Key base_key; this->repo_->config ()->expand_path (this->repo_->root_key (), holder, base_key, 0); this->repo_->config ()->get_string_value (base_key, "id", holder); } // If status isn't 0, then holder will be empty anyway. fv_desc->base_value = holder.fast_rep (); fv_desc->type = this->type_i (); return retval._retn (); }
CORBA::InterfaceAttrExtension::ExtFullInterfaceDescription * TAO_InterfaceAttrExtension_i::describe_ext_interface_i ( ) { CORBA::InterfaceAttrExtension::ExtFullInterfaceDescription *fifd = 0; ACE_NEW_RETURN (fifd, CORBA::InterfaceAttrExtension::ExtFullInterfaceDescription, 0); CORBA::InterfaceAttrExtension::ExtFullInterfaceDescription_var retval = fifd; ACE_TString holder; this->repo_->config ()->get_string_value (this->section_key_, "name", holder); fifd->name = holder.fast_rep (); this->repo_->config ()->get_string_value (this->section_key_, "id", holder); fifd->id = holder.fast_rep (); this->repo_->config ()->get_string_value (this->section_key_, "container_id", holder); fifd->defined_in = holder.fast_rep (); this->repo_->config ()->get_string_value (this->section_key_, "version", holder); fifd->version = holder.fast_rep (); CORBA::ULong i = 0; CORBA::ULong j = 0; ACE_Unbounded_Queue<ACE_Configuration_Section_Key> key_queue; // Store our section key for later restoration after we have // traversed entries for inherited interfaces. ACE_Configuration_Section_Key key_holder = this->section_key_; // Operations TAO_InterfaceDef_i iface (this->repo_); iface.section_key (this->section_key_); iface.inherited_operations (key_queue); // Restore our original section key. // I am not sure this is needed but it will not hurt. this->section_key (key_holder); ACE_Configuration_Section_Key ops_key, op_key; int status = this->repo_->config ()->open_section (this->section_key_, "ops", 0, ops_key); CORBA::ULong count = 0; if (status == 0) { this->repo_->config ()->get_integer_value (ops_key, "count", count); for (j = 0; j < count; ++j) { char *stringified = TAO_IFR_Service_Utils::int_to_string (j); status = this->repo_->config ()->open_section (ops_key, stringified, 0, op_key); if (status == 0) { key_queue.enqueue_tail (op_key); } } } CORBA::ULong size = static_cast<CORBA::ULong> (key_queue.size ()); fifd->operations.length (size); for (i = 0; i < size; ++i) { ACE_Configuration_Section_Key key; key_queue.dequeue_head (key); TAO_OperationDef_i op (this->repo_); op.section_key (key); op.make_description (fifd->operations[i]); } // Restore our original section key. // It may have been overwritten by a superclass key as part of the // make_description() call. this->section_key (key_holder); // Attributes. iface.inherited_attributes (key_queue); // Restore our original section key. // I am not sure this is needed but it will not hurt. this->section_key (key_holder); ACE_Configuration_Section_Key attrs_key; status = this->repo_->config ()->open_section (this->section_key_, "attrs", 0, attrs_key); count = 0; if (status == 0) { this->repo_->config ()->get_integer_value (attrs_key, "count", count); for (j = 0; j < count; ++j) { ACE_Configuration_Section_Key attr_key; char *stringified = TAO_IFR_Service_Utils::int_to_string (j); status = this->repo_->config ()->open_section (attrs_key, stringified, 0, attr_key); if (status == 0) { key_queue.enqueue_tail (attr_key); } } } size = static_cast<CORBA::ULong> (key_queue.size ()); fifd->attributes.length (size); for (i = 0; i < size; ++i) { ACE_Configuration_Section_Key key; key_queue.dequeue_head (key); TAO_ExtAttributeDef_i attr (this->repo_); attr.section_key (key); attr.fill_description (fifd->attributes[i]); } // Restore our original section key. // It may have been overwritten by a superclass key as part of the // fill_description() call. this->section_key (key_holder); CORBA::InterfaceDefSeq_var bases = iface.base_interfaces_i (); CORBA::ULong length = bases->length (); CORBA::RepositoryIdSeq repo_ids (length); repo_ids.length (length); PortableServer::ObjectId_var oid; char *base_path = 0; ACE_Configuration_Section_Key base_key; for (i = 0; i < length; ++i) { base_path = TAO_IFR_Service_Utils::reference_to_path (bases[i]); this->repo_->config ()->expand_path (this->repo_->root_key (), base_path, base_key, 0); this->repo_->config ()->get_string_value (base_key, "id", holder); repo_ids[i] = holder.fast_rep (); } fifd->base_interfaces = repo_ids; fifd->type = iface.type_i (); return retval._retn (); }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { CORBA::ORB_var orb; test_var server; RTScheduling::Scheduler_var safe_scheduler; try { try { orb = CORBA::ORB_init (argc, argv); if (parse_args (argc, argv) == -1) return (-1); CORBA::Object_var manager_obj = orb->resolve_initial_references ("RTSchedulerManager"); TAO_RTScheduler_Manager_var manager = TAO_RTScheduler_Manager::_narrow (manager_obj.in ()); TAO_Scheduler* scheduler = 0; ACE_NEW_RETURN (scheduler, TAO_Scheduler (orb.in ()), -1); safe_scheduler = scheduler; manager->rtscheduler (scheduler); CORBA::Object_var object = orb->string_to_object (ior.c_str ()); server = test::_narrow (object.in ()); if (CORBA::is_nil (server.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "ERROR: Object reference <%s> is nil\n", ior.c_str ()), 1); } CORBA::Object_var current_obj = orb->resolve_initial_references ("RTScheduler_Current"); RTScheduling::Current_var current = RTScheduling::Current::_narrow (current_obj.in ()); const char * name = 0; CORBA::Policy_ptr sched_param = 0; CORBA::Policy_ptr implicit_sched_param = 0; current->begin_scheduling_segment (name, sched_param, implicit_sched_param); ACE_DEBUG ((LM_DEBUG, "Making a one-way request\n")); server->one_way (ACE_TEXT_ALWAYS_CHAR(ior.c_str ())); ACE_DEBUG ((LM_DEBUG, "Making a two-way request\n")); server->two_way (ACE_TEXT_ALWAYS_CHAR(ior.c_str ())); current->end_scheduling_segment (name); } catch (const CORBA::THREAD_CANCELLED& ) { ACE_DEBUG ((LM_DEBUG, "Distributable Thread Cancelled - Expected Exception\n")); server->shutdown (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught exception:"); return 0; } orb->destroy (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Caught unexpected exception:"); return 1; } return 0; }
int ACE_DLL_Handle::open (const ACE_TCHAR *dll_name, int open_mode, ACE_SHLIB_HANDLE handle) { ACE_TRACE ("ACE_DLL_Handle::open"); ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0)); //ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("dll_name: %s; open_mode: %d \n"), // dll_name, // open_mode)); if (this->dll_name_) { // Once dll_name_ has been set, it can't be changed.. if (ACE_OS::strcmp (this->dll_name_, dll_name) != 0) { if (ACE::debug ()) ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("ACE_DLL_Handle::open: error, ") ACE_LIB_TEXT ("tried to reopen %s with name %s\n"), this->dll_name_, dll_name)); return -1; } } else this->dll_name_ = ACE::strnew (dll_name); if (!this->open_called_) this->open_called_ = 1; // If it hasn't been loaded yet, go ahead and do that now. if (this->handle_ == ACE_SHLIB_INVALID_HANDLE) { if (handle) this->handle_ = handle; else { if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("ACE_DLL_Handle::open: calling dlopen on ") ACE_LIB_TEXT ("\"%s\"\n"), dll_name)); /* ** Get the set of names to try loading. We need to do this to ** properly support the ability for a user to specify a simple, ** unadorned name (for example, "ACE") that will work across ** platforms. We apply platform specifics to get a name that will ** work (e.g. libACE, ACEd.dll, ACE.dll, etc.) We rely on the ** underlying dlopen() implementation to "Do The Right Thing" in ** terms of using relative paths, LD_LIBRARY_PATH, system security ** rules, etc. except when ACE_MUST_HELP_DLOPEN_SEARCH_PATH is set. ** If it is set, then ACE::ldfind() scans the configured path ** looking for a match on the name and prefix/suffix applications. ** NOTE: having ACE scan for a file and then pass a fully-qualified ** pathname to dlopen() is a potential security hole; therefore, ** do not use ACE_MUST_HELP_DLOPEN_SEARCH_PATH unless necessary ** and only after considering the risks. */ ACE_Array<ACE_TString> dll_names; dll_names.max_size (10); // Decent guess to avoid realloc later #if defined (ACE_MUST_HELP_DLOPEN_SEARCH_PATH) // Find out where the library is ACE_TCHAR dll_pathname[MAXPATHLEN + 1]; // Transform the pathname into the appropriate dynamic link library // by searching the ACE_LD_SEARCH_PATH. ACE::ldfind (dll_name, dll_pathname, (sizeof dll_pathname / sizeof (ACE_TCHAR))); ACE_TString dll_str (dll_pathname); dll_names.size (1); dll_names.set (dll_str, 0); #else this->get_dll_names (dll_name, dll_names); #endif ACE_Array_Iterator<ACE_TString> name_iter (dll_names); ACE_TString *name = 0; while (name_iter.next (name)) { if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("ACE_DLL_Handle::open: Trying to open DLL %s with %s name\n"), this->dll_name_, name->c_str ())); // The ACE_SHLIB_HANDLE object is obtained. this->handle_ = ACE_OS::dlopen (name->c_str (), open_mode); if (this->handle_ != ACE_SHLIB_INVALID_HANDLE) // Good one break; #if defined (AIX) // AIX often puts the shared library file (most often named // shr.o) inside an archive library. If this is an archive // library name, then try appending [shr.o] and retry. if (ACE_TString::npos != name->strstr (ACE_LIB_TEXT (".a"))) { ACE_TCHAR aix_pathname[MAXPATHLEN + 1]; ACE_OS::strncpy (aix_pathname, name->c_str (), name->length ()); aix_pathname[name->length ()] = '\0'; ACE_OS::strcat (aix_pathname, ACE_LIB_TEXT ("(shr.o)")); open_mode |= RTLD_MEMBER; this->handle_ = ACE_OS::dlopen (aix_pathname, open_mode); if (this->handle_ != ACE_SHLIB_INVALID_HANDLE) break; } #endif /* AIX */ name_iter.advance (); } if (this->handle_ == ACE_SHLIB_INVALID_HANDLE) { if (ACE::debug ()) ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("ACE_DLL_Handle::open: Invalid handle when opening DLL %s: %s\n"), this->dll_name_, this->error ()->c_str ())); return -1; } } } if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("ACE_DLL_Handle::open: loading %s (%d)\n"), this->dll_name_, this->handle_)); ++this->refcount_; return 0; }
void ACE_DLL_Handle::get_dll_names (const ACE_TCHAR *dll_name, ACE_Array<ACE_TString> &try_names) { // Build the array of DLL names to try on this platform by applying the // proper prefixes and/or suffixes to the specified dll_name. ACE_TString base (dll_name); ACE_TString base_dir, base_file, base_suffix; // 1. Separate the dll_name into the dir part and the file part. We // only decorate the file part to determine the names to try loading. int pos = base.rfind (ACE_DIRECTORY_SEPARATOR_CHAR); if (pos != ACE_TString::npos) { base_dir = base.substr (0, static_cast<ssize_t>(pos) + 1); base_file = base.substr (static_cast<size_t>(pos) + 1); } else base_file = base; // 2. Locate the file suffix, if there is one. Move the '.' and the // suffix to base_suffix. if ((pos = base_file.rfind (ACE_LIB_TEXT ('.'))) != ACE_TString::npos) { base_suffix = base_file.substr (static_cast<size_t>(pos)); base_file = base_file.substr (0, static_cast<ssize_t>(pos)); } // 3. Build the combinations to try for this platform. // Try these combinations: // - name as originally given // - name with decorator and platform's suffix appended (if not supplied) // - name with platform's suffix appended (if not supplied) // - name with platform's dll prefix (if it has one) and suffix // - name with platform's dll prefix, decorator, and suffix. // So we need room for 5 entries in try_names. try_names.size (0); if ((try_names.max_size () - try_names.size ()) < 5) try_names.max_size (try_names.max_size () + 5); #if defined (ACE_WIN32) && defined (ACE_LD_DECORATOR_STR) && !defined (ACE_DISABLE_DEBUG_DLL_CHECK) ACE_TString decorator (ACE_LD_DECORATOR_STR); #endif ACE_TString suffix (ACE_DLL_SUFFIX); ACE_TString prefix (ACE_DLL_PREFIX); for (size_t i = 0; i < 5 && try_names.size () < try_names.max_size (); ++i) { ACE_TString try_this; size_t j = try_names.size (); switch (i) { case 0: try_this = dll_name; break; case 1: // Name + decorator + suffix case 2: // Name + suffix case 3: // Prefix + name + decorator + suffix case 4: // Prefix + name + suffix if ( base_suffix.length () > 0 #if !(defined(ACE_WIN32) && defined (ACE_LD_DECORATOR_STR) && !defined (ACE_DISABLE_DEBUG_DLL_CHECK)) || (i == 2 || i == 4) // No decorator desired; skip #endif ) break; try_this = base_dir; if (i > 2) try_this += prefix; try_this += base_file; if (base_suffix.length () > 0) try_this += base_suffix; else { #if defined (ACE_WIN32) && defined (ACE_LD_DECORATOR_STR) && !defined (ACE_DISABLE_DEBUG_DLL_CHECK) try_this += decorator; #endif try_this += suffix; } break; } if (try_this.length ()) { try_names.size (j + 1); try_names.set (try_this, j); } } return; }
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]; } } } }
int GetIntDefault(const char* name, int def) { ACE_TString val; return GetValueHelper(name, val) ? atoi(val.c_str()) : def; };
CORBA::ExtInitializerSeq * TAO_ExtValueDef_i::ext_initializers_i ( ) { CORBA::ExtInitializerSeq *iseq = 0; ACE_NEW_RETURN (iseq, CORBA::ExtInitializerSeq, 0); CORBA::ExtInitializerSeq_var retval = iseq; ACE_Configuration_Section_Key initializers_key; int status = this->repo_->config ()->open_section (this->section_key_, "initializers", 0, initializers_key); if (status != 0) { iseq->length (0); return retval._retn (); } CORBA::ULong count = 0; this->repo_->config ()->get_integer_value (initializers_key, "count", count); iseq->length (count); char *stringified = 0; ACE_Configuration_Section_Key initializer_key, params_key, arg_key; ACE_TString holder; CORBA::ULong arg_count = 0; for (CORBA::ULong i = 0; i < count; ++i) { stringified = TAO_IFR_Service_Utils::int_to_string (i); this->repo_->config ()->open_section (initializers_key, stringified, 0, initializer_key); this->repo_->config ()->get_string_value (initializer_key, "name", holder); retval[i].name = holder.fast_rep (); status = this->repo_->config ()->open_section (initializer_key, "params", 0, params_key); if (status != 0) { retval[i].members.length (0); continue; } this->repo_->config ()->get_integer_value (params_key, "count", arg_count); retval[i].members.length (arg_count); CORBA::Object_var obj; for (CORBA::ULong j = 0; j < arg_count; ++j) { stringified = TAO_IFR_Service_Utils::int_to_string (j); this->repo_->config ()->open_section (params_key, stringified, 0, arg_key); this->repo_->config ()->get_string_value (arg_key, "arg_name", holder); retval[i].members[j].name = holder.fast_rep (); this->repo_->config ()->get_string_value (arg_key, "arg_path", holder); TAO_IDLType_i *impl = TAO_IFR_Service_Utils::path_to_idltype (holder, this->repo_); retval[i].members[j].type = impl->type_i (); obj = TAO_IFR_Service_Utils::path_to_ir_object (holder, this->repo_); retval[i].members[j].type_def = CORBA::IDLType::_narrow (obj.in ()); } this->fill_exceptions (retval[i].exceptions, initializer_key, "excepts"); } return retval._retn (); }
/* * The set of readers and the writer will operate in a staggered sequence * of acquiring and releasing the lock. The sequence is designed to exercise * waiting behavior of both readers and writer, as well as allowing multiple * readers in, without getting tripped up by any differences in ordering * on different platforms which may favor writers, or vice-versa. * In this timeline, time on seconds is on the left, time holding the lock * is solid, time waiting is dots, acquire/release point is a dash, and * time without the lock is blank. * * TIME WRITER READER1 READER2 READER3 * 0 | * | * 1 | . * | . * 2 - - - * | | * 3 | | - * | | | * 4 - | | * | | * 5 - | * | * 6 - - * | * 7 | . . . * | . . . * 8 - - - - * | | | * 9 | | | * * A file is used to test the sequencing. When the writer first gets the * lock, it will ensure the file is not present. At the end of its time * holding the lock the first time, it will write a "writer 1" string to * the file. When it gets the lock the second time, it will write a * different string to the file, and just before releasing the second time * write a "writer 2" string to the file. The readers all check to be sure * that the file is present and says "writer 1" at the start and end of * their periods of holding the reader lock and, similarly, check for * "writer 2" the second time they hold the lock. */ static void reader (int num) { // Let the writer get there first. ACE_OS::sleep (1); ACE_SOCK_Dgram sock; ACE_INET_Addr parent; parent.set (reporting_port, ACE_LOCALHOST, 1, AF_INET); ACE_TCHAR me_str[80]; parent.addr_to_string (me_str, 80); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Sending reports to %s\n"), me_str)); if (sock.open (ACE_Addr::sap_any, PF_INET) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("UDP open"))); Range_Report report; report.child_ = num; ACE_Time_Value start (ACE_Time_Value::zero), stop (ACE_Time_Value::zero); ACE_RW_Process_Mutex mutex (mutex_name.c_str ()); // Make sure the constructor succeeded if (ACE_LOG_MSG->op_status () != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Reader %d, mutex %s %p\n"), num, mutex_name.c_str (), ACE_TEXT ("ctor"))); return; } ACE_OS::sleep (num); // Grab the lock if (-1 == mutex.acquire_read ()) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Reader %d %p\n"), num, ACE_TEXT ("first acquire_read"))); else { start = ACE_OS::gettimeofday (); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Reader %d acquired first time\n"), num)); } // Wait a bit, then release and report the range held. ACE_OS::sleep (num); // Release the lock then wait; in the interim, the writer should change // the file. stop = ACE_OS::gettimeofday (); if (-1 == mutex.release ()) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Reader %d %p\n"), num, ACE_TEXT ("first release"))); else ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Reader %d released first time\n"), num)); report.range_.set (start, stop); ssize_t bytes = sock.send (&report, sizeof (report), parent); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Reader %d sent %b byte report\n"), num, bytes)); ACE_OS::sleep (4 - num); start = stop = ACE_Time_Value::zero; if (-1 == mutex.acquire_read ()) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Reader %d %p\n"), num, ACE_TEXT ("second acquire_read"))); else { start = ACE_OS::gettimeofday (); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Reader %d acquired second time\n"), num)); } // Done; small delay, release, report, and return. ACE_OS::sleep (1); stop = ACE_OS::gettimeofday (); if (-1 == mutex.release ()) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Reader %d %p\n"), num, ACE_TEXT ("second release"))); else ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Reader %d released second time; done\n"), num)); report.range_.set (start, stop); bytes = sock.send (&report, sizeof (report), parent); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Reader %d sent %b byte report\n"), num, bytes)); sock.close (); return; }
void TAO_Port_Desc_Seq_Utils<T_desc_seq>::port_descriptions ( T_desc_seq &desc_seq, ACE_Configuration *config, ACE_Configuration_Section_Key &key, const char *sub_section ) { ACE_Configuration_Section_Key sub_key; int status = config->open_section (key, sub_section, 0, sub_key); if (status != 0) { desc_seq.length (0); return; } CORBA::ULong count = 0; config->get_integer_value (sub_key, "count", count); desc_seq.length (count); ACE_Configuration_Section_Key desc_key; char *stringified = 0; ACE_TString holder; for (CORBA::ULong i = 0; i < count; ++i) { stringified = TAO_IFR_Service_Utils::int_to_string (i); config->open_section (sub_key, stringified, 0, desc_key); config->get_string_value (desc_key, "name", holder); desc_seq[i].name = holder.c_str (); config->get_string_value (desc_key, "id", holder); desc_seq[i].id = holder.c_str (); /// Seems to me that this field should refer to the component /// where the port is defined - NOT where the base type is defined. config->get_string_value (key, "id", holder); desc_seq[i].defined_in = holder.c_str (); config->get_string_value (desc_key, "version", holder); desc_seq[i].version = holder.c_str (); config->get_string_value (desc_key, "base_type", holder); TAO_Port_Desc_Seq_Utils<T_desc_seq>::port_base_type (desc_seq, holder, i); TAO_Port_Desc_Seq_Utils<T_desc_seq>::get_is_multiple (desc_seq, config, desc_key, i); } }
int run_main (int argc, ACE_TCHAR *argv[]) { parse_args (argc, argv); // Child process code. if (child_nr >= 0) { ACE_TCHAR lognm[MAXPATHLEN]; int mypid (ACE_OS::getpid ()); ACE_OS::sprintf(lognm, ACE_TEXT ("RW_Process_Mutex_Test-child-%d"), (int)mypid); ACE_START_TEST (lognm); if (child_nr == 0) writer (); else reader (child_nr); ACE_END_LOG; } else { ACE_START_TEST (ACE_TEXT ("RW_Process_Mutex_Test")); // Although it should be safe for each process to construct and // destruct the rw lock, this can disturb other process still // using the lock. This is not really correct, and should be // looked at, but it gets things moving. // Also see Process_Mutex_Test.cpp for similar issue. ACE_RW_Process_Mutex mutex (mutex_name.c_str ()); // Make sure the constructor succeeded if (ACE_LOG_MSG->op_status () != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Parent, mutex %s %p\n"), mutex_name.c_str (), ACE_TEXT ("ctor"))); } #if !defined (ACE_WIN32) && defined (ACE_USES_WCHAR) static const ACE_TCHAR* format = ACE_TEXT ("%ls -c %d -p %u -n %ls"); #else static const ACE_TCHAR* format = ACE_TEXT ("%s -c %d -p %u -n %s"); #endif /* !ACE_WIN32 && ACE_USES_WCHAR */ // The parent process reads time ranges sent from the children via // UDP. Grab an unused UDP port to tell the children to send to. ACE_INET_Addr me; ACE_SOCK_Dgram sock; if (sock.open (ACE_Addr::sap_any, PF_INET) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Socket %p\n"), ACE_TEXT ("open")), -1); sock.get_local_addr (me); ACE_TCHAR me_str[80]; me.addr_to_string (me_str, 80); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Receiving on %s\n"), me_str)); // Spawn 1 writer and 3 reader processes that will contend for the // lock. Child writer; Child readers[Nr_Processes - 1]; int i; for (i = 0; i < Nr_Processes; i++) { Child *child = (i == 0 ? &writer : &readers[i-1]); ACE_Process_Options options; options.command_line (format, argc > 0 ? argv[0] : ACE_TEXT ("RW_Process_Mutex_Test"), i, (unsigned int)me.get_port_number (), mutex_name.c_str ()); if (child->spawn (options) == -1) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("spawn of child %d %p\n"), i, ACE_TEXT ("failed")), -1); } else { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Child process %d has pid = %d.\n"), i, (int)(child->getpid ()))); } } // Keep reading time ranges reported from the children until all the // children have exited. Alternate between checking for a range and // checking for exits. int processes = Nr_Processes; Child *children[Nr_Processes]; for (i = 0; i < Nr_Processes; i++) children[i] = (i == 0 ? &writer : &readers[i-1]); Range_Report report; ACE_Time_Value poll (0); ACE_INET_Addr from; ssize_t bytes; while (processes > 0) { ACE_Time_Value limit (10); bytes = sock.recv (&report, sizeof (report), from, 0, &limit); if (bytes > 0) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Report from child %d; %b bytes\n"), report.child_, bytes)); if (report.child_ == 0) writer.add_range (report.range_); else { if (report.child_ >= 1 && report.child_ < Nr_Processes) readers[report.child_ - 1].add_range (report.range_); else ACE_ERROR ((LM_ERROR, ACE_TEXT ("Report from out-of-range child #%d\n"), report.child_)); } } else { if (errno == ETIME) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("UDP time out; check child exits\n"))); else ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("UDP recv"))); } for (i = 0; i < Nr_Processes; i++) { if (children[i] == 0) continue; ACE_exitcode child_status; // See if the child has exited. int wait_result = children[i]->wait (poll, &child_status); if (wait_result == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Wait for child %d, %p\n"), i, ACE_TEXT ("error"))); else if (wait_result != 0) { if (child_status == 0) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Child %d finished ok\n"), (int)(children[i]->getpid ()))); else ACE_ERROR ((LM_ERROR, ACE_TEXT ("Child %d finished with status %d\n"), (int)(children[i]->getpid ()), child_status)); children[i] = 0; --processes; } } } sock.close (); if (0 != mutex.remove ()) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("mutex remove"))); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Comparing time ranges...\n"))); // The writer should never overlap any readers bool writer_overlap = false; for (i = 0; i < Nr_Processes - 1; ++i) { if (writer.any_overlaps (readers[i])) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Writer overlaps reader %d\n"), i+1)); writer_overlap = true; } } if (!writer_overlap) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Writer does not overlap with readers; Ok\n"))); // And there should be some overlap between readers. bool reader_overlap = false; for (i = 0; i < Nr_Processes - 1; ++i) { // Just compare to those higher, else it compares the same ones, // only in reverse. for (int j = i + 1; j < Nr_Processes - 1; ++j) { if (readers[i].any_overlaps (readers[j])) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Reader %d overlaps reader %d; Ok\n"), i + 1, j + 1)); reader_overlap = true; } } } if (!reader_overlap) ACE_ERROR ((LM_ERROR, ACE_TEXT ("No readers overlapped!\n"))); ACE_END_TEST; } return 0; }
int32 Config::GetIntDefault(const char* name, int32 def) { ACE_TString val; return GetValueHelper(mConf, name, val) ? atoi(val.c_str()) : def; }
void ACE_DLL_Handle::get_dll_names (const ACE_TCHAR *dll_name, ACE_Array<ACE_TString> &try_names) { // Build the array of DLL names to try on this platform by applying the // proper prefixes and/or suffixes to the specified dll_name. ACE_TString base (dll_name); ACE_TString base_dir, base_file, base_suffix; // 1. Separate the dll_name into the dir part and the file part. We // only decorate the file part to determine the names to try loading. ACE_TString::size_type pos = base.rfind (ACE_DIRECTORY_SEPARATOR_CHAR); if (pos != ACE_TString::npos) { base_dir = base.substr (0, pos + 1); base_file = base.substr (pos + 1); } else base_file = base; // 2. Locate the file suffix, if there is one. Move the '.' and the // suffix to base_suffix. if ((pos = base_file.rfind (ACE_TEXT ('.'))) != ACE_TString::npos) { base_suffix = base_file.substr (pos); base_file = base_file.substr (0, pos); } // 3. Build the combinations to try for this platform. // Try these combinations: // - name with platform's dll prefix (if it has one) and suffix // - name with platform's dll prefix, decorator, and suffix. // - name with decorator and platform's suffix appended (if not supplied) // - name with platform's suffix appended (if not supplied) // - name as originally given // We first try to find the file using the decorator so that when a // filename with and without decorator is used, we get the file with // the same decorator as the ACE dll has and then as last resort // the one without. For example with msvc, the debug build has a "d" // decorator, but the release build has none and we really want to get // the debug version of the library in a debug application instead // of the release one. // So we need room for 5 entries in try_names. try_names.size (0); if ((try_names.max_size () - try_names.size ()) < 5) try_names.max_size (try_names.max_size () + 5); #if defined (ACE_LD_DECORATOR_STR) && !defined (ACE_DISABLE_DEBUG_DLL_CHECK) ACE_TString decorator (ACE_LD_DECORATOR_STR); #endif ACE_TString suffix (ACE_DLL_SUFFIX); ACE_TString prefix (ACE_DLL_PREFIX); for (size_t i = 0; i < 5 && try_names.size () < try_names.max_size (); ++i) { ACE_TString try_this; size_t const j = try_names.size (); switch (i) { case 0: // Prefix + name + decorator + suffix case 1: // Prefix + name + suffix case 2: // Name + decorator + suffix case 3: // Name + suffix if ( base_suffix.length () > 0 #if !(defined (ACE_LD_DECORATOR_STR) && !defined (ACE_DISABLE_DEBUG_DLL_CHECK)) || (i == 1 || i == 3) // No decorator desired; skip #endif ) break; try_this = base_dir; if (i < 2) try_this += prefix; try_this += base_file; if (base_suffix.length () > 0) try_this += base_suffix; else { #if defined (ACE_LD_DECORATOR_STR) && !defined (ACE_DISABLE_DEBUG_DLL_CHECK) try_this += decorator; #endif try_this += suffix; } break; case 4: try_this = dll_name; break; } if (try_this.length ()) { try_names.size (j + 1); try_names.set (try_this, j); } } return; }
std::string Config::GetStringDefault(const char* name, const char* def) { ACE_TString val; return GetValueHelper(mConf, name, val) ? val.c_str() : def; }
int run_main (int argc, ACE_TCHAR *argv[]) { int retval = 0; MCT_Config config; retval = config.open (argc, argv); if (retval != 0) return 1; const ACE_TCHAR *temp = ACE_TEXT ("Multicast_Test_IPV6"); ACE_TString test = temp; u_long role = config.role (); if (ACE_BIT_DISABLED (role, MCT_Config::PRODUCER) || ACE_BIT_DISABLED (role, MCT_Config::CONSUMER)) { if (ACE_BIT_ENABLED (role, MCT_Config::PRODUCER)) test += ACE_TEXT ("-PRODUCER"); else test += ACE_TEXT ("-CONSUMER"); } // Start test only if options are valid. ACE_START_TEST (test.c_str ()); #if defined (ACE_HAS_IPV6) # if !defined (ACE_LACKS_UNIX_SIGNALS) // Register a signal handler to close down application gracefully. ACE_Sig_Action sa ((ACE_SignalHandler) handler, SIGINT); # endif // Dump the configuration info to the log if caller passed debug option. if (config.debug ()) config.dump (); ACE_Reactor *reactor = ACE_Reactor::instance (); MCT_Task *task = new MCT_Task (config, reactor); if (ACE_BIT_ENABLED (role, MCT_Config::CONSUMER)) { ACE_DEBUG ((LM_INFO, ACE_TEXT ("Starting consumer...\n"))); // Open makes it an active object. retval += task->open (); } // now produce the datagrams... if (ACE_BIT_ENABLED (role, MCT_Config::PRODUCER)) retval += producer (config); if (ACE_BIT_ENABLED (role, MCT_Config::CONSUMER)) { // and wait for everything to finish ACE_DEBUG ((LM_INFO, ACE_TEXT ("start waiting for consumer to finish...\n"))); // Wait for the threads to exit. // But, wait for a limited time since we could hang if the last udp // message isn't received. ACE_Time_Value max_wait ( config.wait ()/* seconds */); ACE_Time_Value wait_time (ACE_OS::gettimeofday () + max_wait); ACE_Time_Value *ptime = ACE_BIT_ENABLED (role, MCT_Config::PRODUCER) ? &wait_time : 0; if (ACE_Thread_Manager::instance ()->wait (ptime) == -1) { if (errno == ETIME) ACE_ERROR ((LM_ERROR, ACE_TEXT ("maximum wait time of %d msec exceeded\n"), max_wait.msec ())); else ACE_OS::perror (ACE_TEXT ("wait")); ++error; } } delete task; #endif /* ACE_HAS_IPV6 */ ACE_END_TEST; return (retval == 0 && error == 0) ? 0 : 1; }
int KSGConfig::loadConfig(const std::string& file_name) { ACE_Configuration_Heap config; if(config.open() == -1) { ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1); } ACE_Ini_ImpExp config_importer(config); if(config_importer.import_config(file_name.c_str()) == -1) { ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1); } ACE_Configuration_Section_Key section; if(config.open_section(config.root_section(),ACE_TEXT(KSG_COMMON_SECT) ,0,section) == -1) { ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1); } ACE_TString v; if(config.get_string_value(section,ACE_TEXT(KSG_MAJOR_VER),v) == -1) { ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1); } _majorVer = ACE_OS::atoi(v.c_str()); if(config.get_string_value(section,KSG_MINOR_VER,v) == -1) { ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1); } _minorVer = ACE_OS::atoi(v.c_str()); if(config.open_section(config.root_section(),ACE_TEXT(KSG_SERVER_SECT) ,0,section) == -1 ) ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1); if(config.get_string_value(section,KSG_SVR_IP,v) == -1) { ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1); } _drtpSvrIP = v.c_str(); if(config.get_string_value(section,KSG_SVR_PORT,v) == -1) ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1); _drtpSvrPort = ACE_OS::atoi(v.c_str()); if(config.get_string_value(section,KSG_SVR_BRANCE_NO,v) == -1) ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1); _drtpNo = ACE_OS::atoi(v.c_str()); if(config.get_string_value(section,KSG_SVR_MAINFUNC,v) == -1) ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1); _drtpMainFunc = ACE_OS::atoi(v.c_str()); if(config.get_string_value(section,KSG_SVR_POOL_CONN,v) == -1) _drtpPoolMaxCnt = 5; else _drtpPoolMaxCnt = ACE_OS::atoi(v.c_str()); if(_drtpPoolMaxCnt < 0) _drtpPoolMaxCnt = 5; if(_drtpPoolMaxCnt > 30) _drtpPoolMaxCnt = 30; if(config.open_section(config.root_section(),ACE_TEXT(KSG_GATEWAY_SECT) ,0,section) == -1) ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1); if(config.get_string_value(section,KSG_GW_IP,v) == -1) ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1); _localIP = v.c_str(); if(config.open_section(config.root_section(),ACE_TEXT(KSG_SCHEDULER_SECT) ,0,section) == -1) ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1); _runTaskIds = ""; if(config.get_string_value(section,KSG_SCHD_IDS,v) != -1) { _runTaskIds = v.c_str(); } _listenerIds = ""; if(config.get_string_value(section,KSG_LISTENER_IDS,v) != -1) { _listenerIds = v.c_str(); } if(config.open_section(config.root_section(),ACE_TEXT(KSG_LOG_SECT) ,0,section) == -1) ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取日志配置失败")),-1); if(config.get_string_value(section,KSG_LOG_LEVEL,v)!=-1) { _logLevel = v.c_str(); } if(config.get_string_value(section,KSG_LOG_APPENDER,v)!=-1) { _logOutput = v.c_str(); } if(config.get_string_value(section,KSG_LOG_FILE,v)!=-1) { _logFilePath = v.c_str(); } if(config.get_string_value(section,KSG_LOG_FILEMAX,v) != -1) { _log_max_file_size = ACE_OS::atoi(v.c_str()); if(_log_max_file_size == 0) _log_max_file_size = 1024; _log_max_file_size *= 1024; if(_log_max_file_size <= 0) _log_max_file_size = 1024 * 1024; } if(config.get_string_value(section,KSG_LOG_MAX_COUNT,v) !=-1) { _log_max_backup = ACE_OS::atoi(v.c_str()); if(_log_max_backup == 0) _log_max_backup = 1; } return 0; }
int init_tranport () { int status = 0; if (sub_using_udp) { reader_transport_impl = TheTransportFactory->create_transport_impl (SUB_TRAFFIC, ACE_TEXT("udp"), OpenDDS::DCPS::DONT_AUTO_CONFIG); OpenDDS::DCPS::TransportConfiguration_rch reader_config = TheTransportFactory->create_configuration (SUB_TRAFFIC, ACE_TEXT("udp")); OpenDDS::DCPS::UdpConfiguration* reader_udp_config = static_cast <OpenDDS::DCPS::UdpConfiguration*> (reader_config.in ()); if (!reader_address_given) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) init_transport: sub UDP") ACE_TEXT(" Must specify an address for UDP.\n"))); return 11; } ACE_INET_Addr reader_address (reader_address_str.c_str ()); reader_udp_config->local_address_ = reader_address; if (reader_transport_impl->configure(reader_config.in()) != 0) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) init_transport: sub UDP") ACE_TEXT(" Failed to configure the transport.\n"))); status = 1; } } else { reader_transport_impl = TheTransportFactory->create_transport_impl (SUB_TRAFFIC, ACE_TEXT("SimpleTcp"), OpenDDS::DCPS::DONT_AUTO_CONFIG); OpenDDS::DCPS::TransportConfiguration_rch reader_config = TheTransportFactory->create_configuration (SUB_TRAFFIC, ACE_TEXT("SimpleTcp")); OpenDDS::DCPS::SimpleTcpConfiguration* reader_tcp_config = static_cast <OpenDDS::DCPS::SimpleTcpConfiguration*> (reader_config.in ()); if (reader_address_given) { ACE_INET_Addr reader_address (reader_address_str.c_str ()); reader_tcp_config->local_address_ = reader_address; reader_tcp_config->local_address_str_ = reader_address_str; } // else use default address - OS assigned. if (reader_transport_impl->configure(reader_config.in()) != 0) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) init_transport: sub TCP ") ACE_TEXT(" Failed to configure the transport.\n"))); status = 1; } } if (pub_using_udp) { writer_transport_impl = TheTransportFactory->create_transport_impl (PUB_TRAFFIC, ACE_TEXT("udp"), OpenDDS::DCPS::DONT_AUTO_CONFIG); OpenDDS::DCPS::TransportConfiguration_rch writer_config = TheTransportFactory->create_configuration (PUB_TRAFFIC, ACE_TEXT("udp")); OpenDDS::DCPS::UdpConfiguration* writer_udp_config = static_cast <OpenDDS::DCPS::UdpConfiguration*> (writer_config.in ()); if (!writer_address_given) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) init_transport: pub UDP") ACE_TEXT(" Must specify an address for UDP.\n"))); return 12; } ACE_INET_Addr writer_address (writer_address_str.c_str ()); writer_udp_config->local_address_ = writer_address; if (writer_transport_impl->configure(writer_config.in()) != 0) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) init_transport: sub UDP") ACE_TEXT(" Failed to configure the transport.\n"))); status = 1; } } else { writer_transport_impl = TheTransportFactory->create_transport_impl (PUB_TRAFFIC, ACE_TEXT("SimpleTcp"), OpenDDS::DCPS::DONT_AUTO_CONFIG); OpenDDS::DCPS::TransportConfiguration_rch writer_config = TheTransportFactory->create_configuration (PUB_TRAFFIC, ACE_TEXT("SimpleTcp")); OpenDDS::DCPS::SimpleTcpConfiguration* writer_tcp_config = static_cast <OpenDDS::DCPS::SimpleTcpConfiguration*> (writer_config.in ()); if (writer_address_given) { ACE_INET_Addr writer_address (writer_address_str.c_str()); writer_tcp_config->local_address_ = writer_address; writer_tcp_config->local_address_str_ = writer_address_str; } // else use default address - OS assigned. if (writer_transport_impl->configure(writer_config.in()) != 0) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) init_transport: sub TCP") ACE_TEXT(" Failed to configure the transport.\n"))); status = 1; } } return status; }
int ExtractProperties(const ACE_TString& input, mstrings_t& properties) { TTASSERT(input.find('\n') == input.rfind('\n')); bool bSyntaxError = false; if( input.length() == 0 ) bSyntaxError = true; size_t offset = input.find(' ');//past command if(offset == ACE_TString::npos) return 0; while(offset < input.length() && !bSyntaxError) { //past any spaces offset = pastBlanks(offset, input); if(offset == input.length()) { break; } size_t propBegin = offset; ACE_TString prop; ACE_TString value; while(offset < input.length()) //extract property name { if( input[offset] != ' ' && input[offset] != '=') offset ++; else break; } if(offset == input.length()) { bSyntaxError = true; //no properties in ACE_TString break; } prop = input.substr(propBegin, offset-propBegin); //set propertyname TTASSERT(properties.find(prop) == properties.end()); offset = pastBlanks(offset, input); //past spaces if(offset == input.length()) { bSyntaxError = true; break; } if(input[offset] != '=') { bSyntaxError = true; break; } else offset ++; //past = offset = pastBlanks(offset, input); //past spaces if(offset == input.length()) { bSyntaxError = true; break; } //determine whether it's a string or an integer if(input[offset] == '"') //a ACE_TString { bool found = false; size_t strBegin = ++offset; //past " while(!found && offset<input.length()) { /* if(input[offset]==ACE_TEXT('\"') && input[offset-1] != ACE_TEXT('\\')) found = true; offset++; */ if(input[offset] == '\\') offset += 2; else if(input[offset] == '"') { found = true; offset++; } else offset++; } if(!found) { bSyntaxError = true; break; } value = input.substr(strBegin, offset-strBegin-1); offset ++; //past \" properties[prop] = RebuildString(value); //properties.SetAt(prop, RebuildString(value)); } else if(input[offset] == '[') // an int list { bool found = false; size_t listBegin = ++offset; //past " while(!found && offset<input.length()) { if(input[offset] == ']') found = true; offset++; } if(!found) { bSyntaxError = true; break; } value = input.substr(listBegin, offset-listBegin-1); offset ++; //past ] properties[prop] = RebuildString(value); //properties.SetAt(prop, RebuildString(value)); } else //eat what's left until space { size_t intBegin = offset; while(offset<input.length() && input[offset] != ' ' && input[offset] != '\r' && input[offset] != '\n') offset ++; //past spaces value = input.substr(intBegin, offset-intBegin); properties[prop] = RebuildString(value); //properties.SetAt(prop, RebuildString(value)); } } return bSyntaxError? -1 : (int)properties.size(); }