RequestProcessorResponseStatus RequestProcessor::ProcessSubscribeKeepalive(Envelope &request, vector<Envelope> &output)
{
    OBTAIN_MESSAGE(protocol::request::SubscribeKeepaliveV1, m, request, 0);

    {
        ::zippylog::request_processor::ForwardSubscribeKeepalive log;
        /// @todo support multiple ids
        log.set_subscription(m->id(0));
        LOG_MESSAGE(log, this->logger_sock);
    }
    /// @todo validation

LOG_END:

    RequestProcessorHandlerResult result = this->impl->HandleSubscribeKeepalive(request, output);

    if (result.deferred)
        return DEFERRED;

    return AUTHORITATIVE;
}

    void SaveGameManager::parseScript(Ogre::DataStreamPtr &stream, const Ogre::String &groupName)
    {
        Ogre::String name = stream->getName();
        name = name.substr(0, name.length()-5); //delete ".save" at the and of the name
        int pointpos = name.find_last_of(".");
        name = name.substr(0, pointpos);

        if(Ogre::StringConverter::isNumber(name))
        {
            mHighestSaveGameNumber = std::max(mHighestSaveGameNumber, Ogre::StringConverter::parseInt(name));

            SaveGameFile* file = new SaveGameFile("", Ogre::StringConverter::parseInt(name));        
            
            LOG_MESSAGE(Logger::RULES, "Parsing header of save game: " + name + ".save");
            SaveGameFileReader reader;
            reader.parseSaveGameFileHeader(stream, groupName, file);
            
            if(file->getProperty(SaveGameFile::PROPERTY_MODULEID) != "") // broken save game
                mSaveGames[Ogre::StringConverter::parseInt(name)] = file;
        }
    }

// "trace unset" console command.
void cmd_trace_unset(void) {
	int i, argc;
	const char *arg;
	const char *api;
	TRACE_RESULT ret;
	argc=CMD_ARGC();
	if(argc < 3) {
		LOG_CONSOLE(PLID, "usage: trace unset <routine>");
		return;
	}
	for(i=1; i < argc; i++) {
		arg=CMD_ARGV(i);
		ret=trace_setflag(&arg, mFALSE, &api);
		if(ret==TR_SUCCESS)
			LOG_MESSAGE(PLID, "Un-Tracing %s routine '%s'", api, arg);
		else if(ret==TR_ALREADY)
			LOG_CONSOLE(PLID, "Already not tracing %s routine '%s'", api, arg);
		else
			LOG_CONSOLE(PLID, "Unrecognized API routine '%s'", arg);
	}
}

void Connection::internalSend(OutputMessage_ptr msg)
{
	TRACK_MESSAGE(msg);

	try{
		++m_pendingWrite;
		m_writeTimer.expires_from_now(boost::posix_time::seconds(Connection::write_timeout));
		m_writeTimer.async_wait( boost::bind(&Connection::handleWriteTimeout, boost::weak_ptr<Connection>(shared_from_this()),
			boost::asio::placeholders::error));

		boost::asio::async_write(getHandle(),
			boost::asio::buffer(msg->getOutputBuffer(), msg->getMessageLength()),
			boost::bind(&Connection::onWriteOperation, shared_from_this(), msg, boost::asio::placeholders::error));
	}
	catch(boost::system::system_error& e){
		if(m_logError){
			LOG_MESSAGE("NETWORK", LOGTYPE_ERROR, 1, e.what());
			m_logError = false;
		}
	}
}

void Connection::parseHeader(const boost::system::error_code& error)
{
	m_connectionLock.lock();
	m_readTimer.cancel();

	int32_t size = m_msg.decodeHeader();

	if (error || size <= 0 || size >= NETWORKMESSAGE_MAXSIZE - 16) {
		handleReadError(error);
	}

	if (m_connectionState != CONNECTION_STATE_OPEN || m_readError) {
		closeConnection();
		m_connectionLock.unlock();
		return;
	}

	--m_pendingRead;

	try {
		++m_pendingRead;
		m_readTimer.expires_from_now(boost::posix_time::seconds(Connection::read_timeout));
		m_readTimer.async_wait( boost::bind(&Connection::handleReadTimeout, boost::weak_ptr<Connection>(shared_from_this()),
		                                    boost::asio::placeholders::error));

		// Read packet content
		m_msg.setMessageLength(size + NetworkMessage::header_length);
		boost::asio::async_read(getHandle(), boost::asio::buffer(m_msg.getBodyBuffer(), size),
		                        boost::bind(&Connection::parsePacket, shared_from_this(), boost::asio::placeholders::error));
	} catch (boost::system::system_error& e) {
		if (m_logError) {
			LOG_MESSAGE("NETWORK", LOGTYPE_ERROR, 1, e.what());
			m_logError = false;
		}

		closeConnection();
	}

	m_connectionLock.unlock();
}

