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