misc.hpp

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