src/m_jvmdebug.cc

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