PhysicsRagDoll::PhysicsRagDoll(const Ogre::String& ragdollResource, Actor* actor) :
    mRootBone(NULL),
    mNode(NULL),
    mWorld(NULL),
    mMesh(NULL),
    mSkeleton(NULL)
{
    mRootBone = NULL;
	mNode = actor->_getSceneNode();
	mWorld = PhysicsManager::getSingleton()._getNewtonWorld();
    if (!actor->getControlledObject()->isMeshObject())
        Throw(IllegalArgumentException, "PhysicsRagDoll::PhysicsRagDoll needs a Mesh-Actor as argument!");

    MeshObject* meshObj = static_cast<MeshObject*>(actor->getControlledObject());

    // stop all animations
    meshObj->stopAllAnimations();

	// get the skeleton.
	mSkeleton = meshObj->getEntity()->getSkeleton();

	// get the mesh.
	mMesh = meshObj->getEntity()->getMesh();


    LOG_MESSAGE(Logger::CORE, "Loading ragdoll '" + ragdollResource + "'");

    TiXmlDocument* doc = loadDocument(ragdollResource);
    if (!doc)
    {
        LOG_ERROR(Logger::CORE, "Ragdoll resource '" + ragdollResource + "' not found");
    }
    else
    {

	    TiXmlElement* dataDocumentContent = doc->RootElement();
		mRootBone =_addAllBones(NULL, getChildNamed(dataDocumentContent, "Bone"), actor);
    }
}

/* ModMusic::loadFromMemory
 * Loads mod data for playback
 *******************************************************************/
bool ModMusic::loadFromMemory(const uint8_t* data, const uint32_t size)
{
    // Init DUMB if needed
    if (!init_done)
        initDumb();

    // Close current module if any
    close();

    // Load module file
    dumb_module = dumb_read_any(dumbfile_open_memory((const char*)data, size), 0, 0);
    if (dumb_module != NULL)
    {
        initialize(2, 44100);
        return true;
    }
    else
    {
        LOG_MESSAGE(1, "Failed to load module music data");
        return false;
    }
}

CMaterialPtr CMaterialManager::CreateMaterial(nstring & name, nstring & group,
	nova::CColorRGB AmbientColor,
	nova::CColorRGB DiffuseColor,
	nova::CColorRGB SpecularColor,
	nReal Shininess,
	nReal Transparency,
	nstring TexMap,
	nstring MultiTexMap,
	nstring SpecMap,
	nstring BumpMap,
	nstring ReflectionMap,
	CResource::TAttach state)
{
	CMaterialPtr mat = CResourceManager::AddNewResource(name, group, state);
	if(mat.IsNull())
		throw NOVA_EXP("CMaterialManager::CreateMaterial - resource factory return \
							Null pointer...", MEM_ERROR);

	mat->SetAmbientColor(AmbientColor);
	mat->SetDiffuseColor(DiffuseColor);
	mat->SetSpecularColor(SpecularColor);
	mat->SetShininess(Shininess);
	mat->SetTransparency(Transparency);
	mat->SetTexMap(TexMap);
	mat->SetMultiTexMap(MultiTexMap);
	mat->SetSpecMap(SpecMap);
	mat->SetBumpMap(BumpMap);
	mat->SetReflectionMap(ReflectionMap);

	mat->PrepareResource();
	mat->BuildResource();


	nova::nstringstream str;
	str << "Material Factory: material name: " << name << " group: " << group << " created..";
	LOG_MESSAGE(str.str());

	return mat;
}

