void info_out_data_listener_exec_i::on_one_data ( const ::DDSHello & datum, const ::CCM_DDS::ReadInfo & /* info */) { ++this->received_; ACE_CString rec (datum.hello.in ()); ACE_Date_Time now; int const sec_rec = ACE_OS::atoi (rec.substr (0, 2).c_str() ); if (sec_rec > 0) { int usec_rec = ACE_OS::atoi (rec.substr (3, 6).c_str ()); if (sec_rec != now.second ()) { usec_rec += 10000000; } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("<%C> received <%C> - <%d>. difference <%d>\n"), this->name_.c_str (), datum.hello.in (), datum.iterator, now.microsec () - usec_rec)); } else { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("<%C> received <%C> - <%d>.\n"), this->name_.c_str (), datum.hello.in (), datum.iterator)); } }
Identifier::Identifier (const char *s) : pv_string (0), escaped_ (false) { bool shift = false; if (*s == '_') { // Only one leading underscore is allowed. if (s[1] == '_') { idl_global->err ()->error0 (UTL_Error::EIDL_UNDERSCORE); } shift = true; this->escaped_ = true; ACE_CString str (s); const char *c_prefix = "_cxx_"; if (str.find ("_tc_") == 0 || str.find ("_tao_") == 0) { shift = false; } else if (str.find (c_prefix) == 0) { str = str.substr (ACE_OS::strlen (c_prefix)); const char *eh_suffix = "_excep"; ACE_CString::size_type pos = str.length () - ACE_OS::strlen (eh_suffix); // If we have an AMI exception holder suffix, strip it off. if (str.find (eh_suffix) == pos) { str = str.substr (0, pos); } TAO_IDL_CPP_Keyword_Table cpp_key_tbl; unsigned int len = static_cast<unsigned int> (str.length ()); const TAO_IDL_CPP_Keyword_Entry *entry = cpp_key_tbl.lookup (str.c_str (), len); if (entry != 0) { shift = false; } } } if (shift) { this->pv_string = ACE::strnew (s + 1); } else { this->pv_string = ACE::strnew (s); } }
bool BACIValue::fromString(const ACE_CString value, bool specifyType) { ACE_CString strType; ACE_CString strContent; const char *szType; const char *szContent; unsigned long ulBound = 0; if (specifyType) { ACE_CString::size_type nPos0 = value.find('<'); ACE_CString::size_type nPos1 = value.find(':'); ACE_CString::size_type nPos2 = value.find('>'); if((nPos1 != ACE_CString::npos) && (nPos1 < (nPos2-1))) ulBound = atoi(value.substr(nPos1+1, nPos2-nPos1-1).c_str()); else nPos1 = nPos2; strType = value.substr(nPos0+1, nPos1-nPos0-1); strContent = value.substr(nPos2+1); szType = strType.c_str(); szContent = strContent.c_str(); } else { strType = typeName[type_m]; strContent = value; szType = strType.c_str(); szContent = strContent.c_str(); } /// User defined // special threathment for string (no conversion needed) if(strType.compare(BACIValue::typeName[type_string]) == 0) { if ((ulBound != 0) && (strContent.length() > ulBound)) return false; if(!setType(type_string, ulBound)) return 0; return stringValue(szContent); } PROCESS_INLINE_TYPE(double, BACIdouble) PROCESS_INLINE_TYPE(float, BACIfloat) PROCESS_INLINE_TYPE(long, BACIlong) PROCESS_INLINE_TYPE(longLong, BACIlongLong) PROCESS_INLINE_TYPE(uLongLong, BACIuLongLong) //TBDeleted PROCESS_INLINE_TYPE(pattern, BACIpattern) return false; }
bool GetCmdLine(const ACE_CString& input, ACE_CString& cmd, ACE_CString& remain_input) { if(input.find('\n') != ACE_TString::npos) { size_t pos = input.find('\n'); cmd = input.substr(0, pos+1); size_t len = input.length(); remain_input = input.substr(pos+1, len-pos+1); return true; } return false; }
UTL_ScopedName * FE_Utils::string_to_scoped_name (const char *s) { UTL_ScopedName *retval = 0; ACE_CString str (s); Identifier *id = 0; UTL_ScopedName *sn = 0; while (! str.empty ()) { // Skip a leading double colon. if (str.find (':') == 0) { str = str.substr (2); } // Find the next double colon (if any) and get the next // name segment. ACE_CString::size_type pos = str.find (':'); ACE_CString lname (str.substr (0, pos)); // Construct a UTL_ScopedName segment. ACE_NEW_RETURN (id, Identifier (lname.c_str ()), 0); ACE_NEW_RETURN (sn, UTL_ScopedName (id, 0), 0); // Either make it the head of a new list or the tail of // an existing one. if (retval == 0) { retval = sn; } else { retval->nconc (sn); } // Update the working string. str = str.substr (pos); } return retval; }
bool GetCmd(const ACE_CString& input, ACE_CString& cmd) { size_t nEndCommand = 0; while(nEndCommand < input.length() && input[nEndCommand] != ' ' && input[nEndCommand] != '\r' && input[nEndCommand] != '\n')nEndCommand++; if(nEndCommand) cmd = input.substr(0,nEndCommand); return nEndCommand>0; }
bool FE_Utils::is_include_file_found (ACE_CString & inc_file, UTL_String * idl_file_name) { char abspath[MAXPATHLEN] = ""; char *full_path = 0; // If the include path has literal "s (because of an include // of a Windows path with spaces), we must remove them here. const char *tmp_inc_file = inc_file.c_str (); if (tmp_inc_file && FE_Utils::hasspace (tmp_inc_file) && tmp_inc_file[0] == '\"') { inc_file = inc_file.substr (1, inc_file.length () - 2); } inc_file += ACE_DIRECTORY_SEPARATOR_STR_A; inc_file += idl_file_name->get_string (); full_path = ACE_OS::realpath (inc_file.c_str (), abspath); if (full_path != 0) { FILE *test = ACE_OS::fopen (abspath, "r"); if (test == 0) { return false; } else { // Overwrite inc_file with abspath since the later // is normalized to the native OS representation. inc_file = abspath; ACE_OS::fclose (test); return true; } } return false; }
ACE_TCHAR * ACE::HTBP::ID_Requestor::get_HTID () { if (ACE::HTBP::ID_Requestor::htid_.length() != 0) return ACE::HTBP::ID_Requestor::htid_.rep(); ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, ACE::HTBP::ID_Requestor::htid_lock_, 0); if (ACE::HTBP::ID_Requestor::htid_.length() != 0) return ACE::HTBP::ID_Requestor::htid_.rep(); ACE_SOCK_Stream cli_stream; ACE_TCHAR * htid = 0; if (this->url_.length() == 0 || this->connect_to_server (&cli_stream) == -1 || this->send_request (&cli_stream) == -1) { ACE_Utils::UUID_Generator gen; ACE_Utils::UUID *uuid = gen.generate_UUID (); const ACE_CString *uuidstr = uuid->to_string(); ACE::HTBP::ID_Requestor::htid_ = ACE_TEXT_CHAR_TO_TCHAR (uuidstr->c_str()); delete uuid; return ACE::HTBP::ID_Requestor::htid_.rep(); } iovec recv_buf; ssize_t result = cli_stream.recvv (&recv_buf); cli_stream.close(); if (result > 0) { ACE_CString answer ((char *)recv_buf.iov_base,recv_buf.iov_len); ACE_CString::size_type start = answer.rfind (ACE_TEXT('\n')); if (start == ACE_CString::npos) start = 0; else start++; ACE::HTBP::ID_Requestor::htid_ = ACE_TEXT_CHAR_TO_TCHAR(answer.substr (start).c_str()); htid = ACE::HTBP::ID_Requestor::htid_.rep(); } return htid; }
void Library::set_path (const char *p) { char abspath[1000]; ACE_OS::memset (abspath,0,1000); ssize_t abspathlen = ACE_OS::readlink(p,abspath,999); ACE_CString path (p); if (abspathlen > 0) { abspath[abspathlen] = 0; path = abspath; } ACE_CString::size_type pathsep = path.rfind('/'); if (pathsep == ACE_CString::npos) { path_ = "."; } else { path_ = path.substr(0,pathsep); } }
int BE_GlobalData::outfile_init (TAO_OutStream *& os, const char *file_prefix, const char *file_suffix, const char *guard_prefix, const char *guard_suffix) { ACE_NEW_RETURN (os, TAO_SunSoft_OutStream, -1); ACE_CString fn (idl_global->stripped_filename ()->get_string ()); fn = fn.substr (0, fn.rfind ('.')); fn += file_suffix; const char *path = be_global->output_dir (); ACE_CString target_name; if (path != 0) { target_name = path; target_name += "/"; } target_name += file_prefix; target_name += fn; if (os->open (target_name.c_str ()) != 0) { ACE_ERROR_RETURN ((LM_ERROR, "Failed to open file %s for writing.\n", target_name.c_str ()), -1); } *os << be_nl; os->gen_ifndef_string (fn.c_str (), guard_prefix, guard_suffix); return 0; }
UTL_ScopedName * ast_visitor_reifying::template_module_rel_name (AST_Decl *d) { AST_Decl *tmp = d; ACE_CString name (d->full_name ()); while (tmp != 0) { if (AST_Template_Module::narrow_from_decl (tmp) != 0) { ACE_CString head (tmp->local_name ()->get_string ()); ACE_CString::size_type start = name.find (head) + 2; ACE_CString tail (name.substr (start + head.length ())); return FE_Utils::string_to_scoped_name (tail.c_str ()); } tmp = ScopeAsDecl (tmp->defined_in ()); } return 0; }
UTL_ScopedName * be_visitor_xplicit_pre_proc::xplicit_iface_rel_name (AST_Decl *d) { AST_Decl *tmp = d; ACE_CString name (d->full_name ()); while (tmp != 0) { if (be_home::narrow_from_decl (tmp) != 0) { ACE_CString head (tmp->local_name ()->get_string ()); ACE_CString::size_type start = name.find (head) + 2; ACE_CString tail (name.substr (start + head.length ())); return FE_Utils::string_to_scoped_name (tail.c_str ()); } tmp = ScopeAsDecl (tmp->defined_in ()); } return 0; }
static ACE_THR_FUNC_RETURN process(void* arg){ ACE_INET_Addr addr; ACE_SOCK_Stream stream; ACE_HANDLE handle = (ACE_HANDLE) (intptr_t) arg; stream.set_handle(handle); /*make sure we're not in non-blocking mode.*/ if(stream.disable(ACE_NONBLOCK) == -1){ ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "disable"), 0); } else if(stream.get_remote_addr(addr) == -1){ ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "get_remote_addr"), 0); } ACE_DEBUG ((LM_INFO, "(%P|%t:%l) client %s connected from %d\n", addr.get_host_name (), addr.get_port_number ())); int r_bytes = 0; char buf[SIZE]; ACE_CString cs; do{ r_bytes = stream.recv(buf, SIZE); if(r_bytes == 0 || r_bytes == -1){ ACE_DEBUG((LM_INFO, "(%P|%t:%l) r_bytes = %d, exit from the loop\n", r_bytes)); break; } for(int i=0; i< r_bytes; i++){ cs += buf[i]; } }while(true); stream.close_reader(); /* ACE_DEBUG((LM_INFO, "%s\n", cs.c_str())); */ /*the layout of the message would be: * ^^pq||step1$$ * 1st step: get the d by pq * 2nd calculate * 3rd send back the digest */ int p0, p1; int len = cs.length(); p0 = 2; p1 = cs.find("||"); ACE_CString pq = cs.substr(2, p1 - 2); ACE_CString step1 = cs.substr(p1 + 2, len - p1 -4); /* ACE_DEBUG((LM_INFO, "pq = %s\n step1 = %s\n", pq.c_str(), step1.c_str())); */ //get the d ACE_CString sql = "select d,textid from player0 where pq='"; sql += pq; sql += "'"; /* ACE_DEBUG((LM_INFO, "sql = %s\n", sql.c_str())); */ PGconn* con; con = PQconnectdb("host=45.33.3.188 port=5432 dbname=nv user=dec"); PGresult* res; if(PQstatus(con)!= CONNECTION_OK){ ACE_DEBUG((LM_INFO, "Connection to database failed:%s\n", PQerrorMessage(con))); reclaim_conn(con); } res = PQexec(con, sql.c_str()); int n = PQntuples(res); if(n != 1){ ACE_ERROR((LM_ERROR, "there is significant error: %d\n", n)); // return 0; } ACE_CString d = ""; d += PQgetvalue(res, 0, 0); /* ACE_DEBUG((LM_INFO, "d = %s\n", d.c_str())); */ bn* pq_ = from_hex(&pq); bn* d_ = from_hex(&d); bn* step1_ = from_hex(&step1); bn* step2_ = npmod(step1_ , d_ , pq_ ); ACE_CString* step2 = step2_->to_hex(); //check if the pq is taking the ownnership? /* if pq is 'centralbank', bypass the check, otherwise check the payer whether has the ownnership of the note; * select count(*) from ownership0 o, player0 p where o.owner = p.textid and o.note='0x12345678' and p.pq='0x12345678'; */ bn* e_ = new bn(1); e_->addat(0,0x10001); bn* step3_ = npmod(step2_ , e_ , pq_ ); ACE_CString* rawMsg = encode(step3_); ACE_DEBUG((LM_INFO, "%T :%l step3 = %s\n", rawMsg->c_str())); if(verify_ownership(rawMsg, pq)){ //update the ownership; int pos1 = rawMsg->find("->"); ACE_CString note = rawMsg->substr(2, pos1 -2); int rawlen = rawMsg->length(); ACE_CString id = rawMsg->substr(pos1 + 2, rawlen - pos1 - 6); update_ownership(note, id); /*insert the log entry*/ insert_logentry(pq, *step2, *rawMsg, note, id); stream.send( step2->c_str(), step2->length()); /* ACE_DEBUG((LM_INFO, "%T :%l the step2 message is:\n%s\n", step2->c_str())); */ }else{ ACE_DEBUG((LM_INFO, "%T :%l invalid transfer\n")); ACE_CString reply ="invalid transfer\n"; stream.send( reply.c_str(), reply.length()); } delete step2 ; delete pq_; delete d_; delete step1_; delete step2_; delete e_; delete step3_; delete rawMsg; /* stream.close_writer(); */ stream.close(); ACE_DEBUG((LM_INFO, "%T :%l closed the stream\n")); }
CORBA::ULong TAO_SCIOP_Endpoint::preferred_interfaces (TAO_ORB_Core *oc) { ACE_CString tmp ( oc->orb_params ()->preferred_interfaces ()); ACE_CString::size_type pos = 0; pos = tmp.find (this->host_.in ()); TAO_SCIOP_Endpoint *latest = this; CORBA::ULong count = 0; while (pos != ACE_CString::npos) { // Do we have a "," or an '\0'? ACE_CString::size_type new_pos = tmp.find (",", pos + 1); // Length of the preferred path ACE_CString::size_type length = 0; if (new_pos == ACE_CString::npos) length = tmp.length () - pos; else length = new_pos - pos; ACE_CString rem_tmp = tmp.substr (pos, length); // Search for the ":" ACE_CString::size_type col_pos = rem_tmp.find (":"); if (col_pos == ACE_CString::npos) { pos = tmp.find (latest->host_.in (), pos + length); continue; } ACE_CString path = rem_tmp.substr (col_pos + 1); latest->preferred_path_.host = CORBA::string_dup (path.c_str ()); if (TAO_debug_level > 3) TAOLIB_DEBUG ((LM_DEBUG, "(%P|%t) Adding path [%C] " " as preferred path for [%C]\n", path.c_str (), this->host_.in ())); pos = tmp.find (latest->host_.in (), pos + length); if (pos != ACE_CString::npos) { TAO_Endpoint *tmp_ep = latest->duplicate (); latest->next_ = dynamic_cast<TAO_SCIOP_Endpoint *> (tmp_ep); if (latest->next_ == 0) return count; latest = latest->next_; ++count; } } if (tmp.length () != 0 && !oc->orb_params ()->enforce_pref_interfaces ()) { TAO_Endpoint *tmp_ep = latest->duplicate (); latest->next_ = dynamic_cast<TAO_SCIOP_Endpoint *> (tmp_ep); if (latest->next_ == 0) return count; latest->next_->preferred_path_.host = (const char *) 0; ++count; } return count; }
int be_visitor_ami_pre_proc::visit_interface (be_interface *node) { // We check for an imported node after generating the reply handler. if (node->is_local () || node->is_abstract ()) { return 0; } // The following 3 IF blocks are checks for CCM-related nodes, which // we want to skip until we get AMI integrated with CIAO. // Skip the *EventConsumer added for each eventtype. if (node->is_event_consumer ()) { return 0; } // Check for home equivalent interface. The lookup will find the // home itself, which was declared first. Identifier *node_lname = node->AST_Decl::local_name (); AST_Decl *first_stored = node->defined_in ()->lookup_by_name_local (node_lname, false); if (0 != first_stored && first_stored->node_type () == AST_Decl::NT_home) { return 0; } ACE_CString lname (node_lname->get_string ()); // Skip the *Explict and *Implicit interfaces added for a home. if (lname.substr (lname.length () - 6) == "plicit") { UTL_Scope *s = node->defined_in (); Identifier local_id (lname.substr (0, lname.length () - 8).c_str ()); AST_Decl *d = s->lookup_by_name_local (&local_id, false); local_id.destroy (); if (0 != d) { return 0; } } AST_Module *module = AST_Module::narrow_from_scope (node->defined_in ()); if (!module) { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_ami_pre_proc::" "visit_interface - " "module is null\n"), -1); } be_interface *reply_handler = this->create_reply_handler (node); if (reply_handler) { reply_handler->set_defined_in (node->defined_in ()); // Insert the ami handler after the node, the // exception holder will be placed between these two later. module->be_add_interface (reply_handler, node); // Remember from whom we were cloned reply_handler->original_interface (node); // If this was created for an imported node, it will be wrong // unless we set it. reply_handler->set_imported (node->imported ()); } else { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_ami_pre_proc::" "visit_interface - " "creating the reply handler failed\n"), -1); } if (this->visit_scope (node) == -1) { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_ami_pre_proc::" "visit_interface - " "visit scope failed\n"), -1); } return 0; }
int be_visitor_servant_svh::visit_consumes (be_consumes *node) { if(!be_global->gen_noeventccm ()) { const char *obj_name = node->consumes_type ()->full_name (); const char *port_name = node->local_name ()->get_string (); ACE_CString holder (obj_name); ACE_CString::size_type pos = holder.rfind (':'); const char *ev_lname = 0; if (pos == ACE_CString::npos) { ev_lname = obj_name; } else { holder = holder.substr (pos + 1); ev_lname = holder.c_str (); } os_ << be_uidt_nl << be_nl << "public:" << be_idt_nl; os_ << "// Servant class for the " << port_name << " consumer." << be_nl << "class " << export_macro_.c_str () << " " << ev_lname << "Consumer_" << port_name << "_Servant" << be_idt_nl << ": public virtual ::POA_" << obj_name << "Consumer" << be_uidt_nl << "{" << be_nl << "public:" << be_idt_nl; ACE_CString sname_str ( ScopeAsDecl (node_->defined_in ())->full_name ()); const char *sname = sname_str.c_str (); const char *lname = node_->local_name (); const char *global = (sname_str == "" ? "" : "::"); os_ << ev_lname << "Consumer_" << port_name << "_Servant (" << be_idt_nl << global << sname << "::CCM_" << lname << "_ptr executor," << be_nl << global << sname << "::CCM_" << lname << "_Context_ptr c);" << be_uidt_nl << be_nl; os_ << "virtual ~" << ev_lname << "Consumer_" << port_name << "_Servant (void);"; os_ << be_nl_2 << "virtual void" << be_nl << "push_" << ev_lname << " (" << be_idt_nl << "::" << obj_name << " * evt);" << be_uidt; os_ << be_nl_2 << "/// Inherited from ::Components::EventConsumerBase." << be_nl << "virtual void" << be_nl << "push_event ( ::Components::EventBase * ev);"; os_ << be_nl_2 << "/// Get component implementation." << be_nl << "virtual ::CORBA::Object_ptr" << be_nl << "_get_component (void);"; os_ << be_uidt_nl << be_nl << "protected:" << be_idt_nl; os_ << global << sname << "::CCM_" << lname << "_var" << be_nl << "executor_;"; os_ << be_nl_2 << global << sname << "::CCM_" << lname << "_Context_var" << be_nl << "ctx_;"; os_ << be_uidt_nl << "};"; if (!be_global->gen_lwccm ()) { os_ << be_nl_2 << "virtual ::" << obj_name << "Consumer_ptr" << be_nl << "get_consumer_" << port_name << " (void);"; } os_ << be_uidt_nl << be_nl << "private:" << be_idt_nl; os_ << "void" << be_nl << "setup_consumer_" << port_name << "_i (void);"; os_ << be_uidt_nl << be_nl << "private:" << be_idt_nl; os_ << "::" << obj_name << "Consumer_var" << be_nl << "consumes_" << port_name << "_;"; } return 0; }
void Obj_Module::add_source(const char *p, int imports_only) { ACE_Process nmproc; ACE_Process_Options nm_opts; ACE_CString path (p); ACE_CString::size_type pathsep = path.rfind('/'); ACE_CString src_name; ACE_CString workpath; if (pathsep == ACE_CString::npos) { src_name = path; workpath = "."; } else { src_name = path.substr(pathsep+1); workpath= path.substr(0,pathsep); } ACE_HANDLE pipe[2]; ACE_Pipe io(pipe); nm_opts.working_directory (workpath.c_str()); nm_opts.set_handles (ACE_STDIN,pipe[1]); // Options for the command line shown here are for the GNU nm 2.9.5 int result = nm_opts.command_line ("nm -C %s",src_name.c_str()); // Prevent compiler warning about "unused variable" if ACE_ASSERT is // an empty macro. ACE_UNUSED_ARG (result); ACE_ASSERT (result == 0); nmproc.spawn (nm_opts); if (ACE_OS::close(pipe[1]) == -1) ACE_DEBUG ((LM_DEBUG, "%p\n", "close")); nm_opts.release_handles(); int import_lines = 0; int export_lines = 0; ACE_Message_Block im_buffer (102400); ACE_Message_Block ex_buffer (102400); ACE_Message_Block *im_buf_cur = &im_buffer; ACE_Message_Block *ex_buf_cur = &ex_buffer; char dummy; int eoln = 1; // ACE_Time_Value timeout (1,0); int is_import = 1; int is_export = 1; while (eoln == 1) { for (int i = 0; i < 10; i++) { if (ACE_OS::read(pipe[0],&dummy,1) != 1) { eoln = 2; break; } } if (eoln == 2) break; is_import = dummy == 'U'; is_export = !imports_only && (ACE_OS::strchr("BCDRTVW",dummy) != 0); // if (ACE::recv(pipe[0],&dummy,1,&timeout) != 1) if (ACE_OS::read(pipe[0],&dummy,1) != 1) break; eoln = this->read_line (pipe[0], is_import ? &im_buf_cur : (is_export ? &ex_buf_cur : 0)); import_lines += is_import; export_lines += is_export; } // ACE_DEBUG ((LM_DEBUG, "read %d import lines and %d export lines\n", // import_lines, export_lines)); nmproc.wait (); ACE_OS::close (pipe[0]); this->populate_sig_list (imports_,import_lines,&im_buffer); if (!imports_only) this->populate_sig_list (exports_,export_lines,&ex_buffer); }
int be_visitor_servant_svs::visit_consumes (be_consumes *node) { AST_Type *obj = node->consumes_type (); const char *port_name = node->local_name ()->get_string (); const char *comp_lname = node_->local_name (); ACE_CString comp_sname_str ( ScopeAsDecl (node_->defined_in ())->full_name ()); const char *comp_sname = comp_sname_str.c_str (); const char *global = (comp_sname_str == "" ? "" : "::"); const char *lname = obj->local_name ()->get_string (); const char *fname = obj->full_name (); os_ << be_nl_2 << comp_lname << "_Servant::" << lname << "Consumer_" << port_name << "_Servant::" << lname << "Consumer_" << port_name << "_Servant (" << be_idt << be_idt_nl << global << comp_sname << "::CCM_" << comp_lname << "_ptr executor," << be_nl << global << comp_sname << "::CCM_" << comp_lname << "_Context_ptr c)" << be_uidt_nl << ": executor_ ( " << global << comp_sname << "::CCM_" << comp_lname << "::_duplicate (executor))," << be_idt_nl << "ctx_ ( " << global << comp_sname << "::CCM_" << comp_lname << "_Context::_duplicate (c))" << be_uidt << be_uidt_nl << "{" << be_nl << "}"; os_ << be_nl_2 << comp_lname << "_Servant::" << lname << "Consumer_" << port_name << "_Servant::~" << lname << "Consumer_" << port_name << "_Servant (void)" << be_nl << "{" << be_nl << "}"; os_ << be_nl_2 << "::CORBA::Object_ptr" << be_nl << comp_lname << "_Servant::" << lname << "Consumer_" << port_name << "_Servant::_get_component (void)" << be_nl << "{" << be_idt_nl; if (ACE_OS::strcmp (be_global->ciao_container_type (), "Session") == 0) { os_ << "return this->ctx_->get_CCM_object ();"; } else { os_ << "return ::CORBA::Object::_nil ();"; } os_ << be_uidt_nl << "}"; os_ << be_nl_2 << "void" << be_nl << comp_lname << "_Servant::" << lname << "Consumer_" << port_name << "_Servant::push_" << lname << " (" << be_idt_nl << "::" << fname << " * evt)" << be_uidt_nl << "{" << be_idt_nl << "this->executor_->push_" << port_name << " (evt);" << be_uidt_nl << "}"; os_ << be_nl_2 << "/// Inherited from ::Components::EventConsumerBase." << be_nl << "void" << be_nl << comp_lname << "_Servant::" << lname << "Consumer_" << port_name << "_Servant::push_event (" << be_idt_nl << "::Components::EventBase * ev)" << be_uidt_nl << "{" << be_idt_nl << "::" << fname << " * ev_type =" << be_idt_nl << "::" << fname << "::_downcast (ev);" << be_uidt_nl << be_nl << "if (ev_type != 0)" << be_idt_nl << "{" << be_idt_nl << "this->push_" << lname << " (ev_type);" << be_nl << "return;" << be_uidt_nl << "}" << be_uidt_nl << be_nl << "throw ::Components::BadEventType ();" << be_uidt_nl << "}"; if (!be_global->gen_lwccm ()) { os_ << be_nl_2 << "::" << fname << "Consumer_ptr" << be_nl << node_->local_name () << "_Servant::get_consumer_" << port_name << " (void)" << be_nl << "{" << be_idt_nl << "return" << be_idt_nl << "::" << fname << "Consumer::_duplicate (" << be_idt_nl << "this->consumes_" << port_name << "_.in ());" << be_uidt << be_uidt << be_uidt_nl << "}"; } os_ << be_nl_2 << "void" << be_nl << node_->local_name () << "_Servant::setup_consumer_" << port_name << "_i (void)" << be_nl << "{" << be_idt_nl << "ACE_CString obj_id (this->ins_name_);" << be_nl << "obj_id += \"_" << port_name << "\";" << be_nl_2 << "::CIAO::Container_var cnt_safe =" << be_idt_nl << "::CIAO::Container::_duplicate (" << "this->container_.in ());" << be_uidt_nl << be_nl << "if (::CORBA::is_nil (cnt_safe.in ()))" << be_idt_nl << "{" << be_idt_nl << "throw ::CORBA::INV_OBJREF ();" << be_uidt_nl << "}" << be_uidt_nl << be_nl << "PortableServer::POA_var POA = cnt_safe->the_port_POA ();" << be_nl << node_->local_name () << "_Servant::" << lname << "Consumer_" << port_name << "_Servant *" << port_name << "_servant_impl = " << be_idt_nl << "new " << node_->local_name () << "_Servant::" << lname << "Consumer_" << port_name << "_Servant (" << be_idt_nl << " this->executor_, this->context_);" << be_uidt_nl << be_uidt_nl << be_nl << "PortableServer::ServantBase_var safe_base_servant (" << port_name << "_servant_impl);" << be_nl << "PortableServer::ObjectId_var " << port_name << "_servant_oid =" << be_idt_nl << "PortableServer::string_to_ObjectId (obj_id.c_str());" << be_uidt_nl << be_nl << "POA->activate_object_with_id(" << be_idt_nl << port_name << "_servant_oid.in()," << be_nl << port_name << "_servant_impl);" << be_uidt_nl << be_nl << "::CORBA::Object_var " << port_name << "_servant_impl_obj = " << be_idt_nl << "cnt_safe->generate_reference ( " << be_idt_nl << "obj_id.c_str ()," << be_nl << "\""; ACE_CString work (obj->repoID ()); ACE_CString result (work.substr (0, work.rfind (':'))); result += "Consumer:1.0"; os_ << result.c_str (); os_ << "\"," << be_nl << "::CIAO::Container_Types::FACET_CONSUMER_t);" << be_uidt_nl << be_uidt_nl << "::Components::EventConsumerBase_var ecb =" << be_idt_nl << "::Components::EventConsumerBase::_narrow (" << port_name << "_servant_impl_obj.in ());" << be_uidt_nl << be_nl << "this->add_consumer (\"" << port_name << "\", ecb.in ());" << be_uidt_nl << "}"; return 0; }
void Connection_Manager::load_ep_addr (const char* file_name) { FILE* addr_file = ACE_OS::fopen (file_name, "r"); if (addr_file == 0) { ACE_ERROR ((LM_DEBUG, "Cannot open addr file %C\n", file_name)); return; } else ACE_DEBUG ((LM_DEBUG, "Addr file opened successfully\n")); while (1) { char buf [BUFSIZ]; // Read from the file into a buffer /* int n = ACE_OS::fread (buf, 1, BUFSIZ, addr_file); */ if ((ACE_OS::fgets (buf,BUFSIZ,addr_file)) == 0) { // At end of file break the loop and end the sender. if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG,"End of Addr file\n")); break; } if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "%C\n", buf)); Endpoint_Addresses* addr; ACE_NEW (addr, Endpoint_Addresses); TAO_Tokenizer addr_tokenizer (buf,'/'); ACE_CString flowname; if (addr_tokenizer [0] == 0) { ACE_ERROR ((LM_ERROR, "Corresponding flow name not specified for endpoint addresses\n")); return; } else flowname += addr_tokenizer [0]; if (addr_tokenizer [1] != 0) { ACE_CString token (addr_tokenizer [1]); ACE_CString::size_type pos = token.find ('\r'); if (pos != ACE_CString::npos) { addr->sender_addr = CORBA::string_dup ((token.substr (0, pos)).c_str ()); } else addr->sender_addr = CORBA::string_dup (token.c_str()); pos = addr->sender_addr.find ('\n'); if (pos != ACE_CString::npos) { addr->sender_addr = (addr->sender_addr.substr (0, pos)).c_str (); } } if (addr_tokenizer [2] != 0) { ACE_CString token (addr_tokenizer [2]); ACE_CString::size_type pos = token.find ('\r'); if (pos != ACE_CString::npos) { addr->receiver_addr = CORBA::string_dup ((token.substr (0,pos)).c_str ()); } else addr->receiver_addr = CORBA::string_dup (token.c_str()); pos = addr->receiver_addr.find ('\n'); if (pos != ACE_CString::npos) { addr->receiver_addr = (addr->receiver_addr.substr (0, pos)).c_str (); } } int result = ep_addr_.bind (flowname, addr); if (result == 0) { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "Flowname %C Bound Successfully\n", flowname.c_str ())); } else if (result == 1) ACE_DEBUG ((LM_DEBUG, "Flowname %C already exists\n", flowname.c_str ())); else ACE_DEBUG ((LM_DEBUG, "Flowname %C Bound Failed\n", flowname.c_str ())); } }
/*the accept function*/ static ACE_THR_FUNC_RETURN accept_step1(void *arg) { /*ACE_INET_Addr addr;*/ ACE_SOCK_Stream stream; ACE_HANDLE handle = (ACE_HANDLE)(intptr_t) arg; stream.set_handle(handle); if(stream.disable(ACE_NONBLOCK) == -1){ ACE_ERROR_RETURN((LM_ERROR, "%p\n","get_remote_addr"),0); } /* ACE_DEBUG ((LM_INFO, "(%P|%t) client %s connected from %d\n", addr.get_host_name (), addr.get_port_number ())); */ char* buf = new char[128]; ACE_CString* str = new ACE_CString(); do{ int bytes= stream.recv(buf,128); ACE_DEBUG((LM_INFO, "(%P|%t:%l) bytes = %d\n",bytes)); if(bytes == -1|| bytes == 0){ break; } for(int i=0 ;i < bytes; i++){ *str += buf[i]; } }while(true); delete[] buf; //the input format is '^^pqr->v1$$'; int pos = str->find("->"); int tail = str->find("$$"); ACE_CString* pqr = new ACE_CString(str->substr(2,pos-2)); ACE_CString* pv1 = new ACE_CString(str->substr(pos+2, tail - pos - 2)); ACE_DEBUG((LM_INFO, "(%P|%t:%l) pqr: %s\n pv1:%s\n",pqr->c_str(),pv1->c_str())); bn* _pqr = from_hex(pqr); bn* _v1 = from_hex(pv1); bn* _pr = from_hex(&pr); bn* _r = npmod( _v1, _pr, _pqr); ACE_CString* result = _r->to_hex(); ACE_DEBUG((LM_INFO, "(%P|%t:%l)pqr:%s step1:%s ", pqr->c_str(), result->c_str())); ACE_CString reply = ACE_CString("ack"); stream.send(reply.c_str() , reply.length()); stream.close(); /*send the step1 result to hub:10007 */ ACE_SOCK_Connector connector; ACE_INET_Addr hub_addr(port,hub.c_str()); ACE_DEBUG((LM_DEBUG, "(%P|%t:%l) port:%d host:%s\n", port, hub.c_str())); if(connector.connect(stream, hub_addr) == -1){ ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) %p\n", "connection failed"), 0); } else ACE_DEBUG ((LM_DEBUG, "(%P|%t) connected to %s at port %d\n", hub_addr.get_host_name (), hub_addr.get_port_number ())); /* * message layout: ^^pqr->digest->senderid$$ */ ACE_CString input = ACE_CString("^^"); input += *pqr; input += "->"; input += *result; input += "->"; input += id ; input += "$$"; ACE_DEBUG((LM_INFO, "(%P|%t:%l) input of step1:%s\n", input.c_str())); if(stream.send(input.c_str(),input.length()) != input.length()){ ACE_ERROR((LM_ERROR, "%p\n","send")); } stream.close(); delete str; delete pqr; delete pv1; delete _pqr; delete _v1; delete _pr; delete _r; delete result; return 0; }
/*the repo function talk to the repo.jg.org at a regular interval, 1 minute, and send acknowledgement to repo.jg.org */ static ACE_THR_FUNC_RETURN fetch_step2(void *){ ACE_INET_Addr addr(repo_port, repo_host.c_str()); ACE_SOCK_Connector con; ACE_SOCK_Stream stream; do{ if(con.connect(stream, addr) == -1){ ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t:%l) %p\n", "connection failed"), 0); } else ACE_DEBUG ((LM_DEBUG, "(%P|%t:%l) connected to %s at port %d\n", addr.get_host_name (), addr.get_port_number ())); ACE_CString hb = ACE_CString("^^hb->"); hb+=id+"$$"; ACE_DEBUG((LM_INFO, "%l: %s\n", hb.c_str())); stream.send(hb.c_str(),hb.length()); stream.close_writer(); ACE_DEBUG((LM_INFO, "%l\n")); char* buf = new char[128]; ACE_CString str; do{ int bytes = stream.recv(buf,128); if(bytes == -1 || bytes == 0){ break; } for(int i=0; i< bytes; i++){ str += buf[i]; } }while(true); delete[] buf; stream.close(); ACE_CString acks = ACE_CString("^^"); int p1=2; int p2= str.find("->",p1); int p3 = str.find("->",p2); int p4 = str.find("||",p3); node *head=NULL, *tail=NULL; while(p1 != -1 && p2 != -1 && p3 != -1){ ACE_CString* pqr = new ACE_CString(str.substr(p1, p2 - p1)); ACE_CString* v2 = new ACE_CString(str.substr(p2, p3 - p2)); ACE_CString txn_id = str.substr(p3, p4 - p3); acks+="ack->"+txn_id+"||"; node* n = new node(pqr, v2); if(head == NULL){ head = n; tail = n; }else{ tail->next = n; tail = n; } } acks+="$$"; // delete str; if(con.connect(stream, addr) == -1){ ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t:%l) %p\n", "connection failed"), 0); } else ACE_DEBUG ((LM_DEBUG, "(%P|%t:%l) connected to %s at port %d\n", addr.get_host_name (), addr.get_port_number ())); //send out the acks ACE_DEBUG((LM_INFO, "(%P|%t:%l) %s\n",acks.c_str())); stream.send(acks.c_str(),acks.length()); stream.close(); node* tmp=head; // ACE_SOCK_Connector connector; ACE_INET_Addr _9907addr(9907,"localhost"); //ACE_SOCK_Stream stream; if(con.connect(stream, _9907addr) == -1){ ACE_ERROR_RETURN((LM_ERROR, "(%P|%t:%l) %p\n", "connection failed"),0); }else ACE_DEBUG ((LM_DEBUG, "(%P|%t) connected to %s at port %d\n", _9907addr.get_host_name (), _9907addr.get_port_number ())); ACE_CString reply = ACE_CString("^^"); while(tmp!=NULL){ bn* pqr = from_hex(tmp->pqr); bn* v2 = from_hex(tmp->v2); bn* prv = from_hex(&pr); bn* res = npmod(v2,prv,pqr); ACE_CString* resStr = res->to_hex(); /*send the output to localhost:9907*/ reply += tmp->pqr->c_str(); reply += "->" + *resStr + "||"; ACE_DEBUG((LM_DEBUG, "(%P|%t) %s\n",reply.c_str())); delete pqr; delete v2; delete prv; delete res; delete resStr; tmp = tmp->next; } reply += "$$"; stream.send(reply.c_str(),reply.length()); stream.close(); reclaim_node(head); /*sleep for 1 second, for the next poll;*/ ACE_OS::sleep(1000); }while(true); // delete str; }
int be_visitor_operation_ami_cs::visit_operation (be_operation *node) { // No sendc method for oneway operations. if (node->flags () == AST_Operation::OP_oneway) { return 0; } be_visitor_context ctx; TAO_OutStream *os = this->ctx_->stream (); this->ctx_->node (node); *os << be_nl_2 << "// TAO_IDL - Generated from" << be_nl << "// " << __FILE__ << ":" << __LINE__; // Generate the return type mapping. Return type is simply void. *os << be_nl_2 << "void" << be_nl; // Generate the operation name. // Grab the scope name. be_decl *parent = be_scope::narrow_from_scope (node->defined_in ())->decl (); if (parent == 0) { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_operation_ami_cs::" "visit_operation - " "scope name is nil\n"), -1); } // Generate the scope::operation name. *os << parent->full_name () << "::" << this->ctx_->port_prefix ().c_str () << node->local_name ()->get_string (); // Generate the argument list with the appropriate mapping (same as // in the header file) ctx = *this->ctx_; be_visitor_operation_arglist oa_visitor (&ctx); // Get the AMI version from the strategy class. be_operation *ami_op = node; if (ami_op->accept (&oa_visitor) == -1) { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_operation_ami_cs::" "visit_operation - " "codegen for argument list failed\n"), -1); } // Generate the actual code for the stub. However, if any of the argument // types is "native", we flag a MARSHAL exception. // last argument *os << be_nl << "{" << be_idt; if (node->has_native ()) // native exists => no stub { be_predefined_type bpt (AST_PredefinedType::PT_void, 0); int const status = this->gen_raise_exception ("::CORBA::MARSHAL", ""); if (status == -1) { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_operation_ami_cs::" "visit_operation - " "codegen for has-native exception failed\n"), -1); } } else { *os << be_nl << "if (!this->is_evaluated ())" << be_idt_nl << "{" << be_idt_nl << "::CORBA::Object::tao_object_initialize (this);" << be_uidt_nl << "}" << be_uidt_nl << be_nl; } // Includes the reply handler, but we have to add 1 for the retval anyway. int nargs = ami_op->argument_count (); if (nargs == 1) { // No arguments other than the reply handler, and the return // type is void. No need to generate argument list. *os << be_nl_2 << "TAO::Argument ** _the_tao_operation_signature = 0;"; nargs = 0; // Don't count the reply handler. } else { *os << be_nl<< be_nl << "TAO::Arg_Traits<void>::" << (node->flags () == AST_Operation::OP_oneway && be_global->use_clonable_in_args() ? "clonable_" : "") << "ret_val _tao_retval;"; // Declare the argument helper classes. this->gen_stub_body_arglist (ami_op, os, true); // Assemble the arg helper class pointer array. *os << be_nl_2 << "TAO::Argument *_the_tao_operation_signature[] =" << be_idt_nl << "{" << be_idt_nl << "&_tao_retval"; AST_Argument *arg = 0; UTL_ScopeActiveIterator arg_list_iter (ami_op, UTL_Scope::IK_decls); // For a sendc_* operation, skip the reply handler (first argument). arg_list_iter.next (); for (; ! arg_list_iter.is_done (); arg_list_iter.next ()) { arg = AST_Argument::narrow_from_decl (arg_list_iter.item ()); *os << "," << be_nl << "&_tao_" << arg->local_name (); } *os << be_uidt_nl << "};" << be_uidt; } ACE_CString base (node->local_name ()->get_string ()); /// The sendc_* operation makes the invocation with the /// original operation name. ACE_CString lname_str (base.substr (ACE_OS::strlen ("sendc_"))); const char *lname = lname_str.c_str (); ACE_CString opname (node->is_attr_op () ? "_" : ""); opname += lname; /// Some compilers can't resolve the stream operator overload. const char *op_name = opname.c_str (); ACE_CDR::ULong len = opname.length (); *os << be_nl_2 << "TAO::Asynch_Invocation_Adapter _tao_call (" << be_idt << be_idt_nl << "this," << be_nl << "_the_tao_operation_signature," << be_nl << nargs << "," << be_nl << "\"" << op_name << "\"," << be_nl << len << "," << be_nl; *os << "TAO::TAO_CO_NONE"; if (be_global->gen_direct_collocation()) { *os << " | TAO::TAO_CO_DIRECT_STRATEGY"; } if (be_global->gen_thru_poa_collocation()) { *os << " | TAO::TAO_CO_THRU_POA_STRATEGY"; } *os << be_uidt_nl << ");" << be_uidt; *os << be_nl_2 << "_tao_call.invoke (" << be_idt << be_idt_nl << "ami_handler," << be_nl << "&"; if (parent->is_nested ()) { be_decl *gparent = be_scope::narrow_from_scope (parent->defined_in ())->decl (); *os << gparent->name () << "::"; } *os << "AMI_" << parent->local_name () << "Handler::" << lname << "_reply_stub" << be_uidt_nl << ");" << be_uidt; *os << be_uidt_nl << "}"; return 0; }
// Given a comma separated list of preferred interface directives, which // are of the form <wild_remote>=<wild_local>, this function will retrieve // the list of preferred local ip addresses by matching wild_local against // the list of all local ip interfaces, for any directive where wild_remote // matches the host from our endpoint. void TAO_IIOP_Endpoint::find_preferred_interfaces ( const ACE_CString &host, const ACE_CString &csvPreferred, ACE_Vector<ACE_CString> &preferred) { ACE_Vector<ACE_CString> local_ips; TAO_IIOP_Endpoint_get_ip_interfaces (local_ips); if (local_ips.size () == 0) return; // The outer loop steps through each preferred interface directive // and chains a new endpoint if the remote interface matches the // current endpoint. ACE_CString::size_type index = 0; while (index < csvPreferred.length ()) { ACE_CString::size_type comma = csvPreferred.find (',', index); ACE_CString::size_type assign = csvPreferred.find ('=', index); if (assign == ACE_CString::npos) { assign = csvPreferred.find (':', index); if (assign == ACE_CString::npos) { ACE_ASSERT (assign != ACE_CString::npos); return; } } ACE_CString wild_local; if (comma == ACE_CString::npos) wild_local = csvPreferred.substr (assign + 1); else wild_local = csvPreferred.substr (assign + 1, comma - assign - 1); ACE_CString wild_remote = csvPreferred.substr (index, assign - index); index = comma + 1; // For now, we just try to match against the host literally. In // the future it might be worthwhile to resolve some aliases for // this->host_ using DNS (and possibly reverse DNS) lookups. Then we // could try matching against those too. if (ACE::wild_match (host.c_str (), wild_remote.c_str (), false)) { // If it's a match, then it means we need to use any/all // local interface(s) that matches wild_local. const char *const wild_local_cstr = wild_local.c_str (); bool found= false; for (size_t i = 0u; i < local_ips.size (); ++i) { ACE_CString &ret = local_ips[i]; if (ACE::wild_match (ret.c_str (), wild_local_cstr)) { found= true; TAO_IIOP_Endpoint_none_duplicate_insert (ret, preferred); } } if (!found) { #if defined (ACE_HAS_IPV6) // We interpret the preferred wild_local as an actual interface name/id. // This is useful for link local IPv6 multicast ACE_CString if_name ("if="); if_name += wild_local; TAO_IIOP_Endpoint_none_duplicate_insert (if_name, preferred); #else // There is no matching local interface, so we can skip // to the next preferred interface directive. #endif } } else { // The preferred interface directive is for a different // remote endpoint. } if (comma == ACE_CString::npos) break; } }
// receive the heartbeat information, and return back the enquened messages; static ACE_THR_FUNC_RETURN commu(void* arg){ ACE_INET_Addr addr; ACE_SOCK_Stream stream; ACE_HANDLE handle =(ACE_HANDLE)(intptr_t) arg; stream.set_handle(handle); if(stream.disable(ACE_NONBLOCK) == -1){ ACE_ERROR_RETURN((LM_ERROR, "%p\n","disable"),0); } else if(stream.get_remote_addr(addr)== -1){ ACE_ERROR_RETURN((LM_ERROR, "%p\n","get_remote_addr"),0); } ACE_DEBUG((LM_INFO, "(%P|%t) client %s connected from %d\n", addr.get_host_name(),addr.get_port_number())); ACE_CString str ; char* ch = new char[128]; do{ int bytes = stream.recv(ch, 128); if(bytes == -1){ ACE_ERROR((LM_ERROR, "%p\n","recv")); break; } if(bytes == 0){ ACE_DEBUG((LM_INFO, "(%P|%t) reached end of input, connection closed by client\n")); break; } for(int i = 0; i< bytes; i++){ str += ch[i]; } }while(true); delete[] ch; ACE_DEBUG((LM_INFO, "received message:%s\n", str.c_str())); /* the layout of the heartbeat message: ^^hb->senderid$$ */ /*if got a heartbeat message*/ int pos = str.find("^^hb->"); if( pos >= 0 ){ int p2 = str.find("$$"); ACE_CString id= str.substr(6, p2 -6); // delete str; ACE_CString sql = "select pqr, v2,txn_id from step2 where recipient='"+ id +"' and transmitted='false' "; ACE_DEBUG((LM_DEBUG, "%s\n", sql.c_str())); PGconn* con; PGresult* res; con = PQconnectdb("dbname=pq"); if(PQstatus(con)!= CONNECTION_OK){ ACE_DEBUG((LM_INFO, "Connection to database failed:%s\n", PQerrorMessage(con))); reclaim_conn(con); } res = PQexec(con, sql.c_str()); int n = PQntuples(res); if(n == 0){ /*no pending messages at all, exit immediately*/ ACE_DEBUG((LM_INFO, "(%P|%t) no pending messages at all\n")); PQclear(res); reclaim_conn(con); stream.close(); // delete str; return 0; } /*there are pending messages*/ else{ /* the reply message is in format "^^pqr1->v1->txn_id1||pqr2->v2->txn_id2||pqr3->v3->txn_id3||$$"*/ ACE_CString reply = ACE_CString("^^"); for(int i=0; i < n ; i++){ reply += PQgetvalue(res, i, 0); reply += "->"; reply += PQgetvalue(res, i, 1); reply += "->"; reply += PQgetvalue(res, i, 2); reply += "||"; } reply += "$$"; PQclear(res); /* reclaim_conn(con); */ stream.send(reply.c_str(), reply.length()); ACE_DEBUG((LM_INFO, "(%P|%t:%l) %s\n", reply.c_str())); ACE_DEBUG((LM_INFO, "(%P|%t) close the writer\n")); stream.close(); // delete str; return 0; } } /*if got an ack message '^^ack->txn_id2||ack->txn_id2||$$' */ int p = str.find("^^ack->"); if( p >= 0){ PGconn* con; PGresult* res; con = PQconnectdb("dbname=pq"); if(PQstatus(con)!= CONNECTION_OK){ ACE_DEBUG((LM_INFO, "Connection to database failed:%s\n", PQerrorMessage(con))); reclaim_conn(con); } do{ p += 7; int p2 = str.find("||",p); if(p2< 0){ ACE_DEBUG((LM_INFO, "reached the end of the txn_ids\n")); break; } ACE_CString txn_id = str.substr(pos, p2 - p); ACE_CString sql = ACE_CString("update step2 set transmitted=TRUE where txn_id='"); sql += txn_id; sql += "'"; ACE_DEBUG((LM_INFO, "(%P|%t:%l) sql:%s\n" , sql.c_str())); res = PQexec(con, sql.c_str()); PQclear(res); p = p2; }while(true); reclaim_conn(con); stream.close(); // delete str; return 0; } 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 (); }