OSRM_impl::OSRM_impl(libosrm_config &lib_config)
{
if (lib_config.use_shared_memory)
{
barrier = osrm::make_unique<SharedBarriers>();
query_data_facade = new SharedDataFacade<QueryEdge::EdgeData>();
}
else
{
// populate base path
populate_base_path(lib_config.server_paths);
query_data_facade = new InternalDataFacade<QueryEdge::EdgeData>(lib_config.server_paths);
}
// The following plugins handle all requests.
RegisterPlugin(new DistanceTablePlugin<BaseDataFacade<QueryEdge::EdgeData>>(
query_data_facade, lib_config.max_locations_distance_table));
RegisterPlugin(new HelloWorldPlugin());
RegisterPlugin(new LocatePlugin<BaseDataFacade<QueryEdge::EdgeData>>(query_data_facade));
RegisterPlugin(new MultiTargetPlugin<BaseDataFacade<QueryEdge::EdgeData>, true>(query_data_facade));
RegisterPlugin(new MultiTargetPlugin<BaseDataFacade<QueryEdge::EdgeData>, false>(query_data_facade));
RegisterPlugin(new NearestPlugin<BaseDataFacade<QueryEdge::EdgeData>>(query_data_facade));
RegisterPlugin(new MapMatchingPlugin<BaseDataFacade<QueryEdge::EdgeData>>(
query_data_facade, lib_config.max_locations_map_matching));
RegisterPlugin(new TimestampPlugin<BaseDataFacade<QueryEdge::EdgeData>>(query_data_facade));
RegisterPlugin(new ViaRoutePlugin<BaseDataFacade<QueryEdge::EdgeData>>(query_data_facade));
RegisterPlugin(new RoundTripPlugin<BaseDataFacade<QueryEdge::EdgeData>>(query_data_facade));
}
bool NyquistEffectsModule::AutoRegisterPlugins(PluginManagerInterface & pm)
{
// Autoregister effects that we "think" are ones that have been shipped with
// Audacity. A little simplistic, but it should suffice for now.
wxArrayString pathList = NyquistEffect::GetNyquistSearchPath();
wxArrayString files;
if (!pm.IsPluginRegistered(NYQUIST_PROMPT_ID))
{
RegisterPlugin(pm, NYQUIST_PROMPT_ID);
}
for (int i = 0; i < WXSIZEOF(kShippedEffects); i++)
{
files.Clear();
pm.FindFilesInPathList(kShippedEffects[i], pathList, files);
for (size_t j = 0, cnt = files.GetCount(); j < cnt; j++)
{
if (!pm.IsPluginRegistered(files[j]))
{
RegisterPlugin(pm, files[j]);
}
}
}
// We still want to be called during the normal registration process
return false;
}
PLUGIN_INIT()
{
// register our new plugin
RegisterPlugin(PLUGIN_NAME, CreatePlugin, DestroyPlugin);
return 0;
}
LWRESULT Cx_PluginLoader::RegisterFrameWork(Ix_Module* pModule)
{
ASSERT_CHECK_RET(LWDP_MODULE_LOG, LWDP_PARAMETER_ERROR, (pModule), "Cx_PluginLoader::RegisterFrameWork Para Error");
int32_ existIndex = GetPluginIndex(pModule->GetModuleMODID());
if (existIndex >= 0 && m_modules[existIndex]->modid.empty())
{
return LWDP_PLUGINMGR_MODULE_ALREADY_LOAD;
}
LWRESULT stat = LWDP_ERROR;
if (pModule)
{
pModule->Initialize(this, 0);
if(RegisterPlugin(pModule) == LWDP_OK)
{
int32_ moduleIndex = FindModule(pModule->GetModuleMODID());
ASSERT_CHECK_RET(LWDP_MODULE_LOG, LWDP_PLUGINMGR_MODULE_INDEX_ERROR, (moduleIndex >= 0), "Module Index Error");
ASSERT_CHECK_RET(LWDP_MODULE_LOG, LWDP_PLUGINMGR_MODULE_INDEX_ERROR, (existIndex < 0 || existIndex == moduleIndex), "Module Index Error");
}
}
else
{
return LWDP_PLUGINMGR_LOADMODULE_ERROR;
}
return LWDP_OK;
}
PLUGIN_INIT()
{
// register our new plugin
std::cout << "PLUGIN_INIT" << std::endl;
RegisterPlugin(PLUGIN_NAME, CreatePlugin, DestroyPlugin);
return 0;
}
/**
* Initialize respond2 plugin
*
* @return void function
*/
void SetupRespond2(void)
{
RegisterPlugin("resp", Respond2Init);
GenRandIPID(&config); /* generate random IP ID cache */
return;
}
/****************************************************************************
*
* Function: SetupTemplate()
*
* Purpose: Generic detection engine plugin template. Registers the
* configuration function and links it to a rule keyword. This is
* the function that gets called from InitPlugins in plugbase.c.
*
* Arguments: None.
*
* Returns: void function
*
****************************************************************************/
void SetupTemplate()
{
/* map the keyword to an initialization/processing function */
RegisterPlugin("keyword", TemplateInit);
DebugMessage(DEBUG_PLUGIN,"Plugin: TemplateName Setup\n");
}
void RegisterArchiveContainers(ArchivePluginsRegistrator& registrator)
{
for (const ContainerPluginDescription* it = UNARCHIVES; it != boost::end(UNARCHIVES); ++it)
{
RegisterPlugin(*it, registrator);
}
}
/****************************************************************************
*
* Function: SetupTcpAckCheck()
*
* Purpose: Link the ack keyword to the initialization function
*
* Arguments: None.
*
* Returns: void function
*
****************************************************************************/
void SetupTcpAckCheck()
{
/* map the keyword to an initialization/processing function */
RegisterPlugin("ack", TcpAckCheckInit);
#ifdef DEBUG
printf("Plugin: TcpAckCheck Initialized\n");
#endif
}
/****************************************************************************
*
* Function: SetupReferenceCheck()
*
* Purpose: Registers our keywords
*
* Arguments: None.
*
* Returns: void function
*
****************************************************************************/
void SetupReference()
{
/* map the keyword to an initialization/processing function */
RegisterPlugin("reference", ReferenceInit);
#ifdef DEBUG
printf("Plugin: Reference Setup\n");
#endif
}
/****************************************************************************
*
* Function: SetupIcmpIdCheck()
*
* Purpose: Registers the configuration function and links it to a rule
* keyword. This is the function that gets called from InitPlugins
* in plugbase.c.
*
* Arguments: None.
*
* Returns: void function
*
****************************************************************************/
void SetupIcmpIdCheck()
{
/* map the keyword to an initialization/processing function */
RegisterPlugin("icmp_id", IcmpIdCheckInit);
#ifdef DEBUG
printf("Plugin: IcmpIdCheck Setup\n");
#endif
}
/****************************************************************************
*
* Function: SetupSession()
*
* Purpose: Init the session plugin module.
*
* Arguments: None.
*
* Returns: void function
*
****************************************************************************/
void SetupSession()
{
/* map the keyword to an initialization/processing function */
RegisterPlugin("session", SessionInit);
#ifdef DEBUG
printf("Plugin: Session Setup\n");
#endif
}
//! \fn : DllRegisterServer
//! \brief : Registers plugin (exported function)
//! \return : HRESULT
//! \param : void
HRESULT CALLBACK DllRegisterServer(void)
{
KLSTD_TRACE0 ( MCOU_TL_INFO, L"DllRegisterServer called\n" );
TCHAR szThisModuleFileName [MAX_PATH];
if (MCOU::GetThisModuleFileName (szThisModuleFileName, MAX_PATH) == 0)
return E_FAIL;
return RegisterPlugin (szThisModuleFileName);
}
void ModuleFactory::RegisterAllPlugins() {
TRACE("ModuleFactory::RegisterAllPlugins - Start\n");
DIR* dir;
struct dirent* entry;
dir = opendir("./plugins/");
while ((entry = readdir(dir)) != NULL) {
TRACE( "ModuleFactory::RegisterAllPlugins - Wczytuje: %s\n", entry->d_name );
RegisterPlugin (entry->d_name);
}
TRACE("ModuleFactory::RegisterAllPlugins - Koniec\n" );
}
/****************************************************************************
*
* Function: SetupFlowBits()
*
* Purpose: Generic detection engine plugin template. Registers the
* configuration function and links it to a rule keyword. This is
* the function that gets called from InitPlugins in plugbase.c.
*
* Arguments: None.
*
* Returns: void function
*
* 3/4/05 - man beefed up the hash table size from 100 -> 10000
*
****************************************************************************/
void SetupFlowBits()
{
/* setup our storage hash */
flowbits_hash = sfghash_new( 10000, 0 , 0, 0);
if (!flowbits_hash) {
FatalError("Could not setup flowbits hash\n");
}
/* map the keyword to an initialization/processing function */
RegisterPlugin("flowbits", FlowBitsInit);
DEBUG_WRAP(DebugMessage(DEBUG_PLUGIN, "Plugin: FlowBits Setup\n"););
bool Cx_PluginLoader::LoadPlugin(const wchar_t* filename)
{
if (!x3InMainThread())
{
X3LOG_WARNING2(L"Can't load plugin in sub thread.", filename);
return false;
}
CLockCount locker(&m_loading);
int existIndex = GetPluginIndex(filename);
if (existIndex >= 0 && m_modules[existIndex]->hdll)
{
if (_wcsicmp(filename, m_modules[existIndex]->filename) != 0)
{
X3LOG_DEBUG2(L"The plugin is already loaded.",
filename << L", " << (m_modules[existIndex]->filename));
}
return false;
}
HMODULE hdll = x3LoadLibrary(filename);
DWORD errcode = GetLastError();
if (hdll)
{
if (RegisterPlugin(hdll))
{
int moduleIndex = FindModule(hdll);
ASSERT(moduleIndex >= 0);
ASSERT(existIndex < 0 || existIndex == moduleIndex);
m_modules[moduleIndex]->owned = true;
#ifdef _WIN32
DisableThreadLibraryCalls(hdll);
#endif
}
else
{
FreeLibrary(hdll);
hdll = NULL;
}
}
else if (PathFileExistsW(filename))
{
X3LOG_WARNING2(L"Fail to load plugin.",
x3::GetSystemErrorString(errcode) << L", " << filename);
}
return hdll != NULL;
}
OSRM::OSRM( const ServerPaths & server_paths, const bool use_shared_memory )
:
use_shared_memory(use_shared_memory)
{
if( !use_shared_memory ) {
query_data_facade = new InternalDataFacade<QueryEdge::EdgeData>(
server_paths
);
} else {
query_data_facade = new SharedDataFacade<QueryEdge::EdgeData>( );
}
//The following plugins handle all requests.
RegisterPlugin(
new HelloWorldPlugin()
);
RegisterPlugin(
new LocatePlugin<BaseDataFacade<QueryEdge::EdgeData> >(
query_data_facade
)
);
RegisterPlugin(
new NearestPlugin<BaseDataFacade<QueryEdge::EdgeData> >(
query_data_facade
)
);
RegisterPlugin(
new TimestampPlugin<BaseDataFacade<QueryEdge::EdgeData> >(
query_data_facade
)
);
RegisterPlugin(
new ViaRoutePlugin<BaseDataFacade<QueryEdge::EdgeData> >(
query_data_facade
)
);
}
LWRESULT Cx_PluginLoader::LoadPlugin(const MODID& modid)
{
int32_ existIndex = GetPluginIndex(modid);
if (existIndex >= 0 && m_modules[existIndex]->modid.empty())
{
return LWDP_PLUGINMGR_MODULE_ALREADY_LOAD;
}
Cx_Interface<Ix_FwIntf> iFwIntf(CLSID_FwIntf);
ASSERT_CHECK_RET(LWDP_MODULE_LOG, LWDP_OBJECT_POINTER_IS_NULL, !iFwIntf.IsNull(),
"Cx_PluginLoader::LoadPlugin Get Object(FwIntf) Error");
Ix_Module* pModule = iFwIntf->Api_Fw_GetModulePtr(modid);
if(!pModule)
{
return LWDP_PLUGINMGR_NOT_FIND_MODULE_ENTRY;
}
LWRESULT stat = LWDP_ERROR;
if (pModule)
{
if((stat = CheckPlugin(pModule)) != LWDP_OK)
{
if(pModule->GetModuleInstance()) //!< 只有加载的外部模块才Unload
{
Cx_Interface<Ix_FwIntf> iFwIntf(CLSID_FwIntf);
ASSERT_CHECK_RET(LWDP_MODULE_LOG, LWDP_OBJECT_POINTER_IS_NULL, !iFwIntf.IsNull(),
"Cx_PluginLoader::LoadPlugin Get Object(FwIntf) Error");
iFwIntf->Api_Fw_UnLoadModule(pModule->GetModuleMODID());
}
return stat;
}
pModule->Initialize(this, 0);
if(RegisterPlugin(pModule) == LWDP_OK)
{
int32_ moduleIndex = FindModule(pModule->GetModuleMODID());
ASSERT_CHECK_RET(LWDP_MODULE_LOG, LWDP_PLUGINMGR_MODULE_INDEX_ERROR, (moduleIndex >= 0), "Module Index Error");
ASSERT_CHECK_RET(LWDP_MODULE_LOG, LWDP_PLUGINMGR_MODULE_INDEX_ERROR, (existIndex < 0 || existIndex == moduleIndex), "Module Index Error");
}
}
else
{
return LWDP_PLUGINMGR_LOADMODULE_ERROR;
}
return LWDP_OK;
}
bool BuiltinEffectsModule::AutoRegisterPlugins(PluginManagerInterface & pm)
{
for (size_t i = 0; i < WXSIZEOF(kEffectNames); i++)
{
wxString path(wxString(BUILTIN_EFFECT_PREFIX) + kEffectNames[i]);
if (!pm.IsPluginRegistered(path))
{
RegisterPlugin(pm, path);
}
}
// We still want to be called during the normal registration process
return false;
}
void
GameEvent(CORE_DATA *cd)
{
switch (cd->event) {
case EVENT_START:
RegisterPlugin(OPENCORE_VERSION, CORE_NAME, "cycad", OPENCORE_VERSION, __DATE__, __TIME__, "core handler", 0, 0);
register_commands();
break;
case EVENT_COMMAND:
switch (cd->cmd_id) {
case CMD_DIE: cmd_die(cd); break;
case CMD_STOPBOT: cmd_stopbot(cd); break;
case CMD_GETFILE: cmd_getfile(cd); break;
case CMD_PUTFILE: cmd_putfile(cd); break;
case CMD_LISTBOTS: cmd_listbots(cd); break;
case CMD_TYPES: cmd_types(cd); break;
case CMD_LOADTYPES: cmd_loadtypes(cd); break;
case CMD_LOG: cmd_log(cd); break;
case CMD_CMDLOG: cmd_cmdlog(cd); break;
case CMD_ABOUT: cmd_about(cd); break;
case CMD_INSLIB: cmd_inslib(cd); break;
case CMD_RMLIB: cmd_rmlib(cd); break;
case CMD_HELP: cmd_help(cd); break;
case CMD_SYSINFO: cmd_sysinfo(cd); break;
case CMD_LOADOPS: cmd_loadops(cd); break;
case CMD_LISTOPS: cmd_listops(cd); break;
case CMD_EXEC: cmd_exec(cd); break;
case CMD_STARTBOT: cmd_startbot(cd); break;
case CMD_GO: cmd_go(cd); break;
default: break;
}
break;
default:
break;
}
}
Exporter::Exporter()
{
mMixerSpec = NULL;
RegisterPlugin(New_ExportPCM());
RegisterPlugin(New_ExportMP3());
#ifdef USE_LIBVORBIS
RegisterPlugin(New_ExportOGG());
#endif
#ifdef USE_LIBFLAC
RegisterPlugin(New_ExportFLAC());
#endif
#if USE_LIBTWOLAME
RegisterPlugin(New_ExportMP2());
#endif
// Command line export not available on Windows and Mac platforms
RegisterPlugin(New_ExportCL());
}
void
GameEvent(CORE_DATA *cd)
{
USER_DATA *ud = UD(cd);
switch (cd->event) {
case EVENT_START:
RegisterPlugin(OPENCORE_VERSION, "chess", "cycad", "1.0", __DATE__, __TIME__, "A player-vs-player chess bot", sizeof(USER_DATA), 0);
ud = UD(cd);
// allocate chess board
ud->board = (BOARD)calloc(8, sizeof(PIECE*));
for (int i = 0; i < 8; ++i) {
ud->board[i] = (PIECE*)calloc(8, sizeof(PIECE));
}
BoardReset(ud, ud->board);
// draw the board
LvzDrawAll(ud, NULL, true);
RegisterCommand(COMMAND_CHESSHELP, "!chesshelp", "Chess", 0, CMD_PUBLIC | CMD_PRIVATE, NULL, "Get basic chessbot information", NULL);
RegisterCommand(COMMAND_GAMEINFO, "!gameinfo", "Chess", 0, CMD_PUBLIC | CMD_PRIVATE, NULL, "Get information about the current game", NULL);
RegisterCommand(COMMAND_WHITE, "!white", "Chess", 0, CMD_PUBLIC | CMD_PRIVATE, NULL, "Play as White", NULL);
RegisterCommand(COMMAND_BLACK, "!black", "Chess", 0, CMD_PUBLIC | CMD_PRIVATE, NULL, "Play as Black", NULL);
RegisterCommand(COMMAND_MOVE, "!move", "Chess", 0, CMD_PUBLIC | CMD_PRIVATE, "<coord1>,<coord2>", "Move a chess piece", NULL);
RegisterCommand(COMMAND_QUIT, "!quit", "Chess", 0, CMD_PUBLIC | CMD_PRIVATE, NULL, "Stop playing chess", NULL);
break;
case EVENT_COMMAND:
switch (cd->cmd_id) {
case COMMAND_CHESSHELP: CmdChessHelp(cd); break;
case COMMAND_GAMEINFO: CmdGameInfo(cd); break;
case COMMAND_WHITE: CmdWhite(cd); break;
case COMMAND_BLACK: CmdBlack(cd); break;
case COMMAND_MOVE: CmdMove(cd); break;
case COMMAND_QUIT: CmdQuit(cd); break;
default: assert(0); break;
}
break;
case EVENT_MESSAGE:
#if 0
// eventually handle commands in pubchat, like "b1,c3"
if (cd->msg_type == MSG_PUBLIC &&
ud->in_progress &&
IsPlaying(cd->msg_name)) {
}
#endif
break;
case EVENT_ENTER:
LvzActivateBoard();
LvzDrawAll(ud, cd->p1, true);
LvzToMove(ud->to_move, cd->p1);
if (IsPlaying(ud, cd->p1->name)) {
// player rejoined
ArenaMessageFmt("%s has returned to the game", cd->p1->name);
KillTimer(ud->timer);
ud->timer = 0;
}
break;
case EVENT_LEAVE:
// check if this player is relevant
if (IsPlaying(ud, cd->p1->name)) {
if (ud->in_progress && ud->timer) {
// timer is only set when one player is already gone
StopGame(ud, "Both players left the game");
KillTimer(ud->timer);
ud->timer = 0;
} else if (ud->in_progress) {
// someone left a game in progress
ArenaMessageFmt("%s has left the game and has 2 minutes to return", cd->p1->name);
ud->timer = SetTimer(2 * 60 * 1000, 0, 0);
} else {
// no need to wait for someone not playing
ArenaMessageFmt("%s is no longer playing", cd->p1->name);
UnsetPlayerName(ud, cd->p1->name);
}
}
break;
case EVENT_TIMER:
// this game needs to be stopped due to timeout
if (ud->in_progress && cd->timer_id == ud->timer) {
StopGame(ud, "Player did not return to game");
ud->timer = 0;
} else if (cd->timer_data1) {
uint32_t objid = (uint32_t)(intptr_t)cd->timer_data1;
uint32_t on = (uint32_t)(intptr_t)cd->timer_data2;
if (on) {
PubMessageFmt("*objon %u", objid);
} else {
PubMessageFmt("*objoff %u", objid);
}
}
break;
case EVENT_STOP:
// free chess board
for (int i = 0; i < 8; ++i) {
free(ud->board[i]);
}
free(ud->board);
// free user data
free(cd->user_data);
break;
}
}
/****************************************************************************
*
* Function: SetupDynamic()
*
* Purpose: Load it up
*
* Arguments: None.
*
* Returns: void function
*
****************************************************************************/
void SetupDynamic(void)
{
/* map the keyword to an initialization/processing function */
RegisterPlugin("dynamic", DynamicInit);
DEBUG_WRAP(DebugMessage(DEBUG_PLUGIN,"Plugin: Dynamic Setup\n"););
void
GameEvent(CORE_DATA *cd)
{
switch (cd->event) {
case EVENT_START:
RegisterPlugin(OPENCORE_VERSION, "rabbit", "cycad", "1.0", __DATE__, __TIME__, "A rabbit bot", sizeof(USER_DATA), 0);
/* set rabbit pid to nobody */
ud(cd)->rabbit_pid = PID_NONE;
/* register rabbit command */
RegisterCommand(COMMAND_RABBIT, "!rabbit", "Rabbit", 2, CMD_PRIVATE, "<name>:<bounty>[:<special>]", "Start the rabbit game", NULL); break;
case EVENT_LOGIN:
/* set the bot's location to center */
SetPosition(16 * 512, 16 * 512, 0, 0);
break;
case EVENT_COMMAND:
switch (cd->cmd_id) {
case COMMAND_RABBIT: {
int show_usage = 0;
PLAYER_ID rpid = ud(cd)->rabbit_pid;
if (rpid == PID_NONE) { /* rabbit game is not runnig */
if (cd->cmd_argc <= 1) {
show_usage = 1;
} else {
char *cmd = cd->cmd_argr[1];
int nargs = ArgCount(cmd, ':');
if (nargs != 2 && nargs != 3) {
show_usage = 1;
} else { /* args to command are valid */
/* copy name out of command */
char rname[20];
DelimArgs(rname, sizeof(rname), cmd, 0, ':', 0);
/* copy bounty out of command */
int bty = AtoiArg(cmd, 1, ':');
/* copy special out of command if it was specified */
int special = 0;
if (nargs == 3)
special = AtoiArg(cmd, 2, ':');
/* find the player specified on the command line */
PLAYER *rabbit = FindPlayerName(rname, MATCH_HERE | MATCH_PREFIX);
if (rabbit) {
/* player found, start the game */
start_rabbit_game(cd, rabbit, bty, special);
} else {
RmtMessageFmt(cd->cmd_name, "Player not found: %s", rname);
}
}
}
} else {
/* rabbit game is already running */
PLAYER *p = FindPlayerPid(rpid, MATCH_HERE);
RmtMessageFmt(cd->cmd_name, "Rabbit is already running (%s is the rabbit)",
p ? p->name : "**UNKNOWN**");
}
/* display usage if necessary */
if (show_usage) RmtMessageFmt(cd->cmd_name, "Usage: %s <name>:<bounty>[:<special>]", cd->cmd_argv[0]);
}
default: break;
}
break;
case EVENT_UPDATE:
if (ud(cd)->rabbit_pid == cd->p1->pid) { /* if the update is for the rabbit */
if (cd->p1->status & STATUS_SAFE) { /* check if the rabbit is in safe */
/* the rabbit entered safe, end the game */
ArenaMessageFmt("%s has lost the rabbit game by entering safe!", cd->p1->name);
ud(cd)->rabbit_pid = PID_NONE;
}
}
break;
case EVENT_TIMER:
if (ud(cd)->rabbit_pid != PID_NONE) { /* if the rabbit game is running */
/* find the rabbit */
PLAYER *p = FindPlayerPid(ud(cd)->rabbit_pid, MATCH_HERE);
if (p) {
if (ud(cd)->where_timer == cd->timer_id) {
/* a *where timer expired, send the next one and look for response */
PrivMessage(p, "*where");
ud(cd)->expecting_where = 1;
} else if (ud(cd)->gameover_timer == cd->timer_id) {
/* the game over timer expired, the rabbit didnt die and he won */
ArenaMessageFmt("%s wins the rabbit game by staying alive!", p->name);
ud(cd)->rabbit_pid = PID_NONE;
}
} else {
/* rabbit not found, this should never happen! */
}
}
case EVENT_MESSAGE:
/*
* Only look for a response of the game is running, the bot is expecting *where,
* and the message type is an arena message.
*/
if (ud(cd)->rabbit_pid != PID_NONE && ud(cd)->expecting_where &&
cd->msg_type == MSG_ARENA) {
/* message is a possible *where response */
/* find the rabbit */
PLAYER *p = FindPlayerPid(ud(cd)->rabbit_pid, MATCH_HERE);
if (p) {
char where_prefix[32];
snprintf(where_prefix, 32, "%s: ", p->name);
where_prefix[32 - 1] = '\0';
/*
* Verify that this is *where output by looking for "rabbit: " at the
* beginning of the string.
*/
if (strncasecmp(where_prefix, cd->msg, strlen(where_prefix)) == 0) {
/* this must be a *where response, process it */
char loc[4];
snprintf(loc, 4, "%s", &cd->msg[strlen(where_prefix)]);
loc[4 - 1] = '\0';
/* announce the rabbits location */
ArenaMessageFmt(">>> Rabbit %s is at %-3s <<<", p->name, loc);
/* set the next *where timer */
ud(cd)->where_timer = SetTimer(30 * 1000, 0, 0);
/*
* The bot wont be looking for *where responses until the
* next time it sends the command, so turn parsing off
* for now.
*/
ud(cd)->expecting_where = 0;
}
}
}
break;
case EVENT_KILL:
if (cd->p1->pid == ud(cd)->rabbit_pid) {
/* the rabbit died */
ArenaMessageFmt("%s wins the rabbit game by killing Rabbit %s!", cd->p2->name, cd->p1->name);
ud(cd)->rabbit_pid = PID_NONE;
}
break;
case EVENT_LEAVE:
if (ud(cd)->rabbit_pid == cd->p1->pid) {
/* the rabbit left */
ArenaMessageFmt("%s has lost the rabbit game by leaving the arena!", cd->p1->name);
ud(cd)->rabbit_pid = PID_NONE;
}
break;
case EVENT_CHANGE:
if (ud(cd)->rabbit_pid == cd->p1->pid) {
/* the rabbit changed ship */
ArenaMessageFmt("%s has lost the rabbit game by changing ship/freq!", cd->p1->name);
ud(cd)->rabbit_pid = PID_NONE;
}
break;
}
}
void SetupAsn1()
{
/* map the keyword to an initialization/processing function */
RegisterPlugin("asn1", Asn1Init);
DEBUG_WRAP(DebugMessage(DEBUG_PLUGIN,"Plugin: ASN1 Setup\n"););
/****************************************************************************
*
* Function: SetupIpProto()
*
* Purpose: Generic detection engine plugin ip_proto. Registers the
* configuration function and links it to a rule keyword. This is
* the function that gets called from InitPlugins in plugbase.c.
*
* Arguments: None.
*
* Returns: void function
*
****************************************************************************/
void SetupIpProto(void)
{
/* map the keyword to an initialization/processing function */
RegisterPlugin("ip_proto", IpProtoInit);
DEBUG_WRAP(DebugMessage(DEBUG_PLUGIN,"Plugin: IpProto Setup\n"););
void RegisterAyContainer(ArchivePluginsRegistrator& registrator)
{
RegisterPlugin(AY, registrator);
}
/****************************************************************************
*
* Function: SetupByteTest()
*
* Purpose: Load 'er up
*
* Arguments: None.
*
* Returns: void function
*
****************************************************************************/
void SetupByteTest(void)
{
/* map the keyword to an initialization/processing function */
RegisterPlugin("byte_test", ByteTestInit);
DEBUG_WRAP(DebugMessage(DEBUG_PLUGIN,"Plugin: ByteTest Setup\n"););
/****************************************************************************
*
* Function: SetupTcpWinCheck()
*
* Purpose: Associate the window keyword with TcpWinCheckInit
*
* Arguments: None.
*
* Returns: void function
*
****************************************************************************/
void SetupTcpWinCheck(void)
{
/* map the keyword to an initialization/processing function */
RegisterPlugin("window", TcpWinCheckInit);
}
/****************************************************************************
*
* Function: SetupIsDataAt()
*
* Purpose: Load 'er up
*
* Arguments: None.
*
* Returns: void function
*
****************************************************************************/
void SetupIsDataAt(void)
{
/* map the keyword to an initialization/processing function */
RegisterPlugin("isdataat", IsDataAtInit);
DEBUG_WRAP(DebugMessage(DEBUG_PLUGIN,"Plugin: IsDataAt Setup\n"););
