src/m_jvmdebug.cc

   1 ///
   2 /// \file       m_jvmdebug.cc
   3 ///             Mode class for the JVMDebug mode
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2011, 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 count = 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);
 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("JVMDebug::GetModulesList expect", 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                 count = be_btohl(dpack->u.moduleslist.nbr);
 750
 751                 // Size of modules list
 752                 // I remove the header of packet (contains the field 'number of modules')
 753                 // and 4 bytes (contains the field 'ID of next modules')
 754                 size = bytereceived - SB_JVMMODULES_LIST_HEADER_SIZE - 4;
 755
 756                 // Parse the modules list
 757                 mylist.Parse(Data(response.GetData() + SB_JVMPACKET_HEADER_SIZE + SB_JVMMODULES_LIST_HEADER_SIZE, size));
 758
 759                 // Parse the ID of nextmodules
 760                 size_t id_offset = SB_JVMPACKET_HEADER_SIZE + SB_JVMMODULES_LIST_HEADER_SIZE + size;
 761                 const unsigned char *ptr = (response.GetData() + id_offset);
 762                 CheckSize(response, id_offset + sizeof(uint32_t));
 763                 uint32_t *poffset = (uint32_t *) ptr;
 764
 765                 offset = be_btohl(*poffset);
 766         } while (offset != 0);  // When the offset != 0, there is some modules
 767 }
 768
 769
 770 //
 771 // Get list of Java threads
 772 //
 773 void JVMDebug::GetThreadsList(JVMThreadsList &mylist)
 774 {
 775         uint32_t size = 0;
 776         uint32_t count = 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);
 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         count = be_btohl(dpack->u.threadslist.nbr);
 808
 809         // Size of threads list
 810         // I remove the header of packet (contains the field 'number of threads')
 811         size = bytereceived - SB_JVMTHREADS_LIST_HEADER_SIZE;
 812
 813         // Parse the threads list
 814         mylist.Parse(Data(response.GetData() + SB_JVMPACKET_HEADER_SIZE + SB_JVMTHREADS_LIST_HEADER_SIZE, size));
 815
 816         // Complete threads list
 817         JVMThreadsList::iterator b = mylist.begin();
 818         for( ; b != mylist.end(); b++ ) {
 819                 JVMThreadsEntry entry = (*b);
 820
 821                 // 1°/
 822                 // Send the command packet
 823                 packet.Unknown11(entry.Id);
 824
 825                 m_socket->Packet(packet);
 826
 827                 expect = packet.Size();
 828
 829                 if (expect == 0)
 830                         return;
 831
 832                 // Read the data stream
 833                 m_socket->Receive(response);
 834
 835                 MAKE_JVMPACKET(dpack, response);
 836
 837                 bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 838
 839                 // Check the size read into the previous packet
 840                 if( expect != bytereceived ) {
 841                         ThrowJVMError("JVMDebug::GetThreadsList (1) expect", expect);
 842                 }
 843
 844                 CheckSize(response, SB_JVMPACKET_HEADER_SIZE + SB_JVMUNKNOWN01_HEADER_SIZE);
 845
 846                 // Save values
 847                 entry.Byte = dpack->u.unknown01.byte;
 848                 entry.Address = be_btohl(dpack->u.unknown01.address);
 849
 850                 // 2°/
 851                 if (entry.Address != 0) {
 852                         // Send the command packet
 853                         packet.Unknown12(entry.Address);
 854
 855                         m_socket->Packet(packet);
 856
 857                         expect = packet.Size();
 858
 859                         if (expect == 0)
 860                                 return;
 861
 862                         // Read the data stream
 863                         m_socket->Receive(response);
 864
 865                         MAKE_JVMPACKET(dpack, response);
 866
 867                         bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 868
 869                         // Check the size read into the previous packet
 870                         if( expect != bytereceived ) {
 871                                 ThrowJVMError("JVMDebug::GetThreadsList (2) expect", expect);
 872                         }
 873
 874
 875                         // Save values
 876                         CheckSize(response, SB_JVMPACKET_HEADER_SIZE + sizeof(dpack->u.address));
 877                         entry.Unknown01 = be_btohl(dpack->u.address);
 878                 }
 879                 else
 880                         entry.Unknown01 = 0;
 881
 882                 // 3°/
 883                 // Send the command packet
 884                 packet.Unknown13(entry.Id);
 885
 886                 m_socket->Packet(packet);
 887
 888                 expect = packet.Size();
 889
 890                 if (expect == 0)
 891                         return;
 892
 893                 // Read the data stream
 894                 m_socket->Receive(response);
 895
 896                 dpack = (const Protocol::JVMPacket *) response.GetData();
 897
 898                 bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 899
 900                 // Check the size read into the previous packet
 901                 if( expect != bytereceived ) {
 902                         ThrowJVMError("JVMDebug::GetThreadsList (2) expect", expect);
 903                 }
 904
 905                 // Save values
 906                 CheckSize(response, SB_JVMPACKET_HEADER_SIZE + sizeof(dpack->u.address));
 907                 entry.Unknown02 = be_btohl(dpack->u.address);
 908
 909                 // 4°/
 910                 // Send the command packet
 911                 packet.Unknown14(entry.Id);
 912
 913                 m_socket->Packet(packet);
 914
 915                 expect = packet.Size();
 916
 917                 if (expect == 0)
 918                         return;
 919
 920                 // Read the data stream
 921                 m_socket->Receive(response);
 922
 923                 dpack = (const Protocol::JVMPacket *) response.GetData();
 924
 925                 bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 926
 927                 // Check the size read into the previous packet
 928                 if( expect != bytereceived ) {
 929                         ThrowJVMError("JVMDebug::GetThreadsList (2) expect", expect);
 930                 }
 931
 932                 // Save values
 933                 CheckSize(response, SB_JVMPACKET_HEADER_SIZE + SB_JVMUNKNOWN02_HEADER_SIZE);
 934                 entry.Unknown03 = be_btohl(dpack->u.unknown02.address1);
 935                 entry.Unknown04 = be_btohl(dpack->u.unknown02.address2);
 936
 937                 // 5°/
 938                 // Send the command packet
 939                 packet.Unknown15(entry.Id);
 940
 941                 m_socket->Packet(packet);
 942
 943                 expect = packet.Size();
 944
 945                 if (expect == 0)
 946                         return;
 947
 948                 // Read the data stream
 949                 m_socket->Receive(response);
 950
 951                 dpack = (const Protocol::JVMPacket *) response.GetData();
 952
 953                 bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 954
 955                 // Check the size read into the previous packet
 956                 if( expect != bytereceived ) {
 957                         ThrowJVMError("JVMDebug::GetThreadsList (2) expect", expect);
 958                 }
 959
 960                 // Save values
 961                 CheckSize(response, SB_JVMPACKET_HEADER_SIZE + SB_JVMUNKNOWN02_HEADER_SIZE);
 962                 entry.Unknown05 = be_btohl(dpack->u.unknown02.address1);
 963                 entry.Unknown06 = be_btohl(dpack->u.unknown02.address2);
 964
 965                 // Save...
 966                 (*b) = entry;
 967         }
 968 }
 969
 970
 971 //
 972 // Go
 973 //
 974 void JVMDebug::Go()
 975 {
 976         uint16_t expect = 0;
 977
 978         Data command(-1, 8), response;
 979         JVMPacket packet(command, response);
 980
 981         // Send the command packet
 982         packet.Go();
 983         m_socket->Packet(packet);
 984         expect = packet.Size();
 985
 986         while (expect == 0) {
 987                 m_socket->Receive(packet.GetReceive());
 988
 989                 expect = packet.Size();
 990         }
 991
 992         // Read the data stream
 993         m_socket->Receive(response);
 994
 995         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
 996
 997         // Check the size read into the previous packet
 998         if( expect != bytereceived ) {
 999                 ThrowJVMError("JVMDebug::Attach expect", expect);
1000         }
1001 }
1002
1003
1004 //
1005 // Stop
1006 //
1007 void JVMDebug::Stop()
1008 {
1009         uint16_t expect = 0;
1010
1011         Data command(-1, 8), response;
1012         JVMPacket packet(command, response);
1013
1014         // Send the command packet
1015         packet.Stop();
1016         m_socket->Packet(packet);
1017         expect = packet.Size();
1018
1019         while (expect == 0) {
1020                 m_socket->Receive(packet.GetReceive());
1021
1022                 expect = packet.Size();
1023         }
1024
1025         // Read the data stream
1026         m_socket->Receive(response);
1027
1028         size_t bytereceived = response.GetSize() - SB_JVMPACKET_HEADER_SIZE;
1029
1030         // Check the size read into the previous packet
1031         if( expect != bytereceived ) {
1032                 ThrowJVMError("JVMDebug::Attach expect", expect);
1033         }
1034 }
1035
1036
1037 }} // namespace Barry::Mode
1038