src/dp_codinfo.cc

   1 /**
   2  * @file dp_codinfo.cc
   3  * @author Nicolas VIVIEN
   4  * @date 2009-08-01
   5  *
   6  * @note CopyRight Nicolas VIVIEN
   7  *
   8  * @brief COD debug file parser
   9  *   RIM's JDE generates several files when you build a COD application.
  10  *   Indeed, with the COD files for the device, we have a ".debug" file.
  11  *   This file is usefull to debug an application from JVM.
  12  *   This tool is a parser to understand these ".debug" files.
  13  *
  14  * @par Modifications
  15  *   - 2009/08/01 : N. VIVIEN
  16  *     - First release
  17  *
  18  * @par Licences
  19  *   Copyright (C) 2009-2010, Nicolas VIVIEN
  20  *
  21  *   This program is free software; you can redistribute it and/or modify
  22  *   it under the terms of the GNU General Public License as published by
  23  *   the Free Software Foundation; either version 2 of the License, or
  24  *   (at your option) any later version.
  25  *
  26  *   This program is distributed in the hope that it will be useful,
  27  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  28  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  29  *
  30  *   See the GNU General Public License in the COPYING file at the
  31  *   root directory of this project for more details.
  32  */
  33
  34
  35 #include <fstream>
  36 #include <iomanip>
  37
  38 #include <sys/types.h>
  39 #include <dirent.h>
  40 #include <string.h>
  41
  42 #include "dp_parser.h"
  43 #include "dp_codinfo.h"
  44 #include "debug.h"
  45
  46
  47 #define COD_DEBUG_APPNAME_HEADERFIELD           0x0
  48 #define COD_DEBUG_UNIQUEID_HEADERFIELD          0x8
  49
  50 #define COD_DEBUG_NONE_FIELD                    0x0
  51 #define COD_DEBUG_BOOLEAN_FIELD                 0x1
  52 #define COD_DEBUG_BYTE_FIELD                    0x2
  53 #define COD_DEBUG_CHAR_FIELD                    0x3
  54 #define COD_DEBUG_SHORT_FIELD                   0x4
  55 #define COD_DEBUG_INT_FIELD                     0x5
  56 #define COD_DEBUG_LONG_FIELD                    0x6
  57 #define COD_DEBUG_CLASS_FIELD                   0x7
  58 #define COD_DEBUG_ARRAY_FIELD                   0x8
  59 #define COD_DEBUG_VOID_FIELD                    0xA
  60 #define COD_DEBUG_DOUBLE_FIELD                  0xC
  61
  62
  63 using namespace std;
  64
  65
  66 namespace Barry {
  67
  68 namespace JDG {
  69
  70
  71 // Public API
  72 //------------
  73
  74 #define DEBUG_FILE_EXT          ".debug"
  75
  76
  77 void SearchDebugFile(DebugFileList &list)
  78 {
  79         DIR *path;
  80         struct dirent *entry;
  81
  82         path = opendir(".");
  83
  84         while( (entry = readdir(path)) ) {
  85                 int offset;
  86
  87                 if (strlen(entry->d_name) < strlen(DEBUG_FILE_EXT))
  88                         continue;
  89
  90                 offset = strlen(entry->d_name) - strlen(DEBUG_FILE_EXT);
  91
  92                 if (!strcmp(entry->d_name + offset, DEBUG_FILE_EXT)) {
  93                         ifstream file(entry->d_name);
  94
  95                         CodInfo info;
  96
  97                         // Parse header section
  98                         info.ParseHeaderSection(file);
  99
 100                         // Add element to list
 101                         list.AddElement(info.GetUniqueId(), info.GetAppName(), entry->d_name);
 102                 }
 103         }
 104
 105         closedir(path);
 106 }
 107
 108
 109 bool LoadDebugInfo(const DebugFileList &list, const char *filename, CodInfo &info)
 110 {
 111         if (filename == NULL)
 112                 return false;
 113
 114         DebugFileList::const_iterator b = list.begin();
 115
 116         for( ; b != list.end(); b++ ) {
 117                 const DebugFileEntry &entry = (*b);
 118
 119                 if( entry.fileName == filename ) {
 120                         info.LoadDebugFile(filename);
 121                         return true;
 122                 }
 123         }
 124
 125         return false;
 126 }
 127
 128
 129 bool LoadDebugInfo(const DebugFileList &list, const uint32_t uniqueId, const std::string module, CodInfo &info)
 130 {
 131         DebugFileList::const_iterator b = list.begin();
 132
 133         for( ; b != list.end(); b++ ) {
 134                 const DebugFileEntry &entry = (*b);
 135
 136                 if ((entry.uniqueId == uniqueId) && (entry.appName == module)) {
 137                         info.LoadDebugFile(entry.fileName.c_str());
 138                         return true;
 139                 }
 140         }
 141
 142         return false;
 143 }
 144
 145
 146 // DebugFileList class
 147 //------------------------
 148
 149 void DebugFileList::AddElement(uint32_t uniqueid,
 150                                 const std::string &appname,
 151                                 const std::string &filename)
 152 {
 153         DebugFileEntry entry;
 154
 155         entry.uniqueId = uniqueid;
 156         entry.appName = appname;
 157         entry.fileName = filename;
 158
 159         push_back(entry);
 160 }
 161
 162
 163 void DebugFileList::Dump(std::ostream &os) const
 164 {
 165         const_iterator i = begin(), e = end();
 166
 167         os << "  UniqueID  " << "|";
 168         os << "        Module Name       " << "|";
 169         os << "         File Name        " << endl;
 170
 171         os << "------------+";
 172         os << "--------------------------+";
 173         os << "--------------------------";
 174         os << endl;
 175
 176         for( ; i != e; ++i ) {
 177                 (*i).Dump(os);
 178         }
 179 }
 180
 181
 182 void DebugFileEntry::Dump(std::ostream &os) const
 183 {
 184         os << " 0x" << setfill('0') << setw(8) << hex << uniqueId << " |";
 185         os << " " << appName << setfill(' ') << setw(24) << " |";
 186         os << " " << fileName << endl;
 187 }
 188
 189
 190 // ClassList class
 191 //---------------------------
 192
 193
 194 void ClassList::CreateDefaultEntries()
 195 {
 196         ClassEntry entry;
 197
 198         // 1
 199         entry.classPath = "com.rim.resources";
 200         entry.className = "net_rim_rimsecuridlibRIMResources";
 201         push_back(entry);
 202
 203         // 2
 204         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 205         entry.className = "RimSecurIDLib";
 206         push_back(entry);
 207
 208         // 3
 209         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 210         entry.className = "RimDatabaseFullException";
 211         push_back(entry);
 212
 213         // 4
 214         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 215         entry.className = "RimDecryptFailException";
 216         push_back(entry);
 217
 218         // 5
 219         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 220         entry.className = "RimDuplicateNameException";
 221         push_back(entry);
 222
 223         // 6
 224         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 225         entry.className = "RimDuplicateTokenException";
 226         push_back(entry);
 227
 228         // 7
 229         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 230         entry.className = "RimInvalidParamException";
 231         push_back(entry);
 232
 233         // 8
 234         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 235         entry.className = "RimSecurIDLib";
 236         push_back(entry);
 237
 238         // 9
 239         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 240         entry.className = "RimWrongDeviceIDException";
 241         push_back(entry);
 242
 243         // 10
 244         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 245         entry.className = "RimWrongFormFactorException";
 246         push_back(entry);
 247 }
 248
 249
 250 // CodInfo class
 251 //------------------------
 252
 253 bool CodInfo::LoadDebugFile(const char *filename)
 254 {
 255         uint32_t field;
 256
 257         if (filename == NULL)
 258                 return false;
 259
 260         ifstream file(filename);
 261
 262         // Parse header file
 263         ParseHeaderSection(file);
 264
 265         // Parse type area zone
 266         ParseTypeSection(file);
 267
 268         // FIXME : ???
 269         field = ParseInteger(file); // Read 0x0
 270         field = ParseInteger(file); // Read 0x1
 271
 272         // FIXME : ???
 273         field = ParseInteger(file); // Read 0x0
 274         field = ParseInteger(file); // Read 0x0 or 0xA
 275
 276         if (field == 0xA) {
 277                 // Parse ressource area zone
 278                 ParseResourceSection(file);
 279         }
 280
 281         return true;
 282 }
 283
 284
 285 uint32_t CodInfo::GetUniqueId()
 286 {
 287         return uniqueId;
 288 }
 289
 290
 291 string CodInfo::GetAppName()
 292 {
 293         return appName;
 294 }
 295
 296
 297 // Private API - Section parsing
 298 //-------------------------------
 299
 300 void CodInfo::ParseHeaderSection(istream &input)
 301 {
 302         uint32_t type;
 303
 304         type = ParseNextHeaderField(input);
 305
 306         if (type != COD_DEBUG_UNIQUEID_HEADERFIELD)
 307                 return;
 308
 309         type = ParseNextHeaderField(input);
 310
 311         if (type != COD_DEBUG_APPNAME_HEADERFIELD)
 312                 return;
 313 }
 314
 315
 316 void CodInfo::ParseTypeSection(istream &input)
 317 {
 318         uint32_t type;
 319         uint32_t count;
 320         uint32_t nbr, check;
 321
 322         // Read number of declared type content into this section
 323         nbr = ParseInteger(input);
 324
 325         // Read each object
 326         count = 0;
 327
 328         while (!input.eof()) {
 329                 type = ParseNextTypeField(input);
 330
 331                 if (type == COD_DEBUG_NONE_FIELD)
 332                         break;
 333
 334                 count++;
 335         }
 336
 337         // Read again number of declared type content into this section
 338         // We have to find the same value
 339         check = ParseInteger(input);
 340
 341         // Checking...
 342         dout("Nbr = " << dec << nbr << " / Count = " << dec << count << " / check = " << check);
 343 }
 344
 345
 346 void CodInfo::ParseResourceSection(istream &input)
 347 {
 348         uint32_t len;
 349         uint32_t type;
 350         uint32_t unknown01;
 351         uint32_t unknown02;
 352         uint32_t unknown03;
 353         uint32_t unknown04;
 354         uint32_t unknown05;
 355         uint32_t unknown06;
 356         uint32_t unknown07;
 357
 358         string name;
 359
 360         // type = 1
 361         for (int i=0; i<10; i++) {
 362                 type = ParseInteger(input);
 363
 364                 len = ParseInteger(input);
 365                 name = ParseString(input, len);
 366
 367                 unknown01 = ParseInteger(input);
 368                 unknown02 = ParseInteger(input);
 369                 unknown03 = ParseInteger(input);
 370
 371                 dout("JDGCodInfo::parseRessource"
 372                         << "\n  Name : " << name
 373                         << "\n  unknown01 : " << hex << unknown01
 374                         << "\n  unknown02 : " << hex << unknown02
 375                         << "\n  unknown03 : " << hex << unknown03);
 376         }
 377
 378         // type = 2
 379         type = ParseInteger(input);
 380
 381         len = ParseInteger(input);
 382         name = ParseString(input, len);
 383
 384         unknown01 = ParseInteger(input);
 385         unknown02 = ParseInteger(input);
 386         unknown03 = ParseInteger(input);
 387         unknown04 = ParseInteger(input);
 388         unknown05 = ParseInteger(input);
 389         unknown06 = ParseInteger(input);
 390         unknown07 = ParseInteger(input);
 391
 392         dout("JDGCodInfo::parseRessource"
 393                 << "\n  Name : " << name
 394                 << "\n  unknown01 : " << hex << unknown01
 395                 << "\n  unknown02 : " << hex << unknown02
 396                 << "\n  unknown03 : " << hex << unknown03
 397                 << "\n  unknown04 : " << hex << unknown04
 398                 << "\n  unknown05 : " << hex << unknown05
 399                 << "\n  unknown06 : " << hex << unknown06
 400                 << "\n  unknown07 : " << hex << unknown07);
 401
 402         // type = 1
 403         type = ParseInteger(input);
 404
 405         len = ParseInteger(input);
 406         name = ParseString(input, len);
 407
 408         unknown01 = ParseInteger(input);
 409         unknown02 = ParseInteger(input);
 410         unknown03 = ParseInteger(input);
 411         unknown04 = ParseInteger(input);
 412
 413         dout("JDGCodInfo::parseRessource"
 414                 << "\n  Name : " << name
 415                 << "\n  unknown01 : " << hex << unknown01
 416                 << "\n  unknown02 : " << hex << unknown02
 417                 << "\n  unknown03 : " << hex << unknown03
 418                 << "\n  unknown04 : " << hex << unknown04);
 419
 420         // type = 0
 421         type = ParseInteger(input);
 422
 423         len = ParseInteger(input);
 424         name = ParseString(input, len);
 425
 426         unknown01 = ParseInteger(input);
 427         unknown02 = ParseInteger(input);
 428         unknown03 = ParseInteger(input);
 429         unknown04 = ParseInteger(input);
 430         unknown05 = ParseInteger(input);
 431
 432         dout("JDGCodInfo::parseRessource"
 433                 << "\n  Name : " << name
 434                 << "\n  unknown01 : " << hex << unknown01
 435                 << "\n  unknown02 : " << hex << unknown02
 436                 << "\n  unknown03 : " << hex << unknown03
 437                 << "\n  unknown04 : " << hex << unknown04
 438                 << "\n  unknown05 : " << hex << unknown05);
 439 }
 440
 441
 442
 443 // Private API - Field parsing
 444 //-------------------------------
 445
 446
 447 uint32_t CodInfo::ParseNextHeaderField(istream &input)
 448 {
 449         uint32_t type = ParseInteger(input);
 450
 451         switch (type) {
 452         case COD_DEBUG_UNIQUEID_HEADERFIELD:
 453                 ParseUniqueId(input);
 454                 break;
 455
 456         case COD_DEBUG_APPNAME_HEADERFIELD:
 457                 ParseAppName(input);
 458                 break;
 459
 460         default:
 461                 type = 0xFFFFFFFF;
 462         }
 463
 464         return type;
 465 }
 466
 467
 468 uint32_t CodInfo::ParseNextTypeField(istream &input)
 469 {
 470         uint32_t type = ParseInteger(input);
 471
 472         switch (type) {
 473         case COD_DEBUG_NONE_FIELD:
 474                 break;
 475
 476         case COD_DEBUG_BOOLEAN_FIELD:
 477                 ParseBoolean(input);
 478                 break;
 479
 480         case COD_DEBUG_BYTE_FIELD:
 481                 ParseByte(input);
 482                 break;
 483
 484         case COD_DEBUG_CHAR_FIELD:
 485                 ParseChar(input);
 486                 break;
 487
 488         case COD_DEBUG_SHORT_FIELD:
 489                 ParseShort(input);
 490                 break;
 491
 492         case COD_DEBUG_INT_FIELD:
 493                 ParseInt(input);
 494                 break;
 495
 496         case COD_DEBUG_LONG_FIELD:
 497                 ParseLong(input);
 498                 break;
 499
 500         case COD_DEBUG_CLASS_FIELD:
 501                 ParseClass(input);
 502                 break;
 503
 504         case COD_DEBUG_ARRAY_FIELD:
 505                 ParseArray(input);
 506                 break;
 507
 508         case COD_DEBUG_VOID_FIELD:
 509                 ParseVoid(input);
 510                 break;
 511
 512         case COD_DEBUG_DOUBLE_FIELD:
 513                 ParseDouble(input);
 514                 break;
 515
 516         default:
 517                 dout("Type unknown ! " << hex << type);
 518                 type = 0xFFFFFFFF;
 519         }
 520
 521         return type;
 522 }
 523
 524
 525 void CodInfo::ParseUniqueId(istream &input)
 526 {
 527         uniqueId = ParseInteger(input);
 528 }
 529
 530
 531 void CodInfo::ParseAppName(istream &input)
 532 {
 533         uint32_t len = ParseInteger(input);
 534
 535         appName = ParseString(input, len);
 536 }
 537
 538
 539 void CodInfo::ParseBoolean(istream &input)
 540 {
 541         uint32_t len  = ParseInteger(input);
 542
 543         string str = ParseString(input, len);
 544
 545         dout("JDG::CodInfo::ParseBoolean\n  name : " << str);
 546 }
 547
 548
 549 void CodInfo::ParseByte(istream &input)
 550 {
 551         uint32_t len  = ParseInteger(input);
 552
 553         string str = ParseString(input, len);
 554
 555         dout("JDG::CodInfo::ParseByte\n  name : " << str);
 556 }
 557
 558
 559 void CodInfo::ParseChar(istream &input)
 560 {
 561         uint32_t len  = ParseInteger(input);
 562
 563         string str = ParseString(input, len);
 564
 565         dout("JDG::CodInfo::ParseChar\n  name : " << str);
 566 }
 567
 568
 569 void CodInfo::ParseShort(istream &input)
 570 {
 571         uint32_t len  = ParseInteger(input);
 572
 573         string str = ParseString(input, len);
 574
 575         dout("JDG::CodInfo::ParseShort\n  name : " << str);
 576 }
 577
 578
 579 void CodInfo::ParseInt(istream &input)
 580 {
 581         uint32_t len  = ParseInteger(input);
 582
 583         string str = ParseString(input, len);
 584
 585         dout("JDG::CodInfo::ParseInt\n  name : " << str);
 586 }
 587
 588
 589 void CodInfo::ParseLong(istream &input)
 590 {
 591         uint32_t len  = ParseInteger(input);
 592
 593         string str = ParseString(input, len);
 594
 595         dout("JDG::CodInfo::ParseLong\n  name : " << str);
 596 }
 597
 598
 599 void CodInfo::ParseClass(istream &input)
 600 {
 601         uint32_t len;
 602
 603         ClassEntry object;
 604
 605         dout("JDG::CodInfo::ParseClass");
 606
 607         len  = ParseInteger(input);
 608
 609         object.className = ParseString(input, len);
 610
 611         object.type = ParseInteger(input);
 612         object.unknown02 = ParseInteger(input);
 613         object.unknown03 = ParseInteger(input);
 614         object.id = ParseInteger(input);
 615
 616         len  = ParseInteger(input);
 617
 618         if (len == 0)
 619                 object.classPath = "com.barry." + appName;
 620         else if (len != 0xFFFFFF)
 621                 object.classPath = ParseString(input, len);
 622
 623         len  = ParseInteger(input);
 624
 625         object.sourceFile = ParseString(input, len);
 626
 627         object.unknown05 = ParseInteger(input);
 628         object.unknown06 = ParseInteger(input);
 629         object.unknown07 = ParseInteger(input);
 630         object.unknown08 = ParseInteger(input);
 631
 632         classList.push_back(object);
 633
 634         dout("\n  name : " << object.className
 635                 << "\n  path : " << object.classPath
 636                 << "\n  type : " << hex << object.type
 637                 << "\n  unknown02 : " << hex << object.unknown02
 638                 << "\n  unknown03 : " << hex << object.unknown03
 639                 << "\n  id : " << hex << object.id
 640                 << "\n  source file : " << object.sourceFile
 641                 << "\n  unknown05 : " << hex << object.unknown05
 642                 << "\n  unknown06 : " << hex << object.unknown06
 643                 << "\n  unknown07 : " << hex << object.unknown07
 644                 << "\n  unknown08 : " << hex << object.unknown08);
 645 }
 646
 647
 648 void CodInfo::ParseArray(istream &input)
 649 {
 650         uint32_t len  = ParseInteger(input);
 651
 652         string str = ParseString(input, len);
 653
 654         dout("JDG::CodInfo::ParseArray\n  name : " << str);
 655 }
 656
 657
 658 void CodInfo::ParseVoid(istream &input)
 659 {
 660         uint32_t len  = ParseInteger(input);
 661
 662         string str = ParseString(input, len);
 663
 664         dout("JDG::CodInfo::ParseVoid\n  name : " << str);
 665 }
 666
 667
 668 void CodInfo::ParseDouble(istream &input)
 669 {
 670         uint32_t len  = ParseInteger(input);
 671
 672         string str = ParseString(input, len);
 673
 674         dout("JDG::CodInfo::ParseDouble\n  name : " << str);
 675 }
 676
 677 /*
 678 void CodInfo::ParseType2(istream &input) {
 679         uint32_t value;
 680         uint32_t len  = ParseInteger(input);
 681
 682         string str = ParseString(input, len);
 683
 684         dout("Type2 : " << str);
 685
 686         value = ParseInteger(input);
 687         value = ParseInteger(input);
 688         value = ParseInteger(input);
 689         value = ParseInteger(input);
 690         value = ParseInteger(input);
 691         value = ParseInteger(input);
 692 }
 693 */
 694 } // namespace JDG
 695
 696 } // namespace Barry
 697