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;
}
virtual bool authenticate(ACE::INet::AuthenticationBase& auth) const
{
if (!password.empty ()) auth.password (password);
if (do_login)
{
std::cout << "Authentication (" << auth.scheme() << ") required." << std::endl;
std::cout << "Realm : " << auth.realm () << std::endl
<< "User: "******"Password: \t\t\t (Enter password or press enter for default)\rPassword: ";
char buf[80] = {0};
u_int n = 0;
int ch = 0;
while (n < (sizeof(buf)-1) && (ch = std::cin.get ()) != '\n' && ch != std::char_traits<char>::eof ())
{
buf[n++] = char(ch);
}
if (n>0)
auth.password (buf);
}
return true;
}
int SSL_CallbackManager::passwd_callback (char* buf, int size, int /*rwflag*/, void* user_data)
{
if (user_data == 0)
return 0;
SSL_CallbackManager* cbmngr = reinterpret_cast<SSL_CallbackManager*> (user_data);
ACE_CString pwd;
cbmngr->passwd_callback (pwd);
if (!pwd.empty ())
{
ACE_OS::strncpy (buf, pwd.c_str (), size);
buf[size - 1] = '\0';
if (size > ACE_Utils::truncate_cast<int> (pwd.length ()))
size = ACE_Utils::truncate_cast<int> (pwd.length ());
return size;
}
else
return 0;
}
//
// parse_args
//
int Standard_DAC_App::parse_args (int argc, char * argv [])
{
#if defined (OASIS_HAS_TAO_DAC_SERVANT)
this->orb_ = CORBA::ORB_init (argc, argv);
#endif
const char * optstr = "n:hd:c:v";
ACE_Get_Opt get_opt (argc, argv, optstr);
get_opt.long_option ("name", 'n', ACE_Get_Opt::ARG_REQUIRED);
get_opt.long_option ("database", 'd', ACE_Get_Opt::ARG_REQUIRED);
get_opt.long_option ("config", 'c', ACE_Get_Opt::ARG_REQUIRED);
get_opt.long_option ("help", 'h', ACE_Get_Opt::NO_ARG);
get_opt.long_option ("verbose", 'v', ACE_Get_Opt::NO_ARG);
get_opt.long_option ("debug", ACE_Get_Opt::NO_ARG);
#if defined (OASIS_HAS_TAO_DAC_SERVANT)
get_opt.long_option ("ior-file", ACE_Get_Opt::ARG_REQUIRED);
#endif
ACE_CString config;
// Parse the remaining command-line arguments.
int opt = 0;
while ((opt = get_opt ()) != EOF)
{
switch (opt)
{
case 0:
if (0 == ACE_OS::strcmp ("name", get_opt.long_option ()))
{
DAC::EXECUTION_CONTEXT::instance ()->name (get_opt.long_option ());
}
else if (0 != ACE_OS::strcmp ("database", get_opt.long_option ()))
{
this->connstr_ = get_opt.opt_arg ();
}
else if (0 == ACE_OS::strcmp ("config", get_opt.long_option ()))
{
config = get_opt.opt_arg ();
}
else if (0 == ACE_OS::strcmp ("help", get_opt.long_option ()))
{
this->print_help ();
}
else if (0 == ACE_OS::strcmp ("verbose", get_opt.long_option ()))
{
this->enable_log_level (LM_INFO);
}
else if (0 == ACE_OS::strcmp ("debug", get_opt.long_option ()))
{
this->enable_log_level (LM_DEBUG);
}
#if defined (OASIS_HAS_TAO_DAC_SERVANT)
else if (0 == ACE_OS::strcmp ("ior-file", get_opt.long_option ()))
{
this->servant_.set_trait_value (IOR_File_Trait (), get_opt.opt_arg ());
}
#endif
break;
case 'n':
DAC::EXECUTION_CONTEXT::instance ()->name (get_opt.opt_arg ());
break;
case 'h':
this->print_help ();
break;
case 'd':
this->connstr_ = get_opt.opt_arg ();
break;
case 'v':
this->enable_log_level (LM_INFO);
break;
case 'c':
config = get_opt.opt_arg ();
break;
}
}
if (!config.empty ())
{
// Load the specified configuration, if it exists.
ACE_ERROR ((LM_INFO,
ACE_TEXT ("%T (%t) - %M - loading DAC service configuration %s\n"),
config.c_str ()));
if (!this->svc_config_.load_file (config.c_str ()))
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%T (%t) - %M - failed to load configuration ")
ACE_TEXT ("[file=%s]\n"),
config.c_str ()),
-1);
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv [])
{
ACE_Auto_Ptr<std::ofstream> fout;
std::ostream* sout = &std::cout;
if (!parse_args (argc, argv))
{
return 1;
}
#if defined (ACE_HAS_SSL) && ACE_HAS_SSL == 1
ACE::HTTPS::Context::set_default_ssl_mode (ssl_mode);
ACE::HTTPS::Context::set_default_verify_mode (verify_peer);
ACE::HTTPS::Context::instance ().use_default_ca ();
if (!private_key.empty ())
{
if (certificate.empty ())
{
std::cerr << "ERROR: private key file [" << private_key << "] requires certificate file to be specified." << std::endl;
return 1;
}
if (!ACE::HTTPS::Context::instance ().set_key_files (private_key.c_str (), certificate.c_str ()))
{
std::cerr << "ERROR: failed to set private key [" << private_key << "]." << std::endl;
return 1;
}
}
if (!ca_location.empty ())
{
INET_DEBUG (6, (LM_INFO, DLINFO ACE_TEXT ("loading trusted CA [%C]\n"), ca_location.c_str ()));
if (!ACE::HTTPS::Context::instance ().load_trusted_ca (ca_location.c_str ()))
{
std::cerr << "ERROR: failed to load trusted CA from [" << ca_location << "]." << std::endl;
return 1;
}
INET_DEBUG (6, (LM_INFO, DLINFO ACE_TEXT ("loaded [%d] trusted CA\n"), ACE::HTTPS::Context::instance ().has_trusted_ca ()));
}
if (ignore_verify)
ACE::INet::SSL_CallbackManager::instance ()->set_certificate_callback (new ACE::INet::SSL_CertificateAcceptor);
#endif
std::cout << "Starting..." << std::endl;
if (!url.empty ())
{
if (!outfile.empty ())
{
fout.reset (new std::ofstream (outfile.c_str (), std::ios_base::binary|std::ios_base::out));
if (!*fout)
{
std::cerr << "Failed to open output file : " << outfile.c_str () << std::endl;
return 1;
}
sout = fout.get ();
}
std::cout << "Parsing url [" << url.c_str () << "]" << std::endl;
ACE_Auto_Ptr<ACE::INet::URL_Base> url_safe (ACE::INet::URL_Base::create_from_string (url));
if (url_safe.get () == 0 || url != url_safe->to_string ())
{
std::cerr << "Failed parsing url [" << url << "]" << std::endl;
std::cerr << "\tresult = " << (url_safe.get () == 0 ? "(null)" : url_safe->to_string ().c_str ()) << std::endl;
return 1;
}
ACE::HTTP::URL& http_url = *dynamic_cast<ACE::HTTP::URL*> (url_safe.get ());
if (!proxy_hostname.empty ())
{
std::cout << "Setting proxy: " << proxy_hostname.c_str () << ':' << proxy_port << std::endl;
http_url.set_proxy (proxy_hostname, proxy_port);
}
std::cout << "Opening url...";
My_HTTP_RequestHandler my_rh;
ACE::INet::URLStream urlin = http_url.open (my_rh);
if (urlin)
{
std::cout << "Received response "
<< (int)my_rh.response ().get_status ().get_status ()
<< " "
<< my_rh.response ().get_status ().get_reason ().c_str ()
<< std::endl;
if (my_rh.response ().get_status ().is_ok ())
{
std::cout << "Length: ";
if (my_rh.response ().get_content_length () != ACE::HTTP::Response::UNKNOWN_CONTENT_LENGTH)
std::cout << my_rh.response ().get_content_length () << " [";
else
std::cout << "(unknown) [";
if (my_rh.response ().get_content_type () != ACE::HTTP::Response::UNKNOWN_CONTENT_TYPE)
std::cout << my_rh.response ().get_content_type ().c_str ();
else
std::cout << "(unknown)";
std::cout << "]" << std::endl;
}
std::cout << "Saving to: ";
if (!outfile.empty ())
std::cout << '\'' << outfile.c_str () << '\'' << std::endl;
else
std::cout << "(stdout)" << std::endl;
(*sout) << urlin->rdbuf ();
sout->flush ();
}
}
else
{
std::cerr << "ERROR: No URL specified!" << std::endl;
usage ();
return 1;
}
std::cout << "Done" << std::endl;
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv [])
{
ACE_Auto_Ptr<std::ofstream> fout;
std::ostream* sout = &std::cout;
if (!parse_args (argc, argv))
{
return 1;
}
ACE::INet::URL_INetAuthBase::add_authenticator ("my_auth",
new My_Authenticator);
std::cout << "Starting..." << std::endl;
if (!url.empty ())
{
if (!outfile.empty ())
{
fout.reset (new std::ofstream (outfile.c_str (), std::ios_base::binary|std::ios_base::out));
if (!*fout)
{
std::cerr << "Failed to open output file : " << outfile.c_str () << std::endl;
return 1;
}
sout = fout.get ();
}
ACE::FTP::URL ftp_url;
std::cout << "Parsing url [" << url.c_str () << "]" << std::endl;
if (!ftp_url.parse (url))
{
std::cerr << "Failed parsing url [" << url << "]" << std::endl;
std::cerr << "\tresult = " << ftp_url.to_string ().c_str ();
return 1;
}
std::cout << "Opening url..." << std::endl;
My_FTP_RequestHandler my_rh;
if (do_active) my_rh.use_active_mode ();
ACE::INet::URLStream urlin = ftp_url.open (my_rh);
if (urlin)
{
std::cout << "Saving to: ";
if (!outfile.empty ())
std::cout << '\'' << outfile.c_str () << '\'' << std::endl;
else
std::cout << "(stdout)" << std::endl;
(*sout) << urlin->rdbuf ();
sout->flush ();
}
}
else
{
std::cerr << "ERROR: No URL specified!" << std::endl;
usage ();
return 1;
}
std::cout << "Done" << std::endl;
return 0;
}
void
ImR_Client_Adapter_Impl::imr_notify_startup (TAO_Root_POA* poa )
{
CORBA::Object_var imr = poa->orb_core ().implrepo_service ();
if (CORBA::is_nil (imr.in ()))
{
if (TAO_debug_level > 0)
{
TAOLIB_ERROR ((LM_ERROR,
ACE_TEXT ("TAO_ImR_Client (%P|%t) - ERROR: No usable IMR initial reference ")
ACE_TEXT ("available but use IMR has been specified.\n")));
}
throw ::CORBA::TRANSIENT (
CORBA::SystemException::_tao_minor_code (TAO_IMPLREPO_MINOR_CODE, 0),
CORBA::COMPLETED_NO);
}
if (TAO_debug_level > 0)
{
if (TAO_debug_level > 1)
{
CORBA::ORB_ptr orb = poa->orb_core ().orb ();
CORBA::String_var ior = orb->object_to_string (imr.in ());
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO_ImR_Client (%P|%t) - Notifying ImR of startup IMR IOR <%C>\n"),
ior.in ()));
}
}
ImplementationRepository::Administration_var imr_locator;
{
// ATTENTION: Trick locking here, see class header for details
TAO::Portable_Server::Non_Servant_Upcall non_servant_upcall (*poa);
ACE_UNUSED_ARG (non_servant_upcall);
imr_locator =
ImplementationRepository::Administration::_narrow (imr.in ());
}
if (CORBA::is_nil (imr_locator.in ()))
{
if (TAO_debug_level > 0)
{
TAOLIB_ERROR ((LM_ERROR,
ACE_TEXT ("TAO_ImR_Client (%P|%t) - ERROR: Narrowed IMR initial reference ")
ACE_TEXT ("is nil but use IMR has been specified.\n")));
}
throw ::CORBA::TRANSIENT (
CORBA::SystemException::_tao_minor_code (TAO_IMPLREPO_MINOR_CODE, 0),
CORBA::COMPLETED_NO);
}
TAO_Root_POA *root_poa = poa->object_adapter ().root_poa ();
ACE_NEW_THROW_EX (this->server_object_,
ServerObject_i (poa->orb_core ().orb (),
root_poa),
CORBA::NO_MEMORY ());
PortableServer::ServantBase_var safe_servant (this->server_object_);
ACE_UNUSED_ARG (safe_servant);
// Since this method is called from the POA constructor, there
// shouldn't be any waiting required. Therefore,
// <wait_occurred_restart_call_ignored> can be ignored.
bool wait_occurred_restart_call_ignored = false;
// Activate the servant in the root poa.
PortableServer::ObjectId_var id =
root_poa->activate_object_i (this->server_object_,
poa->server_priority (),
wait_occurred_restart_call_ignored);
CORBA::Object_var obj = root_poa->id_to_reference_i (id.in (), false);
ImplementationRepository::ServerObject_var svr
= ImplementationRepository::ServerObject::_narrow (obj.in ());
if (!svr->_stubobj () || !svr->_stubobj ()->profile_in_use ())
{
if (TAO_debug_level > 0)
{
TAOLIB_ERROR ((LM_ERROR, "TAO_ImR_Client (%P|%t) - Invalid ImR ServerObject, bailing out.\n"));
}
return;
}
CORBA::ORB_var orb = root_poa->_get_orb ();
CORBA::String_var full_ior = orb->object_to_string (obj.in ());
TAO_Profile& profile = *(svr->_stubobj ()->profile_in_use ());
CORBA::String_var ior = profile.to_string();
if (TAO_debug_level > 0)
{
TAOLIB_DEBUG((LM_INFO,
"TAO_ImR_Client (%P|%t) - full_ior <%C>\nior <%C>\n",
full_ior.in(),
ior.in()));
}
char* const pos = find_delimiter (ior.inout (),
profile.object_key_delimiter ());
const ACE_CString partial_ior (ior.in (), (pos - ior.in ()) + 1);
if (TAO_debug_level > 0)
{
CORBA::String_var poaname = poa->the_name ();
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO_ImR_Client (%P|%t) - Informing IMR that <%C> is running at <%C>\n"),
poaname.in(), partial_ior.c_str ()));
}
try
{
// ATTENTION: Trick locking here, see class header for details
TAO::Portable_Server::Non_Servant_Upcall non_servant_upcall (*poa);
ACE_UNUSED_ARG (non_servant_upcall);
ACE_CString const serverId = poa->orb_core ().server_id ();
ACE_CString name;
if (serverId.empty ())
{
name = poa->name ();
}
else
{
name = serverId + ":" + poa->name ();
}
imr_locator->server_is_running (name.c_str (),
partial_ior.c_str (),
svr.in ());
}
catch (const ::CORBA::SystemException&)
{
throw;
}
catch (const ::CORBA::Exception&)
{
throw ::CORBA::TRANSIENT (
CORBA::SystemException::_tao_minor_code (TAO_IMPLREPO_MINOR_CODE, 0),
CORBA::COMPLETED_NO);
}
if (TAO_debug_level > 0)
{
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO_ImR_Client (%P|%t) - Successfully notified ImR of Startup\n")));
}
}