Merge pull request #41 from LefterisJP/finalize_and_use_new_api

Finalize and use new api

Author: Gav Wood

CMakeLists.txt

@@ -20,7 +20,7 @@ set(FILES 	util.h
           	data_sizes.h)
 
 if (MSVC)
-	list(APPEND FILES util.c io_win32.c mmap_win32.c)
+	list(APPEND FILES util_win32.c io_win32.c mmap_win32.c)
 else()
 	list(APPEND FILES io_posix.c)
 endif()

ethash.h

@@ -37,35 +37,15 @@
 #define ETHASH_DATASET_PARENTS 256
 #define ETHASH_CACHE_ROUNDS 3
 #define ETHASH_ACCESSES 64
+#define ETHASH_DAG_MAGIC_NUM_SIZE 8
+#define ETHASH_DAG_MAGIC_NUM 0xFEE1DEADBADDCAFE
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-// LTODO: for consistency's sake maybe use ethash_params_t?
-typedef struct ethash_params {
-	/// Size of full data set (in bytes, multiple of mix size (128)).
-	uint64_t full_size;
-	/// Size of compute cache (in bytes, multiple of node size (64)).
-	uint64_t cache_size;
-} ethash_params;
-
 /// Type of a seedhash/blockhash e.t.c.
 typedef struct ethash_h256 { uint8_t b[32]; } ethash_h256_t;
-static inline uint8_t ethash_h256_get(ethash_h256_t const* hash, unsigned int i)
-{
-	return hash->b[i];
-}
-
-static inline void ethash_h256_set(ethash_h256_t* hash, unsigned int i, uint8_t v)
-{
-	hash->b[i] = v;
-}
-
-static inline void ethash_h256_reset(ethash_h256_t* hash)
-{
-	memset(hash, 0, 32);
-}
 
 // convenience macro to statically initialize an h256_t
 // usage:
@@ -81,55 +61,20 @@ struct ethash_full;
 typedef struct ethash_full* ethash_full_t;
 typedef int(*ethash_callback_t)(unsigned);
 
-// LTODO: for consistency's sake maybe use ethash_return_value_t?
 typedef struct ethash_return_value {
 	ethash_h256_t result;
 	ethash_h256_t mix_hash;
-} ethash_return_value;
-
-uint64_t ethash_get_datasize(uint32_t const block_number);
-uint64_t ethash_get_cachesize(uint32_t const block_number);
-
-// initialize the parameters
-static inline void ethash_params_init(ethash_params* params, uint32_t const block_number)
-{
-	params->full_size = ethash_get_datasize(block_number);
-	params->cache_size = ethash_get_cachesize(block_number);
-}
-
-// LTODO: for consistency's sake maybe use ethash_cache_t?
-typedef struct ethash_cache {
-	void* mem;
-} ethash_cache;
-
-/**
- * Allocate and initialize a new ethash_cache object
- *
- * @param params    The parameters to initialize it with. We are interested in
- *                  the cache_size from here
- * @param seed      Block seedhash to be used during the computation of the
- *                  cache nodes
- * @return          Newly allocated ethash_cache on success or NULL in case of
- *                  ERRNOMEM or invalid parameters used for @ref ethash_compute_cache_nodes()
- */
-ethash_cache* ethash_cache_new(ethash_params const* params, ethash_h256_t const* seed);
-/**
- * Frees a previously allocated ethash_cache
- * @param c            The object to free
- */
-void ethash_cache_delete(ethash_cache* c);
+	bool success;
+} ethash_return_value_t;
 
 /**
  * Allocate and initialize a new ethash_light handler
  *
- * @param params    The parameters to initialize it with. We are interested in
- *                  the cache_size from here
- * @param seed      Block seedhash to be used during the computation of the
- *                  cache nodes
- * @return          Newly allocated ethash_light handler or NULL in case of
- *                  ERRNOMEM or invalid parameters used for @ref ethash_compute_cache_nodes()
+ * @param block_number   The block number for which to create the handler
+ * @return               Newly allocated ethash_light handler or NULL in case of
+ *                       ERRNOMEM or invalid parameters used for @ref ethash_compute_cache_nodes()
  */
