00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "m_javaloader.h"
00026 #include "data.h"
00027 #include "protocol.h"
00028 #include "protostructs.h"
00029 #include "packet.h"
00030 #include "endian.h"
00031 #include "error.h"
00032 #include "usbwrap.h"
00033 #include "controller.h"
00034 #include "cod.h"
00035 #include <stdexcept>
00036 #include <sstream>
00037 #include <iomanip>
00038 #include <vector>
00039 #include <string.h>
00040 #include <time.h>
00041 #include <stdio.h>
00042
00043 #include "debug.h"
00044
00045 using namespace std;
00046
00047 namespace Barry {
00048
00049
00050
00051
00052
00053 JLScreenInfo::JLScreenInfo()
00054 {
00055 }
00056
00057 JLScreenInfo::~JLScreenInfo()
00058 {
00059 }
00060
00061
00062
00063
00064
00065
00066 JLDirectory::JLDirectory(int level)
00067 : m_level(level)
00068 {
00069 }
00070
00071 JLDirectory::~JLDirectory()
00072 {
00073 }
00074
00075 void JLDirectory::ParseTable(const Data &table_packet)
00076 {
00077 m_idTable.clear();
00078
00079 size_t count = table_packet.GetSize() / 2;
00080 uint16_t *item = (uint16_t*) table_packet.GetData();
00081 for( size_t i = 0; i < count; i++, item++ ) {
00082 m_idTable.push_back( be_btohs(*item) );
00083 }
00084 }
00085
00086 void JLDirectory::Dump(std::ostream &os) const
00087 {
00088 int indent = m_level * 2;
00089
00090 os << setfill(' ') << setw(indent) << "";
00091 os << "Directory: " << m_idTable.size() << "/" << size() << " entries\n";
00092
00093 const_iterator i = begin(), e = end();
00094 for( ; i != e; ++i ) {
00095 os << setfill(' ') << setw(indent + 2) << "";
00096 os << *i << "\n";
00097 }
00098 }
00099
00100
00101
00102
00103
00104
00105 JLDirectoryEntry::JLDirectoryEntry(int level)
00106 : m_level(level)
00107 , SubDir(level + 1)
00108 {
00109 }
00110
00111 void JLDirectoryEntry::Parse(uint16_t id, const Data &entry_packet)
00112 {
00113 size_t needed = SB_JLDIRENTRY_HEADER_SIZE;
00114 size_t have = entry_packet.GetSize();
00115 if( have < needed )
00116 throw BadSize("JLDE:Parse(1)", have, needed);
00117
00118 const unsigned char *ptr = entry_packet.GetData();
00119 Protocol::JLDirEntry *entry = (Protocol::JLDirEntry*) ptr;
00120
00121 Id = id;
00122 Timestamp = be_btohl(entry->timestamp);
00123
00124 uint16_t len = be_btohs(entry->filename_size);
00125 needed += len;
00126 if( have < needed )
00127 throw BadSize("JLDE:Parse(2)", have, needed);
00128 Name.assign((char *)entry->filename, len);
00129
00130
00131 ptr += needed;
00132 needed += 2;
00133 if( have < needed )
00134 throw BadSize("JLDE:Parse(3)", have, needed);
00135
00136 len = be_btohs( *((uint16_t*)(ptr)) );
00137 ptr += sizeof(uint16_t);
00138 needed += len;
00139 if( have < needed )
00140 throw BadSize("JLDE:Parse(4)", have, needed);
00141 Version.assign((char*)ptr, len);
00142
00143
00144 ptr += len;
00145 needed += sizeof(uint32_t);
00146 if( have < needed )
00147 throw BadSize("JLDE:Parse(5)", have, needed);
00148 CodSize = be_btohl( *((uint32_t*)(ptr)) );
00149 }
00150
00151 void JLDirectoryEntry::Dump(std::ostream &os) const
00152 {
00153 os << left << setfill(' ') << setw(50) << Name;
00154
00155 os << "\n";
00156 os << left << setw(28) << " ";
00157
00158 os << "0x" << setfill('0') << setw(4) << hex << Id;
00159 os << " " << setw(10) << Version;
00160 os << " " << setw(7) << std::dec << CodSize;
00161
00162 std::string ts = ctime(&Timestamp);
00163 ts.erase(ts.size() - 1);
00164 os << " " << ts;
00165
00166 if( SubDir.size() )
00167 os << "\n" << SubDir;
00168 }
00169
00170
00171
00172
00173
00174 void JLEventlog::Dump(std::ostream &os) const
00175 {
00176 const_iterator i = begin(), e = end();
00177 for( ; i != e; ++i ) {
00178 (*i).Dump(os);
00179 }
00180 }
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194 JLEventlogEntry::Severity_t JLEventlogEntry::SeverityProto2Rec(unsigned int s)
00195 {
00196 return (Severity_t)s;
00197 }
00198
00199 unsigned int JLEventlogEntry::SeverityRec2Proto(Severity_t s)
00200 {
00201 return s;
00202 }
00203
00204 JLEventlogEntry::ViewerType_t JLEventlogEntry::ViewerTypeProto2Rec(unsigned int v)
00205 {
00206 return (ViewerType_t)v;
00207 }
00208
00209 unsigned int JLEventlogEntry::ViewerTypeRec2Proto(ViewerType_t v)
00210 {
00211 return v;
00212 }
00213
00214
00215
00216
00217
00218 void JLEventlogEntry::Parse(uint16_t size, const char* buf)
00219 {
00220
00221
00222
00223 std::string src = std::string(buf, size);
00224 std::istringstream ss(src);
00225
00226 ss.ignore(5);
00227 ss >> Guid;
00228 if( ss.fail() )
00229 throw BadData("JLEventlogEntry:Parse bad guid field");
00230
00231 ss.ignore(6);
00232 ss >> hex >> MSTimestamp;
00233 if( ss.fail() )
00234 throw BadData("JLEventlogEntry:Parse bad time field");
00235
00236 ss.ignore(10);
00237 unsigned int severity;
00238 ss >> severity;
00239 Severity = SeverityProto2Rec(severity);
00240 if( ss.fail() )
00241 throw BadData("JLEventlogEntry:Parse bad severity field");
00242
00243 ss.ignore(6);
00244 unsigned int type;
00245 ss >> type;
00246 Type = ViewerTypeProto2Rec(type);
00247 if( ss.fail() )
00248 throw BadData("JLEventlogEntry:Parse bad type field");
00249
00250 ss.ignore(5);
00251 ss >> App;
00252 if( ss.fail() )
00253 throw BadData("JLEventlogEntry:Parse bad app field");
00254
00255 ss.ignore(6);
00256
00257
00258 stringbuf databuf;
00259 ss >> &databuf;
00260 if( ss.fail() )
00261 throw BadData("JLEventlogEntry:Parse bad data field");
00262
00263 Data = databuf.str();
00264 }
00265
00266 std::string JLEventlogEntry::GetFormattedTimestamp() const
00267 {
00268 char buf[21];
00269 struct tm split;
00270 time_t timestamp = (time_t) (MSTimestamp / 1000);
00271
00272 if( localtime_r(×tamp, &split) == NULL )
00273 return "";
00274
00275 if( strftime(buf, sizeof(buf), "%Y/%m/%d %H:%M:%S.", &split) == 0 )
00276 return "";
00277
00278 std::ostringstream oss;
00279 oss << buf << (MSTimestamp % 1000);
00280 return oss.str();
00281 }
00282
00283 void JLEventlogEntry::Dump(std::ostream &os) const
00284 {
00285 static const char *SeverityNames[] = { "Always Log", "Severe Error", "Error",
00286 "Warning", "Information", "Debug Info"};
00287 static const char *ViewerTypes[] = { "", "Number", "String", "Exception" };
00288
00289 os << "guid:" << Guid;
00290 os << " time:" << GetFormattedTimestamp();
00291 os << " severity:" << SeverityNames[Severity];
00292 os << " type:" << ViewerTypes[Type];
00293 os << " app:" << App;
00294 os << " data:" << Data << endl;
00295 }
00296
00297
00298
00299
00300
00301 void JLDeviceInfo::Dump(std::ostream &os) const
00302 {
00303 os << left << setfill(' ') << setw(17) << "Hardware Id:";
00304 os << "0x" << hex << HardwareId << endl;
00305
00306 os << left << setfill(' ') << setw(17) << "PIN:";
00307 os << "0x" << hex << Pin << endl;
00308
00309 os << left << setfill(' ') << setw(17) << "OS Version:";
00310 os << dec << OsVersion.Major << '.' << OsVersion.Minor << '.' << OsVersion.SubMinor << '.' << OsVersion.Build << endl;
00311
00312 os << left << setfill(' ') << setw(17) << "VM Version:";
00313 os << dec << VmVersion.Major << '.' << VmVersion.Minor << '.' << VmVersion.SubMinor << '.' << VmVersion.Build << endl;
00314
00315 os << left << setfill(' ') << setw(17) << "Radio ID:";
00316 os << "0x" << hex << RadioId << endl;
00317
00318 os << left << setfill(' ') << setw(17) << "Vendor ID:";
00319 os << dec << VendorId << endl;
00320
00321 os << left << setfill(' ') << setw(17) << "Active WAFs:";
00322 os << "0x" << hex << ActiveWafs << endl;
00323
00324 os << left << setfill(' ') << setw(17) << "OS Metrics:" << endl;
00325 os << OsMetrics;
00326
00327 os << left << setfill(' ') << setw(17) << "Bootrom Metrics:" << endl;
00328 os << BootromMetrics;
00329 }
00330
00331
00332 namespace Mode {
00333
00334
00335
00336
00337 JavaLoader::JavaLoader(Controller &con)
00338 : Mode(con, Controller::JavaLoader)
00339 , m_StreamStarted(false)
00340 {
00341 }
00342
00343 JavaLoader::~JavaLoader()
00344 {
00345 if( m_StreamStarted )
00346 StopStream();
00347 }
00348
00349
00350
00351
00352
00353
00354
00355
00356 void JavaLoader::OnOpen()
00357 {
00358 Data response;
00359 m_socket->Receive(response, -1);
00360 }
00361
00362
00363 void JavaLoader::StartStream()
00364 {
00365 Data cmd(-1, 8), data(-1, 8), response;
00366 JLPacket packet(cmd, data, response);
00367
00368 packet.Hello();
00369 m_socket->Packet(packet);
00370
00371 if( packet.Command() != SB_COMMAND_JL_HELLO_ACK ) {
00372 ThrowJLError("JavaLoader::StartStream Hello", packet.Command());
00373 }
00374
00375 packet.SetUnknown1();
00376 m_socket->Packet(packet);
00377
00378 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00379 ThrowJLError("JavaLoader::StartStream Unknown1", packet.Command());
00380 }
00381
00382 m_StreamStarted = true;
00383 }
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416 void JavaLoader::SendStream(std::istream &input, size_t module_size)
00417 {
00418 char buffer[MAX_PACKET_DATA_SIZE - SB_JLPACKET_HEADER_SIZE];
00419 size_t max_data_size = sizeof(buffer);
00420
00421 size_t remaining = module_size;
00422
00423 Data cmd(-1, 8), data(-1, 8), response;
00424 JLPacket packet(cmd, data, response);
00425
00426 packet.SetCodSize(module_size);
00427 m_socket->Packet(packet);
00428
00429 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00430 ThrowJLError("JavaLoader::SendStream set code size", packet.Command());
00431 }
00432
00433 while( remaining > 0 ) {
00434 size_t size = min(remaining, max_data_size);
00435
00436 input.read(buffer, size);
00437 if( input.fail() || (size_t)input.gcount() != size ) {
00438 throw Error("JavaLoader::SendStream input stream read failed");
00439 }
00440
00441 packet.PutData(buffer, size);
00442 m_socket->Packet(packet);
00443
00444 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00445 ThrowJLError("JavaLoader::SendStream send data", packet.Command());
00446 }
00447
00448 remaining -= size;
00449 }
00450 }
00451
00452 void JavaLoader::LoadApp(std::istream &input)
00453 {
00454 uint32_t module_size;
00455 while( (module_size = SeekNextCod(input)) != 0 ) {
00456 SendStream(input, module_size);
00457 }
00458 }
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470 bool JavaLoader::StopStream()
00471 {
00472 Data cmd(-1, 8), data(-1, 8), response;
00473
00474 JLPacket packet(cmd, data, response);
00475 packet.Goodbye();
00476 try {
00477 m_socket->Packet(packet);
00478 } catch( BadPacket &bp ) {
00479
00480
00481
00482
00483
00484 if( bp.response() != SB_COMMAND_JL_NOT_SUPPORTED )
00485 throw;
00486 }
00487
00488 m_StreamStarted = false;
00489
00490 if( packet.Command() == SB_COMMAND_JL_RESET_REQUIRED ) {
00491 m_con.m_zero.SetResetOnClose(true);
00492 return true;
00493 }
00494 else if( packet.Command() != SB_COMMAND_JL_ACK &&
00495 packet.Command() != SB_COMMAND_JL_NOT_SUPPORTED )
00496 {
00497 ThrowJLError("JavaLoader::StopStream", packet.Command());
00498 }
00499
00500 return false;
00501 }
00502
00503 void JavaLoader::SetTime(time_t when)
00504 {
00505 Data cmd(-1, 8), data(-1, 8), response;
00506
00507 JLPacket packet(cmd, data, response);
00508 packet.SetTime(when);
00509 m_socket->Packet(packet);
00510 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00511 ThrowJLError("JavaLoader::SetTime", packet.Command());
00512 }
00513 }
00514
00515 void JavaLoader::ThrowJLError(const std::string &msg, uint8_t cmd)
00516 {
00517 std::ostringstream oss;
00518 oss << msg << ": unexpected packet command code: 0x"
00519 << std::hex << (unsigned int) cmd;
00520 throw Error(oss.str());
00521 }
00522
00523 void JavaLoader::GetDirectoryEntries(JLPacket &packet,
00524 uint8_t entry_cmd,
00525 JLDirectory &dir,
00526 bool include_subdirs)
00527 {
00528 JLDirectory::TableIterator i = dir.TableBegin(), e = dir.TableEnd();
00529 for( ; i != e; ++i ) {
00530 packet.GetDirEntry(entry_cmd, *i);
00531 m_socket->Packet(packet);
00532 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00533 ThrowJLError("JavaLoader::GetDirectoryEntries", packet.Command());
00534 }
00535
00536 Data &response = packet.GetReceive();
00537 m_socket->Receive(response);
00538 JLDirectoryEntry entry(dir.Level());
00539 Protocol::CheckSize(response, 4);
00540 entry.Parse(*i, Data(response.GetData() + 4, response.GetSize() - 4));
00541
00542 if( include_subdirs ) {
00543 packet.GetSubDir(*i);
00544 GetDir(packet, SB_COMMAND_JL_GET_SUBDIR_ENTRY, entry.SubDir, false);
00545 }
00546
00547
00548 dir.push_back(entry);
00549 }
00550 }
00551
00552 void JavaLoader::GetDir(JLPacket &packet,
00553 uint8_t entry_cmd,
00554 JLDirectory &dir,
00555 bool include_subdirs)
00556 {
00557 m_socket->Packet(packet);
00558 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00559 ThrowJLError("JavaLoader::GetDir", packet.Command());
00560 }
00561
00562
00563 unsigned int expect = packet.Size();
00564
00565 if( expect > 0 ) {
00566 Data &response = packet.GetReceive();
00567 m_socket->Receive(response);
00568 Protocol::CheckSize(response, 4);
00569 dir.ParseTable(Data(response.GetData() + 4, response.GetSize() - 4));
00570 GetDirectoryEntries(packet, entry_cmd, dir, include_subdirs);
00571 }
00572 }
00573
00574 void JavaLoader::GetDirectory(JLDirectory &dir, bool include_subdirs)
00575 {
00576 Data cmd(-1, 8), data(-1, 8), response;
00577 JLPacket packet(cmd, data, response);
00578
00579 packet.GetDirectory();
00580 GetDir(packet, SB_COMMAND_JL_GET_DATA_ENTRY, dir, include_subdirs);
00581 }
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608
00609
00610
00611 void JavaLoader::GetScreenshot(JLScreenInfo &info, Data &image)
00612 {
00613
00614 image.Zap();
00615
00616 Data cmd(-1, 8), data(-1, 8), response;
00617 JLPacket packet(cmd, data, response);
00618
00619
00620
00621 packet.GetScreenshot();
00622
00623 m_socket->Packet(packet);
00624
00625 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00626 ThrowJLError("JavaLoader::GetScreenshot", packet.Command());
00627 }
00628
00629
00630
00631
00632
00633
00634
00635
00636 m_socket->Receive(response);
00637
00638
00639 Protocol::CheckSize(response, SB_JLPACKET_HEADER_SIZE + SB_JLSCREENINFO_SIZE);
00640 MAKE_JLPACKET(rpack, response);
00641
00642 info.width = be_btohs(rpack->u.screeninfo.width);
00643 info.height = be_btohs(rpack->u.screeninfo.height);
00644
00645
00646
00647 for (;;) {
00648
00649
00650 packet.GetData();
00651
00652 m_socket->Packet(packet);
00653
00654
00655
00656
00657
00658
00659 if( packet.Command() == SB_COMMAND_JL_ACK )
00660 return;
00661
00662 if( packet.Command() != SB_COMMAND_JL_GET_DATA_ENTRY ) {
00663 ThrowJLError("JavaLoader::GetScreenShot ", packet.Command());
00664 }
00665
00666
00667 size_t expect = packet.Size();
00668
00669
00670
00671 m_socket->Receive(response);
00672
00673
00674
00675 Protocol::CheckSize(response, 4);
00676 const unsigned char *pd = response.GetData();
00677 size_t bytereceived = response.GetSize() - 4;
00678
00679
00680
00681 if( expect != bytereceived ) {
00682 ThrowJLError("JavaLoader::GetScreenShot expect", expect);
00683 }
00684
00685
00686
00687 unsigned char *buffer = image.GetBuffer(image.GetSize() + bytereceived);
00688 memcpy(buffer + image.GetSize(), pd + 4, bytereceived);
00689
00690
00691 image.ReleaseBuffer(image.GetSize() + bytereceived);
00692 }
00693 }
00694
00695 void JavaLoader::DoErase(uint8_t cmd, const std::string &cod_name)
00696 {
00697 Data command(-1, 8), data(-1, 8), response;
00698
00699 JLPacket packet(command, data, response);
00700
00701
00702 packet.SetCodFilename(cod_name);
00703 m_socket->Packet(packet);
00704 if( packet.Command() == SB_COMMAND_JL_COD_NOT_FOUND ) {
00705 throw Error(string("JavaLoader::DoErase: module ") + cod_name + " not found");
00706 }
00707 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00708 ThrowJLError("JavaLoader::DoErase", packet.Command());
00709 }
00710
00711
00712 if( packet.Size() != 2 )
00713 throw Error("JavaLoader::DoErase: expected code not available");
00714
00715
00716 m_socket->Receive(response);
00717 Protocol::CheckSize(response, SB_JLPACKET_HEADER_SIZE + sizeof(uint16_t));
00718 MAKE_JLPACKET(jpack, response);
00719 uint16_t id = be_btohs(jpack->u.id);
00720
00721
00722 packet.Erase(cmd, id);
00723 m_socket->Packet(packet);
00724 if( packet.Command() == SB_COMMAND_JL_COD_IN_USE ) {
00725 throw Error("JavaLoader::DoErase: COD file in use.");
00726 }
00727 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00728 ThrowJLError("JavaLoader::DoErase", packet.Command());
00729 }
00730 }
00731
00732 void JavaLoader::Erase(const std::string &cod_name)
00733 {
00734 DoErase(SB_COMMAND_JL_ERASE, cod_name);
00735 }
00736
00737 void JavaLoader::ForceErase(const std::string &cod_name)
00738 {
00739 DoErase(SB_COMMAND_JL_FORCE_ERASE, cod_name);
00740 }
00741
00742 void JavaLoader::GetEventlog(JLEventlog &log)
00743 {
00744 Data command(-1, 8), data(-1, 8), response;
00745 JLPacket packet(command, data, response);
00746
00747 packet.GetEventlog();
00748
00749 m_socket->Packet(packet);
00750
00751 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00752 ThrowJLError("JavaLoader::GetEventlog", packet.Command());
00753 }
00754
00755 m_socket->Receive(response);
00756 Protocol::CheckSize(response, SB_JLPACKET_HEADER_SIZE + sizeof(uint16_t));
00757
00758
00759 MAKE_JLPACKET(jpack, response);
00760 uint16_t count = be_btohs(jpack->u.response.expect);
00761
00762 for( uint16_t i = 0; i < count; ++ i ) {
00763 packet.GetEventlogEntry(i);
00764
00765 m_socket->Packet(packet);
00766
00767 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00768 ThrowJLError("JavaLoader::GetEventlog", packet.Command());
00769 }
00770
00771 m_socket->Receive(response);
00772 Protocol::CheckSize(response, SB_JLPACKET_HEADER_SIZE + SB_JLEVENTLOG_ENTRY_HEADER_SIZE);
00773
00774 MAKE_JLPACKET(jpack, response);
00775 uint16_t size = be_btohs(jpack->u.logentry.size);
00776
00777 JLEventlogEntry entry;
00778 entry.Parse(size, (const char *)(response.GetData() + SB_JLPACKET_HEADER_SIZE + SB_JLEVENTLOG_ENTRY_HEADER_SIZE));
00779
00780 log.push_back(entry);
00781 }
00782 }
00783
00784 void JavaLoader::ClearEventlog()
00785 {
00786 Data command(-1, 8), data(-1, 8), response;
00787 JLPacket packet(command, data, response);
00788
00789 packet.ClearEventlog();
00790 m_socket->Packet(packet);
00791
00792 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00793 ThrowJLError("JavaLoader::ClearEventlog", packet.Command());
00794 }
00795 }
00796
00797 void JavaLoader::SaveData(JLPacket &packet, uint16_t id, CodFileBuilder &builder, std::ostream &output)
00798 {
00799 packet.SaveModule(id);
00800 m_socket->Packet(packet);
00801
00802 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00803 ThrowJLError("JavaLoader::SaveData", packet.Command());
00804 }
00805
00806
00807 Data &response = packet.GetReceive();
00808 m_socket->Receive(response);
00809 Protocol::CheckSize(response, SB_JLPACKET_HEADER_SIZE + sizeof(uint32_t));
00810 MAKE_JLPACKET(jpack, response);
00811 uint32_t total_size = be_btohl(jpack->u.cod_size);
00812
00813
00814 Data buffer(-1, total_size);
00815 uint32_t offset = 0;
00816
00817 for( ;; ) {
00818 packet.GetData();
00819 m_socket->Packet(packet);
00820
00821 if( packet.Command() == SB_COMMAND_JL_ACK )
00822 break;
00823
00824 if( packet.Command() != SB_COMMAND_JL_GET_DATA_ENTRY ) {
00825 ThrowJLError("JavaLoader::SaveData", packet.Command());
00826 }
00827
00828
00829 unsigned int expect = packet.Size();
00830
00831 m_socket->Receive(response);
00832 Protocol::CheckSize(response, SB_JLPACKET_HEADER_SIZE + expect);
00833
00834 memcpy(buffer.GetBuffer(offset + expect) + offset,
00835 response.GetData() + SB_JLPACKET_HEADER_SIZE,
00836 expect);
00837
00838 offset += expect;
00839 }
00840
00841 buffer.ReleaseBuffer(offset);
00842
00843 builder.WriteNextHeader(output, buffer.GetData(), buffer.GetSize());
00844 output.write((const char *)buffer.GetData(), buffer.GetSize());
00845 }
00846
00847 void JavaLoader::Save(const std::string &cod_name, std::ostream &output)
00848 {
00849 Data command(-1, 8), data(-1, 8), response;
00850
00851 JLPacket packet(command, data, response);
00852
00853
00854 packet.SetCodFilename(cod_name);
00855 m_socket->Packet(packet);
00856
00857 if( packet.Command() == SB_COMMAND_JL_COD_NOT_FOUND ) {
00858 throw Error(string("JavaLoader::Save: module ") + cod_name + " not found");
00859 }
00860
00861 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00862 ThrowJLError("JavaLoader::Save", packet.Command());
00863 }
00864
00865
00866 if( packet.Size() != 2 )
00867 throw Error("JavaLoader::Save: expected module ID");
00868
00869
00870 m_socket->Receive(response);
00871 Protocol::CheckSize(response, SB_JLPACKET_HEADER_SIZE + sizeof(uint16_t));
00872 MAKE_JLPACKET(jpack, response);
00873 uint16_t id = be_btohs(jpack->u.id);
00874
00875
00876 packet.GetSubDir(id);
00877 m_socket->Packet(packet);
00878
00879 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00880 ThrowJLError("JavaLoader::Save", packet.Command());
00881 }
00882
00883
00884 unsigned int expect = packet.Size();
00885
00886
00887 m_socket->Receive(response);
00888 Protocol::CheckSize(response, SB_JLPACKET_HEADER_SIZE + expect);
00889
00890
00891 size_t count = expect / 2;
00892 const uint16_t *begin = (const uint16_t*) (response.GetData() + SB_JLPACKET_HEADER_SIZE);
00893 const uint16_t *end = begin + count;
00894 vector<uint16_t> ids(begin, end);
00895
00896 CodFileBuilder builder(cod_name, count);
00897
00898
00899 for( size_t i = 0; i < count; i++ ) {
00900 SaveData(packet, be_btohs(ids[i]), builder, output);
00901 }
00902
00903 builder.WriteFooter(output);
00904 }
00905
00906 void JavaLoader::DeviceInfo(JLDeviceInfo &info)
00907 {
00908 Data command(-1, 8), data(-1, 8), response;
00909 JLPacket packet(command, data, response);
00910
00911 packet.DeviceInfo();
00912
00913 m_socket->Packet(packet);
00914
00915 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00916 ThrowJLError("JavaLoader::DeviceInfo", packet.Command());
00917 }
00918
00919 m_socket->Receive(response);
00920
00921 Protocol::CheckSize(response, SB_JLPACKET_HEADER_SIZE + SB_JLDEVICEINFO_SIZE);
00922 MAKE_JLPACKET(rpack, response);
00923
00924 info.HardwareId = be_btohl(rpack->u.devinfo.hardware_id);
00925 info.Pin = be_btohl(rpack->u.devinfo.pin);
00926 info.OsVersion = be_btohl(rpack->u.devinfo.os_version);
00927 info.VmVersion = be_btohl(rpack->u.devinfo.vm_version);
00928 info.RadioId = be_btohl(rpack->u.devinfo.radio_id);
00929 info.VendorId = be_btohl(rpack->u.devinfo.vendor_id);
00930 info.ActiveWafs = be_btohl(rpack->u.devinfo.active_wafs);
00931
00932 packet.OsMetrics();
00933
00934 m_socket->Packet(packet);
00935
00936 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00937 ThrowJLError("JavaLoader::DeviceInfo", packet.Command());
00938 }
00939
00940 m_socket->Receive(response);
00941 Protocol::CheckSize(response, SB_JLPACKET_HEADER_SIZE);
00942
00943 size_t offset = SB_JLPACKET_HEADER_SIZE;
00944 size_t size = response.GetSize()-offset;
00945 unsigned char* buf = info.OsMetrics.GetBuffer(size);
00946 memcpy(buf, response.GetData()+offset, size);
00947 info.OsMetrics.ReleaseBuffer(size);
00948
00949 packet.BootromMetrics();
00950
00951 m_socket->Packet(packet);
00952
00953 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00954 ThrowJLError("JavaLoader::DeviceInfo", packet.Command());
00955 }
00956
00957 m_socket->Receive(response);
00958 Protocol::CheckSize(response, SB_JLPACKET_HEADER_SIZE);
00959
00960 offset = SB_JLPACKET_HEADER_SIZE;
00961 size = response.GetSize()-offset;
00962 buf = info.BootromMetrics.GetBuffer(size);
00963 memcpy(buf, response.GetData()+offset, size);
00964 info.BootromMetrics.ReleaseBuffer(size);
00965 }
00966
00967 void JavaLoader::Wipe(bool apps, bool fs)
00968 {
00969 Data command(-1, 8), data(-1, 8), response;
00970 JLPacket packet(command, data, response);
00971
00972 if( apps ) {
00973 packet.WipeApps();
00974 m_socket->Packet(packet);
00975
00976 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00977 ThrowJLError("JavaLoader::WipeApps", packet.Command());
00978 }
00979 }
00980
00981 if( fs ) {
00982 packet.WipeFs();
00983 m_socket->Packet(packet);
00984
00985 if( packet.Command() != SB_COMMAND_JL_ACK ) {
00986 ThrowJLError("JavaLoader::WipeFs", packet.Command());
00987 }
00988 }
00989 }
00990
00991 void JavaLoader::LogStackTraces()
00992 {
00993 Data command(-1, 8), data(-1, 8), response;
00994 JLPacket packet(command, data, response);
00995
00996 packet.LogStackTraces();
00997 m_socket->Packet(packet);
00998
00999 if( packet.Command() != SB_COMMAND_JL_ACK ) {
01000 ThrowJLError("JavaLoader::LogStackTraces", packet.Command());
01001 }
01002 }
01003
01004 void JavaLoader::ResetToFactory()
01005 {
01006 Data command(-1, 8), data(-1, 8), response;
01007 JLPacket packet(command, data, response);
01008
01009 packet.ResetToFactory();
01010 m_socket->Packet(packet);
01011
01012 if( packet.Command() != SB_COMMAND_JL_ACK ) {
01013 ThrowJLError("JavaLoader::ResetToFactory", packet.Command());
01014 }
01015 }
01016
01017 }}
01018