src/a_osloader.cc

   1 ///
   2 /// \file       a_osloader.cc
   3 ///             OS files parser (multi ALX files parser)
   4 ///
   5
   6 /*
   7     Copyright (C) 2010, Nicolas VIVIEN
   8     Copyright (C) 2005-2010, Net Direct Inc. (http://www.netdirect.ca/)
   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 <iostream>
  24 #include <fstream>
  25 #include <algorithm>
  26
  27 #include <sys/types.h>
  28 #include <dirent.h>
  29 #include <errno.h>
  30
  31 #include "a_osloader.h"
  32 #include "a_alxparser.h"
  33 #include "vsmartptr.h"
  34 #include "error.h"
  35
  36
  37 namespace Barry {
  38
  39 namespace ALX {
  40
  41
  42 OSLoader::OSLoader(void)
  43 {
  44 }
  45
  46
  47 OSLoader::~OSLoader(void)
  48 {
  49 }
  50
  51
  52 void OSLoader::Load(const std::string& pathname)
  53 {
  54 #define ALX_FILE_EXT    ".alx"
  55
  56         int offset;
  57
  58         struct dirent *entry;
  59
  60         std::string alxfile;
  61         const std::string ext = ALX_FILE_EXT;
  62
  63         // At first, we have to read platform properties...
  64         alxfile = pathname + "/Platform.alx";
  65         LoadALXFile(alxfile, false);
  66
  67         // Then, we can read all ALX files
  68         // Wrap it in a smart pointer so exceptions are safe
  69         vLateSmartPtr<DIR, int (*)(DIR*)> path(&closedir);
  70         path.reset( opendir(pathname.c_str()) );
  71         if( path.get() == NULL )
  72                 throw Barry::ErrnoError("Could not opendir: " + pathname, errno);
  73
  74         while ((entry = readdir(path.get())) != NULL) {
  75                 alxfile = entry->d_name;
  76
  77                 if (alxfile.length() < ext.length())
  78                         continue;
  79
  80                 offset = alxfile.length() - ext.length();
  81
  82                 // Not supported...
  83                 if (alxfile == "BlackBerry.alx")
  84                         continue;
  85
  86                 // Ignore all files except ".alx" files
  87                 if (alxfile.substr(offset, ext.length()) != ALX_FILE_EXT)
  88                         continue;
  89
  90                 LoadALXFile(pathname + "/" + alxfile, true);
  91         }
  92 }
  93
  94
  95 void OSLoader::LoadALXFile(const std::string& alxfile, const bool enable)
  96 {
  97         std::ifstream file(alxfile.c_str());
  98         if( !file )
  99                 throw Barry::Error("Cannot open ALX file: " + alxfile);
 100
 101         ALX::ALXParser parser(*this, file);
 102
 103         parser.Run(enable);
 104
 105         file.close();
 106 }
 107
 108
 109 void OSLoader::Dump(std::ostream &os) const
 110 {
 111         os << "OS Properties :" << std::endl;
 112
 113         {
 114                 std::map<std::string, std::string>::const_iterator b = properties.begin(), e = properties.end();
 115
 116                 for (; b != e; b++) {
 117                         os << "  - " << (*b).first << " = " << (*b).second << std::endl;
 118                 }
 119         }
 120
 121         os << std::endl;
 122
 123         os << "SFI File :" << std::endl;
 124         os << "  " << sfifile << std::endl;
 125         os << std::endl;
 126
 127         os << "Applications :" << std::endl;
 128
 129         {
 130                 std::vector<CODSection *>::const_iterator b = applications.begin(), e = applications.end();
 131
 132                 for (; b != e; b++) {
 133                         os << (**b) << std::endl;
 134                 }
 135         }
 136
 137         os << "Libraries :" << std::endl;
 138
 139         {
 140                 std::vector<CODSection *>::const_iterator b = libraries.begin(), e = libraries.end();
 141
 142                 for (; b != e; b++) {
 143                         os << (**b) << std::endl;
 144                 }
 145         }
 146 }
 147
 148
 149 void OSLoader::AddProperties(const std::string& property, const std::string& value)
 150 {
 151         properties[property] = value;
 152
 153         if (property == "JVMLevel")
 154                 properties["Java"] = value;
 155 }
 156
 157
 158 void OSLoader::AddProperties(const xmlpp::SaxParser::AttributeList& attrs)
 159 {
 160         for (xmlpp::SaxParser::AttributeList::const_iterator iter = attrs.begin(); iter != attrs.end(); ++iter) {
 161                 std::string attribut(iter->name);
 162                 std::string value(iter->value);
 163
 164                 AddProperties(attribut, value);
 165         }
 166 }
 167
 168
 169 void OSLoader::SetSFIFile(const std::string& name)
 170 {
 171         sfifile = name;
 172 }
 173
 174
 175 bool OSLoader::IsSupported(const xmlpp::SaxParser::AttributeList& attrs)
 176 {
 177         if (properties.empty())
 178                 return false;
 179
 180         for (xmlpp::SaxParser::AttributeList::const_iterator iter = attrs.begin(); iter != attrs.end(); ++iter) {
 181                 std::string attribut(iter->name);
 182                 std::string value(iter->value);
 183
 184                 std::string s = properties[attribut];
 185
 186                 std::transform(value.begin(), value.end(), value.begin(), ::tolower);
 187                 std::transform(s.begin(), s.end(), s.begin(), ::tolower);
 188
 189                 if (value[0] == '~') {
 190                         value = value.substr(1, value.length()-1);
 191
 192                         if (s == value)
 193                                 return false;
 194                 }
 195                 else {
 196                         if (s != value)
 197                                 return false;
 198                 }
 199         }
 200
 201         return true;
 202 }
 203
 204
 205 void OSLoader::AddApplication(CODSection *app)
 206 {
 207         applications.push_back(app);
 208 }
 209
 210
 211 void OSLoader::AddLibrary(CODSection *lib)
 212 {
 213         libraries.push_back(lib);
 214 }
 215
 216
 217 } // namespace ALX
 218
 219 } // namespace Barry
 220