void Connection::closeSocket()
{
	m_connectionLock.lock();

	if (m_socket->is_open()) {
		m_pendingRead = 0;
		m_pendingWrite = 0;

		try {
			boost::system::error_code error;
			m_socket->shutdown(boost::asio::ip::tcp::socket::shutdown_both, error);
			m_socket->close(error);
		} catch (boost::system::system_error& e) {
			if (m_logError) {
				LOG_MESSAGE("NETWORK", LOGTYPE_ERROR, 1, e.what());
				m_logError = false;
			}
		}
	}

	m_connectionLock.unlock();
}

void CTKRepeat::TestKeyboardRepeatRateL(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime)
{
    do
    {
#if defined(LOGGING)
        const TInt KOneSec=1000000;
        const TInt KOneHundrethSec=KOneSec/100;
        TLogMessageText logMessageText;
        _LIT(KRepeatRate,"Repeat Rate Initial=%d.%02dsecs, Subsequent=%d.%02dsecs");
        logMessageText.Format(KRepeatRate,aInitialTime.Int()/KOneSec,(aInitialTime.Int()%KOneSec)/KOneHundrethSec
                              ,aTime.Int()/KOneSec,(aTime.Int()%KOneSec)/KOneHundrethSec);
        LOG_MESSAGE(logMessageText);
#endif
        TheClient->iWs.SetKeyboardRepeatRate(aInitialTime, aTime);
        iWin->SetKeyboardRepeatRate(aInitialTime, aTime);
        CActiveScheduler::Start();
        if (iAbort)
        {
            iTest->AbortL();
        }
    } while(CheckReportL());
}

/* MapSpecials::processZDoomLineSpecial
 * Process ZDoom line special
 *******************************************************************/
void MapSpecials::processZDoomLineSpecial(MapLine* line)
{
	// Get special
	int special = line->getSpecial();
	if (special == 0)
		return;

	// Get parent map
	SLADEMap* map = line->getParentMap();

	// Get args
	int args[5];
	for (unsigned arg = 0; arg < 5; arg++)
		args[arg] = line->intProperty(S_FMT("arg%d", arg));

	// --- TranslucentLine ---
	if (special == 208)
	{
		// Get tagged lines
		vector<MapLine*> tagged;
		if (args[0] > 0)
			map->getLinesById(args[0], tagged);
		else
			tagged.push_back(line);

		// Get args
		double alpha = (double)args[1] / 255.0;
		string type = (args[2] == 0) ? "translucent" : "add";

		// Set transparency
		for (unsigned l = 0; l < tagged.size(); l++)
		{
			tagged[l]->setFloatProperty("alpha", alpha);
			tagged[l]->setStringProperty("renderstyle", type);

			LOG_MESSAGE(3, S_FMT("Line %d translucent: (%d) %1.2f, %s", tagged[l]->getIndex(), args[1], alpha, CHR(type)));
		}
	}
}

void ServicePort::open(IPAddressList ips, uint16_t port)
{
	m_pendingStart = false;
	m_serverPort = port;

	bool error = false;
	IPAddressList pendingIps;
	for(IPAddressList::iterator it = ips.begin(); it != ips.end(); ++it)
	{
		try
		{
			Acceptor_ptr tmp(new boost::asio::ip::tcp::acceptor(m_io_service,
				boost::asio::ip::tcp::endpoint(*it, m_serverPort)));
			tmp->set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
			tmp->set_option(boost::asio::ip::tcp::no_delay(true));

			accept(tmp);
			m_acceptors[tmp] = *it;
		}
		catch(std::exception& e)
		{
			if(m_logError)
			{
				LOG_MESSAGE(LOGTYPE_ERROR, e.what(), "NETWORK")
				pendingIps.push_back(*it);
				if(!error)
					error = true;
			}
		}
	}

	if(error)
	{
		m_logError = false;
		m_pendingStart = true;
		Scheduler::getInstance().addEvent(createSchedulerTask(5000, boost::bind(
			&ServicePort::services, boost::weak_ptr<ServicePort>(shared_from_this()), pendingIps, m_serverPort)));
	}
}

