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