Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include "xmpp/xmpp_proto.h"
       6             : #include <iostream>
       7             : #include <string>
       8             : #include <boost/algorithm/string/replace.hpp>
       9             : #include <boost/algorithm/string/predicate.hpp>
      10             : 
      11             : #include "xmpp/xmpp_connection.h"
      12             : #include "xmpp/xmpp_log.h"
      13             : #include "xmpp/xmpp_session.h"
      14             : #include "xmpp/xmpp_str.h"
      15             : 
      16             : #include "sandesh/sandesh_trace.h"
      17             : #include "sandesh/common/vns_types.h"
      18             : #include "sandesh/common/vns_constants.h"
      19             : #include "sandesh/xmpp_message_sandesh_types.h"
      20             : #include "sandesh/xmpp_trace_sandesh_types.h"
      21             : 
      22             : using namespace std;
      23             : 
      24             : unique_ptr<XmlBase> XmppProto::open_doc_(AllocXmppXmlImpl(sXMPP_STREAM_OPEN));
      25             : 
      26           0 : XmppStanza::XmppStanza() {
      27           0 : }
      28             : 
      29           0 : XmppProto::XmppProto() {
      30           0 : }
      31             : 
      32           0 : XmppProto::~XmppProto() {
      33           0 : }
      34             : 
      35       20311 : int XmppProto::EncodeStream(const XmppStreamMessage &str, string &to,
      36             :                             string &from, const string &xmlns, uint8_t *buf,
      37             :                             size_t size) {
      38       20311 :     int len = 0;
      39             : 
      40       20311 :     switch (str.strmtype) {
      41        8055 :         case (XmppStanza::XmppStreamMessage::INIT_STREAM_HEADER):
      42        8055 :             len = EncodeOpen(buf, to, from, xmlns, size);
      43        8055 :             break;
      44        7819 :         case (XmppStanza::XmppStreamMessage::INIT_STREAM_HEADER_RESP):
      45        7819 :             len = EncodeOpenResp(buf, to, from, size);
      46        7818 :             break;
      47        4437 :         case (XmppStanza::XmppStreamMessage::FEATURE_TLS):
      48        4437 :             switch (str.strmtlstype) {
      49        1509 :                 case (XmppStanza::XmppStreamMessage::TLS_FEATURE_REQUEST):
      50        1509 :                     len = EncodeFeatureTlsRequest(buf);
      51        1509 :                     break;
      52        1467 :                 case (XmppStanza::XmppStreamMessage::TLS_START):
      53        1467 :                     len = EncodeFeatureTlsStart(buf);
      54        1467 :                     break;
      55        1462 :                 case (XmppStanza::XmppStreamMessage::TLS_PROCEED):
      56        1462 :                     len = EncodeFeatureTlsProceed(buf);
      57        1462 :                     break;
      58             :             }
      59        4437 :             break;
      60           0 :         default:
      61           0 :             break;
      62             :     }
      63             : 
      64       20310 :     return len;
      65             : }
      66             : 
      67        6446 : int XmppProto::EncodeStream(const XmppStanza::XmppMessage &str, uint8_t *buf,
      68             :                             size_t size) {
      69        6446 :     int ret = 0;
      70             : 
      71        6446 :     if (str.type == XmppStanza::WHITESPACE_MESSAGE_STANZA) {
      72        6446 :         return EncodeWhitespace(buf);
      73             :     }
      74             : 
      75           0 :     return ret;
      76             : }
      77             : 
      78           0 : int XmppProto::EncodeMessage(XmlBase *dom, uint8_t *buf, size_t size) {
      79           0 :     int len = dom->WriteDoc(buf);
      80             : 
      81           0 :     return len;
      82             : }
      83             : 
      84           0 : int XmppProto::EncodePresence(uint8_t *buf, size_t size) {
      85           0 :     return 0;
      86             : }
      87             : 
      88           0 : int XmppProto::EncodeIq(const XmppStanza::XmppMessageIq *iq,
      89             :                         XmlBase *doc, uint8_t *buf, size_t size) {
      90           0 :     unique_ptr<XmlBase> send_doc_(AllocXmppXmlImpl());
      91             : 
      92             :     // create
      93           0 :     send_doc_->LoadDoc("");
      94           0 :     send_doc_->AddNode("iq", "");
      95             : 
      96           0 :     switch(iq->stype) {
      97           0 :         case XmppStanza::XmppMessageIq::GET:
      98           0 :             send_doc_->AddAttribute("type", "get");
      99           0 :             break;
     100           0 :         case XmppStanza::XmppMessageIq::SET:
     101           0 :             send_doc_->AddAttribute("type", "set");
     102           0 :             break;
     103           0 :         case XmppStanza::XmppMessageIq::RESULT:
     104           0 :             send_doc_->AddAttribute("type", "result");
     105           0 :             break;
     106           0 :         case XmppStanza::XmppMessageIq::ERROR:
     107           0 :             send_doc_->AddAttribute("type", "error");
     108           0 :             break;
     109           0 :         default:
     110           0 :             break;
     111             :     }
     112           0 :     send_doc_->AddAttribute("from", iq->from);
     113           0 :     send_doc_->AddAttribute("to", iq->to);
     114           0 :     send_doc_->AddAttribute("id", "id1");
     115             : 
     116           0 :     send_doc_->AddChildNode("pubsub", "");
     117           0 :     send_doc_->AddAttribute("xmlns", "http://jabber.org/protocol/pubsub");
     118             : 
     119           0 :     send_doc_->AppendDoc("pubsub", doc);
     120             : 
     121             :     //Returns byte encoded in the doc
     122           0 :     int len = send_doc_->WriteDoc(buf);
     123             : 
     124           0 :     return len;
     125           0 : }
     126             : 
     127        6446 : int XmppProto::EncodeWhitespace(uint8_t *buf) {
     128        6446 :     string str(sXMPP_WHITESPACE);
     129             : 
     130        6446 :     int len = str.size();
     131        6446 :     if (len > 0) {
     132        6446 :         memcpy(buf, str.data(), len);
     133             :     }
     134             : 
     135        6446 :     return len;
     136        6446 : }
     137             : 
     138        7819 : int XmppProto::EncodeOpenResp(uint8_t *buf, string &to, string &from,
     139             :                               size_t max_size) {
     140             : 
     141        7819 :     unique_ptr<XmlBase> resp_doc(XmppStanza::AllocXmppXmlImpl(sXMPP_STREAM_RESP));
     142             : 
     143        7818 :     if (resp_doc.get() == NULL) {
     144           0 :         return 0;
     145             :     }
     146             : 
     147        7818 :     SetTo(to, resp_doc.get());
     148        7817 :     SetFrom(from, resp_doc.get());
     149             : 
     150        7818 :     std::stringstream ss;
     151        7818 :     resp_doc->PrintDoc(ss);
     152        7818 :     std::string msg;
     153        7818 :     msg = ss.str();
     154        7819 :     size_t len = msg.size();
     155        7819 :     if (len > max_size) {
     156           0 :         LOG(ERROR, "\n (Open Confirm) size greater than max buffer size \n");
     157           0 :         return 0;
     158             :     } else {
     159        7819 :         boost::algorithm::ireplace_last(msg, "/", " ");
     160        7819 :         memcpy(buf, msg.c_str(), len);
     161        7819 :         return len;
     162             :     }
     163        7819 : }
     164             : 
     165        8055 : int XmppProto::EncodeOpen(uint8_t *buf, string &to, string &from,
     166             :                           const string &xmlns, size_t max_size) {
     167             : 
     168        8055 :     if (open_doc_.get() ==  NULL) {
     169           0 :         return 0;
     170             :     }
     171             : 
     172        8055 :     SetTo(to, open_doc_.get());
     173        8055 :     SetFrom(from, open_doc_.get());
     174        8055 :     SetXmlns(xmlns, open_doc_.get());
     175             : 
     176             :     //Returns byte encoded in the doc
     177        8055 :     std::stringstream ss;
     178        8055 :     open_doc_->PrintDoc(ss);
     179        8055 :     std::string msg;
     180        8055 :     msg = ss.str();
     181        8055 :     size_t len = msg.size();
     182        8055 :     if (len > max_size) {
     183           0 :         LOG(ERROR, "\n (Open Message) size greater than max buffer size \n");
     184           0 :         return 0;
     185             :     } else {
     186        8055 :         boost::algorithm::ireplace_last(msg, "/", " ");
     187        8055 :         memcpy(buf, msg.c_str(), len);
     188        8055 :         return len;
     189             :     }
     190        8055 : }
     191             : 
     192        1509 : int XmppProto::EncodeFeatureTlsRequest(uint8_t *buf) {
     193        1509 :     unique_ptr<XmlBase> resp_doc(XmppStanza::AllocXmppXmlImpl(sXMPP_STREAM_FEATURE_TLS));
     194             :     //Returns byte encoded in the doc
     195        1509 :     int len = resp_doc->WriteDoc(buf);
     196        1509 :     return len;
     197        1509 : }
     198             : 
     199        1467 : int XmppProto::EncodeFeatureTlsStart(uint8_t *buf) {
     200        1467 :     unique_ptr<XmlBase> resp_doc(XmppStanza::AllocXmppXmlImpl(sXMPP_STREAM_START_TLS));
     201             :     //Returns byte encoded in the doc
     202        1467 :     int len = resp_doc->WriteDoc(buf);
     203        1467 :     return len;
     204        1467 : }
     205             : 
     206        1462 : int XmppProto::EncodeFeatureTlsProceed(uint8_t *buf) {
     207        1462 :     unique_ptr<XmlBase> resp_doc(XmppStanza::AllocXmppXmlImpl(sXMPP_STREAM_PROCEED_TLS));
     208             :     //Returns byte encoded in the doc
     209        1462 :     int len = resp_doc->WriteDoc(buf);
     210        1462 :     return len;
     211        1462 : }
     212             : 
     213     4234911 : XmppStanza::XmppMessage *XmppProto::Decode(const XmppConnection *connection,
     214             :                                            const string &ts) {
     215     4234911 :     XmlBase *impl = XmppStanza::AllocXmppXmlImpl();
     216     4234893 :     if (impl == nullptr) {
     217           0 :         return nullptr;
     218             :     }
     219             : 
     220     4234893 :     XmppStanza::XmppMessage *msg = DecodeInternal(connection, ts, impl);
     221     4234963 :     if (!msg) {
     222           0 :         return nullptr;
     223             :     }
     224             : 
     225             :     // transfer ownership of the dom implementation
     226     4234963 :     msg->dom.reset(impl);
     227             : 
     228     4234943 :     return msg;
     229             : }
     230             : 
     231     4234887 : XmppStanza::XmppMessage *XmppProto::DecodeInternal(
     232             :         const XmppConnection *connection, const string &ts, XmlBase *impl) {
     233     4234887 :     XmppStanza::XmppMessage *ret = nullptr;
     234             : 
     235     4234887 :     string ns(sXMPP_STREAM_O);
     236     4234874 :     string ws(sXMPP_WHITESPACE);
     237     4234871 :     string iq(sXMPP_IQ_KEY);
     238             : 
     239     4234867 :     if (ts.find(sXMPP_IQ) != string::npos) {
     240       98579 :         string ts_tmp = ts;
     241             : 
     242       98578 :         if (impl->LoadDoc(ts) == -1) {
     243           0 :             XMPP_WARNING(XmppIqMessageParseFail, connection->ToUVEKey(),
     244             :                          XMPP_PEER_DIR_IN);
     245           0 :             assert(false);
     246             :             goto done;
     247             :         }
     248             : 
     249       98583 :         XmppStanza::XmppMessageIq *msg = new XmppStanza::XmppMessageIq;
     250       98580 :         impl->ReadNode(iq);
     251       98574 :         msg->to = XmppProto::GetTo(impl);
     252       98581 :         msg->from = XmppProto::GetFrom(impl);
     253       98579 :         msg->id = XmppProto::GetId(impl);
     254       98580 :         msg->iq_type = XmppProto::GetType(impl);
     255             :         // action is subscribe,publish,collection
     256       98580 :         const char *action = XmppProto::GetAction(impl, msg->iq_type);
     257       98578 :         if (action) {
     258       98563 :             msg->action = action;
     259             :         }
     260       98578 :         if (XmppProto::GetNode(impl, msg->action)) {
     261       98562 :             msg->node = XmppProto::GetNode(impl, msg->action);
     262             :         }
     263             :         //associate or dissociate collection node
     264       98578 :         if (msg->action.compare("collection") == 0) {
     265       41674 :             if (XmppProto::GetAsNode(impl)) {
     266       27304 :                 msg->as_node = XmppProto::GetAsNode(impl);
     267       27304 :                 msg->is_as_node = true;
     268       14369 :             } else if (XmppProto::GetDsNode(impl)) {
     269       14342 :                 msg->as_node = XmppProto::GetDsNode(impl);
     270       14341 :                 msg->is_as_node = false;
     271             :             }
     272             :         }
     273             : 
     274             :         //msg->dom.reset(impl);
     275             : 
     276       98578 :         ret = msg;
     277             : 
     278       98578 :         XMPP_UTDEBUG(XmppIqMessageProcess, connection->ToUVEKey(),
     279             :                      XMPP_PEER_DIR_IN, msg->node, msg->action, msg->from,
     280             :                      msg->to, msg->id, msg->iq_type);
     281       98579 :         goto done;
     282             : 
     283     4234960 :     } else if (ts.find(sXMPP_MESSAGE) != string::npos) {
     284             : 
     285     1588459 :         if (impl->LoadDoc(ts) == -1) {
     286           0 :             XMPP_WARNING(XmppChatMessageParseFail, connection->ToUVEKey(),
     287             :                          XMPP_PEER_DIR_IN);
     288           0 :             goto done;
     289             :         }
     290             :         XmppStanza::XmppMessage *msg = new XmppStanza::XmppChatMessage(
     291     1588459 :                                            STATE_NONE);
     292     1588459 :         impl->ReadNode(sXMPP_MESSAGE_KEY);
     293             : 
     294     1588459 :         msg->to = XmppProto::GetTo(impl);
     295     1588459 :         msg->from = XmppProto::GetFrom(impl);
     296     1588459 :         ret = msg;
     297             : 
     298     1588459 :         XMPP_UTDEBUG(XmppChatMessageProcess, connection->ToUVEKey(),
     299             :                      XMPP_PEER_DIR_IN, msg->type, msg->from, msg->to);
     300     1588459 :         goto done;
     301             : 
     302     2547927 :     } else if (ts.find(sXMPP_STREAM_O) != string::npos) {
     303             : 
     304             :         // ensusre stream open is at the beginning of the message
     305       15720 :         string ts_tmp = ts;
     306       15717 :         ts_tmp.erase(std::remove(ts_tmp.begin(), ts_tmp.end(), '\n'), ts_tmp.end());
     307             : 
     308       15717 :         if ((ts_tmp.compare(0, strlen(sXMPP_STREAM_START),
     309       31436 :              sXMPP_STREAM_START) != 0) &&
     310       15718 :             (ts_tmp.compare(0, strlen(sXMPP_STREAM_START_S),
     311             :              sXMPP_STREAM_START_S) != 0)) {
     312           0 :             XMPP_WARNING(XmppBadMessage, connection->ToUVEKey(),
     313             :                          XMPP_PEER_DIR_IN,
     314             :                          "Open message not at the beginning.", ts);
     315           0 :             goto done;
     316             :         }
     317             : 
     318             :         // check if the buf is xmpp open or response message
     319             :         // As end tag will be missing we need to modify the
     320             :         // string for stream open, else dom decoder will fail
     321       15718 :         boost::algorithm::replace_last(ts_tmp, ">", "/>");
     322       15720 :         if (impl->LoadDoc(ts_tmp) == -1) {
     323           0 :             XMPP_WARNING(XmppBadMessage, connection->ToUVEKey(),
     324             :                          XMPP_PEER_DIR_IN, "Open message parse failed.", ts);
     325           0 :             goto done;
     326             :         }
     327             : 
     328             :         XmppStanza::XmppStreamMessage *strm =
     329       15722 :             new XmppStanza::XmppStreamMessage();
     330       15719 :         strm->strmtype = XmppStanza::XmppStreamMessage::INIT_STREAM_HEADER;
     331       15719 :         impl->ReadNode(ns);
     332       15717 :         strm->to = XmppProto::GetTo(impl);
     333       15717 :         strm->from = XmppProto::GetFrom(impl);
     334       15720 :         strm->xmlns = XmppProto::GetXmlns(impl);
     335             : 
     336       15719 :         ret = strm;
     337             : 
     338       15719 :         XMPP_UTDEBUG(XmppRxOpenMessage, connection->ToUVEKey(),
     339             :                      XMPP_PEER_DIR_IN, strm->from, strm->to);
     340             : 
     341     2547928 :     } else if (ts.find(sXMPP_STREAM_NS_TLS) != string::npos) {
     342             : 
     343        4359 :         if (impl->LoadDoc(ts) == -1) {
     344           0 :             XMPP_WARNING(XmppBadMessage, connection->ToUVEKey(),
     345             :                          XMPP_PEER_DIR_IN, "Stream TLS parse failed.", ts);
     346           0 :             goto done;
     347             :         }
     348             : 
     349             :         // find stream:features tls required
     350        5812 :         if ((ts.find(sXMPP_STREAM_FEATURES_O) != string::npos) &&
     351        5812 :             (ts.find(sXMPP_STREAM_STARTTLS_O) != string::npos) &&
     352        1453 :             (ts.find(sXMPP_REQUIRED_O) != string::npos)) {
     353             : 
     354             :             XmppStanza::XmppStreamMessage *strm =
     355        1453 :                 new XmppStanza::XmppStreamMessage();
     356        1453 :             strm->strmtype = XmppStanza::XmppStreamMessage::FEATURE_TLS;
     357        1453 :             strm->strmtlstype = XmppStanza::XmppStreamMessage::TLS_FEATURE_REQUEST;
     358             : 
     359        1453 :             ret = strm;
     360             : 
     361        1453 :             XMPP_UTDEBUG(XmppRxStreamTlsRequired, connection->ToUVEKey(),
     362             :                          XMPP_PEER_DIR_IN);
     363             : 
     364        2906 :         } else if (ts.find(sXMPP_STREAM_STARTTLS_O) != string::npos) {
     365             :             XmppStanza::XmppStreamMessage *strm =
     366        1453 :                 new XmppStanza::XmppStreamMessage();
     367        1453 :             strm->strmtype = XmppStanza::XmppStreamMessage::FEATURE_TLS;
     368        1453 :             strm->strmtlstype = XmppStanza::XmppStreamMessage::TLS_START;
     369        1453 :             ret = strm;
     370             : 
     371        1453 :             XMPP_UTDEBUG(XmppRxStreamStartTls, connection->ToUVEKey(),
     372             :                          XMPP_PEER_DIR_IN);
     373             : 
     374        1453 :         } else if (ts.find(sXMPP_STREAM_PROCEED_O) != string::npos) {
     375             :             XmppStanza::XmppStreamMessage *strm =
     376        1453 :                 new XmppStanza::XmppStreamMessage();
     377        1453 :             strm->strmtype = XmppStanza::XmppStreamMessage::FEATURE_TLS;
     378        1453 :             strm->strmtlstype = XmppStanza::XmppStreamMessage::TLS_PROCEED;
     379             : 
     380        1453 :             ret = strm;
     381             : 
     382        1453 :             XMPP_UTDEBUG(XmppRxStreamProceed, connection->ToUVEKey(),
     383             :                          XMPP_PEER_DIR_IN);
     384             :         }
     385        4359 :         goto done;
     386             : 
     387     2527855 :     } else if (ts.find_first_of(sXMPP_VALIDWS) != string::npos) {
     388             : 
     389             :         XmppStanza::XmppMessage *msg =
     390     2527855 :             new XmppStanza::XmppMessage(WHITESPACE_MESSAGE_STANZA);
     391     2527854 :         return msg;
     392             :     } else {
     393           0 :         XMPP_WARNING(XmppBadMessage, connection->ToUVEKey(),
     394             :                      XMPP_PEER_DIR_IN, "Message not supported", ts);
     395             :     }
     396             : 
     397     1707114 : done:
     398             : 
     399     1707114 :     return ret;
     400     4234968 : }
     401             : 
     402       15872 : int XmppProto::SetTo(string &to, XmlBase *doc) {
     403       15872 :     if (!doc) return -1;
     404             : 
     405       15872 :     string ns(sXMPP_STREAM_O);
     406       15872 :     doc->ReadNode(ns);
     407       15872 :     doc->ModifyAttribute("to", to);
     408             : 
     409       15871 :     return 0;
     410       15871 : }
     411             : 
     412       15871 : int XmppProto::SetFrom(string &from, XmlBase *doc) {
     413       15871 :     if (!doc) return -1;
     414             : 
     415       15871 :     string ns(sXMPP_STREAM_O);
     416       15872 :     doc->ReadNode(ns);
     417       15871 :     return doc->ModifyAttribute("from", from);
     418       15871 : }
     419             : 
     420        8055 : int XmppProto::SetXmlns(const string &xmlns, XmlBase *doc) {
     421        8055 :     if (!doc)
     422           0 :         return -1;
     423             : 
     424        8055 :     string ns(sXMPP_STREAM_O);
     425        8055 :     doc->ReadNode(ns);
     426        8055 :     return doc->ModifyAttribute("xmlns", xmlns);
     427        8055 : }
     428             : 
     429     1702719 : const char *XmppProto::GetTo(XmlBase *doc) {
     430     1702719 :     if (!doc) return NULL;
     431             : 
     432     1702719 :     string tmp("to");
     433     1702729 :     return doc->ReadAttrib(tmp);
     434     1702723 : }
     435             : 
     436     1702734 : const char *XmppProto::GetFrom(XmlBase *doc) {
     437     1702734 :     if (!doc) return NULL;
     438             : 
     439     1702734 :     string tmp("from");
     440     1702737 :     return doc->ReadAttrib(tmp);
     441     1702739 : }
     442             : 
     443       15719 : const char *XmppProto::GetXmlns(XmlBase *doc) {
     444       15719 :     if (!doc)
     445           0 :         return NULL;
     446             : 
     447       15719 :     string tmp("xmlns");
     448       15719 :     return doc->ReadAttrib(tmp);
     449       15718 : }
     450             : 
     451       98564 : const char *XmppProto::GetId(XmlBase *doc) {
     452       98564 :     if (!doc) return NULL;
     453             : 
     454       98564 :     string tmp("id");
     455       98577 :     return doc->ReadAttrib(tmp);
     456       98579 : }
     457             : 
     458       98580 : const char *XmppProto::GetType(XmlBase *doc) {
     459       98580 :     if (!doc) return NULL;
     460             : 
     461       98580 :     string tmp("type");
     462       98580 :     return doc->ReadAttrib(tmp);
     463       98580 : }
     464             : 
     465       98579 : const char *XmppProto::GetAction(XmlBase *doc, const string &str) {
     466       98579 :     if (!doc) return NULL;
     467             : 
     468       98579 :     if (str.compare("set") == 0) {
     469       98569 :         doc->ReadNode("pubsub");
     470       98564 :         return(doc->ReadChildNodeName());
     471          15 :     } else if (str.compare("get") == 0) {
     472             :     }
     473             : 
     474          15 :     return(NULL);
     475             : }
     476             : 
     477      197137 : const char *XmppProto::GetNode(XmlBase *doc, const string &str) {
     478      197137 :     if (!doc) return NULL;
     479             : 
     480      197137 :     if (!str.empty()) {
     481      197122 :         return(doc->ReadAttrib("node"));
     482             :     }
     483             : 
     484          15 :     return(NULL);
     485             : }
     486             : 
     487       68977 : const char *XmppProto::GetAsNode(XmlBase *doc) {
     488       68977 :     if (!doc) return NULL;
     489             : 
     490       68977 :     const char *node = doc->ReadNode("associate");
     491       68975 :     if (node != NULL) {
     492       54606 :         return(doc->ReadAttrib("node"));
     493             :     }
     494             : 
     495       14369 :     return(NULL);
     496             : }
     497             : 
     498       28710 : const char *XmppProto::GetDsNode(XmlBase *doc) {
     499       28710 :     if (!doc) return NULL;
     500             : 
     501       28710 :     const char *node = doc->ReadNode("dissociate");
     502       28707 :     if (node != NULL) {
     503       28679 :         return(doc->ReadAttrib("node"));
     504             :     }
     505             : 
     506          28 :     return(NULL);
     507             : }