C_DLLEXPORT int Meta_Query(char *ifvers, plugin_info_t **pPlugInfo, mutil_funcs_t *pMetaUtilFuncs)
{
   // this function is the first function ever called by metamod in the plugin DLL. Its purpose
   // is for metamod to retrieve basic information about the plugin, such as its meta-interface
   // version, for ensuring compatibility with the current version of the running metamod.

   // keep track of the pointers to metamod function tables metamod gives us
   gpMetaUtilFuncs = pMetaUtilFuncs;

   *pPlugInfo = &Plugin_info;

   // check for interface version compatibility
   if (strcmp(ifvers, Plugin_info.ifvers) != 0)
   {
      int mmajor = 0, mminor = 0, pmajor = 0, pminor = 0;

      LOG_CONSOLE(PLID, "%s: meta-interface version mismatch (metamod: %s, %s: %s)", Plugin_info.name, ifvers, Plugin_info.name, Plugin_info.ifvers);
      LOG_MESSAGE(PLID, "%s: meta-interface version mismatch (metamod: %s, %s: %s)", Plugin_info.name, ifvers, Plugin_info.name, Plugin_info.ifvers);

      // if plugin has later interface version, it's incompatible (update metamod)
      sscanf (ifvers, "%d:%d", &mmajor, &mminor);
      sscanf (META_INTERFACE_VERSION, "%d:%d", &pmajor, &pminor);

      if (pmajor > mmajor || (pmajor == mmajor && pminor > mminor))
      {
         LOG_CONSOLE(PLID, "metamod version is too old for this plugin; update metamod");
         LOG_ERROR(PLID, "metamod version is too old for this plugin; update metamod");
      }

      // if plugin has older major interface version, it's incompatible (update plugin)
      else if (pmajor < mmajor)
      {
         LOG_CONSOLE(PLID, "metamod version is incompatible with this plugin; please find a newer version of this plugin");
         LOG_ERROR(PLID, "metamod version is incompatible with this plugin; please find a newer version of this plugin");
      }
   }

   return TRUE; // tell metamod this plugin looks safe
}

Move AspirationSearch::chooseMove(GameState& gameState)
{
	transpositionTable.clear();	// clean up data from previous searches

#ifdef GATHER_STATISTICS
	nodesVisited = 0;
	Timer timer;
	timer.start();
	Move moveToPlay = startAspirationSearch(gameState);
	timer.stop();

#ifdef LOG_STATS_PER_TURN
	if(gameState.getCurrentPlayer() == EPlayerColors::Type::BLACK_PLAYER)
	{
		LOG_MESSAGE(StringBuilder() << "Aspiration Search engine searching move for Black Player")
	}
	else
	{
		LOG_MESSAGE(StringBuilder() << "Aspiration Search engine searching move for White Player")
	}

	LOG_MESSAGE(StringBuilder() << "Search depth:					" << searchDepth)
	LOG_MESSAGE(StringBuilder() << "Number of nodes visited:			" << nodesVisited)
	LOG_MESSAGE(StringBuilder() << "Time spent:					" << timer.getElapsedTimeInMilliSec() << " ms")
	LOG_MESSAGE(StringBuilder() << "% of Transposition Table entries used:		" << ((double)transpositionTable.getNumEntriesUsed() / (TRANSPOSITION_TABLE_NUM_ENTRIES * 2.0)))
	LOG_MESSAGE(StringBuilder() << "% of Transposition Table entries replaced:	" << ((double)transpositionTable.getNumReplacementsRequired() / (TRANSPOSITION_TABLE_NUM_ENTRIES * 2.0)))
	LOG_MESSAGE("")
#endif // LOG_STATS_PER_TURN

#ifdef LOG_STATS_END_OF_MATCH
	totalNodesVisited += nodesVisited;
	totalTimeSpent += timer.getElapsedTimeInMilliSec();
	++turnsPlayed;
#endif // LOG_STATS_END_OF_MATCH

	return moveToPlay;
#else
	return startAspirationSearch(gameState);
#endif // GATHER_STATISTICS
}

void ServicePort::accept()
{
	if(!m_acceptor){
#ifdef __DEBUG_NET__
		std::cout << "Error: [ServerPort::accept] NULL m_acceptor." << std::endl;
#endif
		return;
	}

	try{
		boost::asio::ip::tcp::socket* socket = new boost::asio::ip::tcp::socket(m_io_service);

		m_acceptor->async_accept(*socket,
			boost::bind(&ServicePort::onAccept, this, socket,
			boost::asio::placeholders::error));
	}
	catch(boost::system::system_error& e){
		if(m_logError){
			LOG_MESSAGE("NETWORK", LOGTYPE_ERROR, 1, e.what());
			m_logError = false;
		}
	}
}

