AsyncReply *ModuleController::_send_wait(Uint32 destination_q,
const String & destination_module,
AsyncRequest *message)
{
AutoPtr<AsyncModuleOperationStart> request(new AsyncModuleOperationStart(get_next_xid(),
0,
destination_q,
getQueueId(),
true,
destination_module,
message));
request->dest = destination_q;
AutoPtr<AsyncModuleOperationResult>
response(static_cast<AsyncModuleOperationResult *>(SendWait(request.get())));
AsyncReply *ret = 0;
if (response.get() != NULL && response->getType() == async_messages::ASYNC_MODULE_OP_RESULT )
{
ret = static_cast<AsyncReply *>(response->get_result());
//clear the request out of the envelope so it can be deleted by the module
}
request->get_action();
return ret;
}
Boolean ModuleController::deregister_module(const String & module_name)
{
AutoPtr<DeRegisteredModule> request(new DeRegisteredModule(get_next_xid(),
0,
true,
getQueueId(),
module_name));
request->dest = _meta_dispatcher->getQueueId();
AutoPtr<AsyncReply> response(SendWait(request.get()));
request.reset();
response.reset();
pegasus_module *module;
_module_lock lock(&_modules);
module = _modules.next(0);
while(module != NULL )
{
if( module->get_name() == module_name)
{
_modules.remove_no_lock(module);
return true;
}
module = _modules.next(module);
}
return false;
}
Boolean MessageQueueService::update_service(Uint32 capabilities, Uint32 mask)
{
UpdateCimService *msg = new UpdateCimService(
get_next_xid(),
0,
true,
_queueId,
_capabilities,
_mask);
Boolean registered = false;
AsyncMessage *reply = SendWait(msg);
if (reply)
{
if (reply->getMask() & message_mask::ha_async)
{
if (reply->getMask() & message_mask::ha_reply)
{
if (static_cast<AsyncReply *>(reply)->result == async_results::OK)
{
registered = true;
}
}
}
delete reply;
}
delete msg;
return registered;
}
bool FH2LocalClient::ConnectionChat(void)
{
Settings & conf = Settings::Get();
QueueMessage packet;
color = 0;
race = 0;
name.clear();
id = 0;
// recv ready, banner
DEBUG(DBG_NETWORK, DBG_INFO, "wait ready");
if(!Wait(packet, MSG_READY)) return false;
// get banner
std::string str;
packet.Pop(str);
// dialog: input name
if(!Dialog::InputString("Connected to " + server + "\n \n" + str + "\n \nEnter player name:", name))
return false;
u8 game_type = conf.GameType();
DEBUG(DBG_NETWORK, DBG_INFO, "game type: 0x" << std::hex << static_cast<int>(game_type));
// send hello
packet.Reset();
packet.SetID(MSG_HELLO);
packet.Push(game_type);
packet.Push(name);
if(!SendWait(packet, MSG_HELLO, "ConnectionChat: "))
return false;
packet.Pop(modes);
packet.Pop(game_type);
packet.Pop(id);
DEBUG(DBG_NETWORK, DBG_INFO, (Modes(ST_ADMIN) ? "admin" : "client") << " mode");
if(conf.GameType() != game_type)
conf.SetGameType(game_type);
DEBUG(DBG_NETWORK, DBG_INFO, "game type: 0x" << std::hex << static_cast<int>(game_type));
// ready
DEBUG(DBG_NETWORK, DBG_INFO, "wait: " << Network::GetMsgString(MSG_READY));
if(!Wait(packet, MSG_READY)) return false;
packet.Pop(str);
if(str.size())
{
Dialog::Message("Error", str, Font::BIG, Dialog::OK);
return false;
}
return true;
}
bool FH2LocalClient::GetCurrentMapInfo(void)
{
Settings & conf = Settings::Get();
// send get_current_map
QueueMessage packet(MSG_GET_CURRENT_MAP);
if(!SendWait(packet, MSG_GET_CURRENT_MAP, "GetCurrentMapInfo: "))
return false;
Network::PacketPopMapsFileInfo(packet, conf.CurrentFileInfo());
return true;
}
bool FH2LocalClient::GetLoadMaps(bool forceLoad, bool sendAll)
{
QueueMessage packet(MSG_MAPS_LOAD);
packet.Push(static_cast<u8>(forceLoad));
packet.Push(static_cast<u8>(sendAll));
if(!SendWait(packet, MSG_MAPS_LOAD, "LoadMaps: "))
return false;
if(Game::IO::LoadBIN(packet))
return true;
DEBUG(DBG_NETWORK, DBG_WARN, "error");
return false;
}
void MessageQueueService::enumerate_service(Uint32 queue, message_module *result)
{
if (result == 0)
{
throw NullPointer();
}
EnumerateService *req = new EnumerateService(
get_next_xid(),
0,
_queueId,
true,
queue);
AsyncMessage *reply = SendWait(req);
if (reply)
{
Boolean found = false;
if (reply->getMask() & message_mask::ha_async)
{
if (reply->getMask() & message_mask::ha_reply)
{
if (reply->getType() == async_messages::ENUMERATE_SERVICE_RESULT)
{
if ((static_cast<EnumerateServiceResponse *>(reply))->result == async_results::OK)
{
if (found == false)
{
found = true;
result->put_name((static_cast<EnumerateServiceResponse *>(reply))->name);
result->put_capabilities((static_cast<EnumerateServiceResponse *>(reply))->capabilities);
result->put_mask((static_cast<EnumerateServiceResponse *>(reply))->mask);
result->put_queue((static_cast<EnumerateServiceResponse *>(reply))->qid);
}
}
}
}
}
delete reply;
}
delete req;
return;
}
void MessageQueueService::find_services(
String name,
Uint32 capabilities,
Uint32 mask,
Array<Uint32> *results)
{
if (results == 0)
{
throw NullPointer();
}
results->clear();
FindServiceQueue *req = new FindServiceQueue(
get_next_xid(),
0,
_queueId,
true,
name,
capabilities,
mask);
req->dest = CIMOM_Q_ID;
AsyncMessage *reply = SendWait(req);
if (reply)
{
if (reply->getMask() & message_mask::ha_async)
{
if (reply->getMask() & message_mask::ha_reply)
{
if (reply->getType() == async_messages::FIND_SERVICE_Q_RESULT)
{
if ((static_cast<FindServiceQueueResult *>(reply))->result == async_results::OK)
*results = (static_cast<FindServiceQueueResult *>(reply))->qids;
}
}
}
delete reply;
}
delete req;
return ;
}
bool FH2LocalClient::GetPlayersInfo(void)
{
// get my color
QueueMessage packet(MSG_GET_CURRENT_COLOR);
if(!SendWait(packet, MSG_GET_CURRENT_COLOR, "GetPlayersInfo: "))
return false;
packet.Pop(color);
if(0 == color)
{
DEBUG(DBG_NETWORK, DBG_WARN, "unknown color");
return false;
}
// get players
MsgUpdatePlayers(packet);
return true;
}
Uint32 ModuleController::find_module_in_service(const pegasus_module & handle,
const String & name)
{
if ( false == verify_handle(const_cast<pegasus_module *>(&handle)))
throw(Permission(pegasus_thread_self()));
Uint32 result = 0 ;
AutoPtr<FindModuleInService> request(new FindModuleInService(get_next_xid(),
0,
true,
_meta_dispatcher->getQueueId(),
name));
request->dest = _meta_dispatcher->getQueueId();
AutoPtr<FindModuleInServiceResponse>
response(static_cast<FindModuleInServiceResponse *>(SendWait(request.get())));
if( response.get() != NULL)
result = response->_module_service_queue;
return result;
}
Boolean MessageQueueService::register_service(
String name,
Uint32 capabilities,
Uint32 mask)
{
RegisterCimService *msg = new RegisterCimService(
get_next_xid(),
0,
true,
name,
capabilities,
mask,
_queueId);
msg->dest = CIMOM_Q_ID;
Boolean registered = false;
AsyncReply *reply = static_cast<AsyncReply *>(SendWait(msg));
if (reply != 0)
{
if (reply->getMask() & message_mask::ha_async)
{
if (reply->getMask() & message_mask::ha_reply)
{
if (reply->result == async_results::OK ||
reply->result == async_results::MODULE_ALREADY_REGISTERED)
{
registered = true;
}
}
}
delete reply;
}
delete msg;
return registered;
}
CIMHandleIndicationResponseMessage*
IndicationHandlerService::_handleIndication(
CIMHandleIndicationRequestMessage* request)
{
PEG_METHOD_ENTER (TRC_IND_HANDLE,
"IndicationHandlerService::_handleIndication");
CIMException cimException =
PEGASUS_CIM_EXCEPTION(CIM_ERR_SUCCESS, String::EMPTY);
CIMName className = request->handlerInstance.getClassName();
CIMNamespaceName nameSpace = request->nameSpace;
CIMInstance indication = request->indicationInstance;
CIMInstance handler = request->handlerInstance;
Uint32 pos = PEG_NOT_FOUND;
if (className.equal (PEGASUS_CLASSNAME_INDHANDLER_CIMXML) ||
className.equal (PEGASUS_CLASSNAME_LSTNRDST_CIMXML))
{
pos = handler.findProperty(PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION);
if (pos == PEG_NOT_FOUND)
{
cimException = PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
MessageLoaderParms("HandlerService.IndicationHandlerService."
"CIMXML_HANDLER_WITHOUT_DESTINATION", "CIMXml Handler missing Destination property"));
}
else
{
CIMProperty prop = handler.getProperty(pos);
String destination = prop.getValue().toString();
if (destination.size() == 0)
{
cimException = PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
MessageLoaderParms("HandlerService.IndicationHandlerService."
"INVALID_DESTINATION", "invalid destination"));
}
//compared index 10 is not :
else if (destination.subString(0, 10) == String("localhost/"))
{
Array<Uint32> exportServer;
find_services(PEGASUS_QUEUENAME_EXPORTREQDISPATCHER, 0, 0,
&exportServer);
// Listener is build with Cimom, so send message to ExportServer
AutoPtr<CIMExportIndicationRequestMessage> exportmessage(
new CIMExportIndicationRequestMessage(
XmlWriter::getNextMessageId(),
destination.subString(21), //taking localhost/CIMListener portion out from reg
indication,
QueueIdStack(exportServer[0], getQueueId()),
String::EMPTY,
String::EMPTY));
exportmessage->operationContext.set(
request->operationContext.get(
ContentLanguageListContainer::NAME));
AutoPtr<AsyncOpNode> op( this->get_op());
AutoPtr<AsyncLegacyOperationStart> asyncRequest(
new AsyncLegacyOperationStart(
get_next_xid(),
op.get(),
exportServer[0],
exportmessage.get(),
_queueId));
exportmessage.release();
PEG_TRACE_STRING(TRC_IND_HANDLE, Tracer::LEVEL4,
"Indication handler forwarding message to " +
((MessageQueue::lookup(exportServer[0])) ?
String( ((MessageQueue::lookup(exportServer[0]))->
getQueueName()) ) :
String("BAD queue name")));
//SendAsync(op,
// exportServer[0],
// IndicationHandlerService::_handleIndicationCallBack,
// this,
// (void *)request->queueIds.top());
AutoPtr<AsyncReply> asyncReply(SendWait(asyncRequest.get()));
asyncRequest.release();
// Return the ExportIndication results in HandleIndication
//response
AutoPtr<CIMExportIndicationResponseMessage> exportResponse(
reinterpret_cast<CIMExportIndicationResponseMessage *>(
(static_cast<AsyncLegacyOperationResult *>(
asyncReply.get()))->get_result()));
cimException = exportResponse->cimException;
op->release();
this->return_op(op.release());
}
else
{
_loadHandler(request, cimException);
}
}
}
else if (className.equal (PEGASUS_CLASSNAME_INDHANDLER_SNMP))
{
pos = handler.findProperty(PEGASUS_PROPERTYNAME_LSTNRDST_TARGETHOST);
if (pos == PEG_NOT_FOUND)
{
cimException = PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
MessageLoaderParms("HandlerService.IndicationHandlerService."
"SNMP_HANDLER_WITHOUT_TARGETHOST", "Snmp Handler missing Targethost property"));
}
else
{
CIMProperty prop = handler.getProperty(pos);
String destination = prop.getValue().toString();
if (destination.size() == 0)
{
cimException = PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
MessageLoaderParms("HandlerService.IndicationHandlerService."
"INVALID_TARGETHOST", "invalid targethost"));
}
else
{
_loadHandler(request, cimException);
}
}
}
else if ((className.equal (PEGASUS_CLASSNAME_LSTNRDST_SYSTEM_LOG)) ||
(className.equal (PEGASUS_CLASSNAME_LSTNRDST_EMAIL)))
{
_loadHandler(request, cimException);
}
CIMHandleIndicationResponseMessage* response =
new CIMHandleIndicationResponseMessage(
request->messageId,
cimException,
request->queueIds.copyAndPop());
delete request;
return response;
}
bool FH2LocalClient::ScenarioInfoDialog(void)
{
Settings & conf = Settings::Get();
Cursor & cursor = Cursor::Get();
Display & display = Display::Get();
LocalEvent & le = LocalEvent::Get();
if(!GetCurrentMapInfo() ||
!GetPlayersInfo()) return false;
const Sprite & panel = AGG::GetICN(ICN::NGHSBKG, 0);
const Rect rectPanel(204, 32, panel.w(), panel.h());
const Point pointOpponentInfo(rectPanel.x + 24, rectPanel.y + 202);
const Point pointClassInfo(rectPanel.x + 24, rectPanel.y + 282);
const Rect box(pointOpponentInfo, 360, 180);
Rects::const_iterator itr;
Interface::PlayersInfo playersInfo(true, false, false);
playersInfo.UpdateInfo(conf.GetPlayers(), pointOpponentInfo, pointClassInfo);
RedrawScenarioStaticInfo(rectPanel);
playersInfo.RedrawInfo();
Button buttonSelectMaps(rectPanel.x + 309, rectPanel.y + 45, ICN::NGEXTRA, 64, 65);
Button buttonOk(rectPanel.x + 31, rectPanel.y + 380, ICN::NGEXTRA, 66, 67);
Button buttonCancel(rectPanel.x + 287, rectPanel.y + 380, ICN::NGEXTRA, 68, 69);
SpriteCursor sp;
sp.SetSprite(AGG::GetICN(ICN::NGEXTRA, 80));
if(! Modes(ST_ADMIN))
{
buttonOk.SetDisable(true);
buttonSelectMaps.SetDisable(true);
}
buttonSelectMaps.Draw();
buttonOk.Draw();
buttonCancel.Draw();
cursor.Show();
display.Flip();
bool exit = false;
bool update_info = false;
u8 change_color = Color::NONE;
DEBUG(DBG_NETWORK, DBG_INFO, "start queue");
while(!exit && le.HandleEvents())
{
if(Ready())
{
QueueMessage packet;
if(!Recv(packet)) return false;
DEBUG(DBG_NETWORK, DBG_INFO, "recv: " << Network::GetMsgString(packet.GetID()));
switch(packet.GetID())
{
case MSG_READY:
break;
case MSG_CHANGE_RACE:
Network::UnpackRaceColors(packet);
update_info = true;
break;
case MSG_UPDATE_PLAYERS:
{
MsgUpdatePlayers(packet);
if(Modes(ST_ADMIN))
{
buttonOk.Release();
buttonOk.SetDisable(false);
buttonSelectMaps.Release();
buttonSelectMaps.SetDisable(false);
}
else
{
buttonOk.Press();
buttonOk.SetDisable(true);
buttonSelectMaps.Press();
buttonSelectMaps.SetDisable(true);
}
update_info = true;
break;
}
case MSG_SET_CURRENT_MAP:
Network::PacketPopMapsFileInfo(packet, conf.CurrentFileInfo());
playersInfo.UpdateInfo(conf.GetPlayers(), pointOpponentInfo, pointClassInfo);
update_info = true;
break;
case MSG_MESSAGE:
break;
case MSG_SHUTDOWN:
exit = true;
break;
default: break;
}
}
if(update_info)
{
cursor.Hide();
RedrawScenarioStaticInfo(rectPanel);
playersInfo.RedrawInfo();
buttonSelectMaps.Draw();
buttonOk.Draw();
buttonCancel.Draw();
cursor.Show();
display.Flip();
update_info = false;
}
// press button
if(buttonSelectMaps.isEnable()) le.MousePressLeft(buttonSelectMaps) ? buttonSelectMaps.PressDraw() : buttonSelectMaps.ReleaseDraw();
if(buttonOk.isEnable()) le.MousePressLeft(buttonOk) ? buttonOk.PressDraw() : buttonOk.ReleaseDraw();
le.MousePressLeft(buttonCancel) ? buttonCancel.PressDraw() : buttonCancel.ReleaseDraw();
// click select
if(Game::HotKeyPress(Game::EVENT_BUTTON_SELECT) ||
(buttonSelectMaps.isEnable() && le.MouseClickLeft(buttonSelectMaps)))
{
cursor.Hide();
sp.Hide();
cursor.Show();
// recv maps_info_list
QueueMessage packet(MSG_GET_MAPS_LIST);
if(SendWait(packet, MSG_GET_MAPS_LIST, "ScenarioInfoDialog: "))
{
MapsFileInfoList lists;
Network::PacketPopMapsFileInfoList(packet, lists);
if(const Maps::FileInfo *fi = Dialog::SelectScenario(lists))
{
// send set_maps_info
packet.Reset();
packet.SetID(MSG_SET_CURRENT_MAP);
packet.Push(fi->file);
DEBUG(DBG_NETWORK, DBG_INFO, "send: " << Network::GetMsgString(packet.GetID()));
if(!Send(packet)) return false;
}
update_info = true;
}
}
else
// click cancel
if(le.MouseClickLeft(buttonCancel) || Game::HotKeyPress(Game::EVENT_DEFAULT_EXIT))
return false;
else
// click ok
if(Game::HotKeyPress(Game::EVENT_DEFAULT_READY) || (buttonOk.isEnable() && le.MouseClickLeft(buttonOk)))
{
/*
packet.Reset();
packet.SetID(MSG_START_GAME);
DEBUG(DBG_NETWORK, DBG_INFO, "send: " << Network::GetMsgString(packet.GetID()));
if(!Send(packet)) return false;
cursor.Hide();
return true;
*/
}
else
if(Modes(ST_ADMIN) && le.MouseClickLeft(box))
{
// click colors
if(Player* player = playersInfo.GetFromOpponentClick(le.GetMouseCursor()))
{
u8 humans = conf.GetPlayers().GetColors(CONTROL_HUMAN);
if((humans & player->color) && Color::NONE == change_color)
{
cursor.Hide();
sp.Move((*itr).x - 3, (*itr).y - 3);
cursor.Show();
display.Flip();
change_color = player->color;
}
else
if(conf.CurrentFileInfo().AllowHumanColors() & player->color)
{
cursor.Hide();
sp.Hide();
cursor.Show();
display.Flip();
if(Color::NONE != change_color)
{
QueueMessage packet(MSG_CHANGE_COLORS);
packet.Push(change_color);
packet.Push(player->color);
DEBUG(DBG_NETWORK, DBG_INFO, "send: " << Network::GetMsgString(packet.GetID()));
if(!Send(packet)) return false;
change_color = Color::NONE;
}
}
}
else
// click races
if(Player* player = playersInfo.GetFromClassClick(le.GetMouseCursor()))
{
if(conf.AllowChangeRace(player->color))
{
switch(player->race)
{
case Race::KNGT: player->race = Race::BARB; break;
case Race::BARB: player->race = Race::SORC; break;
case Race::SORC: player->race = Race::WRLK; break;
case Race::WRLK: player->race = Race::WZRD; break;
case Race::WZRD: player->race = Race::NECR; break;
case Race::NECR: player->race = Race::RAND; break;
case Race::RAND: player->race = Race::KNGT; break;
default: break;
}
if(change_color)
{
cursor.Hide();
sp.Hide();
cursor.Show();
display.Flip();
change_color = Color::NONE;
}
if((player->race & Race::ALL) || player->race == Race::RAND)
{
QueueMessage packet(MSG_CHANGE_RACE);
packet.Push(player->color);
packet.Push(player->race);
DEBUG(DBG_NETWORK, DBG_INFO, "send: " << Network::GetMsgString(packet.GetID()));
if(!Send(packet)) return false;
}
}
}
}
DELAY(10);
}
return false;
}
CIMHandleIndicationResponseMessage*
IndicationHandlerService::_handleIndication(
CIMHandleIndicationRequestMessage* request)
{
PEG_METHOD_ENTER(TRC_IND_HANDLER,
"IndicationHandlerService::_handleIndication()");
Boolean handleIndicationSuccess = true;
CIMException cimException =
PEGASUS_CIM_EXCEPTION(CIM_ERR_SUCCESS, String::EMPTY);
CIMName className = request->handlerInstance.getClassName();
CIMNamespaceName nameSpace = request->nameSpace;
CIMInstance indication = request->indicationInstance;
CIMInstance handler = request->handlerInstance;
PEG_TRACE ((TRC_INDICATION_GENERATION, Tracer::LEVEL4,
"Handler service received %s Indication %s for %s:%s.%s Handler",
(const char*)(indication.getClassName().getString().getCString()),
(const char*)(request->messageId.getCString()),
(const char*)(request->nameSpace.getString().getCString()),
(const char*)(handler.getClassName().getString().getCString()),
(const char*)(handler.getProperty(handler.findProperty(
PEGASUS_PROPERTYNAME_NAME)).getValue().toString().getCString())));
Uint32 pos = PEG_NOT_FOUND;
if (className.equal (PEGASUS_CLASSNAME_INDHANDLER_CIMXML) ||
className.equal (PEGASUS_CLASSNAME_LSTNRDST_CIMXML))
{
pos = handler.findProperty(PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION);
if (pos == PEG_NOT_FOUND)
{
cimException = PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
MessageLoaderParms(
"HandlerService.IndicationHandlerService."
"CIMXML_HANDLER_WITHOUT_DESTINATION",
"CIMXml Handler missing Destination property"));
handleIndicationSuccess = false;
}
else
{
CIMProperty prop = handler.getProperty(pos);
String destination = prop.getValue().toString();
if (destination.size() == 0)
{
cimException = PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
MessageLoaderParms(
"HandlerService.IndicationHandlerService."
"INVALID_DESTINATION",
"invalid destination"));
handleIndicationSuccess = false;
}
//compared index 10 is not :
else if (destination.subString(0, 10) == String("localhost/"))
{
Uint32 exportServer =
find_service_qid(PEGASUS_QUEUENAME_EXPORTREQDISPATCHER);
// Listener is build with Cimom, so send message to ExportServer
AutoPtr<CIMExportIndicationRequestMessage> exportmessage(
new CIMExportIndicationRequestMessage(
XmlWriter::getNextMessageId(),
//taking localhost/CIMListener portion out from reg
destination.subString(21),
indication,
QueueIdStack(exportServer, getQueueId()),
String::EMPTY,
String::EMPTY));
exportmessage->operationContext.insert(
IdentityContainer(String::EMPTY));
exportmessage->operationContext.set(
request->operationContext.get(
ContentLanguageListContainer::NAME));
AutoPtr<AsyncOpNode> op( this->get_op());
AutoPtr<AsyncLegacyOperationStart> asyncRequest(
new AsyncLegacyOperationStart(
op.get(),
exportServer,
exportmessage.get()));
exportmessage.release();
PEG_TRACE((TRC_IND_HANDLER, Tracer::LEVEL4,
"Indication handler forwarding message to %s",
((MessageQueue::lookup(exportServer)) ?
((MessageQueue::lookup(exportServer))->
getQueueName()):
"BAD queue name")));
PEG_TRACE ((TRC_INDICATION_GENERATION, Tracer::LEVEL4,
"Sending %s Indication %s to destination %s",
(const char*) (indication.getClassName().getString().
getCString()),
(const char*)(request->messageId.getCString()),
(const char*) destination.getCString()));
//SendAsync(op,
// exportServer[0],
// IndicationHandlerService::_handleIndicationCallBack,
// this,
// (void *)request->queueIds.top());
AutoPtr<AsyncReply> asyncReply(SendWait(asyncRequest.get()));
asyncRequest.release();
// Return the ExportIndication results in HandleIndication
//response
AutoPtr<CIMExportIndicationResponseMessage> exportResponse(
reinterpret_cast<CIMExportIndicationResponseMessage *>(
(static_cast<AsyncLegacyOperationResult *>(
asyncReply.get()))->get_result()));
cimException = exportResponse->cimException;
this->return_op(op.release());
}
else
{
handleIndicationSuccess = _loadHandler(request, cimException);
}
}
}
else if (className.equal (PEGASUS_CLASSNAME_INDHANDLER_SNMP))
{
pos = handler.findProperty(PEGASUS_PROPERTYNAME_LSTNRDST_TARGETHOST);
if (pos == PEG_NOT_FOUND)
{
cimException = PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
MessageLoaderParms(
"HandlerService.IndicationHandlerService."
"SNMP_HANDLER_WITHOUT_TARGETHOST",
"Snmp Handler missing Targethost property"));
handleIndicationSuccess = false;
}
else
{
CIMProperty prop = handler.getProperty(pos);
String destination = prop.getValue().toString();
if (destination.size() == 0)
{
cimException = PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
MessageLoaderParms(
"HandlerService.IndicationHandlerService."
"INVALID_TARGETHOST",
"invalid targethost"));
handleIndicationSuccess = false;
}
else
{
handleIndicationSuccess = _loadHandler(request, cimException);
}
}
}
else if ((className.equal (PEGASUS_CLASSNAME_LSTNRDST_SYSTEM_LOG)) ||
(className.equal (PEGASUS_CLASSNAME_LSTNRDST_EMAIL)))
{
handleIndicationSuccess = _loadHandler(request, cimException);
}
// no success to handle indication
// somewhere an exception message was build
// time to write the error message to the log
if (!handleIndicationSuccess)
{
Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
MessageLoaderParms(
"HandlerService.IndicationHandlerService."
"INDICATION_DELIVERY_FAILED",
"Failed to deliver an indication: $0",
cimException.getMessage()));
}
CIMHandleIndicationResponseMessage* response =
dynamic_cast<CIMHandleIndicationResponseMessage*>(
request->buildResponse());
response->cimException = cimException;
delete request;
PEG_METHOD_EXIT();
return response;
}