bjdwp/utils/codinfo.cc

   1 /**
   2  * @file 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 <iostream>
  36 #include <sstream>
  37 #include <iomanip>
  38
  39 #include <sys/types.h>
  40 #include <dirent.h>
  41 #include <string.h>
  42
  43 #include "parser.h"
  44 #include "codinfo.h"
  45
  46
  47 using namespace std;
  48
  49
  50 namespace Barry {
  51
  52 namespace JDG {
  53
  54
  55 // Public API
  56 //------------
  57
  58 #define DEBUG_FILE_EXT          ".debug"
  59
  60
  61 void searchDebugFile(JDGDebugFileList &list)
  62 {
  63         DIR *path;
  64         struct dirent *entry;
  65
  66         path = opendir(".");
  67
  68         while (entry = readdir(path)) {
  69                 int offset;
  70
  71                 if (strlen(entry->d_name) < strlen(DEBUG_FILE_EXT))
  72                         continue;
  73
  74                 offset = strlen(entry->d_name) - strlen(DEBUG_FILE_EXT);
  75
  76                 if (!strcmp(entry->d_name + offset, DEBUG_FILE_EXT)) {
  77                         ifstream file(entry->d_name);
  78
  79                         JDGCodInfo info;
  80
  81                         // Parse header section
  82                         info.parseHeaderSection(file);
  83
  84                         // Add element to list
  85                         list.AddElement(info.getUniqueId(), info.getAppName(), entry->d_name);
  86                 }
  87         }
  88
  89         closedir(path);
  90 }
  91
  92
  93 bool loadDebugInfo(JDGDebugFileList &list, const char *filename, JDGCodInfo &info)
  94 {
  95         if (filename == NULL)
  96                 return false;
  97
  98         vector<JDGDebugFileEntry>::iterator b = list.begin();
  99
 100         for( ; b != list.end(); b++ ) {
 101                 JDGDebugFileEntry entry = (*b);
 102
 103                 if (entry.fileName == string(filename)) {
 104                         info.loadDebugFile(filename);
 105                         return true;
 106                 }
 107         }
 108
 109         return false;
 110 }
 111
 112
 113 bool loadDebugInfo(JDGDebugFileList &list, const uint32_t uniqueId, const std::string module, JDGCodInfo &info)
 114 {
 115         vector<JDGDebugFileEntry>::iterator b = list.begin();
 116
 117         for( ; b != list.end(); b++ ) {
 118                 JDGDebugFileEntry entry = (*b);
 119
 120                 if ((entry.uniqueId == uniqueId) && (entry.appName == module)) {
 121                         info.loadDebugFile(entry.fileName.c_str());
 122                         return true;
 123                 }
 124         }
 125
 126         return false;
 127 }
 128
 129
 130 // JDGDebugFileList class
 131 //------------------------
 132
 133 void JDGDebugFileList::AddElement(uint32_t uniqueid, std::string appname, std::string filename)
 134 {
 135         JDGDebugFileEntry entry;
 136
 137         entry.uniqueId = uniqueid;
 138         entry.appName = appname;
 139         entry.fileName = filename;
 140
 141         push_back(entry);
 142 }
 143
 144
 145 void JDGDebugFileList::Dump(std::ostream &os) const
 146 {
 147         const_iterator i = begin(), e = end();
 148
 149         os << "  UniqueID  " << "|";
 150         os << "        Module Name       " << "|";
 151         os << "         File Name        " << endl;
 152
 153         os << "------------+";
 154         os << "--------------------------+";
 155         os << "--------------------------";
 156         os << endl;
 157
 158         for( ; i != e; ++i ) {
 159                 (*i).Dump(os);
 160         }
 161 }
 162
 163
 164 void JDGDebugFileEntry::Dump(std::ostream &os) const
 165 {
 166         os << " 0x" << setfill('0') << setw(8) << hex << uniqueId << " |";
 167         os << " " << appName << setfill(' ') << setw(24) << " |";
 168         os << " " << fileName << endl;
 169 }
 170
 171
 172 // JDGClassList class
 173 //---------------------------
 174
 175
 176 void JDGClassList::createDefaultEntries() {
 177         JDGClassEntry entry;
 178
 179         // 1
 180         entry.classPath = "com.rim.resources";
 181         entry.className = "net_rim_rimsecuridlibRIMResources";
 182         push_back(entry);
 183
 184         // 2
 185         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 186         entry.className = "RimSecurIDLib";
 187         push_back(entry);
 188
 189         // 3
 190         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 191         entry.className = "RimDatabaseFullException";
 192         push_back(entry);
 193
 194         // 4
 195         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 196         entry.className = "RimDecryptFailException";
 197         push_back(entry);
 198
 199         // 5
 200         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 201         entry.className = "RimDuplicateNameException";
 202         push_back(entry);
 203
 204         // 6
 205         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 206         entry.className = "RimDuplicateTokenException";
 207         push_back(entry);
 208
 209         // 7
 210         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 211         entry.className = "RimInvalidParamException";
 212         push_back(entry);
 213
 214         // 8
 215         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 216         entry.className = "RimSecurIDLib";
 217         push_back(entry);
 218
 219         // 9
 220         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 221         entry.className = "RimWrongDeviceIDException";
 222         push_back(entry);
 223
 224         // 10
 225         entry.classPath = "net.rim.device.cldc.impl.softtoken.rimsecuridlib";
 226         entry.className = "RimWrongFormFactorException";
 227         push_back(entry);
 228 }
 229
 230
 231 // JDGCodInfo class
 232 //------------------------
 233
 234 bool JDGCodInfo::loadDebugFile(const char *filename)
 235 {
 236         if (filename == NULL)
 237                 return false;
 238
 239         ifstream file(filename);
 240
 241         // Parse header file
 242         parseHeaderSection(file);
 243
 244         // Parse type area zone
 245         parseTypeSection(file);
 246
 247         return true;
 248 }
 249
 250
 251 uint32_t JDGCodInfo::getUniqueId()
 252 {
 253         return uniqueId;
 254 }
 255
 256
 257 string JDGCodInfo::getAppName()
 258 {
 259         return appName;
 260 }
 261
 262
 263 // Private API - Section parsing
 264 //-------------------------------
 265
 266 void JDGCodInfo::parseHeaderSection(ifstream &input)
 267 {
 268         uint32_t type;
 269
 270         type = parseNextHeaderField(input);
 271
 272         if (type != COD_DEBUG_UNIQUEID_HEADERFIELD)
 273                 return;
 274
 275         type = parseNextHeaderField(input);
 276
 277         if (type != COD_DEBUG_APPNAME_HEADERFIELD)
 278                 return;
 279 }
 280
 281
 282 void JDGCodInfo::parseTypeSection(ifstream &input)
 283 {
 284         uint32_t type;
 285         uint32_t count;
 286         uint32_t nbr, check;
 287
 288         // Read number of declared type content into this section
 289         nbr = ParseInteger(input);
 290
 291         // Read each object
 292         count = 0;
 293
 294         while (!input.eof()) {
 295                 type = parseNextTypeField(input);
 296
 297                 if (type == COD_DEBUG_NONE_FIELD)
 298                         break;
 299
 300                 count++;
 301         }
 302
 303         // Read again number of declared type content into this section
 304         // We have to find the same value
 305         check = ParseInteger(input);
 306
 307         // Checking...
 308         cout << "Nbr = " << dec << nbr << " / Count = " << dec << count << " / check = " << check << endl;
 309 }
 310
 311
 312 uint32_t JDGCodInfo::parseNextHeaderField(ifstream &input)
 313 {
 314         uint32_t type = ParseInteger(input);
 315
 316         switch (type) {
 317         case COD_DEBUG_UNIQUEID_HEADERFIELD:
 318                 parseUniqueId(input);
 319                 break;
 320
 321         case COD_DEBUG_APPNAME_HEADERFIELD:
 322                 parseAppName(input);
 323                 break;
 324
 325         default:
 326                 type = 0xFFFFFFFF;
 327         }
 328
 329         return type;
 330 }
 331
 332
 333 uint32_t JDGCodInfo::parseNextTypeField(ifstream &input)
 334 {
 335         uint32_t type = ParseInteger(input);
 336
 337         switch (type) {
 338         case COD_DEBUG_NONE_FIELD:
 339                 break;
 340
 341         case COD_DEBUG_BOOLEAN_FIELD:
 342                 parseBoolean(input);
 343                 break;
 344
 345         case COD_DEBUG_BYTE_FIELD:
 346                 parseByte(input);
 347                 break;
 348
 349         case COD_DEBUG_CHAR_FIELD:
 350                 parseChar(input);
 351                 break;
 352
 353         case COD_DEBUG_SHORT_FIELD:
 354                 parseShort(input);
 355                 break;
 356
 357         case COD_DEBUG_INT_FIELD:
 358                 parseInt(input);
 359                 break;
 360
 361         case COD_DEBUG_LONG_FIELD:
 362                 parseLong(input);
 363                 break;
 364
 365         case COD_DEBUG_CLASS_FIELD:
 366                 parseClass(input);
 367                 break;
 368
 369         case COD_DEBUG_ARRAY_FIELD:
 370                 parseArray(input);
 371                 break;
 372
 373         case COD_DEBUG_VOID_FIELD:
 374                 parseVoid(input);
 375                 break;
 376
 377         case COD_DEBUG_DOUBLE_FIELD:
 378                 parseDouble(input);
 379                 break;
 380
 381         default:
 382                 cout << "Type unknown ! " << hex << type << endl;
 383                 type = 0xFFFFFFFF;
 384         }
 385
 386         return type;
 387 }
 388
 389
 390 void JDGCodInfo::parseUniqueId(ifstream &input)
 391 {
 392         uniqueId = ParseInteger(input);
 393 }
 394
 395
 396 void JDGCodInfo::parseAppName(ifstream &input)
 397 {
 398         uint32_t len = ParseInteger(input);
 399
 400         appName = ParseString(input, len);
 401 }
 402
 403
 404 void JDGCodInfo::parseBoolean(ifstream &input)
 405 {
 406         uint32_t len  = ParseInteger(input);
 407
 408         string str = ParseString(input, len);
 409
 410         cout << "JDGCodInfo::parseBoolean" << endl;
 411         cout << "  name : " << str << endl;
 412 }
 413
 414
 415 void JDGCodInfo::parseByte(ifstream &input)
 416 {
 417         uint32_t len  = ParseInteger(input);
 418
 419         string str = ParseString(input, len);
 420
 421         cout << "JDGCodInfo::parseByte" << endl;
 422         cout << "  name : " << str << endl;
 423 }
 424
 425
 426 void JDGCodInfo::parseChar(ifstream &input)
 427 {
 428         uint32_t len  = ParseInteger(input);
 429
 430         string str = ParseString(input, len);
 431
 432         cout << "JDGCodInfo::parseChar" << endl;
 433         cout << "  name : " << str << endl;
 434 }
 435
 436
 437 void JDGCodInfo::parseShort(ifstream &input)
 438 {
 439         uint32_t len  = ParseInteger(input);
 440
 441         string str = ParseString(input, len);
 442
 443         cout << "JDGCodInfo::parseShort" << endl;
 444         cout << "  name : " << str << endl;
 445 }
 446
 447
 448 void JDGCodInfo::parseInt(ifstream &input)
 449 {
 450         uint32_t len  = ParseInteger(input);
 451
 452         string str = ParseString(input, len);
 453
 454         cout << "JDGCodInfo::parseInt" << endl;
 455         cout << "  name : " << str << endl;
 456 }
 457
 458
 459 void JDGCodInfo::parseLong(ifstream &input)
 460 {
 461         uint32_t len  = ParseInteger(input);
 462
 463         string str = ParseString(input, len);
 464
 465         cout << "JDGCodInfo::parseLong" << endl;
 466         cout << "  name : " << str << endl;
 467 }
 468
 469
 470 void JDGCodInfo::parseClass(ifstream &input)
 471 {
 472         uint32_t len;
 473
 474         JDGClassEntry object;
 475
 476         cout << "JDGCodInfo::parseClass" << endl;
 477
 478         len  = ParseInteger(input);
 479
 480         object.className = ParseString(input, len);
 481
 482         object.type = ParseInteger(input);
 483         object.unknown02 = ParseInteger(input);
 484         object.unknown03 = ParseInteger(input);
 485         object.id = ParseInteger(input);
 486
 487         len  = ParseInteger(input);
 488
 489         if (len == 0)
 490                 object.classPath = "com.barry." + appName;
 491         else if (len != 0xFFFFFF)
 492                 object.classPath = ParseString(input, len);
 493
 494         len  = ParseInteger(input);
 495
 496         object.sourceFile = ParseString(input, len);
 497
 498         object.unknown05 = ParseInteger(input);
 499         object.unknown06 = ParseInteger(input);
 500         object.unknown07 = ParseInteger(input);
 501         object.unknown08 = ParseInteger(input);
 502
 503         classList.push_back(object);
 504
 505         cout << "  name : " << object.className << endl;
 506         cout << "  path : " << object.classPath << endl;
 507         cout << "  type : " << hex << object.type << endl;
 508         cout << "  unknown02 : " << hex << object.unknown02 << endl;
 509         cout << "  unknown03 : " << hex << object.unknown03 << endl;
 510         cout << "  id : " << hex << object.id << endl;
 511         cout << "  source file : " << object.sourceFile << endl;
 512         cout << "  unknown05 : " << hex << object.unknown05 << endl;
 513         cout << "  unknown06 : " << hex << object.unknown06 << endl;
 514         cout << "  unknown07 : " << hex << object.unknown07 << endl;
 515         cout << "  unknown08 : " << hex << object.unknown08 << endl;
 516 }
 517
 518
 519 void JDGCodInfo::parseArray(ifstream &input)
 520 {
 521         uint32_t len  = ParseInteger(input);
 522
 523         string str = ParseString(input, len);
 524
 525         cout << "JDGCodInfo::parseArray" << endl;
 526         cout << "  name : " << str << endl;
 527 }
 528
 529
 530 void JDGCodInfo::parseVoid(ifstream &input)
 531 {
 532         uint32_t len  = ParseInteger(input);
 533
 534         string str = ParseString(input, len);
 535
 536         cout << "JDGCodInfo::parseVoid" << endl;
 537         cout << "  name : " << str << endl;
 538 }
 539
 540
 541 void JDGCodInfo::parseDouble(ifstream &input)
 542 {
 543         uint32_t len  = ParseInteger(input);
 544
 545         string str = ParseString(input, len);
 546
 547         cout << "JDGCodInfo::parseDouble" << endl;
 548         cout << "  name : " << str << endl;
 549 }
 550
 551 /*
 552 void JDGCodInfo::parseType2(ifstream &input) {
 553         uint32_t value;
 554         uint32_t len  = ParseInteger(input);
 555
 556         string str = ParseString(input, len);
 557
 558         cout << "Type2 : " << str << endl;
 559
 560         value = ParseInteger(input);
 561         value = ParseInteger(input);
 562         value = ParseInteger(input);
 563         value = ParseInteger(input);
 564         value = ParseInteger(input);
 565         value = ParseInteger(input);
 566 }
 567 */
 568 } // namespace JDG
 569
 570 } // namespace Barry
 571