bool
compare_OctetSeqs (const CORBA::OctetSeq& seq1, const CORBA::OctetSeq& seq2)
{
if (seq1.length() != seq2.length())
{
return false;
}
for (unsigned int i = 0; i < seq1.length(); i++)
{
if (seq1[i] != seq2[i])
{
return false;
}
}
return true;
}
bool
Cookie_impl::equal
( Components::Cookie* cook )
{
CORBA::OctetSeq x = cookieValue();
Cookie_impl* cook_impl = dynamic_cast < Cookie_impl* > ( cook );
if ( ! cook_impl )
return false;
CORBA::OctetSeq y = dynamic_cast<Cookie_impl*>(cook) -> cookieValue();
if ( x.length() != y.length() )
return false;
for ( unsigned int i = 0; i < x.length(); i++ )
{
if ( x[i] != y[i] )
return false;
}
return true;
}
CORBA::Boolean
Cookie_impl::equal (Components::Cookie* cook)
{
Cookie_impl* foreign_cook = dynamic_cast<Cookie_impl*>(cook);
if (! foreign_cook)
return false;
CORBA::OctetSeq x = cookieValue();
CORBA::OctetSeq y = foreign_cook->cookieValue();
for (unsigned int i = 0; i < x.length(); i++)
{
if (x[i] != y[i])
return false;
}
return true;
}
bool
test_compression (CORBA::ULong nelements,
Compression::CompressionManager_ptr cm)
{
bool succeed = false;
CORBA::OctetSeq mytest;
mytest.length (nelements);
for (CORBA::ULong j = 0; j != nelements; ++j)
{
mytest[j] = 'a';
}
Compression::Compressor_var compressor = cm->get_compressor (
::Compression::COMPRESSORID_BZIP2, 6);
CORBA::OctetSeq myout;
myout.length ((CORBA::ULong)(mytest.length() * 1.1));
compressor->compress (mytest, myout);
CORBA::OctetSeq decompress;
decompress.length (nelements);
compressor->decompress (myout, decompress);
if (decompress != mytest)
{
ACE_ERROR ((LM_ERROR, "Error, decompress not working\n"));
}
else
{
succeed = true;
ACE_DEBUG ((LM_DEBUG, "Compression worked with bzip2, original "
"size %d, compressed size %d\n",
mytest.length(), myout.length ()));
}
return succeed;
}
void
ServerContainerInterceptor::receive_request (Components::ContainerPortableInterceptor::ContainerServerRequestInfo_ptr csi)
{
std::cout << "COPI: receive_request: " << csi->request_info()->operation();
std::cout << " for id:" << csi->component_id() << std::endl;
#ifdef WIN32
/*
* Get encoded context information
*/
std::string trail_id;
char mess_cnt[11];
unsigned long event_number = executor_ -> get_new_event_number();
sprintf (mess_cnt, "__%08x", event_number);
IOP::ServiceContext_var sc = 0;
char *message_data;
CORBA::Any_var any = new CORBA::Any;
try {
sc = csi->request_info()->get_request_service_context(101);
CORBA::OctetSeq data;
data.length(sc->context_data.length());
memcpy(data.get_buffer(), sc->context_data.get_buffer(), sc->context_data.length());
any = executor_-> get_cdr_codec_ptr() -> decode_value(data, CORBA::_tc_string);
any >>= message_data;
} catch (CORBA::BAD_PARAM&)
{
//no service context for tracing
message_data = new char[11];
strcpy(message_data,mess_cnt);
} catch (...)
{
return;
}
// trail_id = process_id_ + message_data;
trail_id = message_data;
org::coach::tracing::api::TraceEvent_var event = new org::coach::tracing::api::TraceEvent;
// set time_stamp
struct _timeb current_time;
_ftime(¤t_time);
CORBA::LongLong tm = current_time.time;
tm = tm * 1000 + current_time.millitm;
event->time_stamp = tm;
// set ineraction point
event->interaction_point = org::coach::tracing::api::POA_IN;
event->trail_label= CORBA::string_dup ("");
event->message_id = CORBA::string_dup (message_data);
event->thread_id = CORBA::string_dup (message_data);
event->trail_id = CORBA::string_dup ("");
event->event_counter = event_number;
event->op_name = CORBA::string_dup (CORBA::string_dup(csi->request_info()->operation()));
event->identity.object_instance_id = CORBA::string_dup (csi->name());
event->identity.object_repository_id = CORBA::string_dup (csi->request_info()->target_most_derived_interface());
event->identity.cmp_name = CORBA::string_dup (csi->component_id());
event->identity.cmp_type = CORBA::string_dup ("UNKNOWN_COMPONENT_TYPE");
event->identity.cnt_name = CORBA::string_dup ("UNKNOW_CONTAINER_NAME");
event->identity.cnt_type = CORBA::string_dup ("UNKONWN_CONTAINER_TYPE");
event->identity.node_name = CORBA::string_dup (hostname_.c_str());
event->identity.node_ip = CORBA::string_dup (" e");
event->identity.process_id = CORBA::string_dup (process_id_.c_str());
// Dynamic::ParameterList_var parameters = new Dynamic::ParameterList();
// parameters->length(0);
event->parameters.length(0);
org::coach::tracing::api::TraceEvents_var trace = new org::coach::tracing::api::TraceEvents;
trace->length(1);
(*trace)[0] = event;
context_-> get_connection_to_trace_server() -> receiveEvent(trace.in());
#endif
}
void TIDorb::core::compression::ZlibCompressorImpl::compress(
const ::CORBA::OctetSeq& source,
::CORBA::OctetSeq& target)
throw (Compression::CompressionException)
{
// TODO: Control error -> throw adequeate exceptions
// target must have memory now??
int ret, flush;
z_stream strm;
/* allocate deflate state */
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
ret = deflateInit(&strm, m_level);
if (ret != Z_OK)
throw Compression::CompressionException();
unsigned have;
unsigned char out[chunk_size]; // temporal buffer
CORBA::ULong source_length = source.length();
const CORBA::Octet* source_buffer = source.get_buffer();
CORBA::ULong target_length = 0;
//CORBA::Octet* target_buffer = target.get_buffer();
// Set initial input buffer
strm.avail_in = source_length;
strm.next_in = (CORBA::Octet*) source_buffer;
// Set flush flag: strm.next_in has the whole input
flush = Z_FINISH;
// Run deflate() on input until output buffer not full, finish
// compression if all of source has been read in
do {
strm.avail_out = chunk_size;
strm.next_out = out;
ret = deflate(&strm, flush); /* no bad return value */
assert(ret != Z_STREAM_ERROR); /* state not clobbered */
have = chunk_size - strm.avail_out;
if (have > 0) {
// Copy 'out' buffer to 'target' OctetSeq
CORBA::Long current_length = target_length;
target_length += have;
target.length(target_length+1);
memcpy(&(target[current_length]), out, have);
}
} while (strm.avail_out == 0);
assert(strm.avail_in == 0); /* all input will be used */
(void)deflateEnd(&strm);
//m_factory->add_sample(target.length(), source.length());
m_compressed_bytes += target.length();
m_uncompressed_bytes += source.length();
}
void TIDorb::core::compression::ZlibCompressorImpl::decompress(
const ::CORBA::OctetSeq& source,
::CORBA::OctetSeq& target)
throw (Compression::CompressionException)
{
// TODO: Control error -> throw adequeate exceptions
int ret;
z_stream strm;
/* allocate inflate state */
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
strm.avail_in = 0;
strm.next_in = Z_NULL;
ret = inflateInit(&strm);
if (ret != Z_OK)
throw Compression::CompressionException();
unsigned char out[chunk_size]; // temporal buffer
CORBA::ULong source_length = source.length();
const CORBA::Octet* source_buffer = source.get_buffer();
CORBA::ULong target_length = 0;
//CORBA::Octet* target_buffer = target.get_buffer();
// Set initial input buffer
strm.avail_in = source_length;
strm.next_in = (CORBA::Octet*) source_buffer;
unsigned have;
/* run inflate() on input until output buffer not full */
do {
strm.avail_out = chunk_size;
strm.next_out = out;
ret = inflate(&strm, Z_NO_FLUSH);
assert(ret != Z_STREAM_ERROR); /* state not clobbered */
switch (ret) {
case Z_NEED_DICT:
ret = Z_DATA_ERROR; /* and fall through */
throw Compression::CompressionException();
case Z_DATA_ERROR:
case Z_MEM_ERROR:
(void)inflateEnd(&strm);
throw Compression::CompressionException();
}
have = chunk_size - strm.avail_out;
if ( have > 0) {
// Copy 'out' buffer to 'target' OctetSeq
CORBA::Long current_length = target_length;
target_length += have;
target.length(target_length);
memcpy(&(target[current_length]), out, have);
}
} while (strm.avail_out == 0);
/* clean up and return */
(void)inflateEnd(&strm);
}
void
TAO_ServerRequest::send_cached_reply (CORBA::OctetSeq &s)
{
#if defined(ACE_INITIALIZE_MEMORY_BEFORE_USE)
// Only inititialize the buffer if we're compiling with Purify.
// Otherwise, there is no real need to do so, especially since
// we can avoid the initialization overhead at runtime if we
// are not compiling with Purify support.
char repbuf[ACE_CDR::DEFAULT_BUFSIZE] = { 0 };
#else
char repbuf[ACE_CDR::DEFAULT_BUFSIZE];
#endif /* ACE_HAS_PURIFY */
TAO_GIOP_Message_Version gv;
if (this->outgoing_)
{
this->outgoing_->get_version (gv);
}
TAO_OutputCDR output (repbuf,
sizeof repbuf,
TAO_ENCAP_BYTE_ORDER,
this->orb_core_->output_cdr_buffer_allocator (),
this->orb_core_->output_cdr_dblock_allocator (),
this->orb_core_->output_cdr_msgblock_allocator (),
this->orb_core_->orb_params ()->cdr_memcpy_tradeoff (),
this->mesg_base_->fragmentation_strategy (),
gv.major,
gv.minor);
this->transport_->assign_translators (0, &output);
// A copy of the reply parameters
TAO_Pluggable_Reply_Params_Base reply_params;
reply_params.request_id_ = this->request_id_;
reply_params.svc_ctx_.length (0);
// Send back the empty reply service context.
reply_params.service_context_notowned (&this->reply_service_info ());
// We are going to send some data
reply_params.argument_flag_ = true;
// Make a default reply status
reply_params.reply_status (GIOP::NO_EXCEPTION);
this->outgoing_->message_attributes (this->request_id_,
0,
TAO_Message_Semantics (TAO_Message_Semantics::TAO_REPLY),
0);
// Make the reply message
if (this->mesg_base_->generate_reply_header (*this->outgoing_,
reply_params) == -1)
{
TAOLIB_ERROR ((LM_ERROR,
ACE_TEXT ("TAO (%P|%t) - ServerRequest::send_cached_reply, ")
ACE_TEXT ("could not make cached reply\n")));
}
/// Append reply here....
this->outgoing_->write_octet_array (
s.get_buffer (),
s.length ());
if (!this->outgoing_->good_bit ())
{
TAOLIB_ERROR ((LM_ERROR,
ACE_TEXT ("TAO (%P|%t) - ServerRequest::send_cached_reply, ")
ACE_TEXT ("could not marshal reply\n")));
}
this->outgoing_->more_fragments (false);
// Send the message
if (this->transport_->send_message (*this->outgoing_,
0,
this,
TAO_Message_Semantics (TAO_Message_Semantics::TAO_REPLY)) == -1)
{
TAOLIB_ERROR ((LM_ERROR,
ACE_TEXT ("TAO (%P|%t) - ServerRequest::send_cached_reply, ")
ACE_TEXT ("could not send cached reply\n")));
}
}