bool Message2::isResult() const {
if (isEmpty())
return false;
return stanza().tagName() == IQ
&& (stanza().type() == IQ_RESULT ||
stanza().type() == IQ_ERROR);
}
Message2::Message2()
{
FStanza = new Stanza();
QDomElement el = stanza().addElement(TNOXMPP_DATA, TNOXMPP_XMLNS);
QDomText dataSec = stanza().document().createTextNode("");
el.appendChild(dataSec);
}
void BcRequest::onProcessFinished()
{
qDebug() << "BC: Process finished";
QByteArray out;
if (proc_->bytesAvailable() > 1024 ) {
plugin()->reply(stanza(), "sorry, result is too long");
deleteLater();
return;
}
out.append( proc_->readAllStandardOutput() );
out.append( proc_->readAllStandardError() );
QString msg(out.trimmed());
int i = msg.length();
if (i <= 0 ) {
deleteLater();
return;
}
if (msg.indexOf('.') != -1) {
while (i--) {
if (msg.at(i) != '0') break;
}
if (msg.at(i) != '.') i++;
}
plugin()->reply( stanza(), QString(msg.left(i).toUtf8()).trimmed());
deleteLater();
}
bool Message2::isReq() const {
if (isEmpty())
return false;
return stanza().tagName() == IQ
&& (stanza().type() == IQ_GET ||
stanza().type() == IQ_SET);
}
void Message2::setType(MessageType FType) {
switch (FType) {
case MT_IQGET:
stanza().setType(IQ_GET);
stanza().setTagName(IQ);
break;
case MT_IQSET:
stanza().setType(IQ_SET);
stanza().setTagName(IQ);
break;
case MT_IQRESULT:
stanza().setType(IQ_RESULT);
stanza().setTagName(IQ);
break;
case MT_IQERROR:
stanza().setType(IQ_ERROR);
stanza().setTagName(IQ);
break;
case MT_MESSAGE:
stanza().setTagName(MSG);
break;
case MT_UNKNOWN:
break;
}
}
Message2::Message2(const ConnectionInfo &AInfo)
{
FStanza = new Stanza();
QDomElement el = stanza().addElement(TNOXMPP_DATA, TNOXMPP_XMLNS);
QDomText dataSec = stanza().document().createTextNode("");
el.appendChild(dataSec);
setFrom(AInfo.jid);
setTo(AInfo.remoteJid);
setFromSid(AInfo.sid);
setToSid(AInfo.remoteSid);
}
void CleanAsyncRequest::sltTimerTimeout()
{
stanza()->addAttribute("type", "groupchat");
stanza()->finalize();
plugin()->reply(stanza(), "", false, false);
count_ --; sent_ ++;
if( count() <= 0 ) {
timer_->stop();
plugin()->reply(stanza(), QString("Clean finished: %1 messages sent.").arg(sent()), true);
deleteLater();
}
}
QString Message2::toSid() const
{
if (isEmpty())
return QString();
QDomElement elem = stanza().firstElement();
return elem.attribute("to-sid", "");
}
void BcRequest::exec()
{
if( myDest.isEmpty() ) {
plugin()->reply(stanza(), QString("!misc bc <expression>") );
deleteLater();
return;
}
for (int i = 0; i < myDest.length(); i++) {
if( myDest.at(i) > 127 || myDest.at(i) < 30 )
myDest[i] = QChar(' ');
}
// if( !myDest.contains(QRegExp("[0-9]")) ) {
// plugin()->reply(stanza(), QString("[ERROR]: unsupported expression."));
// deleteLater();
// return;
//}
proc_ = new QProcess(this);
connect(proc_, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(onProcessFinished()));
connect(proc_, SIGNAL(stateChanged(QProcess::ProcessState)), SLOT(onStateChanged(QProcess::ProcessState)));
QString cmd = "bc";
QStringList args; args << "-l";
proc_->start(cmd, args);
if (!proc_->waitForStarted()) {
qDebug() << "bc: unable to start.";
deleteLater();
return;
}
myDest.replace('!', ' ');
myDest.append("\n");
proc_->write(myDest.toUtf8());
proc_->closeWriteChannel();
if (!proc_->waitForFinished()) {
proc_->kill();
plugin()->reply(stanza(), "bc: timeout.");
deleteLater();
return;
}
}
bool JingleSession::sendAction(IJingle::Action AAction, const QDomElement &AJingleElement)
{
JingleStanza stanza(FThisParty, FOtherParty, FSid, AAction);
FActionId=stanza.id();
FAction=AAction;
stanza.importJingleElement(AJingleElement);
return FJingle->sendStanzaOut(stanza);
}
void CleanAsyncRequest::exec()
{
setCount( myDest_.toInt() );
plugin()->reply(stanza(), QString("Clean started, please wait %1 sec...")
.arg( step() * count() / 1000 ), true);
timer_->stop();
timer_->start( step() );
}
bool JingleSession::sendAction(IJingle::Action AAction, const QDomNodeList &AJingleElements)
{
JingleStanza stanza(FThisParty, FOtherParty, FSid, AAction);
FActionId=stanza.id();
FAction=AAction;
for (quint16 i=0; i<AJingleElements.length(); i++)
stanza.importJingleElement(AJingleElements.at(i).toElement());
return FJingle->sendStanzaOut(stanza);
}
QDomElement Message2::errorElement() const
{
QDomNodeList children = stanza().element().childNodes();
for (int i = 0; i < children.size(); i++) {
if (children.item(i).isElement()) {
QDomElement el = children.item(i).toElement();
if (el.tagName() == TNOXMPP_ERROR)
return el;
}
}
return QDomNode().toElement();
}
bool JingleSession::initiate()
{
JingleStanza stanza(FThisParty, FOtherParty, FSid, IJingle::SessionInitiate);
if (!FValid || FContents.isEmpty()) // Invalid session
return false;
stanza.setInitiator(FThisParty.full());
for (QHash<QString, JingleContent *>::const_iterator it=FContents.constBegin(); it!=FContents.constEnd(); it++)
(*it)->addElementToStanza(stanza);
FActionId=stanza.id();
FAction=IJingle::SessionInitiate;
return FJingle->sendStanzaOut(stanza);
}
bool JingleSession::terminate(IJingle::Reason AReason)
{
JingleStanza stanza(FThisParty, FOtherParty, FSid, IJingle::SessionTerminate);
FActionId=stanza.id();
FAction=IJingle::SessionTerminate;
stanza.setReason(AReason);
if (FJingle->sendStanzaOut(stanza))
{
setTerminated(AReason);
return true;
}
return false;
}
void XmppReg::slotRegister()
{
/*
<iq type='get' id='reg1'>
<query xmlns='jabber:iq:register'/>
</iq>
*/
printf("[XMPPREG] slotRegister\n");
QString type = "get";
id = randomString(6);
Stanza stanza(Stanza::IQ, type, id, QString());
QDomDocument doc("");
QDomElement c = doc.createElement("query");
c.setAttribute("xmlns", "jabber:iq:register");
stanza.node().firstChild().appendChild(c);
x->write(stanza);
}
bool Message2::isError() const
{
if (type() == MT_IQERROR)
return true;
else if (isEmpty())
return false;
bool hasErrorEl = false;
QDomNodeList children = stanza().element().childNodes();
for (int i = 0; i < children.size(); i++) {
if (children.item(i).isElement()) {
QDomElement el = children.item(i).toElement();
if (el.tagName() == TNOXMPP_ERROR) {
hasErrorEl = true;
break;
}
}
}
return hasErrorEl;
}
MessageType Message2::type() const {
if (stanza().tagName() == MSG)
return MT_MESSAGE;
else if (stanza().tagName() == IQ) {
if (stanza().type() == IQ_GET)
return MT_IQGET;
else if (stanza().type() == IQ_SET)
return MT_IQSET;
else if (stanza().type() == IQ_RESULT)
return MT_IQRESULT;
else if (stanza().type() == IQ_ERROR)
return MT_IQERROR;
}
return MT_UNKNOWN;
}
void XmppReg::sendRegistration()
{
QString type = "set";
id = randomString(6);
Stanza stanza(Stanza::IQ, type, id, QString());
QDomDocument doc("");
QDomElement query = doc.createElement("query");
query.setAttribute("xmlns", "jabber:iq:register");
if (needUsername)
{
QDomElement username = doc.createElement("username");
QDomText text = doc.createTextNode(p.jid().node());
username.appendChild(text);
query.appendChild(username);
}
if (needPassword)
{
QDomElement password = doc.createElement("password");
QDomText text = doc.createTextNode(p.password());
password.appendChild(text);
query.appendChild(password);
}
if (needEmail)
{
QDomElement email = doc.createElement("email");
QDomText text = doc.createTextNode(p.jid().bare());
email.appendChild(text);
query.appendChild(email);
}
stanza.node().firstChild().appendChild(query);
x->write(stanza);
}
bool MessageCarbons::stanzaReadWrite(int AHandleId, const Jid &AStreamJid, Stanza &AStanza, bool &AAccept)
{
if (isEnabled(AStreamJid) && FSHIForwards.value(AStreamJid)==AHandleId)
{
QDomElement fwdElem = AStanza.firstElement("forwarded",NS_MESSAGE_FORWARD);
bool isSent = !Stanza::findElement(fwdElem,"sent",NS_MESSAGE_CARBONS).isNull();
bool isReceived = !Stanza::findElement(fwdElem,"received",NS_MESSAGE_CARBONS).isNull();
QDomElement msgElem = Stanza::findElement(fwdElem,"message");
if (!msgElem.isNull() && (isSent || isReceived))
{
AAccept = true;
Stanza stanza(msgElem);
Message message(stanza);
if (isSent)
{
message.stanza().addElement("sent",NS_MESSAGE_CARBONS);
if (FMessageProcessor)
{
if (FMessageProcessor->processMessage(AStreamJid,message,IMessageProcessor::MessageOut))
FMessageProcessor->displayMessage(AStreamJid,message,IMessageProcessor::MessageOut);
}
emit messageSent(AStreamJid,message);
}
else
{
message.stanza().addElement("received",NS_MESSAGE_CARBONS);
if (FMessageProcessor)
{
if (FMessageProcessor->processMessage(AStreamJid,message,IMessageProcessor::MessageIn))
FMessageProcessor->displayMessage(AStreamJid,message,IMessageProcessor::MessageIn);
}
emit messageReceived(AStreamJid,message);
}
}
}
return false;
}
static int parse_obo_file(GtOBOParseTree *obo_parse_tree,
GtIO *obo_file, GtError *err)
{
int had_err = 0;
gt_error_check(err);
gt_assert(obo_parse_tree && obo_file);
while (!had_err && ignored_char(obo_file)) {
had_err = ignored_line(obo_file, err);
}
if (!had_err)
had_err = header(obo_parse_tree, obo_file, err);
while (!had_err && gt_io_has_char(obo_file)) {
switch (gt_io_peek(obo_file)) {
case OBO_BLANK_CHAR:
had_err = blank_line(obo_file, err);
break;
case OBO_COMMENT_CHAR:
had_err = comment_line(obo_file, err);
break;
case GT_CARRIAGE_RETURN:
gt_io_next(obo_file);
if (gt_io_peek(obo_file) == GT_END_OF_LINE)
gt_io_next(obo_file);
break;
case GT_END_OF_LINE:
gt_io_next(obo_file);
break;
default:
had_err = stanza(obo_parse_tree, obo_file, err);
}
}
if (!had_err)
had_err = gt_io_expect(obo_file, GT_END_OF_FILE, err);
if (!had_err)
had_err = gt_obo_parse_tree_validate_stanzas(obo_parse_tree, err);
return had_err;
}
void XmppStream::startStream()
{
LogDetail(QString("[XmppStream][%1] Initializing XMPP stream").arg(FStreamJid.bare()));
FParser.restart();
FKeepAliveTimer.start(KEEP_ALIVE_TIMEOUT);
QDomDocument doc;
QDomElement root = doc.createElementNS(NS_JABBER_STREAMS,"stream:stream");
doc.appendChild(root);
root.setAttribute("xmlns",NS_JABBER_CLIENT);
root.setAttribute("to", FStreamJid.domain());
if (!FDefLang.isEmpty())
root.setAttribute("xml:lang",FDefLang);
FStreamState = SS_INITIALIZE;
Stanza stanza(doc.documentElement());
if (!processStanzaHandlers(stanza,true))
{
QByteArray data = QString("<?xml version=\"1.0\"?>").toUtf8()+stanza.toByteArray().trimmed();
data.remove(data.size()-2,1);
sendData(data);
}
}
bool XmppStream::xmppStanzaIn(IXmppStream *AXmppStream, Stanza &AStanza, int AOrder)
{
if (AXmppStream == this && AOrder == XSHO_XMPP_STREAM)
{
if (FStreamState==SS_INITIALIZE && AStanza.element().nodeName()=="stream:stream")
{
LogDetail(QString("[XmppStream][%1] XMPP stream initialized").arg(FStreamJid.bare()));
FStreamId = AStanza.id();
FStreamState = SS_FEATURES;
if (VersionParser(AStanza.element().attribute("version","0.0")) < VersionParser(1,0))
{
Stanza stanza("stream:features");
stanza.addElement("register",NS_FEATURE_REGISTER);
stanza.addElement("auth",NS_FEATURE_IQAUTH);
xmppStanzaIn(AXmppStream, stanza, AOrder);
}
return true;
}
else if (FStreamState==SS_FEATURES && AStanza.element().nodeName()=="stream:features")
{
LogDetail(QString("[XmppStream][%1] Processing XMPP stream features").arg(FStreamJid.bare()));
FServerFeatures = AStanza.element().cloneNode(true).toElement();
FAvailFeatures = FXmppStreams->xmppFeaturesOrdered();
processFeatures();
return true;
}
else if (AStanza.element().nodeName() == "stream:error")
{
ErrorHandler err(AStanza.element(),NS_XMPP_STREAMS);
LogError(QString("[XmppStream][%1] XMPP stream error received: %2").arg(FStreamJid.bare(),err.message()));
abort(err.message());
return true;
}
}
return false;
}
QString Message2::id() const
{
return stanza().id();
}
Message2& Message2::setAttr(const QString &AName, const QString &AValue)
{
stanza().firstElement().setAttribute(AName, AValue);
return *this;
}
bool Message2::isMessage() const
{
return stanza().tagName() == MSG;
}
bool Message2::isEmpty() const
{
const QDomDocument& doc = stanza().document();
const QDomElement& elem = doc.documentElement();
return elem.childNodes().size() == 0;
}
Message2& Message2::setId(QString AId)
{
stanza().setId(AId);
return *this;
}
void XmppStream::onParserOpened(QDomElement AElem)
{
Stanza stanza(AElem);
processStanzaHandlers(stanza,false);
}
void XmppStream::onParserElement(QDomElement AElem)
{
Stanza stanza(AElem);
LogStanza(QString("[XmppStream][%1] Received stanza:\n%2").arg(FStreamJid.bare(),stanza.toString()));
processStanzaHandlers(stanza,false);
}
