src/j_server.cc

   1 ///
   2 /// \file       j_server.cc
   3 ///             Server protocol implementation
   4 ///
   5
   6 /*
   7     Copyright (C) 2009, Nicolas VIVIEN
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22 #include "i18n.h"
  23 #include "j_server.h"
  24 #include "protocol.h"
  25 #include "data.h"
  26 #include "endian.h"
  27 #include "debug.h"
  28 #include "j_message.h"
  29 #include "protostructs.h"
  30 #include "record-internal.h"
  31 #include "error.h"
  32
  33 #include <unistd.h>
  34 #include <fcntl.h>
  35 #include <sys/types.h>
  36 #include <sys/socket.h>
  37 #include <netinet/in.h>
  38 #include <arpa/inet.h>
  39 #include <netdb.h>
  40 #include <string.h>
  41 #include <errno.h>
  42
  43 #include <sstream>
  44 #include <algorithm>
  45
  46 using namespace std;
  47
  48 namespace Barry { namespace JDWP {
  49
  50 static void * acceptThread(Barry::Thread::CallbackData *data);
  51
  52
  53 JDWServer::JDWServer(Barry::Mode::JVMDebug &device,
  54                         const char *address, int port)
  55         : jvmdebug(&device)
  56         , acceptfd(-1)
  57         , sockfd(-1)
  58         , address(address)
  59         , port(port)
  60         , loop(false)
  61         , targetrunning(false)
  62         , printConsoleMessage(0)
  63 {
  64         SearchDebugFile(debugFileList);
  65 }
  66
  67
  68 JDWServer::~JDWServer()
  69 {
  70         Stop();
  71 }
  72
  73
  74 void JDWServer::SetPasswordDevice(string password)
  75 {
  76         this->password = password;
  77 }
  78
  79
  80 void JDWServer::SetConsoleCallback(ConsoleCallbackType callback)
  81 {
  82         printConsoleMessage = callback;
  83 }
  84
  85 static const char* h_strerror(int code)
  86 {
  87         // Codes and messages taken from the Linux gethostbyname(3) manpage
  88         switch( code )
  89         {
  90         case HOST_NOT_FOUND:
  91                 return _("HOST_NOT_FOUND: The specified host is unknown");
  92
  93         case NO_ADDRESS:
  94                 return _("NO_ADDRESS: The requested name is valid but does not have an IP address");
  95
  96         case NO_RECOVERY:
  97                 return _("NO_RECOVERY: A non-recoverable name server error occurred");
  98
  99         case TRY_AGAIN:
 100                 return _("TRY_AGAIN: A temporary error occurred on an authoritative name server. Try again later.");
 101
 102         default:
 103                 return _("Unknown network error code");
 104         }
 105 }
 106
 107 bool JDWServer::Start()
 108 {
 109         int rc;
 110
 111         struct hostent *hp;
 112         struct sockaddr_in sad;
 113
 114
 115         memset((char *) &sad, '\0', sizeof(struct sockaddr_in));
 116
 117         if (!address.size())
 118                 sad.sin_addr.s_addr = INADDR_ANY;
 119         else {
 120                 sad.sin_addr.s_addr = inet_addr(address.c_str());
 121
 122                 if (sad.sin_addr.s_addr == INADDR_NONE) {
 123                         hp = gethostbyname(address.c_str());
 124
 125                         if (hp == NULL) {
 126                                 std::ostringstream oss;
 127                                 oss << "JDWServer::Start: " << h_errno << h_strerror(h_errno);
 128                                 throw Barry::Error(oss.str());
 129                         }
 130
 131                         memcpy((char*) &sad.sin_addr, (char*) hp->h_addr, (size_t) hp->h_length);
 132                 }
 133         }
 134
 135         sad.sin_family = AF_INET;
 136         sad.sin_port = htons((short) (port & 0xFFFF));
 137
 138         // Open socket
 139         sockfd = socket(sad.sin_family, SOCK_STREAM, 0);
 140
 141         if (sockfd < 0) {
 142                 throw Barry::ErrnoError(_("JDWServer::Start: Cannot open socket."), errno);
 143         }
 144
 145         // Bind
 146         rc = bind(sockfd, (struct sockaddr *) &sad, sizeof(sad));
 147
 148         if (rc < 0) {
 149                 int code = errno;
 150
 151                 close(sockfd);
 152                 sockfd = -1;
 153
 154                 throw Barry::ErrnoError(_("JDWServer::Start: Cannot bind socket"), code);
 155         }
 156
 157         // Listen
 158         if (listen(sockfd, SOMAXCONN) < 0) {
 159                 int code = errno;
 160
 161                 close(sockfd);
 162                 sockfd = -1;
 163
 164                 throw Barry::ErrnoError(_("JDWServer::Start: Cannot listen on socket"), code);
 165         }
 166
 167         handler.reset(new Thread(sockfd, acceptThread, (void*) this));
 168
 169         return true;
 170 }
 171
 172
 173 static void * acceptThread(Barry::Thread::CallbackData *data)
 174 {
 175         JDWServer *s = (JDWServer *) data->userdata;
 176
 177         while( !data->stopflag ) {
 178                 if( s->AcceptConnection() &&
 179                         s->AttachToDevice() &&
 180                         s->InitVisibleClassList() &&
 181                         s->Hello() )
 182                 {
 183                         s->Run(data->stopflag);
 184                         s->DetachFromDevice();
 185                 }
 186         }
 187
 188         return NULL;
 189 }
 190
 191
 192 // Returns true if a new connection was accepted and established
 193 bool JDWServer::AcceptConnection()
 194 {
 195         struct sockaddr_in addr;
 196         struct sockaddr *sa = (struct sockaddr*) &addr;
 197         socklen_t addrlen = sizeof(addr);
 198
 199         acceptfd = accept(sockfd, sa, &addrlen);
 200         if( acceptfd < 0 )
 201                 return false;
 202
 203         fcntl(acceptfd, F_SETFL, O_NONBLOCK);
 204         return true;
 205 }
 206
 207
 208 bool JDWServer::AttachToDevice()
 209 {
 210         targetrunning = false;
 211
 212         jvmdebug->Open(password.c_str());
 213         jvmdebug->Attach();
 214
 215         jvmdebug->Unknown01();
 216         jvmdebug->Unknown02();
 217         jvmdebug->Unknown03();
 218         jvmdebug->Unknown04();
 219         jvmdebug->Unknown05();
 220
 221         jvmdebug->GetModulesList(modulesList);
 222         dout(modulesList);
 223
 224         // Check debug info for each modules
 225         JVMModulesList::const_iterator b = modulesList.begin();
 226         for ( ; b != modulesList.end(); b++) {
 227                 JDG::CodInfo codInfo;
 228
 229                 const JVMModulesEntry &entry = *b;
 230
 231                 bool ret = LoadDebugInfo(debugFileList, entry.UniqueID, entry.Name, codInfo);
 232
 233                 if (ret == true) {
 234                         appList[entry.UniqueID].Load(codInfo);
 235                 }
 236                 else {
 237                         dout(_("No debug information found for: ") << entry.Name);
 238                         dout("' (" << hex << setfill('0') << setw(8) << entry.UniqueID << ")." << endl)
 239                 }
 240         }
 241
 242         return true;
 243 }
 244
 245
 246 void JDWServer::DetachFromDevice()
 247 {
 248         jvmdebug->Detach();
 249         jvmdebug->Close();
 250 }
 251
 252
 253 #define JDWP_HELLO_STRING               "JDWP-Handshake"
 254
 255
 256
 257 bool JDWServer::Hello()
 258 {
 259         bool ret;
 260
 261         Barry::Data response;
 262
 263         const size_t len = strlen(JDWP_HELLO_STRING);
 264
 265         JDWMessage msg(acceptfd);
 266
 267         do {
 268                 ret = msg.Receive(response);
 269         }
 270         while (!ret);
 271
 272         size_t size = response.GetSize();
 273         char *str = (char *) response.GetBuffer();
 274
 275         if (size != len)
 276                 return false;
 277
 278         if (!strncmp(str, JDWP_HELLO_STRING, len)) {
 279                 Data command(JDWP_HELLO_STRING, len);
 280
 281                 msg.Send(command);
 282
 283                 return true;
 284         }
 285
 286         return false;
 287 }
 288
 289
 290 void JDWServer::Run(volatile bool &stopflag)
 291 {
 292         string str;
 293         JDWMessage msg(acceptfd);
 294
 295         Barry::Data command;
 296
 297         MAKE_JDWPPACKET(rpack, command);
 298
 299         loop = true;
 300
 301         while( loop && !stopflag ) {
 302                 if (targetrunning) {
 303                         // Read JDWP message from device
 304                         int value = jvmdebug->GetConsoleMessage(str);
 305
 306                         if (value < 0) {
 307                                 bool ret;
 308                                 int status;
 309
 310                                 ret = jvmdebug->GetStatus(status);
 311
 312                                 while (!ret) {
 313                                         // Read JDB message from host
 314                                         msg.Receive(command);
 315
 316                                         if (command.GetSize() > 0) {
 317                                                 // Convert to packet
 318                                                 rpack = (const Barry::Protocol::JDWP::Packet *) command.GetData();
 319
 320                                                 if (command.GetSize() != be_btohl(rpack->length)) {
 321                                                         dout(_("Packet size error !!!") << endl);
 322
 323                                                         // TODO : add throw exception
 324
 325                                                         continue;
 326                                                 }
 327
 328                                                 CommandsetProcess(command);
 329
 330                                                 break;
 331                                         }
 332                                         else
 333                                                 ret = jvmdebug->WaitStatus(status);
 334                                 }
 335                         }
 336                         else {
 337                                 if (printConsoleMessage != NULL)
 338                                         printConsoleMessage(str);
 339                         }
 340                 }
 341                 else {
 342                         // Read JDB message from host
 343                         msg.Receive(command);
 344
 345                         if (command.GetSize() > 0) {
 346                                 // Convert to packet
 347                                 rpack = (const Barry::Protocol::JDWP::Packet *) command.GetData();
 348
 349                                 if (command.GetSize() != be_btohl(rpack->length)) {
 350                                         dout(_("Packet size error !!!") << endl);
 351
 352                                         // TODO : add throw exception
 353
 354                                         continue;
 355                                 }
 356
 357                                 CommandsetProcess(command);
 358                         }
 359
 360                         usleep(50);
 361                 }
 362         }
 363 }
 364
 365
 366 bool JDWServer::Stop()
 367 {
 368         if( handler.get() ) {
 369                 handler->StopFlag();
 370                 handler.reset();
 371         }
 372
 373         if( sockfd >= 0 ) {
 374                 close(sockfd);
 375                 sockfd = -1;
 376         }
 377
 378         if( acceptfd >= 0 ) {
 379                 close(acceptfd);
 380                 acceptfd = -1;
 381         }
 382
 383         return true;
 384 }
 385
 386
 387 bool JDWServer::InitVisibleClassList()
 388 {
 389         int index;
 390
 391         // Skip the cell '0'
 392         // it's very ugly, but I want use an index started at '1' inside of '0'
 393         // JDB works from '1' :(
 394         JDG::ClassEntry e;
 395         visibleClassList.push_back(e);
 396
 397         // Count and index the class (start to '1')
 398         index = 1;
 399         JDWAppList::iterator it;
 400
 401         for (it = appList.begin(); it != appList.end(); it++) {
 402                 JDWAppInfo &appInfo = it->second;
 403                 JDG::ClassList &list = appInfo.classList;
 404
 405                 JDG::ClassList::iterator b;
 406
 407                 for (b = list.begin(); b != list.end(); b++) {
 408                         // FIXME
 409                         // I don't from class field, we have to filter the class view by JDB
 410 //                      if ((b->type != 0x824) && (b->type != 0x64)) {
 411                         if (b->id == 0xffffffff) {
 412                                 b->index = -1;
 413
 414                                 continue;
 415                         }
 416
 417                         b->index = index;
 418
 419                         visibleClassList.push_back(*b);
 420
 421                         index++;
 422                 }
 423         }
 424
 425         visibleClassList.CreateDefaultEntries();
 426
 427         return true;
 428 }
 429
 430
 431 void JDWServer::CommandsetProcess(Data &cmd)
 432 {
 433         MAKE_JDWPPACKET(rpack, cmd);
 434
 435         switch (rpack->u.command.commandset) {
 436                 case JDWP_CMDSET_VIRTUALMACHINE:
 437                         CommandsetVirtualMachineProcess(cmd);
 438                         break;
 439
 440                 case JDWP_CMDSET_REFERECENTYPE:
 441                         break;
 442
 443                 case JDWP_CMDSET_CLASSTYPE:
 444                         break;
 445
 446                 case JDWP_CMDSET_ARRAYTYPE:
 447                         break;
 448
 449                 case JDWP_CMDSET_INTERFACETYPE:
 450                         break;
 451
 452                 case JDWP_CMDSET_METHOD:
 453                         break;
 454
 455                 case JDWP_CMDSET_FIELD:
 456                         break;
 457
 458                 case JDWP_CMDSET_OBJECTREFERENCE:
 459                         break;
 460
 461                 case JDWP_CMDSET_STRINGREFERENCE:
 462                         break;
 463
 464                 case JDWP_CMDSET_THREADREFERENCE:
 465                         break;
 466
 467                 case JDWP_CMDSET_THREADGROUPREFERENCE:
 468                         break;
 469
 470                 case JDWP_CMDSET_ARRAYREFERENCE:
 471                         break;
 472
 473                 case JDWP_CMDSET_CLASSLOADERREFERENCE:
 474                         break;
 475
 476                 case JDWP_CMDSET_EVENTREQUEST:
 477                         CommandsetEventRequestProcess(cmd);
 478                         break;
 479
 480                 case JDWP_CMDSET_STACKFRAME:
 481                         break;
 482
 483                 case JDWP_CMDSET_CLASSOBJECTREFERENCE:
 484                         break;
 485
 486                 case JDWP_CMDSET_EVENT:
 487                         break;
 488
 489                 default:
 490                         // TODO : add exception (or alert)
 491                         dout(_("Commandset unknown !!!") << endl);
 492         }
 493 }
 494
 495
 496 void JDWServer::CommandsetVirtualMachineProcess(Data &cmd)
 497 {
 498         MAKE_JDWPPACKET(rpack, cmd);
 499
 500         switch (rpack->u.command.command) {
 501                 case JDWP_CMD_VERSION:
 502                         CommandVersion(cmd);
 503                         break;
 504
 505                 case JDWP_CMD_ALLCLASSES:
 506                         CommandAllClasses(cmd);
 507                         break;
 508
 509                 case JDWP_CMD_ALLTHREADS:
 510                         CommandAllThreads(cmd);
 511                         break;
 512
 513                 case JDWP_CMD_DISPOSE:
 514                         loop = false;
 515                         targetrunning = false;
 516                         close(acceptfd);
 517                         acceptfd = -1;
 518                         break;
 519
 520                 case JDWP_CMD_IDSIZES:
 521                         CommandIdSizes(cmd);
 522                         break;
 523
 524                 case JDWP_CMD_SUSPEND:
 525                         CommandSuspend(cmd);
 526                         targetrunning = false;
 527                         break;
 528
 529                 case JDWP_CMD_RESUME:
 530                         CommandResume(cmd);
 531                         targetrunning = true;
 532                         break;
 533
 534                 case JDWP_CMD_CLASSPATHS:
 535                         CommandClassPaths(cmd);
 536                         break;
 537         }
 538 }
 539
 540
 541 void JDWServer::CommandsetEventRequestProcess(Data &cmd)
 542 {
 543         MAKE_JDWPPACKET(rpack, cmd);
 544
 545         switch (rpack->u.command.command) {
 546                 case JDWP_CMD_SET:
 547                         CommandSet(cmd);
 548                         break;
 549         }
 550 }
 551
 552
 553 void JDWServer::CommandVersion(Data &cmd)
 554 {
 555         JDWMessage msg(acceptfd);
 556
 557         // Build packet data
 558         Data response;
 559
 560         size_t offset = JDWP_PACKET_HEADER_SIZE + JDWP_RESPONSE_HEADER_SIZE;
 561
 562         AddJDWString(response, offset, string("RIM JVM"));
 563         AddJDWInt(response, offset, be_htobl(1));
 564         AddJDWInt(response, offset, be_htobl(4));
 565         AddJDWString(response, offset, string("1.4"));
 566         AddJDWString(response, offset, string("RIM JVM"));
 567
 568         response.ReleaseBuffer(offset);
 569
 570
 571         size_t total_size = response.GetSize();
 572
 573         // Fill in the header values
 574         MAKE_JDWPPACKETPTR_BUF(cpack, response.GetBuffer(total_size));
 575         Barry::Protocol::JDWP::Packet &packet = *cpack;
 576
 577
 578         MAKE_JDWPPACKET(rpack, cmd);
 579
 580         packet.length = be_htobl(total_size);
 581         packet.id = rpack->id;
 582         packet.flags = 0x80;
 583         packet.u.response.errorcode = be_htobs(0);
 584
 585         response.ReleaseBuffer(total_size);
 586         msg.Send(response);
 587 }
 588
 589
 590 void JDWServer::CommandAllClasses(Data &cmd)
 591 {
 592         size_t i;
 593         int size;
 594
 595         JDWMessage msg(acceptfd);
 596
 597         // Build packet data
 598         Data response;
 599
 600         size_t offset = JDWP_PACKET_HEADER_SIZE + JDWP_RESPONSE_HEADER_SIZE;
 601
 602         // Size of known class list
 603         size = visibleClassList.size() - 1;
 604
 605         AddJDWInt(response, offset, be_htobl(size));
 606
 607         // Then, write the list of known class
 608         for (i=1; i<visibleClassList.size(); i++) {
 609                 string str = visibleClassList[i].GetFullClassName();
 610
 611                 str = "L" + str + ";";
 612                 replace_if(str.begin(), str.end(), bind2nd(equal_to<char>(),'.'), '/');
 613
 614                 AddJDWByte(response, offset, 0x01);
 615                 AddJDWInt(response, offset, i); // Should be equal to visibleClassList[i].index
 616                 AddJDWString(response, offset, str);
 617                 AddJDWInt(response, offset, be_htobl(0x04));
 618         }
 619
 620         response.ReleaseBuffer(offset);
 621
 622
 623         size_t total_size = response.GetSize();
 624
 625         // Fill in the header values
 626         MAKE_JDWPPACKETPTR_BUF(cpack, response.GetBuffer(total_size));
 627         Barry::Protocol::JDWP::Packet &packet = *cpack;
 628
 629
 630         MAKE_JDWPPACKET(rpack, cmd);
 631
 632         packet.length = be_htobl(total_size);
 633         packet.id = rpack->id;
 634         packet.flags = 0x80;
 635         packet.u.response.errorcode = be_htobs(0);
 636
 637         response.ReleaseBuffer(total_size);
 638         msg.Send(response);
 639 }
 640
 641
 642 void JDWServer::CommandAllThreads(Data &cmd)
 643 {
 644         JDWMessage msg(acceptfd);
 645
 646         // Get threads list from device
 647         JVMThreadsList list;
 648         jvmdebug->GetThreadsList(list);
 649         dout(list);
 650
 651         // Build packet data
 652         Data response;
 653
 654         size_t offset = JDWP_PACKET_HEADER_SIZE + JDWP_RESPONSE_HEADER_SIZE;
 655
 656         // Indicate the number of element
 657         AddJDWInt(response, offset, be_htobl(list.size()));
 658
 659         // Send all threads ID
 660         JVMThreadsList::const_iterator b = list.begin();
 661         for( ; b != list.end(); b++ ) {
 662                 const JVMThreadsEntry &entry = *b;
 663
 664                 AddJDWInt(response, offset, be_htobl(entry.Id));
 665         }
 666
 667         response.ReleaseBuffer(offset);
 668
 669
 670         size_t total_size = response.GetSize();
 671
 672         // Fill in the header values
 673         MAKE_JDWPPACKETPTR_BUF(cpack, response.GetBuffer(total_size));
 674         Barry::Protocol::JDWP::Packet &packet = *cpack;
 675
 676
 677         MAKE_JDWPPACKET(rpack, cmd);
 678
 679         packet.length = be_htobl(total_size);
 680         packet.id = rpack->id;
 681         packet.flags = 0x80;
 682         packet.u.response.errorcode = be_htobs(0);
 683
 684         response.ReleaseBuffer(total_size);
 685         msg.Send(response);
 686 }
 687
 688
 689 void JDWServer::CommandIdSizes(Data &cmd)
 690 {
 691         JDWMessage msg(acceptfd);
 692
 693         MAKE_JDWPPACKET(rpack, cmd);
 694
 695         size_t size;
 696
 697         Barry::Protocol::JDWP::Packet packet;
 698
 699         size = JDWP_PACKET_HEADER_SIZE + JDWP_RESPONSE_HEADER_SIZE
 700                 + JDWP_PACKETVIRTUALMACHINEIDSIZES_DATA_SIZE;
 701
 702         packet.length = be_htobl(size);
 703         packet.id = rpack->id;
 704         packet.flags = 0x80;
 705         packet.u.response.errorcode = be_htobs(0);
 706         packet.u.response.u.virtualMachine.u.IDSizes.fieldIDSize = be_htobl(0x04);
 707         packet.u.response.u.virtualMachine.u.IDSizes.methodIDSize = be_htobl(0x04);
 708         packet.u.response.u.virtualMachine.u.IDSizes.objectIDSize = be_htobl(0x04);
 709         packet.u.response.u.virtualMachine.u.IDSizes.referenceTypeIDSize = be_htobl(0x04);
 710         packet.u.response.u.virtualMachine.u.IDSizes.frameIDSize = be_htobl(0x04);
 711
 712         Data response(&packet, size);
 713
 714         msg.Send(response);
 715 }
 716
 717
 718 void JDWServer::CommandSuspend(Data &cmd)
 719 {
 720         JDWMessage msg(acceptfd);
 721
 722
 723         // Suspend device
 724         jvmdebug->Stop();
 725
 726         // Notify debugger
 727         MAKE_JDWPPACKET(rpack, cmd);
 728
 729         size_t size;
 730
 731         Barry::Protocol::JDWP::Packet packet;
 732
 733         size = JDWP_PACKET_HEADER_SIZE + JDWP_RESPONSE_HEADER_SIZE;
 734
 735         packet.length = be_htobl(size);
 736         packet.id = rpack->id;
 737         packet.flags = 0x80;
 738         packet.u.response.errorcode = be_htobs(0);
 739
 740         Data response(&packet, size);
 741
 742         msg.Send(response);
 743 }
 744
 745
 746 void JDWServer::CommandResume(Data &cmd)
 747 {
 748         JDWMessage msg(acceptfd);
 749
 750
 751         // Resume device
 752         jvmdebug->Unknown06();
 753         jvmdebug->Unknown07();
 754         jvmdebug->Unknown08();
 755         jvmdebug->Unknown09();
 756         jvmdebug->Unknown10();
 757         jvmdebug->Go();
 758
 759         // Notify debugger
 760         MAKE_JDWPPACKET(rpack, cmd);
 761
 762         size_t size;
 763
 764         Barry::Protocol::JDWP::Packet packet;
 765
 766         size = JDWP_PACKET_HEADER_SIZE + JDWP_RESPONSE_HEADER_SIZE;
 767
 768         packet.length = be_htobl(size);
 769         packet.id = rpack->id;
 770         packet.flags = 0x80;
 771         packet.u.response.errorcode = be_htobs(0);
 772
 773         Data response(&packet, size);
 774
 775         msg.Send(response);
 776 }
 777
 778
 779 void JDWServer::CommandClassPaths(Data &cmd)
 780 {
 781         JDWMessage msg(acceptfd);
 782
 783         // Build packet data
 784         Data response;
 785
 786         size_t offset = JDWP_PACKET_HEADER_SIZE + JDWP_RESPONSE_HEADER_SIZE;
 787
 788         AddJDWString(response, offset, string(""));
 789         AddJDWInt(response, offset, be_htobl(0));
 790         AddJDWInt(response, offset, be_htobl(0));
 791
 792         response.ReleaseBuffer(offset);
 793
 794
 795         size_t total_size = response.GetSize();
 796
 797         // Fill in the header values
 798         MAKE_JDWPPACKETPTR_BUF(cpack, response.GetBuffer(total_size));
 799         Barry::Protocol::JDWP::Packet &packet = *cpack;
 800
 801
 802         MAKE_JDWPPACKET(rpack, cmd);
 803
 804         packet.length = be_htobl(total_size);
 805         packet.id = rpack->id;
 806         packet.flags = 0x80;
 807         packet.u.response.errorcode = be_htobs(0);
 808
 809         response.ReleaseBuffer(total_size);
 810         msg.Send(response);
 811 }
 812
 813
 814
 815 void JDWServer::CommandSet(Data &cmd)
 816 {
 817         static int value = 2;
 818
 819         JDWMessage msg(acceptfd);
 820
 821         MAKE_JDWPPACKET(rpack, cmd);
 822
 823         size_t size;
 824
 825         Barry::Protocol::JDWP::Packet packet;
 826
 827         size = JDWP_PACKET_HEADER_SIZE + JDWP_RESPONSE_HEADER_SIZE + sizeof(uint32_t);
 828
 829         packet.length = be_htobl(size);
 830         packet.id = rpack->id;
 831         packet.flags = 0x80;
 832         packet.u.response.errorcode = be_htobs(0);
 833         packet.u.response.u.value = be_htobl(value);
 834
 835         Data response(&packet, size);
 836
 837         msg.Send(response);
 838
 839         value++;
 840 }
 841
 842
 843 }} // namespace Barry::JDWP
 844