misc.hpp

   1 #ifndef _misc__hpp__included__
   2 #define _misc__hpp__included__
   3
   4 #include <string>
   5 #include <vector>
   6 #include <boost/lexical_cast.hpp>
   7
   8 /**
   9  * \brief Get random hexes
  10  *
  11  * Get string of random hex characters of specified length.
  12  *
  13  * \param length The number of hex characters to return.
  14  * \return The random hexadecimal string.
  15  * \throws std::bad_alloc Not enough memory.
  16  */
  17 std::string get_random_hexstring(size_t length) throw(std::bad_alloc);
  18
  19 /**
  20  * \brief Set random seed
  21  *
  22  * This function sets the random seed to use.
  23  *
  24  * \param seed The value to use as seed.
  25  * \throw std::bad_alloc Not enough memory.
  26  */
  27 void set_random_seed(const std::string& seed) throw(std::bad_alloc);
  28
  29 /**
  30  * \brief Set random seed to (hopefully) unique value
  31  *
  32  * This function sets the random seed to value that should only be used once. Note, the value is not necressarily
  33  * crypto-secure, even if it is unique.
  34  *
  35  * \throw std::bad_alloc Not enough memory.
  36  */
  37 void set_random_seed() throw(std::bad_alloc);
  38
  39 /**
  40  * \brief Load a ROM.
  41  *
  42  * Given commandline arguments, load a ROM.
  43  *
  44  * \param cmdline The command line.
  45  * \return The loaded ROM set.
  46  * \throws std::bad_alloc Not enough memory.
  47  * \throws std::runtime_error Can't load the ROMset.
  48  */
  49 struct loaded_rom load_rom_from_commandline(std::vector<std::string> cmdline) throw(std::bad_alloc,
  50         std::runtime_error);
  51
  52 /**
  53  * \brief Dump listing of regions to graphics system messages.
  54  *
  55  * \throws std::bad_alloc Not enough memory.
  56  */
  57 void dump_region_map() throw(std::bad_alloc);
  58
  59 /**
  60  * \brief Fatal error.
  61  *
  62  * Fatal error.
  63  */
  64 void fatal_error() throw();
  65
  66 /**
  67  * \brief Get path to config directory.
  68  *
  69  * \return The config directory path.
  70  * \throw std::bad_alloc Not enough memory.
  71  */
  72 std::string get_config_path() throw(std::bad_alloc);
  73
  74 /**
  75  * \brief Panic on OOM.
  76  */
  77 void OOM_panic();
  78
  79 /**
  80  * messages -> window::out().
  81  */
  82 std::ostream& _messages();
  83 #define messages _messages()
  84
  85 /**
  86  * \brief Typeconvert string.
  87  */
  88 template<typename T> inline T parse_value(const std::string& value) throw(std::bad_alloc, std::runtime_error)
  89 {
  90         try {
  91                 //Hack, since lexical_cast lets negative values slip through.
  92                 if(!std::numeric_limits<T>::is_signed && value.length() && value[0] == '-') {
  93                         throw std::runtime_error("Unsigned values can't be negative");
  94                 }
  95                 return boost::lexical_cast<T>(value);
  96         } catch(std::exception& e) {
  97                 throw std::runtime_error("Can't parse value '" + value + "': " + e.what());
  98         }
  99 }
 100
 101 template<> inline std::string parse_value(const std::string& value) throw(std::bad_alloc, std::runtime_error)
 102 {
 103         return value;
 104 }
 105
 106 void create_lsnesrc();
 107
 108 /**
 109  * \brief Opaque internal state of SHA256
 110  */
 111 struct sha256_opaque;
 112
 113 /**
 114  * \brief SHA-256 function
 115  *
 116  * This class implements interface to SHA-256.
 117  */
 118 class sha256
 119 {
 120 public:
 121 /**
 122  * \brief Create new SHA-256 context
 123  *
 124  * Creates new SHA-256 context, initially containing empty data.
 125  */
 126         sha256() throw(std::bad_alloc);
 127
 128 /**
 129  * \brief Destructor
 130  */
 131         ~sha256() throw();
 132
 133 /**
 134  * \brief Append data to be hashed
 135  *
 136  * This function appends specified data to be hashed. Don't call after calling read().
 137  *
 138  * \param data The data to write.
 139  * \param datalen The length of data written.
 140  */
 141         void write(const uint8_t* data, size_t datalen) throw();
 142
 143 /**
 144  * \brief Read the hash value
 145  *
 146  * Reads the hash of data written. Can be called multiple times, but after the first call, data can't be appended
 147  * anymore.
 148  *
 149  * \param hashout 32-byte buffer to store the hash to.
 150  */
 151         void read(uint8_t* hashout) throw();
 152
 153 /**
 154  * \brief Read the hash value
 155  *
 156  * Similar to read(uint8_t*) but instead returns the hash as hexadecimal string.
 157  *
 158  * \return The hash in hex form.
 159  * \throw std::bad_alloc Not enough memory.
 160  */
 161         std::string read() throw(std::bad_alloc);
 162
 163 /**
 164  * \brief Hash block of data.
 165  *
 166  * Hashes block of data.
 167  *
 168  * \param hashout 32-byte buffer to write the hash to.
 169  * \param data The data to hash.
 170  * \param datalen The length of data hashed.
 171  */
 172         static void hash(uint8_t* hashout, const uint8_t* data, size_t datalen) throw();
 173
 174 /**
 175  * \brief Hash block of data.
 176  *
 177  * Hashes block of data.
 178  *
 179  * \param hashout 32-byte buffer to write the hash to.
 180  * \param data The data to hash.
 181  */
 182         static void hash(uint8_t* hashout, const std::vector<uint8_t>& data) throw()
 183         {
 184                 hash(hashout, &data[0], data.size());
 185         }
 186
 187 /**
 188  * \brief Hash block of data.
 189  *
 190  * Hashes block of data.
 191  *
 192  * \param hashout 32-byte buffer to write the hash to.
 193  * \param data The data to hash.
 194  */
 195         static void hash(uint8_t* hashout, const std::vector<char>& data) throw()
 196         {
 197                 hash(hashout, reinterpret_cast<const uint8_t*>(&data[0]), data.size());
 198         }
 199
 200 /**
 201  * \brief Hash block of data.
 202  *
 203  * Hashes block of data.
 204  *
 205  * \param data The data to hash.
 206  * \param datalen The length of data hashed.
 207  * \return Hexadecimal hash of the data.
 208  */
 209         static std::string hash(const uint8_t* data, size_t datalen) throw(std::bad_alloc)
 210         {
 211                 uint8_t hashout[32];
 212                 hash(hashout, data, datalen);
 213                 return tostring(hashout);
 214         }
 215
 216 /**
 217  * \brief Hash block of data.
 218  *
 219  * Hashes block of data.
 220  *
 221  * \param data The data to hash.
 222  * \return Hexadecimal hash of the data.
 223  */
 224         static std::string hash(const std::vector<uint8_t>& data) throw(std::bad_alloc)
 225         {
 226                 uint8_t hashout[32];
 227                 hash(hashout, &data[0], data.size());
 228                 return tostring(hashout);
 229         }
 230
 231 /**
 232  * \brief Hash block of data.
 233  *
 234  * Hashes block of data.
 235  *
 236  * \param data The data to hash.
 237  * \return Hexadecimal hash of the data.
 238  */
 239         static std::string hash(const std::vector<char>& data) throw(std::bad_alloc)
 240         {
 241                 uint8_t hashout[32];
 242                 hash(hashout, reinterpret_cast<const uint8_t*>(&data[0]), data.size());
 243                 return tostring(hashout);
 244         }
 245
 246 /**
 247  * \brief Translate binary hash to hexadecimal hash
 248  *
 249  * Reads 32-byte binary hash from hashout and returns 64-hex hexadecimal hash.
 250  *
 251  * \param hashout The binary hash
 252  * \return Hexadecimal hash
 253  * \throws std::bad_alloc Not enough memory.
 254  */
 255         static std::string tostring(const uint8_t* hashout) throw(std::bad_alloc);
 256 private:
 257         sha256(const sha256& x) throw();
 258         sha256& operator=(const sha256& x) throw();
 259         sha256_opaque* opaque;
 260         bool finished;
 261 };
 262
 263 #endif