//----------------------------------------------------------------------------- // Removes a CClientCommandManager instance for the given name. //----------------------------------------------------------------------------- void RemoveCClientCommandManager(const char* szName) { // Find if the given name is a registered client command ClientCommandMap::iterator commandMapIter = g_ClientCommandMap.find(szName); if( commandMapIter != g_ClientCommandMap.end()) { // If the command is registered, delete the CClientCommandManager instance // and remove the command from the mapping delete commandMapIter->second; g_ClientCommandMap.erase(commandMapIter); } }
//----------------------------------------------------------------------------- // Returns a CClientCommandManager for the given command name. //----------------------------------------------------------------------------- CClientCommandManager* GetClientCommand(const char* szName) { // Find if the given name is a registered client command ClientCommandMap::iterator commandMapIter = g_ClientCommandMap.find(szName); if( commandMapIter == g_ClientCommandMap.end()) { // If the command is not already registered, add the name and the CClientCommandManager instance to the mapping g_ClientCommandMap.insert(std::make_pair(szName, new CClientCommandManager(szName))); // Get the client command in the mapping commandMapIter = g_ClientCommandMap.find(szName); } // Return the CClientCommandManager instance for the command return commandMapIter->second; }
//----------------------------------------------------------------------------- // Dispatches a client command. //----------------------------------------------------------------------------- PLUGIN_RESULT DispatchClientCommand(edict_t* pEntity, const CCommand &command) { unsigned int iIndex; if (!IndexFromEdict(pEntity, iIndex)) return PLUGIN_CONTINUE; // Loop through all registered Client Command Filters for(int i = 0; i < s_ClientCommandFilters.m_vecCallables.Count(); i++) { BEGIN_BOOST_PY() // Get the PyObject instance of the callable PyObject* pCallable = s_ClientCommandFilters.m_vecCallables[i].ptr(); // Call the callable and store its return value object returnValue = CALL_PY_FUNC(pCallable, boost::ref(command), iIndex); // Does the Client Command Filter want to block the command? if( !returnValue.is_none() && extract<int>(returnValue) == (int)BLOCK) { // Block the command return PLUGIN_STOP; } END_BOOST_PY_NORET() } // Get the command's name const char* szCommand = command.Arg(0); // Find if the command exists in the mapping ClientCommandMap::iterator commandMapIter = g_ClientCommandMap.find(szCommand); if( commandMapIter != g_ClientCommandMap.end() ) { // If the command exists, get the CClientCommandManager instance and call its Dispatch method CClientCommandManager* pCClientCommandManager = commandMapIter->second; // Does the command need to be blocked? if( !pCClientCommandManager->Dispatch(command, iIndex)) { // Block the command return PLUGIN_STOP; } } return PLUGIN_CONTINUE; }
void Client::readSocket() { using boost::format; ClientCallbackFunction funcPtr; std::string command, commandBuf, arguments; size_t endpos, argpos; ClientCommandMap commandMap = DC::instance().getClientCommandMap(); ClientCommandMap::iterator function; std::string sendBuf; *m_socket >> m_buff; logTrace( TRACE, format("Client::readSocket: m_buff: %1%") % Utils::hexDump(m_buff) ); endpos = m_buff.find("|", 0); while (endpos != std::string::npos) { commandBuf = m_buff.substr(0, endpos); argpos = commandBuf.find(" "); command = commandBuf.substr(0, argpos); function = commandMap.find(command); if (function != commandMap.end()) { if (argpos != std::string::npos) { arguments = commandBuf.substr(argpos+1); } sendBuf.append(((*function).second)(this, arguments)); } else { logTrace( TRACE, format("Command %s not found") % command ); } m_buff.erase(0, endpos + 1); endpos = m_buff.find("|", 0); } // send the sendBuf (this processes commands received in batches, // needed for some parts of the protocol expecting same packet replies) *m_socket << sendBuf; }