int OpenDDS::DCPS::ThreadPerConnectionSendTask::add_request(SendStrategyOpType op, TransportQueueElement* element) { DBG_ENTRY("ThreadPerConnectionSendTask","add"); ACE_Auto_Ptr<SendRequest> req (new SendRequest); req->op_ = op; req->element_ = element; int result = -1; { // guard scope GuardType guard(this->lock_); if (this->shutdown_initiated_) return -1; result = this->queue_.put (req.get()); if (result == 0) { this->work_available_.signal(); req.release (); } else ACE_ERROR((LM_ERROR, "(%P|%t)ERROR: ThreadPerConnectionSendTask::add %p\n", "put")); } return result; }
TAO::PG_Group_List_Store::PG_Group_List_Store ( Storable_Factory & storable_factory) : next_group_id_ (0) , storable_factory_ (storable_factory) , loaded_from_stream_ (false) , last_changed_ (0) , stale_ (false) { // Create a temporary stream simply to check if a readable // version already exists. bool stream_exists = false; { ACE_Auto_Ptr<TAO::Storable_Base> stream ( this->create_stream ("r")); if (stream->exists ()) stream_exists = true; } if (stream_exists) { File_Guard fg(*this, SFG::CREATE_WITH_FILE); } else { File_Guard fg(*this, SFG::CREATE_WITHOUT_FILE); this->write (fg.peer ()); } }
::Test::arr_bds_str_slice * A_i::arr_method_s (::Test::A::FailOn where, const ::Test::arr_bds_str, ::Test::arr_bds_str_out arg2, ::Test::arr_bds_str arg3) { arg2 = ::Test::arr_bds_str_alloc (); ::Test::arr_bds_str_slice *res = ::Test::arr_bds_str_alloc (); ACE_Auto_Ptr< ::Test::arr_bds_str_slice > safe (res); switch (where) { case ::Test::A::ARG1: // must be never reached. break; case ::Test::A::ARG2: { ::Test::arr_bds_str_slice *& arg2_slice = arg2; arg2_slice[0] = CORBA::string_dup (::Test::FailStr); } break; case ::Test::A::ARG3: arg3[0] = CORBA::string_dup (::Test::FailStr); break; case ::Test::A::RETN: res[0] = CORBA::string_dup (::Test::FailStr); break; } safe.release (); return res; }
Savable::Savable (TAO::Storable_Factory & storable_factory) : storable_factory_(storable_factory) , loaded_from_stream_ (false) { for (int index = 0; index < 2; ++index) { this->i_[index] = 0; this->ui_[index] = 0; this->bytes_size_[index] = 0; this->bytes_[index] = new char [this->bytes_size_max]; for (int i = 0; i < this->bytes_size_max; ++i) { this->bytes_[index][i] = ACE_CHAR_MAX; } } ACE_Auto_Ptr<TAO::Storable_Base> stream (storable_factory_.create_stream("test.dat", "r")); if (stream->exists ()) { Savable_File_Guard fg(*this, SFG::CREATE_WITH_FILE); } else { Savable_File_Guard fg(*this, SFG::CREATE_WITHOUT_FILE); this->write (fg.peer ()); } }
bool TAO::PG_Group_List_Store::list_obsolete () { // TODO: Upate if obsolete flag is set based on CORBA call. ACE_Auto_Ptr<TAO::Storable_Base> stream (this->create_stream ("r")); if (!stream->exists ()) throw CORBA::INTERNAL (); if (stream->open () != 0) throw CORBA::INTERNAL (); return this->is_obsolete (stream->last_changed ()); }
TAO::PG_Object_Group_Storable::~PG_Object_Group_Storable (void) { if (destroyed_) { ACE_Auto_Ptr<TAO::Storable_Base> stream ( this->create_stream ("r")); if (stream->exists ()) { stream->remove (); } } }
int HTTP_Server::init (int argc, ACE_TCHAR *argv[]) // Document this function { // Ignore signals generated when a connection is broken unexpectedly. ACE_Sig_Action sig ((ACE_SignalHandler) SIG_IGN, SIGPIPE); ACE_UNUSED_ARG (sig); // Parse arguments which sets the initial state. this->parse_args (argc, argv); //If the IO strategy is synchronous (SYNCH case), then choose a handler //factory based on the desired caching scheme HTTP_Handler_Factory *f = 0; if (this->strategy_ != (JAWS::JAWS_POOL | JAWS::JAWS_ASYNCH)) { if (this->caching_) { ACE_NEW_RETURN (f, Synch_HTTP_Handler_Factory (), -1); } else { ACE_NEW_RETURN (f, No_Cache_Synch_HTTP_Handler_Factory (), -1); } } //NOTE: At this point f better not be a NULL pointer, //so please do not change the ACE_NEW_RETURN macros unless //you know what you are doing ACE_Auto_Ptr<HTTP_Handler_Factory> factory (f); // Choose what concurrency strategy to run. switch (this->strategy_) { case (JAWS::JAWS_POOL | JAWS::JAWS_ASYNCH) : return this->asynch_thread_pool (); case (JAWS::JAWS_PER_REQUEST | JAWS::JAWS_SYNCH) : return this->thread_per_request (*factory.get ()); case (JAWS::JAWS_POOL | JAWS::JAWS_SYNCH) : default: return this->synch_thread_pool (*factory.get ()); } ACE_NOTREACHED (return 0); }
TAO::PG_Object_Group_Storable::PG_Object_Group_Storable ( CORBA::ORB_ptr orb, PortableGroup::FactoryRegistry_ptr factory_registry, TAO::PG_Object_Group_Manipulator & manipulator, CORBA::Object_ptr empty_group, const PortableGroup::TagGroupTaggedComponent & tagged_component, const char * type_id, const PortableGroup::Criteria & the_criteria, const TAO::PG_Property_Set_var & type_properties, TAO::Storable_Factory & storable_factory) : PG_Object_Group(orb, factory_registry, manipulator, empty_group, tagged_component, type_id, the_criteria, type_properties) , group_previously_stored_(false) , group_id_previously_stored_(0) , storable_factory_ (storable_factory) , last_changed_ (0) , loaded_from_stream_ (false) , destroyed_ (false) , write_occurred_ (false) { // Create a temporary stream simply to check if a readable // version already exists. bool stream_exists = false; { ACE_Auto_Ptr<TAO::Storable_Base> stream ( this->create_stream ("r")); if (stream->exists ()) stream_exists = true; } if (stream_exists) { Object_Group_File_Guard fg (*this, SFG::CREATE_WITH_FILE); } else { Object_Group_File_Guard fg (*this, SFG::CREATE_WITHOUT_FILE); this->write (fg.peer ()); } }
bool STD_PC_Intf::prepare_PC (const char *file) { DANCE_TRACE("STD_PC_Intf::prepare_PC"); ACE_Auto_Ptr<XML_Helper> helper (new XML_Helper); if (!helper->is_initialized ()) return false; // parse the .pcd (PackageConfigurationDescription) file xercesc::DOMDocument *dom = helper->create_dom (file); if (!dom) return false; PackageConfiguration pc = packageConfiguration (dom); Deployment::PackageConfiguration idl_pc; STD_PCD_Handler pcd_handler (helper.get ()); pcd_handler.package_config (pc, idl_pc); Deployment::PackageConfiguration *p_idl_pc = new Deployment::PackageConfiguration (idl_pc); // let ACE_Auto_Ptr take over this->idl_pc_.reset (p_idl_pc); if (this->idl_pc_.get ()) return true; return false; }
void TAO_Leader_Follower::resume_events () { // not need to obtain the lock, only called when holding the lock while (!this->deferred_event_set_.is_empty ()) { ACE_Auto_Ptr<Deferred_Event> event (this->deferred_event_set_.pop_front ()); // Send a notification to the reactor to cause the awakening of a new // follower, if there is one already available. ACE_Reactor *reactor = this->orb_core_->reactor (); int const retval = reactor->notify (event->handler (), ACE_Event_Handler::READ_MASK); if (TAO_debug_level > 2) { // @@todo: need to think about what is the action that // we can take when we get here with an error?! TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - TAO_Leader_Follower::resume_events, ") ACE_TEXT ("an event handler[%d] has been resumed, ") ACE_TEXT ("notified the reactor, retval=%d.\n"), event->handler ()->get_handle (), retval)); } } }
TAO::PG_Object_Group_Storable::PG_Object_Group_Storable ( PortableGroup::ObjectGroupId group_id, CORBA::ORB_ptr orb, PortableGroup::FactoryRegistry_ptr factory_registry, TAO::PG_Object_Group_Manipulator & manipulator, TAO::Storable_Factory & storable_factory) : PG_Object_Group(orb, factory_registry, manipulator) , group_previously_stored_(true) , group_id_previously_stored_(group_id) , storable_factory_ (storable_factory) , last_changed_ (0) , loaded_from_stream_ (false) , destroyed_ (false) , write_occurred_ (false) { // Create a temporary stream to simply to check if a readable // version already exists. bool stream_exists = false; { ACE_Auto_Ptr<TAO::Storable_Base> stream ( this->create_stream ("r")); if (stream->exists ()) stream_exists = true; } if (stream_exists) { Object_Group_File_Guard fg (*this, SFG::ACCESSOR); } else { throw CORBA::INTERNAL (); } }
int ACE_Service_Gestalt::initialize (const ACE_Service_Type_Factory *stf, const ACE_TCHAR *parameters) { ACE_TRACE ("ACE_Service_Gestalt::initialize"); #ifndef ACE_NLOGGING if (ACE::debug ()) ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE (%P|%t) SG::initialize - repo=%@, name=%s") ACE_TEXT (" - looking up in the repo\n"), this->repo_, stf->name ())); #endif ACE_Service_Type *srp = 0; int const retv = this->repo_->find (stf->name (), (const ACE_Service_Type **) &srp); // If there is an active service already, remove it first // before it can be re-installed. if (retv >= 0) { #ifndef ACE_NLOGGING if (ACE::debug ()) ACELIB_DEBUG ((LM_WARNING, ACE_TEXT ("ACE (%P|%t) SG::initialize - repo=%@,") ACE_TEXT (" name=%s - removing a pre-existing namesake.\n"), this->repo_, stf->name ())); #endif this->repo_->remove (stf->name ()); } // If there is an inactive service by that name it may have been // either inactivated, or just a forward declaration for a service, // that is in the process of being initialized. If it is the latter, // then we have detected an attempt to initialize the same dynamic // service while still processing previous attempt. This can lock up // the process, because the ACE_DLL_Manager::open () is not // re-entrant - it uses a Singleton lock to serialize concurent // invocations. This use case must be handled here, because if the // DLL_Manager was re-entrant we would have entered an infinite // recursion here. if (retv == -2 && srp->type () == 0) ACELIB_ERROR_RETURN ((LM_WARNING, ACE_TEXT ("ACE (%P|%t) SG::initialize - repo=%@,") ACE_TEXT (" name=%s - forward-declared; ") ACE_TEXT (" recursive initialization requests are") ACE_TEXT (" ignored.\n"), this->repo_, stf->name ()), -1); // Reserve a spot for the dynamic service by inserting an incomplete // service declaration, i.e. one that can not produce a service // object if asked (a forward declaration). This declaration // ensures maintaining the proper partial ordering of the services // with respect to their finalization. For example, dependent static // services must be registered *after* the dynamic service that // loads them, so that their finalization is complete *before* // finalizing the dynamic service. ACE_Service_Type_Dynamic_Guard dummy (*this->repo_, stf->name ()); // make_service_type() is doing the dynamic loading and also runs // any static initializers ACE_Auto_Ptr<ACE_Service_Type> tmp (stf->make_service_type (this)); if (tmp.get () != 0 && this->initialize_i (tmp.get (), parameters) == 0) { // All good. Tthe ACE_Service_Type instance is now owned by the // repository and we should make sure it is not destroyed upon // exit from this method. tmp.release (); return 0; } return -1; }
int WorldSocket::ProcessIncoming(WorldPacket* new_pct) { ACE_ASSERT (new_pct); // manage memory ;) ACE_Auto_Ptr<WorldPacket> aptr (new_pct); const ACE_UINT16 opcode = new_pct->GetOpcode(); if (closing_) return -1; // Dump received packet. if (sPacketLog->CanLogPacket()) sPacketLog->LogPacket(*new_pct, CLIENT_TO_SERVER); try { switch (opcode) { case CMSG_PING: return HandlePing (*new_pct); case CMSG_AUTH_SESSION: if (m_Session) { sLog->outError("WorldSocket::ProcessIncoming: Player send CMSG_AUTH_SESSION again"); return -1; } sScriptMgr->OnPacketReceive(this, WorldPacket(*new_pct)); return HandleAuthSession(*new_pct); case CMSG_KEEP_ALIVE: sLog->outStaticDebug ("CMSG_KEEP_ALIVE, size: " UI64FMTD, uint64(new_pct->size())); sScriptMgr->OnPacketReceive(this, WorldPacket(*new_pct)); return 0; default: { ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1); if (m_Session != NULL) { // Our Idle timer will reset on any non PING opcodes. // Catches people idling on the login screen and any lingering ingame connections. m_Session->ResetTimeOutTime(); // OK, give the packet to WorldSession aptr.release(); // WARNINIG here we call it with locks held. // Its possible to cause deadlock if QueuePacket calls back m_Session->QueuePacket (new_pct); return 0; } else { sLog->outError("WorldSocket::ProcessIncoming: Client not authed opcode = %u", uint32(opcode)); return -1; } } } } catch (ByteBufferException &) { sLog->outError("WorldSocket::ProcessIncoming ByteBufferException occured while parsing an instant handled packet (opcode: %u) from client %s, accountid=%i. Disconnected client.", opcode, GetRemoteAddress().c_str(), m_Session?m_Session->GetAccountId():-1); if (sLog->IsOutDebug()) { sLog->outDebug(LOG_FILTER_NETWORKIO, "Dumping error causing packet:"); new_pct->hexlike(); } return -1; } ACE_NOTREACHED (return 0); }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { // Initialize the ORB. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); CORBA::ORB_var s_orb; // Find the Naming Service. CORBA::Object_var obj = orb->resolve_initial_references ("NameService"); CosNaming::NamingContextExt_var root_context = CosNaming::NamingContextExt::_narrow (obj.in ()); obj = root_context->resolve_str ("CosEventService"); // Downcast the object reference to an EventChannel reference. CosEventChannelAdmin::EventChannel_var ec = CosEventChannelAdmin::EventChannel::_narrow (obj.in ()); if (CORBA::is_nil (ec.in ())) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Could not narrow the EventChannel.\n"))); return 1; } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Found the EventChannel.\n"))); bool consumer = false; bool supplier = false; bool hang = false; for (int i=1; i < argc; ++i) { if (0 == ACE_OS::strcasecmp (argv[i], ACE_TEXT ("-consumer"))) consumer = true; else if (0 == ACE_OS::strcasecmp (argv[i], ACE_TEXT ("-supplier"))) supplier = true; else if (0 == ACE_OS::strcasecmp (argv[i], ACE_TEXT ("-hang"))) hang = true; } TestEventConsumer_i servant (orb.in (), hang); if (consumer) { // Register it with the RootPOA. obj = orb->resolve_initial_references ("RootPOA"); PortableServer::POA_var poa = PortableServer::POA::_narrow (obj.in ()); PortableServer::ObjectId_var oid = poa->activate_object (&servant); CORBA::Object_var consumer_obj = poa->id_to_reference (oid.in ()); CosEventComm::PushConsumer_var consumer = CosEventComm::PushConsumer::_narrow (consumer_obj.in ()); // Get a ConsumerAdmin object from the EventChannel. CosEventChannelAdmin::ConsumerAdmin_var consumerAdmin = ec->for_consumers (); // Get a ProxyPushSupplier from the ConsumerAdmin. CosEventChannelAdmin::ProxyPushSupplier_var supplier = consumerAdmin->obtain_push_supplier (); // Connect to the ProxyPushSupplier, passing our PushConsumer object // reference to it. supplier->connect_push_consumer (consumer.in ()); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Consumer connected\n"))); // Activate the POA via its POAManager. PortableServer::POAManager_var poa_manager = poa->the_POAManager (); poa_manager->activate (); servant.activate (); } ACE_Auto_Ptr<SupplierTask> pST; if (supplier) { // The supplier will use its own ORB. CORBA::String_var ec_str = orb->object_to_string (ec.in ()); int no_args = 0; ACE_TCHAR **no_argv = 0; s_orb = CORBA::ORB_init (no_args, no_argv, "Supplier_pure_client_ORB"); CORBA::Object_var s_ec_obj = s_orb->string_to_object (ec_str.in ()); CosEventChannelAdmin::EventChannel_var s_ec = CosEventChannelAdmin::EventChannel::_narrow (s_ec_obj.in ()); // Get a SupplierAdmin object from the EventChannel. CosEventChannelAdmin::SupplierAdmin_var supplierAdmin = s_ec->for_suppliers (); // Get a ProxyPushConsumer from the SupplierAdmin. CosEventChannelAdmin::ProxyPushConsumer_var consumer = supplierAdmin->obtain_push_consumer (); // Connect to the ProxyPushConsumer as a PushSupplier // (passing a nil PushSupplier object reference to it because // we don't care to be notified about disconnects). consumer->connect_push_supplier (CosEventComm::PushSupplier::_nil ()); SupplierTask *tmp = 0; ACE_NEW_RETURN (tmp, SupplierTask (consumer.in (), s_orb.in ()), -1); pST.reset (tmp); pST->activate (); } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Ready to receive events...\n"))); // Enter the ORB event loop. orb->run (); ACE_Thread_Manager::instance ()->wait (); if (!CORBA::is_nil (s_orb.in ())) { s_orb->destroy (); } orb->destroy (); return 0; } catch (CORBA::Exception &ex) { ex._tao_print_exception ( ACE_TEXT ( "TimeoutTest: Caught CORBA::Exception:")); } return 1; }
int PoolSocket::ProcessIncoming (WorldPacket* new_pct) { ACE_ASSERT (new_pct); // manage memory ;) ACE_Auto_Ptr<WorldPacket> aptr (new_pct); const ACE_UINT16 opcode = new_pct->GetOpcode(); if (closing_) return -1; // Dump received packet. if (sPacketLog->CanLogPacket()) sPacketLog->LogPacket(*new_pct, CLIENT_TO_SERVER); try { switch (opcode) { case CMSG_PING: return HandlePing (*new_pct); case LOGON_AUTH_MASTER: if (m_Session) { sLog->outError ("PoolSocket::ProcessIncoming: Player send CMSG_AUTH_SESSION again"); return -1; } return HandleAuthSession (*new_pct); case CMSG_KEEP_ALIVE: sLog->outStaticDebug ("CMSG_KEEP_ALIVE, size: " UI64FMTD, uint64(new_pct->size())); return 0; default: { ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1); if (m_Session != NULL) { // OK, give the packet to WorldSession aptr.release(); // WARNINIG here we call it with locks held. // Its possible to cause deadlock if QueuePacket calls back m_Session->QueueServerPacket (new_pct); return 0; } else { new_pct->Initialize(SMSG_AUTH_RESPONSE, 1); *new_pct << uint8(AUTH_REJECT); SendPacket(*new_pct); sLog->outError ("PoolSocket::ProcessIncoming: Client not authed opcode = %u => rejected", uint32(opcode)); return -1; } } } } catch (ByteBufferException &) { sLog->outError("PoolSocket::ProcessIncoming ByteBufferException occured while parsing an instant handled packet (opcode: %u) from client %s, accountid=%i. Disconnected client.", opcode, GetRemoteAddress().c_str(), m_Session?m_Session->GetServerId():-1); if (sLog->IsOutDebug()) { sLog->outDebug(LOG_FILTER_NETWORKIO, "Dumping error causing packet:"); new_pct->hexlike(); } return -1; } ACE_NOTREACHED (return 0); }
int WorldSocket::ProcessIncoming (WorldPacket* new_pct) { ACE_ASSERT (new_pct); // manage memory ;) ACE_Auto_Ptr<WorldPacket> aptr (new_pct); const ACE_UINT16 opcode = new_pct->GetOpcode (); if (opcode >= NUM_MSG_TYPES) { sLog.outError( "SESSION: received non-existed opcode 0x%.4X", opcode); return -1; } if (closing_) return -1; // Dump received packet. sLog.outWorldPacketDump(uint32(get_handle()), new_pct->GetOpcode(), LookupOpcodeName(new_pct->GetOpcode()), new_pct, true); try { switch(opcode) { case CMSG_PING: return HandlePing (*new_pct); case CMSG_AUTH_SESSION: if (m_Session) { sLog.outError ("WorldSocket::ProcessIncoming: Player send CMSG_AUTH_SESSION again"); return -1; } return HandleAuthSession (*new_pct); case CMSG_KEEP_ALIVE: DEBUG_LOG ("CMSG_KEEP_ALIVE ,size: %d", new_pct->size ()); return 0; default: { ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1); if (m_Session != NULL) { // OK ,give the packet to WorldSession aptr.release (); // WARNINIG here we call it with locks held. // Its possible to cause deadlock if QueuePacket calls back m_Session->QueuePacket (new_pct); return 0; } else { sLog.outError ("WorldSocket::ProcessIncoming: Client not authed opcode = %u", uint32(opcode)); return -1; } } } } catch (ByteBufferException &) { sLog.outError("WorldSocket::ProcessIncoming ByteBufferException occured while parsing an instant handled packet (opcode: %u) from client %s, accountid=%i. Disconnected client.", opcode, GetRemoteAddress().c_str(), m_Session?m_Session->GetAccountId():-1); if(sLog.IsOutDebug()) { sLog.outDebug("Dumping error-causing packet:"); new_pct->hexlike(); } return -1; } ACE_NOTREACHED (return 0); }
int WorldSocket::ProcessIncoming (WorldPacket* new_pct) { ACE_ASSERT (new_pct); // manage memory ;) ACE_Auto_Ptr<WorldPacket> aptr (new_pct); const ACE_UINT16 opcode = new_pct->GetOpcode (); if (closing_) return -1; // Dump received packet. if (sWorldLog.LogWorld ()) { sWorldLog.Log ("CLIENT:\nSOCKET: %u\nLENGTH: %u\nOPCODE: %s (0x%.4X)\nDATA:\n", (uint32) get_handle (), new_pct->size (), LookupOpcodeName (new_pct->GetOpcode ()), new_pct->GetOpcode ()); uint32 p = 0; while (p < new_pct->size ()) { for (uint32 j = 0; j < 16 && p < new_pct->size (); j++) sWorldLog.Log ("%.2X ", (*new_pct)[p++]); sWorldLog.Log ("\n"); } sWorldLog.Log ("\n\n"); } // like one switch ;) if (opcode == CMSG_PING) { return HandlePing (*new_pct); } else if (opcode == CMSG_AUTH_SESSION) { if (m_Session) { sLog.outError ("WorldSocket::ProcessIncoming: Player send CMSG_AUTH_SESSION again"); return -1; } return HandleAuthSession (*new_pct); } else if (opcode == CMSG_KEEP_ALIVE) { DEBUG_LOG ("CMSG_KEEP_ALIVE ,size: %d", new_pct->size ()); return 0; } else { ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1); if (m_Session != NULL) { // OK ,give the packet to WorldSession aptr.release (); // WARNINIG here we call it with locks held. // Its possible to cause deadlock if QueuePacket calls back m_Session->QueuePacket (new_pct); return 0; } else { sLog.outError ("WorldSocket::ProcessIncoming: Client not authed opcode = ", opcode); return -1; } } ACE_NOTREACHED (return 0); }
int ACE_TMAIN (int argc, ACE_TCHAR *argv []) { ACE_Auto_Ptr<std::ofstream> fout; std::ostream* sout = &std::cout; if (!parse_args (argc, argv)) { return 1; } ACE::INet::URL_INetAuthBase::add_authenticator ("my_auth", new My_Authenticator); std::cout << "Starting..." << std::endl; if (!url.empty ()) { if (!outfile.empty ()) { fout.reset (new std::ofstream (outfile.c_str (), std::ios_base::binary|std::ios_base::out)); if (!*fout) { std::cerr << "Failed to open output file : " << outfile.c_str () << std::endl; return 1; } sout = fout.get (); } ACE::FTP::URL ftp_url; std::cout << "Parsing url [" << url.c_str () << "]" << std::endl; if (!ftp_url.parse (url)) { std::cerr << "Failed parsing url [" << url << "]" << std::endl; std::cerr << "\tresult = " << ftp_url.to_string ().c_str (); return 1; } std::cout << "Opening url..." << std::endl; My_FTP_RequestHandler my_rh; if (do_active) my_rh.use_active_mode (); ACE::INet::URLStream urlin = ftp_url.open (my_rh); if (urlin) { std::cout << "Saving to: "; if (!outfile.empty ()) std::cout << '\'' << outfile.c_str () << '\'' << std::endl; else std::cout << "(stdout)" << std::endl; (*sout) << urlin->rdbuf (); sout->flush (); } } else { std::cerr << "ERROR: No URL specified!" << std::endl; usage (); return 1; } std::cout << "Done" << std::endl; return 0; }
int WorldSocket::ProcessIncoming (WorldPacket* new_pct) { ACE_ASSERT (new_pct); // manage memory ;) ACE_Auto_Ptr<WorldPacket> aptr (new_pct); const ACE_UINT16 opcode = new_pct->GetOpcode(); if (closing_) return -1; // Dump received packet. if (sWorldLog.LogWorld()) { sWorldLog.outTimestampLog ("CLIENT:\nSOCKET: %u\nLENGTH: %u\nOPCODE: %s (0x%.4X)\nDATA:\n", (uint32) get_handle(), new_pct->size(), LookupOpcodeName (new_pct->GetOpcode()), new_pct->GetOpcode()); uint32 p = 0; while (p < new_pct->size()) { for (uint32 j = 0; j < 16 && p < new_pct->size(); j++) sWorldLog.outLog ("%.2X ", (*new_pct)[p++]); sWorldLog.outLog ("\n"); } sWorldLog.outLog ("\n"); } try { switch(opcode) { case CMSG_PING: return HandlePing (*new_pct); case CMSG_AUTH_SESSION: if (m_Session) { sLog.outError ("WorldSocket::ProcessIncoming: Player send CMSG_AUTH_SESSION again"); return -1; } return HandleAuthSession (*new_pct); case CMSG_KEEP_ALIVE: DEBUG_LOG ("CMSG_KEEP_ALIVE ,size: %d", new_pct->size()); return 0; default: { ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1); if (m_Session != NULL) { // Our Idle timer will reset on any non PING opcodes. // Catches people idling on the login screen and any lingering ingame connections. m_Session->ResetTimeOutTime(); // OK ,give the packet to WorldSession aptr.release(); // WARNINIG here we call it with locks held. // Its possible to cause deadlock if QueuePacket calls back m_Session->QueuePacket (new_pct); return 0; } else { sLog.outError ("WorldSocket::ProcessIncoming: Client not authed opcode = %u", uint32(opcode)); return -1; } } } } catch(ByteBufferException &) { sLog.outError("WorldSocket::ProcessIncoming ByteBufferException occured while parsing an instant handled packet (opcode: %u) from client %s, accountid=%i. Disconnected client.", opcode, GetRemoteAddress().c_str(), m_Session?m_Session->GetAccountId():-1); if (sLog.IsOutDebug()) { sLog.outDebug("Dumping error causing packet:"); new_pct->hexlike(); } return -1; } ACE_NOTREACHED (return 0); }
int ACE_TMAIN (int argc, ACE_TCHAR *argv []) { ACE_Auto_Ptr<std::ofstream> fout; std::ostream* sout = &std::cout; if (!parse_args (argc, argv)) { return 1; } #if defined (ACE_HAS_SSL) && ACE_HAS_SSL == 1 ACE::HTTPS::Context::set_default_ssl_mode (ssl_mode); ACE::HTTPS::Context::set_default_verify_mode (verify_peer); ACE::HTTPS::Context::instance ().use_default_ca (); if (!private_key.empty ()) { if (certificate.empty ()) { std::cerr << "ERROR: private key file [" << private_key << "] requires certificate file to be specified." << std::endl; return 1; } if (!ACE::HTTPS::Context::instance ().set_key_files (private_key.c_str (), certificate.c_str ())) { std::cerr << "ERROR: failed to set private key [" << private_key << "]." << std::endl; return 1; } } if (!ca_location.empty ()) { INET_DEBUG (6, (LM_INFO, DLINFO ACE_TEXT ("loading trusted CA [%C]\n"), ca_location.c_str ())); if (!ACE::HTTPS::Context::instance ().load_trusted_ca (ca_location.c_str ())) { std::cerr << "ERROR: failed to load trusted CA from [" << ca_location << "]." << std::endl; return 1; } INET_DEBUG (6, (LM_INFO, DLINFO ACE_TEXT ("loaded [%d] trusted CA\n"), ACE::HTTPS::Context::instance ().has_trusted_ca ())); } if (ignore_verify) ACE::INet::SSL_CallbackManager::instance ()->set_certificate_callback (new ACE::INet::SSL_CertificateAcceptor); #endif std::cout << "Starting..." << std::endl; if (!url.empty ()) { if (!outfile.empty ()) { fout.reset (new std::ofstream (outfile.c_str (), std::ios_base::binary|std::ios_base::out)); if (!*fout) { std::cerr << "Failed to open output file : " << outfile.c_str () << std::endl; return 1; } sout = fout.get (); } std::cout << "Parsing url [" << url.c_str () << "]" << std::endl; ACE_Auto_Ptr<ACE::INet::URL_Base> url_safe (ACE::INet::URL_Base::create_from_string (url)); if (url_safe.get () == 0 || url != url_safe->to_string ()) { std::cerr << "Failed parsing url [" << url << "]" << std::endl; std::cerr << "\tresult = " << (url_safe.get () == 0 ? "(null)" : url_safe->to_string ().c_str ()) << std::endl; return 1; } ACE::HTTP::URL& http_url = *dynamic_cast<ACE::HTTP::URL*> (url_safe.get ()); if (!proxy_hostname.empty ()) { std::cout << "Setting proxy: " << proxy_hostname.c_str () << ':' << proxy_port << std::endl; http_url.set_proxy (proxy_hostname, proxy_port); } std::cout << "Opening url..."; My_HTTP_RequestHandler my_rh; ACE::INet::URLStream urlin = http_url.open (my_rh); if (urlin) { std::cout << "Received response " << (int)my_rh.response ().get_status ().get_status () << " " << my_rh.response ().get_status ().get_reason ().c_str () << std::endl; if (my_rh.response ().get_status ().is_ok ()) { std::cout << "Length: "; if (my_rh.response ().get_content_length () != ACE::HTTP::Response::UNKNOWN_CONTENT_LENGTH) std::cout << my_rh.response ().get_content_length () << " ["; else std::cout << "(unknown) ["; if (my_rh.response ().get_content_type () != ACE::HTTP::Response::UNKNOWN_CONTENT_TYPE) std::cout << my_rh.response ().get_content_type ().c_str (); else std::cout << "(unknown)"; std::cout << "]" << std::endl; } std::cout << "Saving to: "; if (!outfile.empty ()) std::cout << '\'' << outfile.c_str () << '\'' << std::endl; else std::cout << "(stdout)" << std::endl; (*sout) << urlin->rdbuf (); sout->flush (); } } else { std::cerr << "ERROR: No URL specified!" << std::endl; usage (); return 1; } std::cout << "Done" << std::endl; return 0; }