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