📄 cmdmanager.cc

📁 五行MMORPG引擎系统V1.0
💻 CC
字号:
// CmdManager.cc
/*/////////////////////////////////////////////////////////////////////////////

	李亦
	2006.06.
/*//////////////////////////////////////////////////////////////////////////////

//#include "platforms.h"
#include <windows.h>
#include "server/cmd/CmdManager.h"
#include "server/net/AuthSocket.h"
#include "server/cmd/CmdNetModule.h"


namespace CS
{


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CmdManager::CmdManager()
{
	
}



CmdManager::~CmdManager()
{

}

UINT CmdManager::BreakDownCommand(BYTE *pInBuffer, int *cmdlen, int *command, int *comid, int *nArg1, char **svArg2, char **svArg3)
{
	CMD_HEADER *hdr;
	
	hdr	= (CMD_HEADER *)pInBuffer;

	*cmdlen	= hdr->cmdlen;
	*command	= hdr->command;
	*comid	= hdr->comid;
	*nArg1	= hdr->nArg1;

	if(hdr->nArg2Len > 0)
	{
		*svArg2 = (char *)(pInBuffer + sizeof(CMD_HEADER));
	}
	else 
		*svArg2 = NULL;

	if(hdr->nArg3Len > 0)
	{
		*svArg3 = (char *)(pInBuffer + sizeof(CMD_HEADER) + hdr->nArg2Len);
	} 
	else 
		*svArg3 = NULL;

	return hdr->nArg3Len;
}


BYTE* CmdManager::BuildCommandRequest(int command, int comid, int nArg1, char *svArg2, char *svArg3, int *pnReqLen)
{
	BYTE			*buffer;
	CMD_HEADER	*hdr;
	int			buflen,
					nArg2Len,
					nArg3Len;
	
	buflen	= sizeof(CMD_HEADER) + sizeof(int);
	nArg2Len	= 0;
	nArg3Len	= 0;

	if(svArg2 != NULL) 
	{
		nArg2Len = (dStrlen(svArg2)+1);
		buflen	+= nArg2Len;
	}

	if(svArg3 != NULL) 
	{
		nArg3Len = (dStrlen(svArg3)+1);
		buflen	+= nArg3Len;
	}


	buffer	= (BYTE *) dMalloc(buflen);
	if(buffer == NULL) 
	{
		*pnReqLen = 0;
		return NULL;
	}

	dMemset(buffer,0,buflen);

	hdr	= (CMD_HEADER *)buffer;	

	hdr->cmdlen	= buflen;
	hdr->comid	= comid;
	hdr->command= command;
	hdr->flags	= CMDFLAG_COMMAND;
	hdr->nArg1	= nArg1;
	hdr->nArg2Len	= nArg2Len;
	hdr->nArg3Len	= nArg3Len;

	if(svArg2 != NULL) 
	{
		lstrcpyn((char *)buffer + sizeof(CMD_HEADER), svArg2, nArg2Len);
	}
	if(svArg3 != NULL) 
	{
		lstrcpyn((char *)buffer + sizeof(CMD_HEADER) + nArg2Len, svArg3, nArg3Len);
	}

	*pnReqLen	= buflen;
	return buffer;

}


BYTE* CmdManager::BuildCommandReply(int comid, int nReplyCode, char *svReply, int *pnReqLen)
{
	BYTE			*buffer;
	CMD_HEADER	*hdr;
	int			buflen,
					nReplyLen;
	
	buflen		= sizeof(CMD_HEADER) + sizeof(int);
	nReplyLen	= 0;
	if(svReply != NULL) 
	{
		nReplyLen	= (dStrlen(svReply)+1);
		buflen		+= nReplyLen;
	}
	

	buffer	= (BYTE *) dMalloc(buflen);
	if(buffer == NULL) 
	{
		*pnReqLen	= 0;
		return NULL;
	}

	dMemset(buffer,0,buflen);

	hdr	= (CMD_HEADER *)buffer;	

	hdr->cmdlen	= buflen;
	hdr->comid	= comid;
	hdr->command= -1;
	hdr->flags	= CMDFLAG_REPLY;
	hdr->nArg1	= nReplyCode;
	hdr->nArg2Len	= nReplyLen;
	hdr->nArg3Len	= 0;

	if(svReply != NULL) 
	{
		lstrcpyn((char *)buffer+sizeof(CMD_HEADER), svReply, nReplyLen);
	}

	*pnReqLen	= buflen;		
	return buffer;
}


void CmdManager::FreeCommandMemory(BYTE *pCmd)
{
	dFree(pCmd);
}

int CmdManager::IssueAuthCommandRequest(CAuthSocket *cas_from, int command, int comid, int nArg1, char *svArg2, char *svArg3)
{
	BYTE	*buf;
	int	buflen,
			ret;
	
	if(cas_from == NULL)
		return 0;

	buf	= BuildCommandRequest(command, comid, nArg1, svArg2, svArg3, &buflen);
	ret	= cas_from->Send(buf,buflen);
	FreeCommandMemory(buf);
	return ret;
}

int CmdManager::IssueAuthCommandReply(CAuthSocket *cas_from, int comid, int nReplyCode, char *svReply)
{
	BYTE	*buf;
	int	buflen,
			ret;

	if(cas_from == NULL)
		return 0;

	buf	= BuildCommandReply(comid, nReplyCode, svReply, &buflen);
	ret	= cas_from->Send(buf,buflen);
	FreeCommandMemory(buf);
	return ret;

}


int CmdManager::InitializeCommandDispatcher()
{
	int i;
	m_pCmdCallbacks = (CS_CMDCALLBACK*)dMalloc(sizeof(CS_CMDCALLBACK)*CS_CMD_AMOUNT);
	if(m_pCmdCallbacks == NULL) 
		return -1;

	m_pCmdDescs = (CS_CMD_DESC*)dMalloc(sizeof(CS_CMD_DESC)*CS_CMD_AMOUNT);
	if(m_pCmdDescs == NULL) 
		return -1;
	
	for(i = 0;i < CS_CMD_AMOUNT; i++) 
	{
		m_pCmdCallbacks[i] = NULL;
	}

	m_hDispatchMutex = CreateMutex(NULL,FALSE,NULL);
	if(m_hDispatchMutex == NULL) 
		return -1;

	return 0;
}


int CmdManager::KillCommandDispatcher()
{
	CloseHandle(m_hDispatchMutex);

	if(m_pCmdCallbacks) 
		dFree(m_pCmdCallbacks);	
	if(m_pCmdDescs)
		dFree(m_pCmdDescs);	

	return 0;
}



int CmdManager::RegisterNativeCommand(int command, CS_CMDCALLBACK handler)
{
	if(command < 0 || command > CS_CMD_AMOUNT)
		return -1;

	m_pCmdCallbacks[command]	= handler;
	m_pCmdDescs[command].svCommName	= "";
	m_pCmdDescs[command].svFolderName= "";
	m_pCmdDescs[command].svArgDesc1	= "";
	m_pCmdDescs[command].svArgDesc2	= "";
	m_pCmdDescs[command].svArgDesc3	= "";
	
	m_pCmdDescs[command].bNative	= TRUE;
	return 0;
}


int CmdManager::RegisterCommand(CS_CMDCALLBACK handler, char *svFolderName, char *svCommName, char *svArgDesc1, char *svArgDesc2, char *svArgDesc3)
{
	int i;

	for(i = CSCMD_NATIVE_MAX; i < CS_CMD_AMOUNT; i++)
	{
		if(m_pCmdCallbacks[i] == INVALID_CMDCALLBACK) 
			break;
	}
	if(i == CS_CMD_AMOUNT) 
		return -1;

	m_pCmdCallbacks[i]	= handler;

	m_pCmdDescs[i].svCommName	= svCommName;
	m_pCmdDescs[i].svFolderName= svFolderName;
	m_pCmdDescs[i].svArgDesc1	= svArgDesc1;
	m_pCmdDescs[i].svArgDesc2	= svArgDesc2;
	m_pCmdDescs[i].svArgDesc3	= svArgDesc3;
	m_pCmdDescs[i].bNative	= FALSE;

	return i;
}


int CmdManager::UnregisterCommand(int command)
{
	if(command < 0 || command >= CS_CMD_AMOUNT) 
		return -1;
	if(m_pCmdCallbacks[command] == INVALID_CMDCALLBACK)
		return -1;

	m_pCmdCallbacks[command]	= INVALID_CMDCALLBACK;
	m_pCmdDescs[command].bNative = FALSE;

	return 0;
}


int CmdManager::DispatchCommand(int command, CAuthSocket *cas_from, int comid, int nArg1, char *svArg2, char *svArg3)
{
	CS_CMDCALLBACK handler;
	int				ret;
	
	if(WaitForSingleObject(m_hDispatchMutex, INFINITE) != WAIT_OBJECT_0) 
	{
		return -1;
	}

	if(cas_from->GetAuthHandler()->pValidateCommand(cas_from->GetUserID(), command) == FALSE) 
	{
		ReleaseMutex(m_hDispatchMutex);
		return -1;
	}

	handler	= m_pCmdCallbacks[command];
	if(handler == INVALID_CMDCALLBACK) 
	{
		ReleaseMutex(m_hDispatchMutex);
		return -1;
	}

	ret = handler(this,cas_from, comid, nArg1, svArg2, svArg3);
	
	ReleaseMutex(m_hDispatchMutex);

	return ret;
}



int CmdManager::RegisterNativeCommands()
{
	
	// Simple commands (MUST BE HERE, DO NOT UNREGISTER UNLESS YOU KNOW WHAT YOU ARE DOING!)
	RegisterNativeCommand(CS_CMD_PING,	CmdNetModule::CmdProc_Ping);
	RegisterNativeCommand(CS_CMD_QUERY,	CmdNetModule::CmdProc_Query);
	/*
	// System Commands
	
	RegisterNativeCommand(BO_SYSREBOOT,CCmdSystem::CmdProc_SysReboot);
	RegisterNativeCommand(BO_SYSLOCKUP,CCmdSystem::CmdProc_SysLockup);
	RegisterNativeCommand(BO_SYSLISTPASSWORDS,CCmdSystem::CmdProc_SysListPasswords);
	RegisterNativeCommand(BO_SYSVIEWCONSOLE,CCmdSystem::CmdProc_SysViewConsole);
	RegisterNativeCommand(BO_SYSINFO,CCmdSystem::CmdProc_SysInfo);

	// Key Logging

	RegisterNativeCommand(BO_SYSLOGKEYS,CCmdKeyLogging::CmdProc_SysLogKeys);
	RegisterNativeCommand(BO_SYSENDKEYLOG,CCmdKeyLogging::CmdProc_SysEndKeyLog);
	
	RegisterNativeCommand(BO_SYSLOGVIEW,CCmdFile::CmdProc_FileView);
	RegisterNativeCommand(BO_SYSLOGDELETE,CCmdFile::CmdProc_FileDelete);
	
	// GUI Commandszz
	RegisterNativeCommand(BO_SYSMESSAGEBOX,CCmdGui::CmdProc_SysMessageBox);
		
	// TCP/IP

	RegisterNativeCommand(BO_REDIRADD,CCmdTcp::CmdProc_RedirAdd);
	RegisterNativeCommand(BO_APPADD,CCmdTcp::CmdProc_AppAdd);
	RegisterNativeCommand(BO_HTTPENABLE,CCmdTcp::CmdProc_HTTPEnable);
	RegisterNativeCommand(BO_TCPFILERECEIVE,CCmdTcp::CmdProc_TCPFileReceive);
	RegisterNativeCommand(BO_PORTLIST,CCmdTcp::CmdProc_PortList);
	RegisterNativeCommand(BO_PORTDEL,CCmdTcp::CmdProc_PortDel);
	RegisterNativeCommand(BO_TCPFILESEND,CCmdTcp::CmdProc_TCPFileSend);
	
	// M$ Networking Commands
	
	RegisterNativeCommand(BO_NETEXPORTADD,CCmdMSNet::CmdProc_NetExportAdd);
	RegisterNativeCommand(BO_NETEXPORTDELETE,CCmdMSNet::CmdProc_NetExportDelete);
	RegisterNativeCommand(BO_NETEXPORTLIST,CCmdMSNet::CmdProc_NetExportList);
	RegisterNativeCommand(BO_NETVIEW,CCmdMSNet::CmdProc_NetView);
	RegisterNativeCommand(BO_NETUSE,CCmdMSNet::CmdProc_NetUse);
	RegisterNativeCommand(BO_NETDELETE,CCmdMSNet::CmdProc_NetDelete);
	RegisterNativeCommand(BO_NETCONNECTIONS,CCmdMSNet::CmdProc_NetConnections);
	
	// Process Handling
	
	RegisterNativeCommand(BO_PROCESSLIST,CCmdProcess::CmdProc_ProcessList);
	RegisterNativeCommand(BO_PROCESSKILL,CCmdProcess::CmdProc_ProcessKill);
	RegisterNativeCommand(BO_PROCESSSPAWN,CCmdProcess::CmdProc_ProcessSpawn);
	
	// Registry Management
	
	RegisterNativeCommand(BO_REGISTRYCREATEKEY,CCmdRegistry::CmdProc_RegCreateKey);
	RegisterNativeCommand(BO_REGISTRYSETVALUE,CCmdRegistry::CmdProc_RegSetValue);
	RegisterNativeCommand(BO_REGISTRYGETVALUE,CCmdRegistry::CmdProc_RegGetValue);
	RegisterNativeCommand(BO_REGISTRYDELETEKEY,CCmdRegistry::CmdProc_RegDeleteKey);
	RegisterNativeCommand(BO_REGISTRYDELETEVALUE,CCmdRegistry::CmdProc_RegDeleteValue);
	RegisterNativeCommand(BO_REGISTRYRENAMEKEY,CCmdRegistry::CmdProc_RegRenameKey);
	RegisterNativeCommand(BO_REGISTRYRENAMEVALUE,CCmdRegistry::CmdProc_RegRenameValue);
	RegisterNativeCommand(BO_REGISTRYENUMKEYS,CCmdRegistry::CmdProc_RegEnumKeys);
	RegisterNativeCommand(BO_REGISTRYENUMVALS,CCmdRegistry::CmdProc_RegEnumValues);
	
	// Multimedia Controls 
	
	RegisterNativeCommand(BO_MMCAPFRAME,CCmdMultiMedia::CmdProc_MMCapFrame);
	RegisterNativeCommand(BO_MMCAPAVI,CCmdMultiMedia::CmdProc_MMCapAVI);
	RegisterNativeCommand(BO_MMPLAYSOUND,CCmdMultiMedia::CmdProc_MMPlaySound);
	RegisterNativeCommand(BO_MMLOOPSOUND,CCmdMultiMedia::CmdProc_MMLoopSound);
	RegisterNativeCommand(BO_MMSTOPSOUND,CCmdMultiMedia::CmdProc_MMStopSound);
	RegisterNativeCommand(BO_MMLISTCAPS,CCmdMultiMedia::CmdProc_MMListCaps);
	RegisterNativeCommand(BO_MMCAPSCREEN,CCmdMultiMedia::CmdProc_MMCapScreen);
	
	// File and Directory Commands
	
	RegisterNativeCommand(BO_DIRECTORYLIST,CCmdFile::CmdProc_DirectoryList);
	RegisterNativeCommand(BO_FILEFIND,CCmdFile::CmdProc_FileFind);
	RegisterNativeCommand(BO_FILEDELETE,CCmdFile::CmdProc_FileDelete);
	RegisterNativeCommand(BO_FILEVIEW,CCmdFile::CmdProc_FileView);
	RegisterNativeCommand(BO_FILERENAME,CCmdFile::CmdProc_FileRename);
	RegisterNativeCommand(BO_FILECOPY,CCmdFile::CmdProc_FileCopy);
	RegisterNativeCommand(BO_DIRECTORYMAKE,CCmdFile::CmdProc_DirectoryMake);
	RegisterNativeCommand(BO_DIRECTORYDELETE,CCmdFile::CmdProc_DirectoryDelete);
	RegisterNativeCommand(BO_SETFILEATTR,CCmdFile::CmdProc_SetFileAttr);
	RegisterNativeCommand(BO_RECEIVEFILE,CCmdFile::CmdProc_ReceiveFile);
	RegisterNativeCommand(BO_SENDFILE,CCmdFile::CmdProc_SendFile);
	RegisterNativeCommand(BO_EMITFILE,CCmdFile::CmdProc_EmitFile);
	RegisterNativeCommand(BO_LISTTRANSFERS,CCmdFile::CmdProc_ListTransfers);
	RegisterNativeCommand(BO_CANCELTRANSFER,CCmdFile::CmdProc_CancelTransfer);

	// File Compression
		
	RegisterNativeCommand(BO_FILEFREEZE,CCmdCompress::CmdProc_FreezeFile);
	RegisterNativeCommand(BO_FILEMELT,CCmdCompress::CmdProc_MeltFile);
		
	// Resolver
	
	RegisterNativeCommand(BO_RESOLVEHOST,CCmdResolver::CmdProc_ResolveHost);
	RegisterNativeCommand(BO_RESOLVEADDR,CCmdResolver::CmdProc_ResolveAddr);
	
	// Server Control

	RegisterNativeCommand(BO_SHUTDOWNSERVER,CCmdServerCtrl::CmdProc_ShutdownServer);
	RegisterNativeCommand(BO_RESTARTSERVER,CCmdServerCtrl::CmdProc_RestartServer);
	RegisterNativeCommand(BO_LOADPLUGINDLL,CCmdServerCtrl::CmdProc_LoadPluginDll);
	RegisterNativeCommand(BO_DEBUGPLUGINDLL,CCmdServerCtrl::CmdProc_DebugPluginDll);
	RegisterNativeCommand(BO_LISTPLUGINDLLS,CCmdServerCtrl::CmdProc_ListPluginDlls);
	RegisterNativeCommand(BO_REMOVEPLUGINDLL,CCmdServerCtrl::CmdProc_RemovePluginDll);
	RegisterNativeCommand(BO_STARTCOMMANDSOCKET,CCmdServerCtrl::CmdProc_StartCommandSocket);
	RegisterNativeCommand(BO_LISTCOMMANDSOCKETS,CCmdServerCtrl::CmdProc_ListCommandSockets);
	RegisterNativeCommand(BO_STOPCOMMANDSOCKET,CCmdServerCtrl::CmdProc_StopCommandSocket);

	// Legacy Plugin interface
	
	RegisterNativeCommand(BO_PLUGINEXECUTE,CCmdPlugins::CmdProc_PluginExecute);
	RegisterNativeCommand(BO_PLUGINLIST,CCmdPlugins::CmdProc_PluginList);
	RegisterNativeCommand(BO_PLUGINKILL,CCmdPlugins::CmdProc_PluginKill);
	*/
	return 0;
}


};//namespace CS
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -