void main()
{
string msg ="<Login><Name>Ider</Name></Login>";
MessageHandler mh;
Message snd = mh.RespondToMessage(msg,EndPoint());
cout<<snd.ToString()<<endl;
cout<<"Message type: "<<snd.Type()<<endl<<endl;
msg ="<Dependency><Name>*.*</Name></Dependency>";
snd = mh.RespondToMessage(msg,EndPoint());
cout<<snd.ToString()<<endl;
cout<<"Message type: "<<snd.Type()<<endl<<endl;
msg ="<Dependency><Name>Display</Name></Dependency>";
snd = mh.RespondToMessage(msg,EndPoint());
cout<<snd.ToString()<<endl;
cout<<"Message type: "<<snd.Type()<<endl<<endl;
msg ="*.*";
snd = mh.RespondToMessage(msg,EndPoint());
cout<<snd.ToString()<<endl;
cout<<"Message type: "<<snd.Type()<<endl<<endl;
}
ErrorResult validateXML(const QString &fileName, const QString &schemaFileName)
{
QXmlSchema schema;
schema.load(QUrl(schemaFileName));
MessageHandler schemaMessageHandler;
schema.setMessageHandler(&schemaMessageHandler);
if (!schema.isValid())
return ErrorResult(ErrorResultType_Critical, QObject::tr("Schena '%1' is not valid. %2").
arg(schemaFileName).
arg(schemaMessageHandler.statusMessage()));
QFile file(fileName);
file.open(QIODevice::ReadOnly);
QXmlSchemaValidator validator(schema);
MessageHandler validatorMessageHandler;
validator.setMessageHandler(&validatorMessageHandler);
//TODO neslo mi nacist soubor se dvema poli
// if (!validator.validate(&file, QUrl::fromLocalFile(file.fileName())))
// return ErrorResult(ErrorResultType_Critical, QObject::tr("File '%1' is not valid Agros2D problem file. Error (line %3, column %4): %2").
// arg(fileName).
// arg(validatorMessageHandler.statusMessage()).
// arg(validatorMessageHandler.line()).
// arg(validatorMessageHandler.column()));
return ErrorResult();
}
bool MessageRouter::registerHandler(
MessageHandler& handler,
const bool& isDefaultHandler)
{
bool isRegistered = false;
// Find an empty slot and store the handler.
for (int i = 0; i < MAX_NUM_HANDLERS; i++)
{
if (handlers[i] == 0)
{
handlers[i] = &handler;
isRegistered = true;
break;
}
}
// Log a failure to register.
if (isRegistered == false)
{
Logger::logDebug("Failed to register handler " + handler.getId() + ".\n");
}
else
{
Logger::logDebug("Registered message handler " + handler.getId() + ".\n");
if (isDefaultHandler)
{
defaultHandler = &handler;
Logger::logDebug("Handler " + handler.getId() + " set as default handler.\n");
}
}
return (isRegistered);
}
//! [3]
void MainWindow::validate()
{
const QByteArray schemaData = schemaView->toPlainText().toUtf8();
const QByteArray instanceData = instanceEdit->toPlainText().toUtf8();
MessageHandler messageHandler;
QXmlSchema schema;
schema.setMessageHandler(&messageHandler);
schema.load(schemaData);
bool errorOccurred = false;
if (!schema.isValid()) {
errorOccurred = true;
} else {
QXmlSchemaValidator validator(schema);
if (!validator.validate(instanceData))
errorOccurred = true;
}
if (errorOccurred) {
validationStatus->setText(messageHandler.statusMessage());
moveCursor(messageHandler.line(), messageHandler.column());
} else {
validationStatus->setText(tr("validation successful"));
}
const QString styleSheet = QString("QLabel {background: %1; padding: 3px}")
.arg(errorOccurred ? QColor(Qt::red).lighter(160).name() :
QColor(Qt::green).lighter(160).name());
validationStatus->setStyleSheet(styleSheet);
}
TEST(BalanceExecuteCommand, ByCategoryAndWallet)
{
// category specified by '-c' is not found
// set-up 1
createFile("testWalletFile" ,
"1447245226;-;500.00;categ;RON\n"
"1447245226;-;500.00;bam;RON\n"
"1447245226;-;500.00;categ;RON\n"
"1447245226;+;100.00;bam;RON\n"
"1448011815;+;20.00;salaros;RON\n");
BalanceCmd balance ;
vector <string> params ;
params.push_back("-c") ;
params.push_back("bam") ;
params.push_back("-w") ;
params.push_back("testWalletFile") ;
MessageHandler message ;
balance.setMessageHandler(message) ;
// test
EXPECT_EQ(true, balance.validateParams(params)) ;
EXPECT_EQ(true, balance.executeCommand(params)) ;
EXPECT_EQ(BALANCE_IS_MSG, message.getMessageCode()) ;
EXPECT_EQ("-400.00", params.at(0)) ;
// tear-down
remove("testWalletFile") ;
}
DBusHandlerResult MessageHandler::message_handler_callback(DBusConnection * conn, DBusMessage * message, void * user_data)
{
if ( user_data == NULL ) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
MessageHandler* handler = static_cast<MessageHandler*>(user_data);
return static_cast<DBusHandlerResult>(handler->handle_message( Connection::self(conn), Message::create(message) ));
}
void MessageRouter::routeMessage(Message* msg)
{
MessageHandler* msgHandler;
#ifdef DEBUG
std::cout << "MessageRouter::routeMessage( 0x" << std::hex << msg->getID() << std::dec << " )]" << std::endl;
#endif
/// Determine the Destination Address based on the MessageID
msgHandler = msgIDToMsgHandlerTable[msg->getID()];
msgHandler->addToQueue(msg);
}
MessageHandlerChain::~MessageHandlerChain()
{
kDebug(14010) ;
MessageHandler *handler = d->first;
while( handler )
{
MessageHandler *next = handler->next();
delete handler;
handler = next;
}
delete d;
}
int main( int argc, char *argv[] ) {
QApplication app( argc, argv );
IRCClient *irc = new IRCClient();
MessageHandler *mh = new MessageHandler( irc );
QObject::connect( &app, SIGNAL( aboutToQuit() ), irc, SLOT( quit() ) );
mh->show();
irc->connectAndRegister( argc > 1 ? argv[1] : "dev1", 6667, argc > 2 ? argv[2] : "Test", "correlr", "Correl Roush" );
return app.exec();
}
void OpConsolePrefsHelper::ConstructL()
{
// Register as listener to relevant preferences
g_pccore->RegisterListenerL(this);
g_pcfiles->RegisterFilesListenerL(this);
// Register with the message handler
MessageHandler *mmh = g_main_message_handler;
mmh->SetCallBack(this, MSG_CONSOLE_RECONFIGURE, 0);
// Set up the logger later
mmh->PostMessage(MSG_CONSOLE_RECONFIGURE, 0, 0);
}
void Fenetre::ouvrir()
{
QString fileName = QFileDialog::getOpenFileName(this, tr("Séléctionner un fichier"),
QDir::currentPath(),
tr("Fichiers XML (*.xml)"));
if (fileName.isEmpty())
return;
QFile fileXML(fileName);
if (!fileXML.open(QFile::ReadOnly | QFile::Text)) {
QMessageBox::warning(this, tr("Erreur lecture"),
tr("Impossible de lire le fichier %1:\n%2.")
.arg(fileName)
.arg(fileXML.errorString()));
return;
}
QFile fileSchema("schemaGraph.xsd");
fileSchema.open(QIODevice::ReadOnly);
QXmlSchema schema;
MessageHandler messageHandler;
schema.setMessageHandler(&messageHandler);
schema.load(&fileSchema, QUrl::fromLocalFile(fileSchema.fileName()));
if (schema.isValid()) {
QFile fileXML2(fileName);
fileXML2.open(QIODevice::ReadOnly);
QXmlSchemaValidator validator(schema);
if (!validator.validate(&fileXML2, QUrl::fromLocalFile(fileXML2.fileName()))){
QMessageBox::warning(this, tr("Fichier malformé"),
tr("Impossible d'ouvrir le fichier' %1'.\n Le document ne correspond pas au schéma. \n%2")
.arg(fileName)
.arg(messageHandler.statusMessage()));
return;
}
}
ImportExport import=ImportExport(&graphe,xmltree, affichageSVG);
if (import.ouvrir(&fileXML, &domDocument))
ui->statusBar->showMessage(tr("Fichier chargé"), 2000);
affichageSVG->drawGraph();
ui->afficheGraphe->adjustSize();
//On pense à remettre la liste des sommets pour créer les arcs
redessinerComboArc();
}
bool Narrator::hasAudio(const char *identifier, std::string encoding)
{
LOG4CXX_DEBUG(narratorLog, "Find audio with identifier: '" << identifier << "' and encoding '" << encoding << "'");
Message message;
message.setString(identifier);
message.setClass("userdata");
// use function in MessageHandler to find message
MessageHandler mh;
long id = mh.findMessage(message);
if (id > 0) return true;
LOG4CXX_DEBUG(narratorLog, "No entry found for identifier: '" << identifier << "'");
return false;
}
TEST(BalanceValidateParams, CategoryNotDefined)
{
// category specified by '-c' is not found
createFile("testWalletFile" ,
"1447245226;-;564.00;other;RON\n"
"1448011815;+;20.00;salary;RON\n");
createFile("batchTestFile", "default_wallet = testWalletFile");
// set-up 1
BalanceCmd balance("batchTestFile") ;
vector <string> params ;
params.push_back("-c") ;
params.push_back("inexistent_category") ;
MessageHandler message ;
balance.setMessageHandler(message) ;
// test
EXPECT_EQ(false, balance.validateParams(params)) ;
EXPECT_EQ(NO_TRANSACTION_REG_ERR, message.getMessageCode());
// set-up 2
BalanceCmd balance2("batchTestFile") ;
MessageHandler message2 ;
params.clear() ;
params.push_back("--category") ;
params.push_back("nonexistent_category") ;
balance2.setMessageHandler(message2);
// test
EXPECT_EQ(false, balance2.validateParams(params)) ;
EXPECT_EQ(NO_TRANSACTION_REG_ERR, message2.getMessageCode());
// set-up 3
BalanceCmd balance3("batchTestFile") ;
MessageHandler message3 ;
params.clear() ;
params.push_back("--category") ;
params.push_back("nonexistent_category") ;
params.push_back("-w") ;
params.push_back("testWalletFile") ;
balance3.setMessageHandler(message3);
// test
EXPECT_EQ(false, balance3.validateParams(params)) ;
EXPECT_EQ(NO_TRANSACTION_REG_ERR, message3.getMessageCode());
//tear-down
remove("testWalletFile") ;
remove("batchTestFile");
}
/*
At first the arguments are read and passed. Then the ssl context is gotten
by calling 'BIO_get_ssl(client, &ssl)'. Afterwards the ssl handshake is
performed and the certificate verified. Then the line is read from the certificate.
This value is mapped to 'organizationalUnitName'.
An example usage of the connection is shown and then the connectino will be
terminated.
*/
void* handleConn(void *argsv){
connArgs* args = (connArgs*) argsv;
MessageHandler* msgHandler = args->msgHandler;
BIO* client = args->conn;
SSL* ssl;
BIO_get_ssl(client, &ssl);
/*ssl handshake*/
msgHandler->debug("performing ssl handshake");
if(BIO_do_handshake(client) != 1){
string fail("handshake failed\nSSL_ERROR: ");
fail.append(ERR_reason_error_string(ERR_get_error()));
msgHandler->log(fail);
} else
msgHandler->log("handshake successful");
/*verifying the certificate*/
X509* peerCert;
if(SSL_get_verify_result(ssl) != X509_V_OK){
string error("verification failed\nSSL_Error: ");
error.append(ERR_reason_error_string(ERR_get_error()));
msgHandler->error(error, CRITICAL);
} else {
msgHandler->debug("verification successful");
peerCert = SSL_get_peer_certificate(ssl);
}
msgHandler->debug("trying to get the line");
/*getting the line*/
char lineN[6];
X509_NAME* name = X509_get_subject_name(peerCert);
X509_NAME_get_text_by_NID(name, NID_organizationalUnitName, lineN, 6);
string line("line is: ");
line.append(lineN);
msgHandler->debug(line);
/*example use of the connection (echoing the incoming msg)*/
char buffer[1024];
bzero(buffer, 1024);
SSL_read(ssl, buffer, 1024);
string debug("message received: ");
debug.append(buffer);
msgHandler->debug(debug);
SSL_write(ssl, buffer, 1024);
/*closing the connection*/
BIO_reset(client);
X509_free(peerCert);
return NULL;
}
void MessageRouter::handleMessages(
Adapter& adapter)
{
bool handledMessage = false;
// Get the first available message.
const Message* message = adapter.getMessage();
if (message)
{
Logger::logDebug("MessageRouter::handleMessages: Got message " + toString(message->getMessageId()) + ".\n");
}
while (message)
{
MessageHandler* handler = getHandler(message->getDestination());
if (!handler)
{
Logger::logDebug("Failed to handle message " + toString(message->getMessageId()) +
". No handler specified for destination \"" + message->getDestination() + "\"\n");
}
else
{
// Allow the handler to handle the message.
handledMessage = handler->handleMessage(*message);
if (!handledMessage)
{
Logger::logDebug("Component \"" + handler->getId() + "\" failed to handle message " +
toString(message->getMessageId()) + ". Unsupported message.\n");
}
}
// Free up the memory from the handled message.
delete message;
// Get the next available message.
message = adapter.getMessage();
if (message)
{
Logger::logDebug("MessageRouter::handleMessages: Got message " + toString(message->getMessageId()) + ".\n");
}
}
}
TEST(BalanceValidateParams, NoDefaultWallet)
{
// default_wallet is not configured
// set-up
BalanceCmd balance("testConfigFile") ;
createFile("testConfigFile" , "default_wallet = ");
vector <string> params0 ;
MessageHandler message ;
balance.setMessageHandler(message) ;
balance.validateParams(params0) ;
EXPECT_EQ(false, balance.validateParams(params0)) ;
EXPECT_EQ(NO_DEFAULT_WALLET_ERR, message.getMessageCode());
}
void PrefsLoader::HandleCallback(OpMessage msg, MH_PARAM_1 par1, MH_PARAM_2 par2)
{
switch(msg)
{
case MSG_URL_LOADING_FAILED:
FinishLoading(par2);
break;
case MSG_URL_DATA_LOADED:
LoadData(par1);
break;
case MSG_URL_MOVED:
{
MessageHandler *mmh = g_main_message_handler;
mmh->UnsetCallBack(this, MSG_URL_DATA_LOADED);
mmh->UnsetCallBack(this, MSG_URL_LOADING_FAILED);
mmh->UnsetCallBack(this, MSG_URL_MOVED);
mmh->SetCallBack(this, MSG_URL_DATA_LOADED, par2);
mmh->SetCallBack(this, MSG_URL_LOADING_FAILED, par2);
mmh->SetCallBack(this, MSG_URL_MOVED, par2);
}
break;
}
}
TEST(BalanceValidateParams, CannotOpenDefaultWallet)
{
// default_wallet can not be opened
// set-up
BalanceCmd balance("testConfigFile") ;
createFile("testConfigFile" , "default_wallet = bambamparam");
vector <string> params0 ;
MessageHandler message ;
balance.setMessageHandler(message) ;
balance.validateParams(params0) ;
// test
EXPECT_EQ(false, balance.validateParams(params0)) ;
EXPECT_EQ(COULD_NOT_OPEN_FILE_BAL_ERR, message.getMessageCode());
remove("testConfigFile") ;
}
TEST(BalanceValidateParams, NoConfigFile)
{
// moneytracker config can not be opened
// set-up
BalanceCmd balance("noConfigFile") ;
vector <string> params0 ;
MessageHandler message ;
balance.setMessageHandler(message) ;
balance.validateParams(params0) ;
EXPECT_EQ(false, balance.validateParams(params0)) ;
EXPECT_EQ(COULD_NOT_OPEN_CONFIG_ERR, message.getMessageCode());
}
bool ExCommand::handleMessage() {
int cnt = 0;
for (MessageHandler *m = g_fullpipe->_messageHandlers; m; m = m->nextItem)
cnt += m->callback(this);
if (_messageKind == 17 || (_excFlags & 1)) {
if (_parId) {
MessageQueue *mq = g_fullpipe->_globalMessageQueueList->getMessageQueueById(_parId);
if (mq)
mq->update();
}
}
if (_excFlags & 2)
delete this;
return (cnt > 0);
}
OP_STATUS PrefsLoader::StartLoading()
{
MessageHandler *mmh = g_main_message_handler;
CommState stat = m_serverURL->Load(mmh, URL(),FALSE,FALSE,FALSE,FALSE);
if(stat == COMM_REQUEST_FAILED)
return OpStatus::ERR;
URL_ID url_id = m_serverURL->Id();
OP_STATUS rc = OpStatus::OK;
if (OpStatus::IsError(rc = mmh->SetCallBack(this, MSG_URL_DATA_LOADED, url_id)) ||
OpStatus::IsError(rc = mmh->SetCallBack(this, MSG_URL_MOVED, url_id)) ||
OpStatus::IsError(rc = mmh->SetCallBack(this, MSG_URL_LOADING_FAILED, url_id)))
{
mmh->UnsetCallBacks(this);
}
return rc;
}
void MessageQueue::handleAllMessages(MessageHandler& handler)
{
for(int i = 0; i < queue.numberOfMessages; ++i)
{
queue.setSelectedMessageForReading(i);
in.config.reset();
in.text.reset();
handler.handleMessage(in);
}
}
void Poll::removeMessages(const MessageHandler& handler, int what) {
#if DEBUG_CALLBACKS
ALOGD("%p ~ removeMessages - handler=%p, what=%d", this, handler.get(), what);
#endif
{ // acquire lock
AutoMutex _l(mLock);
//more ....
} // release lock
}
int main(int argc, char** argv)
{
CmdLineParser clp;
loadCmdLine(clp);
ConfigInput input;
if(!parseCommandLine(argc, argv, clp, input))
{
return 1;
}
setupSignalHandling();
//
// Create and Initialize the SocketHandler and MessageHandler
//
SocketHandler *server = new TcpSocketHandlerImpl(input.listenPort, input.ipAddress);
MessageHandler *msgHandler = new EchoServerTcpMessageHandler();
msgHandler->setDebug(input.isVerbose);
server->setMessageHandler(msgHandler);
server->setHandlerMode(SocketHandler::MODE_SERVER);
server->setDebug(input.isVerbose);
if(!server->initialize())
{
cerr << "Error Initializing the SocketServer, exiting";
return 1;
}
SOCKET_SERVER = server;
//
// Run the Echo Server
// It will be stopped by a SIGINT (CTRL-C) signal
//
server->run(); // This call blocks
cout << "Server stopped" << endl;
delete server;
delete msgHandler;
return 0;
}
static int tolua_MessageHandler_GetCurWildMsgPackage(lua_State *tolua_S)
{
#ifndef TOLUA_TXGUI_RELEASE
tolua_Error tolua_err;
if(
!tolua_isusertype(tolua_S,1,"MessageHandler",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
{
tolua_error(tolua_S,"#ferror in function 'MessageHandler::getCurWildMsgPackage'",&tolua_err);
return 0;
}
#endif
MessageHandler* self = (MessageHandler*)tolua_tousertype(tolua_S,1,0);
WILD_MSG_PACKAGE* tolua_ret = (WILD_MSG_PACKAGE*) self->getWildMsgPackage();
tolua_pushusertype(tolua_S,(void*)tolua_ret,"WILD_MSG_PACKAGE");
return 1;
}
/**
* This method handles messages sent from the WebView.
* @param webView The WebView that sent the message.
* @param urlData Data object that holds message content.
* Note that the data object will be valid only during
* the life-time of the call of this method, then it
* will be deallocated.
*/
void handleWebViewMessage(WebView* webView, MAHandle urlData)
{
// Create message object. This parses the message.
WebViewMessage message(webView, urlData);
// Let the message handler handle the message.
mMessageHandler.handleMessage(message);
// Tell the WebView that we have processed the message, so that
// it can send the next one.
callJS("bridge.messagehandler.processedMessage()");
}
int main() {
// Create NFC Manager and do initialize.
NfcManager* pNfcManager = new NfcManager();
// Create service thread to receive message from nfc library.
NfcService* service = NfcService::Instance();
MessageHandler* msgHandler = new MessageHandler(service);
service->initialize(pNfcManager, msgHandler);
// Create IPC socket & main thread will enter while loop to read data from socket.
NfcIpcSocket* socket = NfcIpcSocket::Instance();
socket->initialize(msgHandler);
socket->setSocketListener(service);
msgHandler->setOutgoingSocket(socket);
socket->loop();
//TODO delete NfcIpcSocket, NfcService
delete msgHandler;
delete pNfcManager;
//exit(0);
}
bool MessageDispatcher::install(MessageHandler* handler)
{
DDebug(DebugAll,"MessageDispatcher::install(%p)",handler);
if (!handler)
return false;
Lock lock(this);
ObjList *l = m_handlers.find(handler);
if (l)
return false;
unsigned p = handler->priority();
int pos = 0;
for (l=&m_handlers; l; l=l->next(),pos++) {
MessageHandler *h = static_cast<MessageHandler *>(l->get());
if (!h)
continue;
if (h->priority() < p)
continue;
if (h->priority() > p)
break;
// at the same priority we sort them in pointer address order
if (h > handler)
break;
}
m_changes++;
if (l) {
XDebug(DebugAll,"Inserting handler [%p] on place #%d",handler,pos);
l->insert(handler);
}
else {
XDebug(DebugAll,"Appending handler [%p] on place #%d",handler,pos);
m_handlers.append(handler);
}
handler->m_dispatcher = this;
if (handler->null())
Debug(DebugInfo,"Registered broadcast message handler %p",handler);
return true;
}
bool Narrator::addAudio(const char *identifier, std::string encoding, const char *data, int size)
{
LOG4CXX_DEBUG(narratorLog, "Add audio with identifier: '" << identifier << "' and encoding '" << encoding << "'");
// create MessageAudio object
MessageAudio messageAudio;
messageAudio.setTagid(0);
messageAudio.setText(identifier);
messageAudio.setAudioData(data, size);
messageAudio.setSize(size);
messageAudio.setLength(0);
messageAudio.setEncoding(encoding);
messageAudio.setMd5("");
messageAudio.setUri("");
// create MessageTranslation object
MessageTranslation messageTranslation;
messageTranslation.setLanguage(mLanguage); // use current language
messageTranslation.setText(identifier);
messageTranslation.setAudiotags("[0]");
messageTranslation.addAudio(messageAudio);
// create Message object
Message message;
message.setString(identifier);
message.setClass("userdata");
message.setTranslation(messageTranslation);
// use function in MessageHandler to insert/update message
MessageHandler mh;
long id = mh.updateMessage(message);
if (id > 0) return true;
LOG4CXX_WARN(narratorLog, "Failed to add audio with identifier: '" << identifier << "'");
return false;
}
bool MainWindow::validate()
{
QUrl url("qrc:/resources/peach.xsd");
const QByteArray instanceData = completingTextEdit->toPlainText().toUtf8();
MessageHandler messageHandler;
QXmlSchema schema;
schema.setMessageHandler(&messageHandler);
schema.load(url);
bool errorOccurred = false;
if (!schema.isValid()) {
errorOccurred = true;
} else {
QXmlSchemaValidator validator(schema);
if (!validator.validate(instanceData))
errorOccurred = true;
}
if (errorOccurred) {
statusLabel->setText(messageHandler.statusMessage());
moveCursor(messageHandler.line(), messageHandler.column());
return false;
} else {
statusLabel->setText(tr("Validation successful"));
return true;
}
const QString styleSheet = QString("QstatusLabel {background: %1; padding: 3px}")
.arg(errorOccurred ? QColor(Qt::red).lighter(160).name() :
QColor(Qt::green).lighter(160).name());
statusLabel->setStyleSheet(styleSheet);
}
