m_javaloader.h

Go to the documentation of this file.
00001 ///
00002 /// \file       m_javaloader.h
00003 ///             Mode class for the JavaLoader mode
00004 ///
00005 
00006 /*
00007     Copyright (C) 2005-2010, Net Direct Inc. (http://www.netdirect.ca/)
00008     Copyright (C) 2008-2009, Nicolas VIVIEN
00009 
00010         Some parts are inspired from m_desktop.h
00011 
00012     This program is free software; you can redistribute it and/or modify
00013     it under the terms of the GNU General Public License as published by
00014     the Free Software Foundation; either version 2 of the License, or
00015     (at your option) any later version.
00016 
00017     This program is distributed in the hope that it will be useful,
00018     but WITHOUT ANY WARRANTY; without even the implied warranty of
00019     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00020 
00021     See the GNU General Public License in the COPYING file at the
00022     root directory of this project for more details.
00023 */
00024 
00025 #ifndef __BARRY_M_JAVALOADER_H__
00026 #define __BARRY_M_JAVALOADER_H__
00027 
00028 #include "dll.h"
00029 #include "m_mode_base.h"
00030 #include "socket.h"
00031 #include "record.h"
00032 #include "data.h"
00033 #include "pin.h"
00034 
00035 namespace Barry {
00036 
00037 // forward declarations
00038 class Parser;
00039 class Builder;
00040 class Controller;
00041 class CodFileBuilder;
00042 
00043 class JLDirectoryEntry;
00044 
00045 class JLEventlogEntry;
00046 
00047 class BXEXPORT JLDirectory : public std::vector<JLDirectoryEntry>
00048 {
00049 public:
00050         typedef std::vector<JLDirectoryEntry>   BaseType;
00051         typedef BaseType::iterator              BaseIterator;
00052         typedef std::vector<uint16_t>           TableType;
00053         typedef TableType::iterator             TableIterator;
00054 
00055 private:
00056         TableType m_idTable;
00057 
00058         int m_level;
00059 
00060 public:
00061         JLDirectory(int level = 0);
00062         ~JLDirectory();
00063 
00064         int Level() const { return m_level; }
00065         TableIterator TableBegin() { return m_idTable.begin(); }
00066         TableIterator TableEnd()   { return m_idTable.end(); }
00067 
00068         void ParseTable(const Data &table_packet);
00069 
00070         void Dump(std::ostream &os) const;
00071 };
00072 BXEXPORT inline std::ostream& operator<<(std::ostream &os, const JLDirectory &d) {
00073         d.Dump(os);
00074         return os;
00075 }
00076 
00077 class BXEXPORT JLDirectoryEntry
00078 {
00079 private:
00080         int m_level;
00081 
00082 public:
00083         uint16_t Id;
00084         std::string Name;
00085         std::string Version;
00086         uint32_t CodSize;
00087         time_t Timestamp;
00088 
00089         JLDirectory SubDir;
00090 
00091 public:
00092         explicit JLDirectoryEntry(int level);
00093 
00094         void Parse(uint16_t id, const Data &entry_packet);
00095 
00096         void Dump(std::ostream &os) const;
00097 };
00098 BXEXPORT inline std::ostream& operator<<(std::ostream &os, const JLDirectoryEntry &e) {
00099         e.Dump(os);
00100         return os;
00101 }
00102 
00103 
00104 class BXEXPORT JLScreenInfo {
00105 public:
00106         uint16_t width;
00107         uint16_t height;
00108 
00109 public:
00110         JLScreenInfo();
00111         ~JLScreenInfo();
00112 };
00113 
00114 
00115 class BXEXPORT JLEventlog : public std::vector<JLEventlogEntry>
00116 {
00117 public:
00118         void Dump(std::ostream &os) const;
00119 };
00120 BXEXPORT inline std::ostream& operator<<(std::ostream &os, const JLEventlog &log) {
00121         log.Dump(os);
00122         return os;
00123 }
00124 
00125 
00126 class BXEXPORT JLEventlogEntry
00127 {
00128 public:
00129         typedef enum {
00130                 ALWAYS_LOG,
00131                 SEVERE_ERROR,
00132                 ERROR,
00133                 WARNING,
00134                 INFORMATION,
00135                 DEBUG_INFO
00136         } Severity_t;
00137 
00138         typedef enum {
00139                 NUMBER = 1,
00140                 STRING,
00141                 EXCEPTION
00142         } ViewerType_t;
00143 
00144         std::string     Guid;
00145         uint64_t        MSTimestamp;    // time_t in milliseconds
00146         Severity_t      Severity;
00147         ViewerType_t    Type;
00148         std::string     App;
00149         std::string     Data;
00150 
00151 protected:
00152         static Severity_t SeverityProto2Rec(unsigned int s);
00153         static unsigned int SeverityRec2Proto(Severity_t s);
00154 
00155         static ViewerType_t ViewerTypeProto2Rec(unsigned int v);
00156         static unsigned int ViewerTypeRec2Proto(ViewerType_t v);
00157 
00158 public:
00159         void Parse(uint16_t size, const char* str);
00160 
00161         std::string GetFormattedTimestamp() const;
00162 
00163         void Dump(std::ostream &os) const;
00164 };
00165 
00166 
00167 class BXEXPORT JLDeviceInfo
00168 {
00169 public:
00170         struct VersionQuad {
00171                 VersionQuad() { }
00172                 VersionQuad(uint32_t v) {
00173                         Major = (v & 0xff000000) >> 24;
00174                         Minor = (v & 0xff0000) >> 16;
00175                         SubMinor = (v & 0xff00) >> 8;
00176                         Build = (v & 0xff);
00177                 }
00178 
00179                 unsigned int Major;
00180                 unsigned int Minor;
00181                 unsigned int SubMinor;
00182                 unsigned int Build;
00183         };
00184 
00185 public:
00186         uint32_t        HardwareId;
00187         struct Pin      Pin;
00188         VersionQuad     OsVersion;
00189         VersionQuad     VmVersion;
00190         uint32_t        RadioId;
00191         uint32_t        VendorId;
00192         uint32_t        ActiveWafs;
00193         Data            OsMetrics;
00194         Data            BootromMetrics;
00195 
00196 public:
00197         void Dump(std::ostream &os) const;
00198 };
00199 BXEXPORT inline std::ostream& operator<<(std::ostream &os, const JLDeviceInfo &info) {
00200         info.Dump(os);
00201         return os;
00202 }
00203 
00204 
00205 namespace Mode {
00206 
00207 //
00208 // JavaLoader class
00209 //
00210 /// The main interface class to the java program loader protocol
00211 ///
00212 /// To use this class, use the following steps:
00213 ///
00214 ///     - Create a Controller object (see Controller class for more details)
00215 ///     - Create this Mode::JavaLoader object, passing in the Controller
00216 ///             object during construction
00217 ///     - Call Open() to open database socket and finish constructing.
00218 ///     - Call LoadDatabase() to retrieve and store a database
00219 ///
00220 class BXEXPORT JavaLoader : public Mode
00221 {
00222 private:
00223         bool m_StreamStarted;
00224 
00225 protected:
00226         void GetDirectoryEntries(JLPacket &packet, uint8_t entry_cmd,
00227                 JLDirectory &dir, bool include_subdirs);
00228         void GetDir(JLPacket &packet, uint8_t entry_cmd, JLDirectory &dir,
00229                 bool include_subdirs);
00230         void ThrowJLError(const std::string &msg, uint8_t cmd);
00231         void DoErase(uint8_t cmd, const std::string &cod_name);
00232         void SaveData(JLPacket &packet, uint16_t, CodFileBuilder &builder,
00233                 std::ostream &output);
00234 
00235         //////////////////////////////////
00236         // overrides
00237 
00238         virtual void OnOpen();
00239 
00240 public:
00241         JavaLoader(Controller &con);
00242         ~JavaLoader();
00243 
00244         //////////////////////////////////
00245         // API
00246         void StartStream();
00247         bool StopStream();
00248 
00249         // mid-stream operations
00250         void SendStream(std::istream &input, size_t module_size);
00251         void LoadApp(std::istream &input);
00252         void SetTime(time_t when);
00253         void GetDirectory(JLDirectory &dir, bool include_subdirs);
00254         void GetScreenshot(JLScreenInfo &info, Data &image);
00255         void Erase(const std::string &cod_name);
00256         void ForceErase(const std::string &cod_name);
00257         void GetEventlog(JLEventlog &log);
00258         void ClearEventlog();
00259         void Save(const std::string &cod_name, std::ostream &output);
00260         void DeviceInfo(JLDeviceInfo &info);
00261         void Wipe(bool apps = true, bool fs = true);
00262         void LogStackTraces();
00263         void ResetToFactory();
00264 };
00265 
00266 }} // namespace Barry::Mode
00267 
00268 #endif
00269 
Generated by  doxygen 1.6.2-20100208