-ethash_light_t ethash_light_new(ethash_params const* params, ethash_h256_t const* seed);
+ethash_light_t ethash_light_new(uint64_t block_number);
 /**
  * Frees a previously allocated ethash_light handler
  * @param light        The light handler to free
@@ -138,63 +83,33 @@ void ethash_light_delete(ethash_light_t light);
 /**
  * Calculate the light client data
  *
- * @param ret            An object of ethash_return_value to hold the return value
  * @param light          The light client handler
- * @param params         The parameters to use
  * @param header_hash    The header hash to pack into the mix
  * @param nonce          The nonce to pack into the mix
- * @return               true if all went well and false if there were invalid
- *                       parameters given.
+ * @return               an object of ethash_return_value_t holding the return values
  */
-bool ethash_light_compute(
-	ethash_return_value* ret,
+ethash_return_value_t ethash_light_compute(
 	ethash_light_t light,
-	ethash_params const* params,
-	const ethash_h256_t* header_hash,
-	uint64_t const nonce
+	ethash_h256_t const header_hash,
+	uint64_t nonce
 );
-/**
- * Get a pointer to the cache object held by the light client
- *
- * @param light    The light client whose cache to request
- * @return         A pointer to the cache held by the light client or NULL if
- *                 there was no cache in the first place
- */
-ethash_cache* ethash_light_get_cache(ethash_light_t light);
-/**
- * Move the memory ownership of the cache somewhere else
- *
- * @param light    The light client whose cache's memory ownership  to acquire.
- *                 After this function concludes it will no longer have a cache.
- * @return         A pointer to the moved cache or NULL if there was no cache in the first place
- */
-ethash_cache* ethash_light_acquire_cache(ethash_light_t light);
 
 /**
  * Allocate and initialize a new ethash_full handler
  *
- * @param dirname   The directory in which to put the DAG file.
- * @param seedhash  The seed hash of the block. Used in the DAG file naming.
- * @param params    The parameters to initialize it with. We are interested in
- *                  the full_size from here
- * @param cache     A cache object to use that was allocated with @ref ethash_cache_new().
- *                  Iff this function succeeds the ethash_full_t will take memory
- *                  ownership of the cache and free it at deletion. If not then the user
- *                  still has to handle freeing of the cache himself.
- * @param callback  A callback function with signature of @ref ethash_callback_t
- *                  It accepts an unsigned with which a progress of DAG calculation
- *                  can be displayed. If all goes well the callback should return 0.
- *                  If a non-zero value is returned then DAG generation will stop.
- * @return          Newly allocated ethash_full handler or NULL in case of
- *                  ERRNOMEM or invalid parameters used for @ref ethash_compute_full_data()
+ * @param light         The light handler containing the cache.
+ * @param callback      A callback function with signature of @ref ethash_callback_t
+ *                      It accepts an unsigned with which a progress of DAG calculation
+ *                      can be displayed. If all goes well the callback should return 0.
+ *                      If a non-zero value is returned then DAG generation will stop.
+ *                      Be advised. A progress value of 100 means that DAG creation is
+ *                      almost complete and that this function will soon return succesfully.
+ *                      It does not mean that the function has already had a succesfull return.
+ * @return              Newly allocated ethash_full handler or NULL in case of
+ *                      ERRNOMEM or invalid parameters used for @ref ethash_compute_full_data()
  */
-ethash_full_t ethash_full_new(
-	char const* dirname,
-	ethash_h256_t const* seed_hash,
-	ethash_params const* params,
-	ethash_cache const* cache,
-	ethash_callback_t callback
-);
+ethash_full_t ethash_full_new(ethash_light_t light, ethash_callback_t callback);
+
 /**
  * Frees a previously allocated ethash_full handler
  * @param full    The light handler to free
@@ -203,97 +118,29 @@ void ethash_full_delete(ethash_full_t full);
 /**
  * Calculate the full client data
  *
- * @param ret            An object of ethash_return_value to hold the return value
  * @param full           The full client handler
- * @param params         The parameters to use
  * @param header_hash    The header hash to pack into the mix
  * @param nonce          The nonce to pack into the mix
- * @return               true if all went well and false if there were invalid
- *                       parameters given or if there was a callback given and
- *                       at some point return a non-zero value
+ * @return               An object of ethash_return_value to hold the return value
  */
-bool ethash_full_compute(
-	ethash_return_value* ret,
+ethash_return_value_t ethash_full_compute(
 	ethash_full_t full,
-	ethash_params const* params,
-	ethash_h256_t const* header_hash,
-	uint64_t const nonce
+	ethash_h256_t const header_hash,
+	uint64_t nonce
 );
 /**
- * Get a pointer to the cache object held by the full client
- *
- * @param full    The full client whose cache to request
- * @return        A pointer to the cache held by the full client or NULL
- *                if there was no cache in the first place
+ * Get a pointer to the full DAG data
  */
-ethash_cache* ethash_full_get_cache(ethash_full_t full);
+void const* ethash_full_dag(ethash_full_t full);
 /**
- * Move the memory ownership of the cache somewhere else
- *
- * @param full     The full client whose cache's memory ownership  to acquire.
- *                 After this function concludes it will no longer have a cache.
- * @return         A pointer to the moved cache or NULL if there was no cache in the first place
+ * Get the size of the DAG data
  */
-ethash_cache* ethash_full_acquire_cache(ethash_full_t full);
-
-void ethash_get_seedhash(ethash_h256_t *seedhash, const uint32_t block_number);
-
-// Returns if hash is less than or equal to difficulty
-static inline int ethash_check_difficulty(
-	ethash_h256_t const* hash,
-	ethash_h256_t const* difficulty
-)
-{
-	// Difficulty is big endian
-	for (int i = 0; i < 32; i++) {
-		if (ethash_h256_get(hash, i) == ethash_h256_get(difficulty, i)) {
-			continue;
-		}
-		return ethash_h256_get(hash, i) < ethash_h256_get(difficulty, i);
-	}
-	return 1;
-}
-
-int ethash_quick_check_difficulty(
-	ethash_h256_t const* header_hash,
-	uint64_t const nonce,
-	ethash_h256_t const* mix_hash,
-	ethash_h256_t const* difficulty
-);
-
+uint64_t ethash_full_dag_size(ethash_full_t full);
 
 /**
- * =========================
- * =	DEPRECATED API	   =
- * =========================
- *
- * Kept for backwards compatibility with whoever still uses it. Please consider
- * switching to the new API (look above)
- */
-void ethash_mkcache(ethash_cache* cache, ethash_params const* params, ethash_h256_t const* seed);
-void ethash_full(
-	ethash_return_value* ret,
-	void const* full_mem,
-	ethash_params const* params,
-	ethash_h256_t const* header_hash,
-	uint64_t const nonce
-);
-void ethash_light(
-	ethash_return_value* ret,
-	ethash_cache const* cache,
-	ethash_params const* params,
-	ethash_h256_t const* header_hash,
-	uint64_t const nonce
-);
-/**
- * Compute the memory data for a full node's memory
- *
- * @param mem         A pointer to an ethash full's memory
- * @param params      The parameters to compute the data with
- * @param cache       A cache object to use in the calculation
- * @return            true if all went fine and false for invalid parameters
+ * Calculate the seedhash for a given block number
  */
-bool ethash_compute_full_data(void* mem, ethash_params const* params, ethash_cache const* cache);
+ethash_h256_t ethash_get_seedhash(uint64_t block_number);
 
 #ifdef __cplusplus
 }

internal.c

@@ -31,23 +31,112 @@ typedef union node {
 
 } node;
 
+static inline uint8_t ethash_h256_get(ethash_h256_t const* hash, unsigned int i)
+{
+	return hash->b[i];
+}
+
+static inline void ethash_h256_set(ethash_h256_t* hash, unsigned int i, uint8_t v)
+{
+	hash->b[i] = v;
+}
+
+static inline void ethash_h256_reset(ethash_h256_t* hash)
+{
+	memset(hash, 0, 32);
+}
+
+// Returns if hash is less than or equal to difficulty
+static inline int ethash_check_difficulty(
+	ethash_h256_t const* hash,
+	ethash_h256_t const* difficulty
+)
+{
+	// Difficulty is big endian
+	for (int i = 0; i < 32; i++) {
+		if (ethash_h256_get(hash, i) == ethash_h256_get(difficulty, i)) {
+			continue;
+		}
+		return ethash_h256_get(hash, i) < ethash_h256_get(difficulty, i);
+	}
+	return 1;
+}
+
+int ethash_quick_check_difficulty(
+	ethash_h256_t const* header_hash,
+	uint64_t const nonce,
+	ethash_h256_t const* mix_hash,
+	ethash_h256_t const* difficulty
+);
+
 struct ethash_light {
-	ethash_cache* cache;
+	void* cache;
+	uint64_t cache_size;
+	uint64_t block_number;
 };
 
+/**
+ * Allocate and initialize a new ethash_light handler. Internal version
+ *
+ * @param cache_size    The size of the cache in bytes
+ * @param seed          Block seedhash to be used during the computation of the
+ *                      cache nodes
+ * @return              Newly allocated ethash_light handler or NULL in case of
+ *                      ERRNOMEM or invalid parameters used for @ref ethash_compute_cache_nodes()
+ */
+ethash_light_t ethash_light_new_internal(uint64_t cache_size, ethash_h256_t const* seed);
+
+/**
+ * Calculate the light client data. Internal version.
+ *
+ * @param light          The light client handler
+ * @param full_size      The size of the full data in bytes.
+ * @param header_hash    The header hash to pack into the mix
+ * @param nonce          The nonce to pack into the mix
+ * @return               The resulting hash.
+ */
+ethash_return_value_t ethash_light_compute_internal(
+	ethash_light_t light,
+	uint64_t full_size,
+	ethash_h256_t const header_hash,
+	uint64_t nonce
+);
+
 struct ethash_full {
 	FILE* file;
-	size_t file_size;
-	ethash_cache* cache;
+	uint64_t file_size;
 	node* data;
-	ethash_callback_t callback;
 };
 
+/**
+ * Allocate and initialize a new ethash_full handler. Internal version.
+ *
+ * @param dirname        The directory in which to put the DAG file.
+ * @param seedhash       The seed hash of the block. Used in the DAG file naming.
+ * @param full_size      The size of the full data in bytes.
+ * @param cache          A cache object to use that was allocated with @ref ethash_cache_new().
+ *                       Iff this function succeeds the ethash_full_t will take memory
+ *                       memory ownership of the cache and free it at deletion. If
+ *                       not then the user still has to handle freeing of the cache himself.
+ * @param callback       A callback function with signature of @ref ethash_callback_t
+ *                       It accepts an unsigned with which a progress of DAG calculation
+ *                       can be displayed. If all goes well the callback should return 0.
+ *                       If a non-zero value is returned then DAG generation will stop.
+ * @return               Newly allocated ethash_full handler or NULL in case of
+ *                       ERRNOMEM or invalid parameters used for @ref ethash_compute_full_data()
+ */
+ethash_full_t ethash_full_new_internal(
+	char const* dirname,
+	ethash_h256_t const seed_hash,
+	uint64_t full_size,
+	ethash_light_t const light,
+	ethash_callback_t callback
+);
+
 void ethash_calculate_dag_item(
 	node* const ret,
-	const unsigned node_index,
-	ethash_params const* params,
-	ethash_cache const* cache
+	uint32_t node_index,
+	ethash_light_t const cache
 );
 
 void ethash_quick_hash(
@@ -57,6 +146,25 @@ void ethash_quick_hash(
 	ethash_h256_t const* mix_hash
 );
 
+uint64_t ethash_get_datasize(uint64_t const block_number);
+uint64_t ethash_get_cachesize(uint64_t const block_number);
+
+/**
+ * Compute the memory data for a full node's memory
+ *
+ * @param mem         A pointer to an ethash full's memory
+ * @param full_size   The size of the full data in bytes
+ * @param cache       A cache object to use in the calculation
+ * @param callback    The callback function. Check @ref ethash_full_new() for details.
+ * @return            true if all went fine and false for invalid parameters
+ */
+bool ethash_compute_full_data(
+	void* mem,
+	uint64_t full_size,
+	ethash_light_t const light,
+	ethash_callback_t callback
+);
+
 #ifdef __cplusplus
 }
 #endif

internal.h

@@ -26,7 +26,8 @@ enum ethash_io_rc ethash_io_prepare(
 	char const* dirname,
 	ethash_h256_t const seedhash,
 	FILE** output_file,
-	size_t file_size
+	uint64_t file_size,
+	bool force_create
 )
 {
 	char mutable_name[DAG_MUTABLE_NAME_MAX_SIZE];
@@ -43,35 +44,53 @@ enum ethash_io_rc ethash_io_prepare(
 		goto end;
 	}
 
-	// try to open the file
-	FILE* f = ethash_fopen(tmpfile, "rb+");
-	if (f) {
-		size_t found_size;
-		if (!ethash_file_size(f, &found_size)) {
-			fclose(f);
-			goto free_memo;
+	FILE *f;
+	if (!force_create) {
+		// try to open the file
+		f = ethash_fopen(tmpfile, "rb+");
+		if (f) {
+			size_t found_size;
+			if (!ethash_file_size(f, &found_size)) {
+				fclose(f);
+				goto free_memo;
+			}
+			if (file_size != found_size - ETHASH_DAG_MAGIC_NUM_SIZE) {
+				fclose(f);
+				ret = ETHASH_IO_MEMO_SIZE_MISMATCH;
+				goto free_memo;
+			}
+			// compare the magic number, no need to care about endianess since it's local
+			uint64_t magic_num;
+			if (fread(&magic_num, ETHASH_DAG_MAGIC_NUM_SIZE, 1, f) != 1) {
+				// I/O error
+				fclose(f);
+				ret = ETHASH_IO_MEMO_SIZE_MISMATCH;
+				goto free_memo;
+			}
+			if (magic_num != ETHASH_DAG_MAGIC_NUM) {
+				fclose(f);
+				ret = ETHASH_IO_MEMO_SIZE_MISMATCH;
+				goto free_memo;
+			}
+			ret = ETHASH_IO_MEMO_MATCH;
+			goto set_file;
 		}
-		if (file_size != found_size) {
-			fclose(f);
-			ret = ETHASH_IO_MEMO_SIZE_MISMATCH;
-			goto free_memo;
-		}
-	} else {
-		// file does not exist, will need to be created
-		f = ethash_fopen(tmpfile, "wb+");
-		if (!f) {
-			goto free_memo;
-		}
-		// make sure it's of the proper size
-		if (fseek(f, file_size - 1, SEEK_SET) != 0) {
-			fclose(f);
-			goto free_memo;
-		}
-		fputc('\n', f);
-		fflush(f);
-		ret = ETHASH_IO_MEMO_MISMATCH;
-		goto set_file;
 	}
+	
+	// file does not exist, will need to be created
+	f = ethash_fopen(tmpfile, "wb+");
+	if (!f) {
+		goto free_memo;
+	}
+	// make sure it's of the proper size
+	if (fseek(f, (long int)(file_size + ETHASH_DAG_MAGIC_NUM_SIZE - 1), SEEK_SET) != 0) {
+		fclose(f);
+		goto free_memo;
+	}
+	fputc('\n', f);
+	fflush(f);
+	ret = ETHASH_IO_MEMO_MISMATCH;
+	goto set_file;
 
 	ret = ETHASH_IO_MEMO_MATCH;
 set_file:

io.c

@@ -69,13 +69,16 @@ enum ethash_io_rc {
  *                           mode, while on the case of mismatch a new file is created
  *                           on write mode
  * @param[in] file_size      The size that the DAG file should have on disk
+ * @param[out] force_create  If true then there is no check to see if the file
+ *                           already exists
  * @return                   For possible return values @see enum ethash_io_rc
  */
 enum ethash_io_rc ethash_io_prepare(
 	char const* dirname,
 	ethash_h256_t const seedhash,
 	FILE** output_file,
-	size_t file_size
+	uint64_t file_size,
+	bool force_create
 );
 
 /**
@@ -112,7 +115,7 @@ char* ethash_strncat(char* dest, size_t dest_size, char const* src, size_t count
 
 /**
  * A cross-platform mkdir wrapper to create a directory or assert it's there
- * 
+ *
  * @param dirname        The full path of the directory to create
  * @return               true if the directory was created or if it already
  *                       existed
@@ -130,12 +133,39 @@ bool ethash_file_size(FILE* f, size_t* ret_size);
 
 /**
  * Get a file descriptor number from a FILE stream
- * 
+ *
  * @param f            The file stream whose fd to get
  * @return             Platform specific fd handler
  */
 int ethash_fileno(FILE* f);
 
+/**
+ * Create the filename for the DAG.
+ *
+ * @param dirname            The directory name in which the DAG file should reside
+ *                           If it does not end with a directory separator it is appended.
+ * @param filename           The actual name of the file
+ * @param filename_length    The length of the filename in bytes
+ * @return                   A char* containing the full name. User must deallocate.
+ */
+char* ethash_io_create_filename(
+	char const* dirname,
+	char const* filename,
+	size_t filename_length
+);
+
+/**
+ * Gets the default directory name for the DAG depending on the system
+ *
+ * The spec defining this directory is here: https://github.com/ethereum/wiki/wiki/Ethash-DAG
+ *
+ * @param[out] strbuf          A string buffer of sufficient size to keep the
+ *                             null termninated string of the directory name
+ * @param[in]  buffsize        Size of @a strbuf in bytes
+ * @return                     true for success and false otherwise
+ */
+bool ethash_get_default_dirname(char* strbuf, size_t buffsize);
+
 static inline bool ethash_io_mutable_name(
 	uint32_t revision,
 	ethash_h256_t const* seed_hash,
@@ -149,26 +179,6 @@ static inline bool ethash_io_mutable_name(
     return snprintf(output, DAG_MUTABLE_NAME_MAX_SIZE, "%u_%016" PRIx64, revision, hash) >= 0;
 }
 
-static inline char* ethash_io_create_filename(
-	char const* dirname,
-	char const* filename,
-	size_t filename_length
-)
-{
-	size_t dirlen = strlen(dirname);
-	// in C the cast is not needed, but a C++ compiler will complain for invalid conversion
-	char* name = (char*)malloc(dirlen + filename_length + 1);
-	if (!name) {
-		return NULL;
-	}
-
-	name[0] = '\0';
-	ethash_strncat(name, dirlen + filename_length + 1, dirname, dirlen);
-	ethash_strncat(name, dirlen + filename_length + 1, filename, filename_length);
-	return name;
-}
-
-
 #ifdef __cplusplus
 }
 #endif

io.h

@@ -48,6 +48,31 @@ int ethash_fileno(FILE *f)
 	return fileno(f);
 }
 
+char* ethash_io_create_filename(
+	char const* dirname,
+	char const* filename,
+	size_t filename_length
+)
+{
+	size_t dirlen = strlen(dirname);
+	size_t dest_size = dirlen + filename_length + 1;
+	if (dirname[dirlen] != '/') {
+		dest_size += 1;
+	}
+	char* name = malloc(dest_size);
+	if (!name) {
+		return NULL;
+	}
+
+	name[0] = '\0';
+	ethash_strncat(name, dest_size, dirname, dirlen);
+	if (dirname[dirlen] != '/') {
+		ethash_strncat(name, dest_size, "/", 1);
+	}
+	ethash_strncat(name, dest_size, filename, filename_length);
+	return name;
+}
+
 bool ethash_file_size(FILE* f, size_t* ret_size)
 {
 	struct stat st;
@@ -58,3 +83,20 @@ bool ethash_file_size(FILE* f, size_t* ret_size)
 	*ret_size = st.st_size;
 	return true;
 }
+
+bool ethash_get_default_dirname(char* strbuf, size_t buffsize)
+{
+	static const char dir_suffix[] = ".ethash/";
+	strbuf[0] = '\0';
+	char* home_dir = getenv("HOME");
+	size_t len = strlen(home_dir);
+	if (!ethash_strncat(strbuf, buffsize, home_dir, len)) {
+		return false;
+	}
+	if (home_dir[len] != '/') {
+		if (!ethash_strncat(strbuf, buffsize, "/", 1)) {
+			return false;
+		}
+	}
+	return ethash_strncat(strbuf, buffsize, dir_suffix, sizeof(dir_suffix));
+}

io_posix.c

@@ -25,6 +25,7 @@
 #include <stdio.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <Shlobj.h>
 
 FILE* ethash_fopen(char const* file_name, char const* mode)
 {
@@ -48,6 +49,31 @@ int ethash_fileno(FILE* f)
 	return _fileno(f);
 }
 
+char* ethash_io_create_filename(
+	char const* dirname,
+	char const* filename,
+	size_t filename_length
+)
+{
+	size_t dirlen = strlen(dirname);
+	size_t dest_size = dirlen + filename_length + 1;
+	if (dirname[dirlen] != '\\' || dirname[dirlen] != '/') {
+		dest_size += 1;
+	}
+	char* name = malloc(dest_size);
+	if (!name) {
+		return NULL;
+	}
+
+	name[0] = '\0';
+	ethash_strncat(name, dest_size, dirname, dirlen);
+	if (dirname[dirlen] != '\\' || dirname[dirlen] != '/') {
+		ethash_strncat(name, dest_size, "\\", 1);
+	}
+	ethash_strncat(name, dest_size, filename, filename_length);
+	return name;
+}
+
 bool ethash_file_size(FILE* f, size_t* ret_size)
 {
 	struct _stat st;
@@ -58,3 +84,17 @@ bool ethash_file_size(FILE* f, size_t* ret_size)
 	*ret_size = st.st_size;
 	return true;
 }
+
+bool ethash_get_default_dirname(char* strbuf, size_t buffsize)
+{
+	static const char dir_suffix[] = "Appdata\\Ethash\\";
+	strbuf[0] = '\0';
+	if (!SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_PROFILE, NULL, 0, (WCHAR*)strbuf))) {
+		return false;
+	}
+	if (!ethash_strncat(strbuf, buffsize, "\\", 1)) {
+		return false;
+	}
+
+	return ethash_strncat(strbuf, buffsize, dir_suffix, sizeof(dir_suffix));
+}