void ServerInterceptor::receive_request ( PortableInterceptor::ServerRequestInfo_ptr ri) { bool permission_granted = false; std::cout << "Calling receive_request()." << std::endl; if (ri->target_is_a(restricted_interfaces[0])){ IOP::ServiceId id = service_id; // Check that the request service context can be retrieved. IOP::ServiceContext_var sc = ri->get_request_service_context (id); CORBA::OctetSeq ocSeq = sc->context_data; const char * buf = reinterpret_cast<const char *> (ocSeq.get_buffer ()); for (unsigned int i=0; i<num_allowed_users; ++i) { if (ACE_OS::strcmp (buf, allowed_users[i]) == 0) { permission_granted = true; } } } if (permission_granted == true) { std::cout << "Permission Granted " << std::endl; } else { std::cout << "Permission Denied " << std::endl;; } }
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; }
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 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; }
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"))); } }