src/m_javaloader.h

   1 ///
   2 /// \file       m_javaloader.h
   3 ///             Mode class for the JavaLoader mode
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2009, Net Direct Inc. (http://www.netdirect.ca/)
   8     Copyright (C) 2008-2009, Nicolas VIVIEN
   9
  10         Some parts are inspired from m_desktop.h
  11
  12     This program is free software; you can redistribute it and/or modify
  13     it under the terms of the GNU General Public License as published by
  14     the Free Software Foundation; either version 2 of the License, or
  15     (at your option) any later version.
  16
  17     This program is distributed in the hope that it will be useful,
  18     but WITHOUT ANY WARRANTY; without even the implied warranty of
  19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  20
  21     See the GNU General Public License in the COPYING file at the
  22     root directory of this project for more details.
  23 */
  24
  25 #ifndef __BARRY_M_JAVALOADER_H__
  26 #define __BARRY_M_JAVALOADER_H__
  27
  28 #include "dll.h"
  29 #include "socket.h"
  30 #include "record.h"
  31
  32 namespace Barry {
  33
  34 // forward declarations
  35 class Parser;
  36 class Builder;
  37 class Controller;
  38 class CodFile;
  39 class CodFileBuilder;
  40
  41 class JLDirectoryEntry;
  42
  43 class JLEventlogEntry;
  44
  45 class BXEXPORT JLDirectory : public std::vector<JLDirectoryEntry>
  46 {
  47 public:
  48         typedef std::vector<JLDirectoryEntry>   BaseType;
  49         typedef BaseType::iterator              BaseIterator;
  50         typedef std::vector<uint16_t>           TableType;
  51         typedef TableType::iterator             TableIterator;
  52
  53 private:
  54         TableType m_idTable;
  55
  56         int m_level;
  57
  58 public:
  59         JLDirectory(int level = 0);
  60         ~JLDirectory();
  61
  62         int Level() const { return m_level; }
  63         TableIterator TableBegin() { return m_idTable.begin(); }
  64         TableIterator TableEnd()   { return m_idTable.end(); }
  65
  66         void ParseTable(const Data &table_packet);
  67
  68         void Dump(std::ostream &os) const;
  69 };
  70 BXEXPORT inline std::ostream& operator<<(std::ostream &os, const JLDirectory &d) {
  71         d.Dump(os);
  72         return os;
  73 }
  74
  75 class BXEXPORT JLDirectoryEntry
  76 {
  77 private:
  78         int m_level;
  79
  80 public:
  81         uint16_t Id;
  82         std::string Name;
  83         std::string Version;
  84         uint32_t CodSize;
  85         time_t Timestamp;
  86
  87         JLDirectory SubDir;
  88
  89 public:
  90         explicit JLDirectoryEntry(int level);
  91
  92         void Parse(uint16_t id, const Data &entry_packet);
  93
  94         void Dump(std::ostream &os) const;
  95 };
  96 BXEXPORT inline std::ostream& operator<<(std::ostream &os, const JLDirectoryEntry &e) {
  97         e.Dump(os);
  98         return os;
  99 }
 100
 101
 102 class BXEXPORT JLScreenInfo {
 103 public:
 104         uint16_t width;
 105         uint16_t height;
 106
 107 public:
 108         JLScreenInfo();
 109         ~JLScreenInfo();
 110 };
 111
 112
 113 class BXEXPORT JLEventlog : public std::vector<JLEventlogEntry>
 114 {
 115 public:
 116         void Dump(std::ostream &os) const;
 117 };
 118 BXEXPORT inline std::ostream& operator<<(std::ostream &os, const JLEventlog &log) {
 119         log.Dump(os);
 120         return os;
 121 }
 122
 123
 124 class BXEXPORT JLEventlogEntry
 125 {
 126 public:
 127         typedef enum {
 128                 ALWAYS_LOG,
 129                 SEVERE_ERROR,
 130                 ERROR,
 131                 WARNING,
 132                 INFORMATION,
 133                 DEBUG_INFO
 134         } Severity_t;
 135
 136         typedef enum {
 137                 NUMBER = 1,
 138                 STRING,
 139                 EXCEPTION
 140         } ViewerType_t;
 141
 142         std::string  Guid;
 143         uint64_t     Timestamp; //FIXME what is this? time since epoch? eg: 0x11F133E6470
 144         Severity_t   Severity;
 145         ViewerType_t Type;
 146         std::string  App;
 147         std::string  Data;
 148
 149 protected:
 150         static Severity_t SeverityProto2Rec(unsigned int s);
 151         static unsigned int SeverityRec2Proto(Severity_t s);
 152
 153         static ViewerType_t ViewerTypeProto2Rec(unsigned int v);
 154         static unsigned int ViewerTypeRec2Proto(ViewerType_t v);
 155
 156 public:
 157         void Parse(uint16_t size, const char* str);
 158
 159         void Dump(std::ostream &os) const;
 160 };
 161
 162
 163 namespace Mode {
 164
 165 //
 166 // JavaLoader class
 167 //
 168 /// The main interface class to the java program loader protocol
 169 ///
 170 /// To use this class, use the following steps:
 171 ///
 172 ///     - Create a Controller object (see Controller class for more details)
 173 ///     - Create this Mode::JavaLoader object, passing in the Controller
 174 ///             object during construction
 175 ///     - Call Open() to open database socket and finish constructing.
 176 ///     - Call LoadDatabase() to retrieve and store a database
 177 ///
 178 class BXEXPORT JavaLoader
 179 {
 180 private:
 181         Controller &m_con;
 182
 183         SocketHandle m_socket;
 184
 185         uint16_t m_ModeSocket;                  // socket recommended by device
 186                                                 // when mode was selected
 187
 188         bool m_StreamStarted;
 189
 190 protected:
 191         void GetDirectoryEntries(JLPacket &packet, uint8_t entry_cmd,
 192                 JLDirectory &dir, bool include_subdirs);
 193         void GetDir(JLPacket &packet, uint8_t entry_cmd, JLDirectory &dir,
 194                 bool include_subdirs);
 195         void ThrowJLError(const std::string &msg, uint8_t cmd);
 196         void DoErase(uint8_t cmd, const std::string &cod_name);
 197         void SaveData(JLPacket &packet, uint16_t, CodFileBuilder &builder,
 198                 std::ostream &output);
 199
 200 public:
 201         JavaLoader(Controller &con);
 202         ~JavaLoader();
 203
 204         //////////////////////////////////
 205         // primary operations - required before anything else
 206
 207         void Open(const char *password = 0);
 208         void RetryPassword(const char *password);
 209
 210         //////////////////////////////////
 211         // API
 212         void StartStream();
 213         bool StopStream();
 214
 215         // mid-stream operations
 216         void SendStream(std::istream &input, size_t module_size);
 217         void LoadApp(std::istream &input);
 218         void SetTime(time_t when);
 219         void GetDirectory(JLDirectory &dir, bool include_subdirs);
 220         void GetScreenshot(JLScreenInfo &info, Data &image);
 221         void Erase(const std::string &cod_name);
 222         void ForceErase(const std::string &cod_name);
 223         void GetEventlog(JLEventlog &log);
 224         void ClearEventlog();
 225         void Save(const std::string &cod_name, std::ostream &output);
 226 };
 227
 228 }} // namespace Barry::Mode
 229
 230 #endif
 231