int prepareServerAddress(char* address, int port, struct sockaddr_in * server_addr) 
{
	memset((char *) server_addr , 0, sizeof(struct sockaddr_in));

	if (address != NULL) {
		struct hostent *server;
		server = gethostbyname(address);

		if (server == NULL) {
			LOG_MESSAGE("could not find server host by name %s\n", address);
			return -1;
		}

		memcpy((char *) &(server_addr->sin_addr.s_addr), (char *) server->h_addr, server->h_length);
	}
	else
		server_addr->sin_addr.s_addr = htonl(INADDR_ANY);

    server_addr->sin_family = AF_INET;
    server_addr->sin_port = htons(port);

    return 0;
}

	AbstractWindow::AbstractWindow(const CeGuiString& xmlfile, int inputType, bool closeOnEscape, bool modal)
	: mVisible(false),
		mModal(modal),
		mWindowInputType(inputType),
		mCloseOnEscape(closeOnEscape)
	{
        LOG_MESSAGE(Logger::UI,
		    "Lade Fenster '" + Ogre::String(xmlfile.c_str()) + "'");
   		mWindow = AbstractWindow::loadWindow(xmlfile, mNamePrefix);
		if (mWindow == NULL)
		{
			Throw(rl::IllegalStateException, Ogre::String("Could not load window '")+xmlfile.c_str()+"'.");
		}

		getRoot()->addChildWindow(mWindow);

        if (modal)
		{
			mWindow->setModalState(true);
			mWindow->setAlwaysOnTop(true);
            mWindow->moveToFront();
            mWindow->show();
		}
        else
        {
       		mWindow->hide();
        }

		mNormalAlpha = mWindow->getAlpha();
		mName = mWindow->getName();
		WindowManager::getSingleton().registerWindow(this);
		mWindow->subscribeEvent(Window::EventActivated,
			boost::bind(
				&rl::WindowManager::handleMovedToFront,
				rl::WindowManager::getSingletonPtr(),
				this));
	}

/* UndoManager::undo
 * Performs an undo operation
 *******************************************************************/
string UndoManager::undo()
{
	// Can't while currently recording
	if (current_level)
		return "";

	// Can't if no more levels to undo
	if (current_level_index < 0)
		return "";

	// Perform undo level
	undo_running = true;
	current_undo_manager = this;
	UndoLevel* level = undo_levels[current_level_index];
	if (!level->doUndo())
		LOG_MESSAGE(3, "Undo operation \"%s\" failed", level->getName());
	undo_running = false;
	current_undo_manager = NULL;
	current_level_index--;

	announce("undo");

	return level->getName();
}

CAuthHelperTest::UserInfo CAuthHelperTest::getCurrentUser()
{
	UserInfo userInfo;

#ifdef _WIN_

	TCHAR pszUname[100];
	ZeroMemory(pszUname, sizeof(pszUname));
	DWORD dwSize = 100;
	if (GetUserName(pszUname, &dwSize))
		userInfo.name = UTF16SZ_2QSTR(pszUname, dwSize-1);
	else
		LOG_MESSAGE(DBG_FATAL, "Couldn't to extract user name. Error code: %d", GetLastError());

#else




#endif


	return userInfo;
}

void Connection::accept()
{
	try
	{
		++m_pendingRead;
		m_readTimer.expires_from_now(boost::posix_time::seconds(Connection::readTimeout));
		m_readTimer.async_wait(boost::bind(&Connection::handleReadTimeout,
			boost::weak_ptr<Connection>(shared_from_this()), boost::asio::placeholders::error));

		// Read size of the first packet
		boost::asio::async_read(getHandle(),
			boost::asio::buffer(m_msg.buffer(), NETWORK_HEADER_SIZE),
			boost::bind(&Connection::parseHeader, shared_from_this(), boost::asio::placeholders::error));
	}
	catch(boost::system::system_error& e)
	{
		if(m_logError)
		{
			LOG_MESSAGE(LOGTYPE_ERROR, e.what(), "NETWORK");
			m_logError = false;
			close();
		}
	}
}