example/diameter/pcapDecoder/main.cpp

   1 // ANNA - Anna is Not Nothingness Anymore
   2 //
   3 // (c) Copyright 2005-2014 Eduardo Ramos Testillano & Francisco Ruiz Rayo
   4 //
   5 // http://redmine.teslayout.com/projects/anna-suite
   6 //
   7 // Redistribution and use in source and binary forms, with or without
   8 // modification, are permitted provided that the following conditions
   9 // are met:
  10 //
  11 //     * Redistributions of source code must retain the above copyright
  12 // notice, this list of conditions and the following disclaimer.
  13 //     * Redistributions in binary form must reproduce the above
  14 // copyright notice, this list of conditions and the following disclaimer
  15 // in the documentation and/or other materials provided with the
  16 // distribution.
  17 //     *  Neither the name of the copyright holder nor the names of its
  18 // contributors may be used to endorse or promote products derived from
  19 // this software without specific prior written permission.
  20 //
  21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32 //
  33 // Authors: eduardo.ramos.testillano@gmail.com
  34 //          cisco.tierra@gmail.com
  35
  36 // Standard
  37 #include <pcap.h>
  38 #include <stdlib.h>
  39 #include <netinet/ip.h>
  40 #include <arpa/inet.h>
  41 #include <iostream>
  42 #include <fstream>
  43
  44 // STL
  45 #include <string>
  46 #include <map>
  47
  48 #include <anna/core/DataBlock.hpp>
  49 #include <anna/core/util/Tokenizer.hpp>
  50 #include <anna/core/functions.hpp>
  51 #include <anna/core/tracing/Logger.hpp>
  52 #include <anna/core/tracing/TraceWriter.hpp>
  53 #include <anna/core/RuntimeException.hpp>
  54 #include <anna/xml/xml.hpp>
  55 #include <anna/diameter/stack/Engine.hpp>
  56 #include <anna/diameter/codec/Engine.hpp>
  57 #include <anna/diameter/codec/Message.hpp>
  58 //#include <anna/diameter/defines.hpp> // typedef unsigned int ApplicationId;
  59 #include <anna/diameter/codec/functions.hpp> // ApplicationId anna::diameter::codec::functions::getApplicationId(const anna::DataBlock &) throw(anna::RuntimeException);
  60
  61
  62 using namespace anna;
  63 using namespace anna::diameter;
  64
  65 // Payload and frame metadata /////////////////////////////////////////////////////////////////////////////
  66 class Payload {
  67
  68   std::string _sourceIP;
  69   std::string _destinationIP;
  70   time_t _timestamp;
  71   int _timestampU; // usecs
  72   std::string _data;
  73   size_t _diameterLength;
  74
  75 public:
  76   Payload() {
  77     reset();
  78   }
  79
  80   void setDiameterLength(size_t dl) {
  81     if(_diameterLength == -1) {
  82       _diameterLength = dl;
  83       LOGDEBUG(
  84         Logger::debug(anna::functions::asString("Diameter message length: %d bytes", dl), ANNA_FILE_LOCATION));
  85     }
  86   }
  87
  88   void setSourceIP(const std::string &srcIP) throw() {
  89     _sourceIP = srcIP;
  90   }
  91   void setDestinationIP(const std::string &dstIP) throw() {
  92     _destinationIP = dstIP;
  93   }
  94   void setTimestamp(time_t ts) throw() {
  95     _timestamp = ts;
  96   }
  97   void setTimestampU(int tsu) throw() {
  98     _timestampU = tsu;
  99   }
 100   // Returns true if completed:
 101   bool appendData(const char *data, size_t size) throw(RuntimeException) {
 102     LOGDEBUG(
 103       Logger::debug(anna::functions::asString("Appending %d bytes", size), ANNA_FILE_LOCATION));
 104     _data.append(data, size);
 105
 106     if(_data.size() > _diameterLength)
 107       throw RuntimeException(
 108         "Data overflow (unexpected offset exceed diameter message length)",
 109         ANNA_FILE_LOCATION);
 110
 111     if(_data.size() < _diameterLength)
 112       return false;
 113
 114     LOGDEBUG(anna::Logger::debug("Completed!", ANNA_FILE_LOCATION));
 115     return true;
 116   }
 117
 118   void reset() throw() {
 119     _sourceIP = "";
 120     _destinationIP = "";
 121     _timestamp = 0;
 122     _timestampU = 0;
 123     _data = "";
 124     _diameterLength = -1; // not calculated yet
 125   }
 126
 127   const std::string &getSourceIP() const throw() {
 128     return _sourceIP;
 129   }
 130   const std::string &getDestinationIP() const throw() {
 131     return _destinationIP;
 132   }
 133   time_t getTimestamp() const throw() {
 134     return _timestamp;
 135   }
 136   int getTimestampU() const throw() {
 137     return _timestampU;
 138   }
 139   const std::string &getData() const throw() {
 140     return _data;
 141   }
 142   std::string getDataAsHex() const throw() {
 143     return anna::functions::asHexString(
 144              anna::DataBlock(_data.c_str(), _data.size()));
 145   }
 146 };
 147
 148 // Data maps //////////////////////////////////////////////////////////////////////////////////////////////
 149 typedef std::map < int /* frame */, Payload > payloads_t;
 150 typedef std::map < int /* frame */, Payload >::const_iterator payloads_it;
 151 payloads_t G_payloads;
 152 anna::diameter::codec::Message G_codecMsg;
 153 anna::diameter::codec::Engine *G_codecEngine;
 154
 155 // Sniffing structures ////////////////////////////////////////////////////////////////////////////////////
 156
 157 /* ethernet headers are always exactly 14 bytes */
 158 #define SIZE_ETHERNET 14
 159 /* Ethernet addresses are 6 bytes */
 160 #define ETHER_ADDR_LEN  6
 161
 162 /* Ethernet header */
 163 struct sniff_ethernet {
 164   u_char ether_dhost[ETHER_ADDR_LEN]; /* Destination host address */
 165   u_char ether_shost[ETHER_ADDR_LEN]; /* Source host address */
 166   u_short ether_type; /* IP? ARP? RARP? etc */
 167 };
 168
 169 /* IP header */
 170 struct sniff_ip {
 171   u_char ip_vhl; /* version << 4 | header length >> 2 */
 172   u_char ip_tos; /* type of service */
 173   u_short ip_len; /* total length */
 174   u_short ip_id; /* identification */
 175   u_short ip_off; /* fragment offset field */
 176 #define IP_RF 0x8000    /* reserved fragment flag */
 177 #define IP_DF 0x4000    /* dont fragment flag */
 178 #define IP_MF 0x2000    /* more fragments flag */
 179 #define IP_OFFMASK 0x1fff /* mask for fragmenting bits */
 180   u_char ip_ttl; /* time to live */
 181   u_char ip_p; /* protocol */
 182   u_short ip_sum; /* checksum */
 183   struct in_addr ip_src, ip_dst; /* source and dest address */
 184 };
 185 #define IP_OFF(ip)              (((ip)->ip_off) & IP_OFFMASK)
 186 #define IP_DF_VAL(ip)           ((((ip)->ip_off) & IP_DF) >> 14)
 187 #define IP_MF_VAL(ip)           ((((ip)->ip_off) & IP_MF) >> 13)
 188 #define IP_HL(ip)   (((ip)->ip_vhl) & 0x0f)
 189 #define IP_V(ip)    (((ip)->ip_vhl) >> 4)
 190
 191 /* TCP header */
 192 typedef u_int tcp_seq;
 193
 194 struct sniff_tcp {
 195   u_short th_sport; /* source port */
 196   u_short th_dport; /* destination port */
 197   tcp_seq th_seq; /* sequence number */
 198   tcp_seq th_ack; /* acknowledgement number */
 199   u_char th_offx2; /* data offset, rsvd */
 200 #define TH_OFF(th)  (((th)->th_offx2 & 0xf0) >> 4)
 201   u_char th_flags;
 202 #define TH_FIN 0x01
 203 #define TH_SYN 0x02
 204 #define TH_RST 0x04
 205 #define TH_PUSH 0x08
 206 #define TH_ACK 0x10
 207 #define TH_URG 0x20
 208 #define TH_ECE 0x40
 209 #define TH_CWR 0x80
 210 #define TH_FLAGS (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)
 211   u_short th_win; /* window */
 212   u_short th_sum; /* checksum */
 213   u_short th_urp; /* urgent pointer */
 214 };
 215
 216 // Payload extraction /////////////////////////////////////////////////////////////////////////////////////
 217 u_char *getPayload(const u_char* packet, int packetSize, int &payloadSize,
 218                    std::string &srcIp, std::string &dstIp, int &fragmentId, bool &dfFlag,
 219                    bool &mfFlag, int &fragmentOffset) {
 220   const struct sniff_ethernet *ethernet; /* The ethernet header */
 221   const struct sniff_ip *ip; /* The IP header */
 222   const struct sniff_tcp *tcp; /* The TCP header */
 223   u_int size_ip;
 224   u_int size_tcp;
 225   ethernet = (struct sniff_ethernet*)(packet);
 226   ip = (struct sniff_ip*)(packet + SIZE_ETHERNET);
 227   size_ip = IP_HL(ip) * 4; // 4 bytes per 32 bits word
 228
 229   if(size_ip < 20) {
 230     LOGDEBUG(
 231       Logger::debug(anna::functions::asString("Invalid IP header length: %d bytes", size_ip), ANNA_FILE_LOCATION));
 232     return NULL;
 233   }
 234
 235   static char str[INET_ADDRSTRLEN];
 236   inet_ntop(AF_INET, &(ip->ip_src), str, INET_ADDRSTRLEN);
 237   srcIp = str;
 238   inet_ntop(AF_INET, &(ip->ip_dst), str, INET_ADDRSTRLEN);
 239   dstIp = str;
 240   LOGDEBUG(
 241     Logger::debug(anna::functions::asString("ip_id: %d | ip_off: %d", ip->ip_id, ip->ip_off), ANNA_FILE_LOCATION));
 242   fragmentId = ip->ip_id;
 243   dfFlag = IP_DF_VAL(ip);
 244   mfFlag = IP_MF_VAL(ip);
 245   fragmentOffset = IP_OFF(ip);
 246   tcp = (struct sniff_tcp*)(packet + SIZE_ETHERNET + size_ip);
 247   size_tcp = TH_OFF(tcp) * 4;
 248
 249   if(size_tcp < 20) {
 250     LOGDEBUG(
 251       Logger::debug(anna::functions::asString("Invalid TCP header length: %d bytes", size_tcp), ANNA_FILE_LOCATION));
 252     return NULL;
 253   }
 254
 255   int payloadOffset = SIZE_ETHERNET + size_ip + size_tcp;
 256   LOGDEBUG(
 257     Logger::debug(anna::functions::asString("PayloadOffset=%d", payloadOffset), ANNA_FILE_LOCATION));
 258   payloadSize = packetSize - payloadOffset;
 259   return ((u_char *)(packet + payloadOffset));
 260 }
 261
 262 // Sniffing callback //////////////////////////////////////////////////////////////////////////////////////
 263 void my_callback(u_char *useless, const struct pcap_pkthdr* pkthdr,
 264                  const u_char* packet) {
 265   static int count = 1;
 266   static Payload auxPayload;
 267   int packetSize = pkthdr->len;
 268   int payloadSize;
 269   std::string srcIp, dstIp;
 270   int fragmentId, fragmentOffset;
 271   bool dfFlag, mfFlag;
 272   const u_char* payload = getPayload(packet, packetSize, payloadSize, srcIp,
 273                                      dstIp, fragmentId, dfFlag, mfFlag, fragmentOffset);
 274
 275   if(payload && (payloadSize > 0)) {
 276     LOGDEBUG(
 277       std::string msg; msg += anna::functions::asString("\nFrame %d:", count); msg += anna::functions::asHexString(anna::DataBlock((const char *)packet, pkthdr->len)); time_t time = pkthdr->ts.tv_sec; msg += "\n"; msg += anna::functions::asString("\ntimestamp %d.%d", pkthdr->ts.tv_sec, pkthdr->ts.tv_usec); msg += anna::functions::asString("\ndate %s", ctime(&time)); msg += anna::functions::asString("\ncaplen %d", pkthdr->caplen); msg += anna::functions::asString("\npacketSize %d", packetSize); msg += anna::functions::asString("\npayloadSize %d", payloadSize); msg += "\nPayload:"; msg += anna::functions::asHexString(anna::DataBlock((const char *)payload, payloadSize)); msg += "\n"; msg += anna::functions::asString("\nsourceIP %s", srcIp.c_str()); msg += anna::functions::asString("\ndestinationIP %s", dstIp.c_str()); msg += "\n"; msg += anna::functions::asString("\nfragmentId %d:", fragmentId); msg += anna::functions::asString("\nDF %s:", (dfFlag ? "1" : "0")); msg += anna::functions::asString("\nMF %s:", (mfFlag ? "1" : "0")); msg += anna::functions::asString("\nfragmentOffset %d:", fragmentOffset);
 278       Logger::debug(msg, ANNA_FILE_LOCATION););
 279     auxPayload.setDiameterLength(
 280       (payload[1] << 16) + (payload[2] << 8) + payload[3]);
 281     auxPayload.setSourceIP(srcIp);
 282     auxPayload.setDestinationIP(dstIp);
 283     auxPayload.setTimestamp(pkthdr->ts.tv_sec);
 284     auxPayload.setTimestampU(pkthdr->ts.tv_usec);
 285     bool completed = auxPayload.appendData((const char *) payload, payloadSize);
 286
 287     if(completed) {
 288       G_payloads[count] = auxPayload;
 289       auxPayload.reset();
 290     }
 291   }
 292
 293   count++;
 294 }
 295
 296 bool getDataBlockFromHexFile(const std::string &pathfile, anna::DataBlock &db) throw() {
 297   // Get hex string
 298   static char buffer[8192];
 299   std::ifstream infile(pathfile.c_str(), std::ifstream::in);
 300
 301   if(infile.is_open()) {
 302     infile >> buffer;
 303     std::string hexString(buffer, strlen(buffer));
 304     // Allow colon separator in hex string: we have to remove them before processing with 'fromHexString':
 305     hexString.erase(std::remove(hexString.begin(), hexString.end(), ':'), hexString.end());
 306     LOGDEBUG(
 307       std::string msg = "Hex string (remove colons if exists): ";
 308       msg += hexString;
 309       anna::Logger::debug(msg, ANNA_FILE_LOCATION);
 310     );
 311     anna::functions::fromHexString(hexString, db);
 312     // Close file
 313     infile.close();
 314     return true;
 315   }
 316
 317   return false;
 318 }
 319
 320
 321 void _exit(const std::string &message, int resultCode = 1) {
 322   if(resultCode)
 323     std::cerr << message << std::endl << std::endl;
 324   else
 325     std::cout << message << std::endl << std::endl;
 326
 327   exit(resultCode);
 328 }
 329
 330 // Decodes a diameter message coming from a datablock
 331 void decodeDataBlock(const anna::DataBlock &db, unsigned int & detectedApplicationId) throw() {
 332   try {
 333     detectedApplicationId = anna::diameter::codec::functions::getApplicationId(db);
 334     G_codecEngine->setDictionary(detectedApplicationId);
 335     G_codecMsg.decode(db);
 336   } catch(RuntimeException &ex) {
 337     _exit(ex.asString());
 338   }
 339 }
 340
 341
 342 //-------------------------------------------------------------------
 343 int main(int argc, char **argv) {
 344   std::string exec = argv[0];
 345   std::string execBN = exec.substr(exec.find_last_of("/") + 1);
 346   std::string filetrace = execBN + ".trace";
 347   std::cout << std::endl;
 348
 349   //check command line arguments
 350   if(argc < 3) {
 351     std::string msg = "Usage: "; msg += exec;
 352     msg += " <stacks> <input file> [--no-validation] [--ignore-flags] [--debug]\n\n";
 353     msg += "       stacks:                  <id1,dictionary1#id2,dictionary2#...#idN,dictionaryN>\n";
 354     msg += "                                This is a list of #-separated stacks defined by a comma-separated pair <application-id,xml dictionary pathfile>\n";
 355     msg += "                                If only one stack is provided, application-id could be omitted and then, all the messages will be decoded with the\n";
 356     msg += "                                dictionary regardless the value of the application-id (the stack will be registered with id=0).\n";
 357     msg += "       Input file:              normally a pcap file, but hexadecimal content (colons allowed) can also be decoded (use '.hex' extension).\n";
 358     msg += "       --no-validation:         no validation is performed.\n";
 359     msg += "       --ignore-flags:          wrong flags regarding dictionary are ignored in xml representation.\n";
 360     msg += "       --debug:                 activates debug level traces (warning by default).";
 361     _exit(msg);
 362   }
 363
 364   // Command-line parameters:
 365   std::string stacks = argv[1];
 366   std::string inputFile = argv[2];
 367   bool isHex = (inputFile.substr(inputFile.find_last_of(".") + 1) == "hex");
 368   std::string outputFile = inputFile; // extension will be added later
 369   std::string optionals;
 370   int indx = 3;
 371
 372   while(indx < argc) { optionals += " "; optionals += argv[indx]; indx++; }
 373
 374   bool no_validation = (optionals.find("--no-validation") != std::string::npos);
 375   bool ignore_flags = (optionals.find("--ignore-flags") != std::string::npos);
 376   bool debug = (optionals.find("--debug") != std::string::npos);
 377   Logger::setLevel(debug ? Logger::Debug:Logger::Warning);
 378   Logger::initialize(execBN.c_str(), new TraceWriter(filetrace.c_str(), 2048000));
 379   G_codecEngine = new anna::diameter::codec::Engine();
 380   anna::diameter::stack::Engine &stackEngine =
 381     anna::diameter::stack::Engine::instantiate();
 382
 383   // Register stacks:
 384   try {
 385     anna::Tokenizer stacksTok;
 386     stacksTok.apply(stacks, "#");
 387     anna::Tokenizer::const_iterator stacks_it, stack_it;
 388
 389     for(stacks_it = stacksTok.begin(); stacks_it != stacksTok.end(); stacks_it++) {
 390       std::string stack = anna::Tokenizer::data(stacks_it);
 391       anna::Tokenizer stackTok;
 392       stackTok.apply(stack, ",");
 393
 394       if(stackTok.size() == 1) {
 395         if(stacksTok.size() != 1)
 396           throw anna::RuntimeException("Application Id value is mandatory when more than one stack is going to be configured", ANNA_FILE_LOCATION);
 397
 398         anna::diameter::stack::Dictionary * d = stackEngine.createDictionary(0 /* no matter */, stack); // the stack is the dictionary
 399         G_codecEngine->setDictionary(d);
 400         break;
 401       }
 402
 403       if(stackTok.size() != 2)
 404         throw anna::RuntimeException("Each stack must be in the form '<application-id>#<xml dictionary pathfile>'", ANNA_FILE_LOCATION);
 405
 406       stack_it = stackTok.begin();
 407       unsigned int stackId = atoll(anna::Tokenizer::data(stack_it));
 408       stack_it++;
 409       std::string file = anna::Tokenizer::data(stack_it);
 410       anna::diameter::stack::Dictionary * d = stackEngine.createDictionary(stackId, file);
 411     }
 412
 413     std::cout << "Stacks provided:          " << std::endl;
 414     std::cout << anna::functions::tab(stackEngine.asString(false /* light */));
 415     std::cout << std::endl;
 416     std::cout << "Input file provided:      " << inputFile << std::endl;
 417     std::cout << "Validation:               " << (!no_validation ? "yes" : "no") << std::endl;
 418     std::cout << "Ignore Flags:             " << (ignore_flags ? "yes" : "no") << std::endl;
 419     std::cout << std::endl;
 420   } catch(anna::RuntimeException &ex) {
 421     _exit(ex.asString());
 422   }
 423
 424   // Validation kindness
 425   G_codecEngine->setValidationDepth(anna::diameter::codec::EngineImpl::ValidationDepth::Complete); // complete validation for better reports
 426   if(no_validation) G_codecEngine->setValidationMode(anna::diameter::codec::EngineImpl::ValidationMode::Never);
 427
 428   if(ignore_flags) G_codecEngine->ignoreFlagsOnValidation(true);
 429
 430   // Tracing:
 431   //if (cl.exists("trace"))
 432   //   anna::Logger::setLevel(anna::Logger::asLevel(cl.getValue("trace")));
 433   // Check hex content input file (look extension):
 434   anna::DataBlock db_aux(true);
 435   unsigned int detectedApplicationId;
 436
 437   if(isHex) {
 438     if(!getDataBlockFromHexFile(inputFile, db_aux))
 439       _exit("Error reading hex file provided");
 440
 441     // Decode datablock:
 442     decodeDataBlock(db_aux, detectedApplicationId);
 443     // Open output file:
 444     outputFile += ".as.xml";
 445     std::ofstream out(outputFile.c_str(), std::ifstream::out);
 446     out << G_codecMsg.asXMLString();
 447     // Close output file:
 448     out.close();
 449     std::string msg = "Open '"; msg += filetrace; msg += "' in order to see process traces.\n";
 450     msg += "Open '"; msg += outputFile; msg += "' to see decoding results.";
 451     _exit(msg, 0);
 452   }
 453
 454   // Normal input: pcap file:
 455   // SNIFFING //////////////////////////////////////////////////////////////////////////////////////////////7
 456   //temporary packet buffers
 457   struct pcap_pkthdr header; // The header that pcap gives us
 458   const u_char *packet;      // The actual packet
 459   //------------------
 460   //open the pcap file
 461   pcap_t *handle;
 462   char errbuf[PCAP_ERRBUF_SIZE];        //not sure what to do with this, oh well
 463   handle = pcap_open_offline(inputFile.c_str(), errbuf); //call pcap library function
 464
 465   if(handle == NULL) _exit(errbuf, 2);
 466
 467   //begin processing the packets in this particular file
 468   int packets = -1;
 469
 470   try {
 471     while(packets != 0)
 472       packets = pcap_dispatch(handle, -1, (pcap_handler) my_callback, NULL);
 473   } catch(RuntimeException &ex) {
 474     _exit(ex.asString());
 475   }
 476
 477   pcap_close(handle);  //close the pcap file
 478   // Print payloads //////////////////////////////////////////////////////////////////////////////////////////////
 479   // Open output file:
 480   outputFile += ".report";
 481   std::ofstream out(outputFile.c_str(), std::ifstream::out);
 482
 483   for(payloads_it it = G_payloads.begin(); it != G_payloads.end(); it++) {
 484     LOGDEBUG(
 485       Logger::debug(anna::functions::asString("Dumping frame %d", it->first), ANNA_FILE_LOCATION));
 486     time_t ts = (it->second).getTimestamp();
 487     int tsu = (it->second).getTimestampU();
 488     std::string ts_str = ctime(&ts);
 489     ts_str.erase(ts_str.find("\n"));
 490     out << std::endl;
 491     out
 492         << "==================================================================================================="
 493         << std::endl;
 494     out << "Date:            " << ts_str << std::endl;
 495     out << "Timestamp:       " << anna::functions::asString((int)ts) << "."
 496         << anna::functions::asString((int)tsu) << std::endl;
 497     out << "Origin IP:       " << (it->second).getSourceIP() << std::endl;
 498     out << "Destination IP:  " << (it->second).getDestinationIP() << std::endl;
 499     // decode hex string:
 500     anna::functions::fromHexString((it->second).getDataAsHex(), db_aux);
 501     // Decode datablock:
 502     decodeDataBlock(db_aux, detectedApplicationId);
 503     // Stack identification:
 504     //out << "Application Id:  " << detectedApplicationId << std::endl;
 505     out << "Dictionary used: " << G_codecEngine->getDictionary()->getName() << std::endl;
 506     out << std::endl;
 507     out << G_codecMsg.asXMLString();
 508   }
 509
 510   // Close output file:
 511   out.close();
 512   std::string msg = "Open '"; msg += filetrace; msg += "' in order to see process traces.\n";
 513   msg += "Open '"; msg += outputFile; msg += "' to see decoding results.";
 514   _exit(msg, 0);
 515 }
 516