src/m_jvmdebug.cc

   1 ///
   2 /// \file       m_jvmdebug.cc
   3 ///             Mode class for the JVMDebug mode
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2013, Net Direct Inc. (http://www.netdirect.ca/)
   8     Copyright (C) 2008-2009, Nicolas VIVIEN
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18
  19     See the GNU General Public License in the COPYING file at the
  20     root directory of this project for more details.
  21 */
  22
  23 #include "i18n.h"
  24 #include "m_jvmdebug.h"
  25 #include "data.h"
  26 #include "protocol.h"
  27 #include "protostructs.h"
  28 #include "packet.h"
  29 #include "endian.h"
  30 #include "error.h"
  31 #include "usbwrap.h"
  32 #include "controller.h"
  33 #include "cod.h"
  34 #include <stdexcept>
  35 #include <sstream>
  36 #include <iomanip>
  37 #include <vector>
  38 #include <string.h>
  39 #include <time.h>
  40 #include <stdio.h>
  41 #include "ios_state.h"
  42
  43 #include "debug.h"
  44
  45 using namespace std;
  46 using namespace Barry::Protocol;
  47
  48 namespace Barry {
  49
  50 ///////////////////////////////////////////////////////////////////////////////
  51 // JDModulesList class
  52
  53 void JVMModulesList::Parse(const Data &entry_packet)
  54 {
  55         uint32_t count = 0;
  56
  57         size_t size = entry_packet.GetSize();
  58
  59         while (count < size) {
  60                 uint16_t len = 0;
  61
  62                 const unsigned char *ptr = (entry_packet.GetData() + count);
  63                 Protocol::JVMModulesEntry *e = (Protocol::JVMModulesEntry *) ptr;
  64
  65                 len = SB_JVMMODULES_ENTRY_HEADER_SIZE + be_btohs(e->sizename);
  66                 if( (count + len) > size )
  67                         break;
  68
  69                 JVMModulesEntry entry;
  70
  71                 entry.Id = be_btohl(e->id);
  72                 entry.UniqueID = be_btohl(e->uniqueId);
  73                 (entry.Name).assign((char *) (ptr + SB_JVMMODULES_ENTRY_HEADER_SIZE), be_btohs(e->sizename));
  74
  75                 push_back(entry);
  76
  77                 count += len;
  78         }
  79 }
  80
  81
  82 void JVMModulesList::Dump(std::ostream &os) const
  83 {
  84         ios_format_state state(os);
  85
  86         const_iterator i = begin(), e = end();
  87
  88         os << _("     ID     ") << "|";
  89         os << _("  UniqueID  ") << "|";
  90         os << _(" Module Name") << endl;
  91
  92         os << "------------+";
  93         os << "------------+";
  94         os << "-------------";
  95         os << endl;
  96
  97         for( ; i != e; ++i ) {
  98                 (*i).Dump(os);
  99         }
 100 }
 101
 102
 103 ///////////////////////////////////////////////////////////////////////////////
 104 // JVMModulesEntry class
 105
 106 void JVMModulesEntry::Dump(std::ostream &os) const
 107 {
 108         ios_format_state state(os);
 109
 110         os << " 0x" << setfill('0') << setw(8) << hex << Id << " |";
 111         os << " 0x" << setfill('0') << setw(8) << hex << UniqueID << " |";
 112         os << " " << Name << endl;
 113 }
 114
 115
 116 ///////////////////////////////////////////////////////////////////////////////
 117 // JVMThreadsList class
 118
 119 void JVMThreadsList::Parse(const Data &entry_packet)
 120 {
 121         uint32_t count = 0;
 122
 123         size_t size = entry_packet.GetSize();
 124
 125         while (count < size) {
 126                 uint16_t len = 0;
 127
 128                 const unsigned char *ptr = (entry_packet.GetData() + count);
 129                 uint32_t *e = (uint32_t *) ptr;
 130
 131                 len = sizeof(uint32_t);
 132                 if( (count + len) > size )
 133                         break;
 134
 135                 JVMThreadsEntry entry;
 136
 137                 entry.Id = be_btohl(*e);
 138
 139                 push_back(entry);
 140
 141                 count += len;
 142         }
 143 }
 144
 145
 146 void JVMThreadsList::Dump(std::ostream &os) const
 147 {
 148         ios_format_state state(os);
 149
 150         const_iterator i = begin(), e = end();
 151
 152         os << _("  Thread  ") << "|";
 153         os << _("  Address   ") << "|";
 154         os << _(" Byte ") << "|";
 155         os << _(" Unknown01  ") << "|";
 156         os << _(" Unknown02  ") << "|";
 157         os << _(" Unknown03  ") << "|";
 158         os << _(" Unknown04  ") << "|";
 159         os << _(" Unknown05  ") << "|";
 160         os << _(" Unknown06  ") << "|";
 161
 162         os << "------------+";
 163         os << "------------+";
 164         os << "------+";
 165         os << "------------+";
 166         os << "------------+";
 167         os << "------------+";
 168         os << "------------+";
 169         os << "------------+";
 170         os << "-------------";
 171         os << endl;
 172
 173         for(int k=0 ; i != e; ++i, k++ ) {
 174                 (*i).Dump(os, k);
 175         }
 176 }
 177
 178
 179 void JVMThreadsEntry::Dump(std::ostream &os, int num) const
 180 {
 181         ios_format_state state(os);
 182
 183         os << " " << setfill(' ') << setw(8) << dec << num << " |";
 184         os << " 0x" << setfill('0') << setw(8) << hex << (Id) << " |";
 185         os << " 0x" << setfill('0') << setw(2) << hex << (Byte) << " |";
 186         os << " 0x" << setfill('0') << setw(8) << hex << (Address) << " |";
 187         os << " 0x" << setfill('0') << setw(8) << hex << (Unknown01) << " |";
 188         os << " 0x" << setfill('0') << setw(8) << hex << (Unknown02) << " |";
 189         os << " 0x" << setfill('0') << setw(8) << hex << (Unknown03) << " |";
 190         os << " 0x" << setfill('0') << setw(8) << hex << (Unknown04) << " |";
 191         os << " 0x" << setfill('0') << setw(8) << hex << (Unknown05) << " |";
 192         os << " 0x" << setfill('0') << setw(8) << hex << (Unknown06) << endl;
 193 }
 194
 195
 196 namespace Mode {
 197
 198 ///////////////////////////////////////////////////////////////////////////////
 199 // JVMDebug Mode class
 200
 201 JVMDebug::JVMDebug(Controller &con)
 202         : Mode(con, Controller::JVMDebug)
 203         , m_Attached(false)
 204 {
 205 }
 206
 207 JVMDebug::~JVMDebug()
 208 {
 209         if( m_Attached )
 210                 Detach();
 211 }
 212
 213 ///////////////////////////////////////////////////////////////////////////////
 214 // protected members
 215
 216
 217 ///////////////////////////////////////////////////////////////////////////////
 218 // public API
 219
 220 void JVMDebug::OnOpen()
 221 {
 222 }
 223
 224 // FIXME - is this necessary?  and if it is, wouldn't it be better
 225 // in the m_jvmdebug mode class?  I'm not convinced that applications
 226 // should have to bother with socket-level details.
 227 void JVMDebug::Close()
 228 {
 229         if( m_ModeSocket ) {
 230                 m_socket->Close();
 231                 m_socket.reset();
 232                 m_ModeSocket = 0;
 233         }
 234 }
 235
 236 //
 237 // Attach
 238 //
 239 /// These commands are sent to prepare the debug communication.
 240 /// Must be called at the start of a JVMDebug session.
 241 ///
 242 void JVMDebug::Attach()
 243 {
 244 }
 245
 246 //
 247 // Detach
 248 //
 249 /// Must be called at the end of a JVMDebug session.  The JVM_GOODBYE
 250 /// command is sent to the device.
 251 ///
 252 void JVMDebug::Detach()
 253 {
 254 }
 255
 256
 257 void JVMDebug::ThrowJVMError(const std::string &msg, uint16_t cmd)
 258 {
 259         std::ostringstream oss;
 260         oss << msg << ": " << _("unexpected packet command code: ")
 261                 << "0x" << std::hex << (unsigned int) cmd;
 262         throw Error(oss.str());
 263 }
 264
 265
 266 //
 267 // Unknown 01 ???
 268 //
 269 void JVMDebug::Unknown01()
 270 {
 271         uint16_t expect = 0;
 272
 273         Data command(-1, 8), response;
 274         JVMPacket packet(command, response);
 275
 276         // Send the command packet
 277         packet.Unknown01();
 278         m_socket->Packet(packet);
 279         expect = packet.Size();
 280
 281         if (expect == 0)
 282                 return;
 283
 284         // Read the data stream
 285         m_socket->Receive(response);
 286
 287         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 288
 289         // Check the size read into the previous packet
 290         if( expect != bytereceived ) {
 291                 ThrowJVMError(string("JVMDebug::Unknown01(): ") + _("byte count mismatch"), expect);
 292         }
 293 }
 294
 295
 296 //
 297 // Unknown 02 ???
 298 //
 299 void JVMDebug::Unknown02()
 300 {
 301         uint16_t expect = 0;
 302
 303         Data command(-1, 8), response;
 304         JVMPacket packet(command, response);
 305
 306         // Send the command packet
 307         packet.Unknown02();
 308         m_socket->Packet(packet);
 309         expect = packet.Size();
 310
 311         if (expect == 0)
 312                 return;
 313
 314         // Read the data stream
 315         m_socket->Receive(response);
 316
 317         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 318
 319         // Check the size read into the previous packet
 320         if( expect != bytereceived ) {
 321                 ThrowJVMError(string("JVMDebug::Unknown02(): ") + _("byte count mismatch"), expect);
 322         }
 323 }
 324
 325
 326 //
 327 // Unknown 03 ???
 328 //
 329 void JVMDebug::Unknown03()
 330 {
 331         uint16_t expect = 0;
 332
 333         Data command(-1, 8), response;
 334         JVMPacket packet(command, response);
 335
 336         // Send the command packet
 337         packet.Unknown03();
 338         m_socket->Packet(packet);
 339         expect = packet.Size();
 340
 341         if (expect == 0)
 342                 return;
 343
 344         // Read the data stream
 345         m_socket->Receive(response);
 346
 347         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 348
 349         // Check the size read into the previous packet
 350         if( expect != bytereceived ) {
 351                 ThrowJVMError(string("JVMDebug::Unknown03(): ") + _("byte count mismatch"), expect);
 352         }
 353 }
 354
 355
 356 //
 357 // Unknown 04 ???
 358 //
 359 void JVMDebug::Unknown04()
 360 {
 361         uint16_t expect = 0;
 362
 363         Data command(-1, 8), response;
 364         JVMPacket packet(command, response);
 365
 366         // Send the command packet
 367         packet.Unknown04();
 368         m_socket->Packet(packet);
 369         expect = packet.Size();
 370
 371         if (expect == 0)
 372                 return;
 373
 374         // Read the data stream
 375         m_socket->Receive(response);
 376
 377         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 378
 379         // Check the size read into the previous packet
 380         if( expect != bytereceived ) {
 381                 ThrowJVMError(string("JVMDebug::Unknown04(): ") + _("byte count mismatch"), expect);
 382         }
 383 }
 384
 385
 386 //
 387 // Unknown 05 ???
 388 //
 389 void JVMDebug::Unknown05()
 390 {
 391         uint16_t expect = 0;
 392
 393         Data command(-1, 8), response;
 394         JVMPacket packet(command, response);
 395
 396         // Send the command packet
 397         packet.Unknown05();
 398         m_socket->Packet(packet);
 399         expect = packet.Size();
 400
 401         if (expect == 0)
 402                 return;
 403
 404         // Read the data stream
 405         m_socket->Receive(response);
 406
 407         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 408
 409         // Check the size read into the previous packet
 410         if( expect != bytereceived ) {
 411                 ThrowJVMError(string("JVMDebug::Unknown05(): ") + _("byte count mismatch"), expect);
 412         }
 413 }
 414
 415
 416 //
 417 // Unknown 06 ???
 418 //
 419 void JVMDebug::Unknown06()
 420 {
 421         uint16_t expect = 0;
 422
 423         Data command(-1, 8), response;
 424         JVMPacket packet(command, response);
 425
 426         // Send the command packet
 427         packet.Unknown06();
 428         m_socket->Packet(packet);
 429         expect = packet.Size();
 430
 431         if (expect == 0)
 432                 return;
 433
 434         // Read the data stream
 435         m_socket->Receive(response);
 436
 437         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 438
 439         // Check the size read into the previous packet
 440         if( expect != bytereceived ) {
 441                 ThrowJVMError(string("JVMDebug::Unknown06(): ") + _("byte count mismatch"), expect);
 442         }
 443 }
 444
 445
 446 //
 447 // Unknown 07 ???
 448 //
 449 void JVMDebug::Unknown07()
 450 {
 451         uint16_t expect = 0;
 452
 453         Data command(-1, 8), response;
 454         JVMPacket packet(command, response);
 455
 456         // Send the command packet
 457         packet.Unknown07();
 458         m_socket->Packet(packet);
 459         expect = packet.Size();
 460
 461         if (expect == 0)
 462                 return;
 463
 464         // Read the data stream
 465         m_socket->Receive(response);
 466
 467         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 468
 469         // Check the size read into the previous packet
 470         if( expect != bytereceived ) {
 471                 ThrowJVMError(string("JVMDebug::Unknown07(): ") + _("byte count mismatch"), expect);
 472         }
 473 }
 474
 475
 476 //
 477 // Unknown 08 ???
 478 //
 479 void JVMDebug::Unknown08()
 480 {
 481         uint16_t expect = 0;
 482
 483         Data command(-1, 8), response;
 484         JVMPacket packet(command, response);
 485
 486         // Send the command packet
 487         packet.Unknown08();
 488         m_socket->Packet(packet);
 489         expect = packet.Size();
 490
 491         if (expect == 0)
 492                 return;
 493
 494         // Read the data stream
 495         m_socket->Receive(response);
 496
 497         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 498
 499         // Check the size read into the previous packet
 500         if( expect != bytereceived ) {
 501                 ThrowJVMError(string("JVMDebug::Unknown08(): ") + _("byte count mismatch"), expect);
 502         }
 503 }
 504
 505
 506 //
 507 // Unknown 09 ???
 508 //
 509 void JVMDebug::Unknown09()
 510 {
 511         uint16_t expect = 0;
 512
 513         Data command(-1, 8), response;
 514         JVMPacket packet(command, response);
 515
 516         // Send the command packet
 517         packet.Unknown09();
 518         m_socket->Packet(packet);
 519         expect = packet.Size();
 520
 521         if (expect == 0)
 522                 return;
 523
 524         // Read the data stream
 525         m_socket->Receive(response);
 526
 527         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 528
 529         // Check the size read into the previous packet
 530         if( expect != bytereceived ) {
 531                 ThrowJVMError(string("JVMDebug::Unknown09(): ") + _("byte count mismatch"), expect);
 532         }
 533 }
 534
 535
 536 //
 537 // Unknown 10 ???
 538 //
 539 void JVMDebug::Unknown10()
 540 {
 541         uint16_t expect = 0;
 542
 543         Data command(-1, 8), response;
 544         JVMPacket packet(command, response);
 545
 546         // Send the command packet
 547         packet.Unknown10();
 548         m_socket->Packet(packet);
 549         expect = packet.Size();
 550
 551         if (expect == 0)
 552                 return;
 553
 554         // Read the data stream
 555         m_socket->Receive(response);
 556
 557         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 558
 559         // Check the size read into the previous packet
 560         if( expect != bytereceived ) {
 561                 ThrowJVMError(string("JVMDebug::Unknown10(): ") + _("byte count mismatch"), expect);
 562         }
 563 }
 564
 565
 566 //
 567 // Get Status
 568 //
 569 bool JVMDebug::GetStatus(int &status)
 570 {
 571         uint16_t expect = 0;
 572
 573         Data command(-1, 8), response;
 574         JVMPacket packet(command, response);
 575
 576         // Send the command packet
 577         packet.GetStatus();
 578
 579         m_socket->Packet(packet);
 580
 581         expect = packet.Size();
 582
 583         if (expect == 0)
 584                 return false;
 585
 586         // Read the data stream
 587         m_socket->Receive(response);
 588
 589         MAKE_JVMPACKET(dpack, response);
 590
 591         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 592
 593         // Check the size read into the previous packet
 594         if( expect != bytereceived ) {
 595                 ThrowJVMError(string("JVMDebug::GetStatus():") + _("byte count mismatch"), expect);
 596         }
 597
 598         // Make sure we have a header to read
 599         CheckSize(response, SB_JVMPACKET_HEADER_SIZE + sizeof(dpack->u.status));
 600
 601         // Return status
 602         status = dpack->u.status;
 603
 604         return true;
 605 }
 606
 607
 608 //
 609 // Wait Status
 610 //
 611 bool JVMDebug::WaitStatus(int &status)
 612 {
 613         uint16_t expect = 0;
 614
 615         Data command(-1, 8), response;
 616         JVMPacket packet(command, response);
 617
 618         // Prepare the command packet
 619         packet.GetStatus();
 620
 621         try {
 622                 m_socket->Receive(packet.GetReceive(), 100);
 623         } catch (Usb::Timeout &DEBUG_ONLY(to) ) {
 624                 return false;
 625         }
 626
 627         expect = packet.Size();
 628
 629         if (expect == 0)
 630                 return false;
 631
 632         // Read the data stream
 633         m_socket->Receive(response);
 634
 635         MAKE_JVMPACKET(dpack, response);
 636
 637         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 638
 639         // Check the size read into the previous packet
 640         if( expect != bytereceived ) {
 641                 ThrowJVMError(string("JVMDebug::WaitStatus():") + _("byte count mismatch"), expect);
 642         }
 643
 644         // Make sure we have a header to read
 645         CheckSize(response, SB_JVMPACKET_HEADER_SIZE + sizeof(dpack->u.status));
 646
 647         // Return status
 648         status = dpack->u.status;
 649
 650         return true;
 651 }
 652
 653
 654 //
 655 // Get Console Message
 656 // Sample, display the output of System.out.println(...) and all JVM messages output
 657 //
 658 // Return the length message or -1 if message doesn't exit or is empty
 659 //
 660 int JVMDebug::GetConsoleMessage(std::string &message)
 661 {
 662         uint16_t expect = 0;
 663
 664         Data command(-1, 8), response;
 665         JVMPacket packet(command, response);
 666
 667         // Send the command packet
 668         packet.GetConsoleMessage();
 669
 670         m_socket->Packet(packet);
 671
 672         expect = packet.Size();
 673
 674         if (expect == 0)
 675                 return -1;
 676
 677         // Read the data stream
 678         m_socket->Receive(response);
 679
 680         MAKE_JVMPACKET(dpack, response);
 681
 682         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 683
 684         // Check the size read into the previous packet
 685         if( expect != bytereceived ) {
 686                 ThrowJVMError(string("JVMDebug::GetConsoleMessage():") + _("byte count mismatch"), expect);
 687         }
 688
 689         // Make sure we have a header to read
 690         CheckSize(response, SB_JVMPACKET_HEADER_SIZE + sizeof(dpack->u.msglength));
 691
 692         // Length of message
 693         uint16_t length = be_btohs(dpack->u.msglength);
 694
 695         if (length == 0)
 696                 return -1;
 697
 698         CheckSize(response, SB_JVMPACKET_HEADER_SIZE + sizeof(dpack->u.msglength) + length);
 699
 700         // Parse the ID of nextmodules
 701         const unsigned char *ptr = (response.GetData() + SB_JVMPACKET_HEADER_SIZE + sizeof(dpack->u.msglength));
 702
 703         message.assign((char *) ptr, length);
 704
 705         return length;
 706 }
 707
 708
 709 //
 710 // Get list of Java modules
 711 //
 712 void JVMDebug::GetModulesList(JVMModulesList &mylist)
 713 {
 714         uint32_t size = 0;
 715         uint32_t offset = 0;
 716         uint16_t expect = 0;
 717
 718         Data command(-1, 8), response;
 719         JVMPacket packet(command, response);
 720
 721         do {
 722                 // Send the command packet
 723                 packet.GetModulesList(offset);
 724
 725                 m_socket->Packet(packet);
 726
 727                 expect = packet.Size();
 728
 729                 if (expect == 0)
 730                         break;
 731
 732                 // Read the data stream
 733                 m_socket->Receive(response);
 734
 735 //              MAKE_JVMPACKET(dpack, response);        // unused
 736
 737                 size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 738
 739                 // Check the size read into the previous packet
 740                 if( expect != bytereceived ) {
 741                         ThrowJVMError(string("JVMDebug::GetModulesList():") + _("byte count mismatch"), expect);
 742                 }
 743
 744                 // Make sure there's enough for packet header + module list
 745                 // header + 4 bytes of ID
 746                 CheckSize(response, SB_JVMPACKET_HEADER_SIZE + SB_JVMMODULES_LIST_HEADER_SIZE + 4);
 747
 748                 // Number of modules entries in the list
 749                 // (Valid, but unused variable... disabled to stop compiler
 750                 // warnings)
 751 //              uint32_t count = be_btohl(dpack->u.moduleslist.nbr);
 752
 753                 // Size of modules list
 754                 // I remove the header of packet (contains the field 'number of modules')
 755                 // and 4 bytes (contains the field 'ID of next modules')
 756                 size = bytereceived - SB_JVMMODULES_LIST_HEADER_SIZE - 4;
 757
 758                 // Parse the modules list
 759                 mylist.Parse(Data(response.GetData() + SB_JVMPACKET_HEADER_SIZE + SB_JVMMODULES_LIST_HEADER_SIZE, size));
 760
 761                 // Parse the ID of nextmodules
 762                 size_t id_offset = SB_JVMPACKET_HEADER_SIZE + SB_JVMMODULES_LIST_HEADER_SIZE + size;
 763                 const unsigned char *ptr = (response.GetData() + id_offset);
 764                 CheckSize(response, id_offset + sizeof(uint32_t));
 765                 uint32_t *poffset = (uint32_t *) ptr;
 766
 767                 offset = be_btohl(*poffset);
 768         } while (offset != 0);  // When the offset != 0, there is some modules
 769 }
 770
 771
 772 //
 773 // Get list of Java threads
 774 //
 775 void JVMDebug::GetThreadsList(JVMThreadsList &mylist)
 776 {
 777         uint32_t size = 0;
 778         uint16_t expect = 0;
 779
 780         Data command(-1, 8), response;
 781         JVMPacket packet(command, response);
 782
 783         // Send the command packet
 784         packet.GetThreadsList();
 785
 786         m_socket->Packet(packet);
 787
 788         expect = packet.Size();
 789
 790         if (expect == 0)
 791                 return;
 792
 793         // Read the data stream
 794         m_socket->Receive(response);
 795
 796 //      MAKE_JVMPACKET(dpack, response);        // unused
 797
 798         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 799
 800         // Check the size read into the previous packet
 801         if( expect != bytereceived ) {
 802                 ThrowJVMError(string("JVMDebug::GetThreadsList():") + _("byte count mismatch"), expect);
 803         }
 804
 805         CheckSize(response, SB_JVMPACKET_HEADER_SIZE + SB_JVMTHREADS_LIST_HEADER_SIZE);
 806
 807         // Number of threads entries in the list
 808         // (Valid, but unused variable... disabled to stop compiler warnings)
 809 //      uint32_t count = be_btohl(dpack->u.threadslist.nbr);
 810
 811         // Size of threads list
 812         // I remove the header of packet (contains the field 'number of threads')
 813         size = bytereceived - SB_JVMTHREADS_LIST_HEADER_SIZE;
 814
 815         // Parse the threads list
 816         mylist.Parse(Data(response.GetData() + SB_JVMPACKET_HEADER_SIZE + SB_JVMTHREADS_LIST_HEADER_SIZE, size));
 817
 818         // Complete threads list
 819         JVMThreadsList::iterator b = mylist.begin();
 820         for( ; b != mylist.end(); b++ ) {
 821                 JVMThreadsEntry entry = (*b);
 822
 823                 // 1°/
 824                 // Send the command packet
 825                 packet.Unknown11(entry.Id);
 826
 827                 m_socket->Packet(packet);
 828
 829                 expect = packet.Size();
 830
 831                 if (expect == 0)
 832                         return;
 833
 834                 // Read the data stream
 835                 m_socket->Receive(response);
 836
 837                 MAKE_JVMPACKET(dpack, response);
 838
 839                 bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 840
 841                 // Check the size read into the previous packet
 842                 if( expect != bytereceived ) {
 843                         ThrowJVMError(string("JVMDebug::GetThreadsList() (1):") + _("byte count mismatch"), expect);
 844                 }
 845
 846                 CheckSize(response, SB_JVMPACKET_HEADER_SIZE + SB_JVMUNKNOWN01_HEADER_SIZE);
 847
 848                 // Save values
 849                 entry.Byte = dpack->u.unknown01.byte;
 850                 entry.Address = be_btohl(dpack->u.unknown01.address);
 851
 852                 // 2°/
 853                 if (entry.Address != 0) {
 854                         // Send the command packet
 855                         packet.Unknown12(entry.Address);
 856
 857                         m_socket->Packet(packet);
 858
 859                         expect = packet.Size();
 860
 861                         if (expect == 0)
 862                                 return;
 863
 864                         // Read the data stream
 865                         m_socket->Receive(response);
 866
 867                         MAKE_JVMPACKET(dpack, response);
 868
 869                         bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 870
 871                         // Check the size read into the previous packet
 872                         if( expect != bytereceived ) {
 873                                 ThrowJVMError(string("JVMDebug::GetThreadsList() (2):") + _("byte count mismatch"), expect);
 874                         }
 875
 876
 877                         // Save values
 878                         CheckSize(response, SB_JVMPACKET_HEADER_SIZE + sizeof(dpack->u.address));
 879                         entry.Unknown01 = be_btohl(dpack->u.address);
 880                 }
 881                 else
 882                         entry.Unknown01 = 0;
 883
 884                 // 3°/
 885                 // Send the command packet
 886                 packet.Unknown13(entry.Id);
 887
 888                 m_socket->Packet(packet);
 889
 890                 expect = packet.Size();
 891
 892                 if (expect == 0)
 893                         return;
 894
 895                 // Read the data stream
 896                 m_socket->Receive(response);
 897
 898                 dpack = (const Protocol::JVMPacket *) response.GetData();
 899
 900                 bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 901
 902                 // Check the size read into the previous packet
 903                 if( expect != bytereceived ) {
 904                         ThrowJVMError(string("JVMDebug::GetThreadsList() (3):") + _("byte count mismatch"), expect);
 905                 }
 906
 907                 // Save values
 908                 CheckSize(response, SB_JVMPACKET_HEADER_SIZE + sizeof(dpack->u.address));
 909                 entry.Unknown02 = be_btohl(dpack->u.address);
 910
 911                 // 4°/
 912                 // Send the command packet
 913                 packet.Unknown14(entry.Id);
 914
 915                 m_socket->Packet(packet);
 916
 917                 expect = packet.Size();
 918
 919                 if (expect == 0)
 920                         return;
 921
 922                 // Read the data stream
 923                 m_socket->Receive(response);
 924
 925                 dpack = (const Protocol::JVMPacket *) response.GetData();
 926
 927                 bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 928
 929                 // Check the size read into the previous packet
 930                 if( expect != bytereceived ) {
 931                         ThrowJVMError(string("JVMDebug::GetThreadsList() (4):") + _("byte count mismatch"), expect);
 932                 }
 933
 934                 // Save values
 935                 CheckSize(response, SB_JVMPACKET_HEADER_SIZE + SB_JVMUNKNOWN02_HEADER_SIZE);
 936                 entry.Unknown03 = be_btohl(dpack->u.unknown02.address1);
 937                 entry.Unknown04 = be_btohl(dpack->u.unknown02.address2);
 938
 939                 // 5°/
 940                 // Send the command packet
 941                 packet.Unknown15(entry.Id);
 942
 943                 m_socket->Packet(packet);
 944
 945                 expect = packet.Size();
 946
 947                 if (expect == 0)
 948                         return;
 949
 950                 // Read the data stream
 951                 m_socket->Receive(response);
 952
 953                 dpack = (const Protocol::JVMPacket *) response.GetData();
 954
 955                 bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 956
 957                 // Check the size read into the previous packet
 958                 if( expect != bytereceived ) {
 959                         ThrowJVMError(string("JVMDebug::GetThreadsList() (5):") + _("byte count mismatch"), expect);
 960                 }
 961
 962                 // Save values
 963                 CheckSize(response, SB_JVMPACKET_HEADER_SIZE + SB_JVMUNKNOWN02_HEADER_SIZE);
 964                 entry.Unknown05 = be_btohl(dpack->u.unknown02.address1);
 965                 entry.Unknown06 = be_btohl(dpack->u.unknown02.address2);
 966
 967                 // Save...
 968                 (*b) = entry;
 969         }
 970 }
 971
 972
 973 //
 974 // Go
 975 //
 976 void JVMDebug::Go()
 977 {
 978         uint16_t expect = 0;
 979
 980         Data command(-1, 8), response;
 981         JVMPacket packet(command, response);
 982
 983         // Send the command packet
 984         packet.Go();
 985         m_socket->Packet(packet);
 986         expect = packet.Size();
 987
 988         while (expect == 0) {
 989                 m_socket->Receive(packet.GetReceive());
 990
 991                 expect = packet.Size();
 992         }
 993
 994         // Read the data stream
 995         m_socket->Receive(response);
 996
 997         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 998
 999         // Check the size read into the previous packet
1000         if( expect != bytereceived ) {
1001                 ThrowJVMError(string("JVMDebug::Go():") + _("byte count mismatch"), expect);
1002         }
1003 }
1004
1005
1006 //
1007 // Stop
1008 //
1009 void JVMDebug::Stop()
1010 {
1011         uint16_t expect = 0;
1012
1013         Data command(-1, 8), response;
1014         JVMPacket packet(command, response);
1015
1016         // Send the command packet
1017         packet.Stop();
1018         m_socket->Packet(packet);
1019         expect = packet.Size();
1020
1021         while (expect == 0) {
1022                 m_socket->Receive(packet.GetReceive());
1023
1024                 expect = packet.Size();
1025         }
1026
1027         // Read the data stream
1028         m_socket->Receive(response);
1029
1030         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
1031
1032         // Check the size read into the previous packet
1033         if( expect != bytereceived ) {
1034                 ThrowJVMError(string("JVMDebug::Stop():") + _("byte count mismatch"), expect);
1035         }
1036 }
1037
1038
1039 }} // namespace Barry::Mode
1040