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