* @param ret pointer to where to write the hashcode
*/
void
-GNUNET_CRYPTO_hash (const void *block,
- size_t size,
- GNUNET_HashCode * ret)
+GNUNET_CRYPTO_hash (const void *block, size_t size, GNUNET_HashCode * ret)
{
struct sha512_ctx ctx;
-
+
sha512_init (&ctx);
sha512_update (&ctx, block, size);
sha512_final (&ctx, (unsigned char *) ret);
/**
* Context used when hashing a file.
*/
-struct FileHashContext
+struct GNUNET_CRYPTO_FileHashContext
{
/**
char *filename;
/**
- * Cummulated hash.
+ * File descriptor.
*/
- struct sha512_ctx hctx;
+ struct GNUNET_DISK_FileHandle *fh;
/**
- * Blocksize.
+ * Our scheduler.
*/
- size_t bsize;
+ struct GNUNET_SCHEDULER_Handle *sched;
+
+ /**
+ * Cummulated hash.
+ */
+ struct sha512_ctx hctx;
/**
* Size of the file.
* Current offset.
*/
uint64_t offset;
-
+
/**
- * Run on shutdown?
+ * Current task for hashing.
*/
- int run_on_shutdown;
+ GNUNET_SCHEDULER_TaskIdentifier task;
/**
- * File descriptor.
+ * Blocksize.
*/
- struct GNUNET_DISK_FileHandle *fh;
+ size_t bsize;
};
* and free associated resources.
*/
static void
-file_hash_finish (struct FileHashContext *fhc, const GNUNET_HashCode * res)
+file_hash_finish (struct GNUNET_CRYPTO_FileHashContext *fhc,
+ const GNUNET_HashCode * res)
{
fhc->callback (fhc->callback_cls, res);
GNUNET_free (fhc->filename);
static void
file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- struct FileHashContext *fhc = cls;
+ struct GNUNET_CRYPTO_FileHashContext *fhc = cls;
GNUNET_HashCode res;
size_t delta;
+ fhc->task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_assert (fhc->offset < fhc->fsize);
delta = fhc->bsize;
if (fhc->fsize - fhc->offset < delta)
file_hash_finish (fhc, &res);
return;
}
- GNUNET_SCHEDULER_add_after (tc->sched,
- fhc->run_on_shutdown,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_TASK,
- &file_hash_task, fhc);
+ fhc->task
+ = GNUNET_SCHEDULER_add_after (tc->sched,
+ GNUNET_SCHEDULER_NO_TASK,
+ &file_hash_task, fhc);
}
*
* @param sched scheduler to use
* @param priority scheduling priority to use
- * @param run_on_shutdown should we complete even on shutdown?
* @param filename name of file to hash
* @param blocksize number of bytes to process in one task
* @param callback function to call upon completion
* @param callback_cls closure for callback
+ * @return NULL on (immediate) errror
*/
-void
+struct GNUNET_CRYPTO_FileHashContext *
GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched,
enum GNUNET_SCHEDULER_Priority priority,
- int run_on_shutdown,
const char *filename,
size_t blocksize,
GNUNET_CRYPTO_HashCompletedCallback callback,
void *callback_cls)
{
- struct FileHashContext *fhc;
+ struct GNUNET_CRYPTO_FileHashContext *fhc;
GNUNET_assert (blocksize > 0);
- fhc = GNUNET_malloc (sizeof (struct FileHashContext) + blocksize);
+ fhc = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_FileHashContext) + blocksize);
fhc->callback = callback;
fhc->callback_cls = callback_cls;
+ fhc->sched = sched;
fhc->buffer = (unsigned char *) &fhc[1];
fhc->filename = GNUNET_strdup (filename);
fhc->fh = NULL;
fhc->bsize = blocksize;
if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fhc->fsize, GNUNET_NO))
{
- file_hash_finish (fhc, NULL);
- return;
+ GNUNET_free (fhc->filename);
+ GNUNET_free (fhc);
+ return NULL;
}
- fhc->run_on_shutdown = run_on_shutdown;
fhc->fh = GNUNET_DISK_file_open (filename,
- GNUNET_DISK_OPEN_READ,
- GNUNET_DISK_PERM_NONE);
+ GNUNET_DISK_OPEN_READ,
+ GNUNET_DISK_PERM_NONE);
if (!fhc->fh)
{
- file_hash_finish (fhc, NULL);
- return;
+ GNUNET_free (fhc->filename);
+ GNUNET_free (fhc);
+ return NULL;
}
- GNUNET_SCHEDULER_add_after (sched,
- run_on_shutdown,
- priority,
- GNUNET_SCHEDULER_NO_TASK,
- &file_hash_task, fhc);
+ fhc->task
+ = GNUNET_SCHEDULER_add_with_priority (sched, priority,
+ &file_hash_task, fhc);
+ return fhc;
}
+/**
+ * Cancel a file hashing operation.
+ *
+ * @param fhc operation to cancel (callback must not yet have been invoked)
+ */
+void
+GNUNET_CRYPTO_hash_file_cancel (struct GNUNET_CRYPTO_FileHashContext *fhc)
+{
+ GNUNET_SCHEDULER_cancel (fhc->sched,
+ fhc->task);
+ GNUNET_free (fhc->filename);
+ GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fhc->fh));
+ GNUNET_free (fhc);
+}
+
+
+
/* ***************** binary-ASCII encoding *************** */
/**
}
void
-GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode, GNUNET_HashCode * result)
+GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode,
+ GNUNET_HashCode * result)
{
int i;
- for (i = (sizeof (GNUNET_HashCode) / sizeof (uint32_t)) - 1; i >= 0;
- i--)
- result->bits[i] = GNUNET_CRYPTO_random_u32 (mode, (uint32_t)-1);
+ for (i = (sizeof (GNUNET_HashCode) / sizeof (uint32_t)) - 1; i >= 0; i--)
+ result->bits[i] = GNUNET_CRYPTO_random_u32 (mode, (uint32_t) - 1);
}
void
GNUNET_CRYPTO_hash_difference (const GNUNET_HashCode * a,
- const GNUNET_HashCode * b,
- GNUNET_HashCode * result)
+ const GNUNET_HashCode * b,
+ GNUNET_HashCode * result)
{
int i;
for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
void
GNUNET_CRYPTO_hash_sum (const GNUNET_HashCode * a,
- const GNUNET_HashCode * delta,
- GNUNET_HashCode * result)
+ const GNUNET_HashCode * delta,
+ GNUNET_HashCode * result)
{
int i;
for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
void
GNUNET_CRYPTO_hash_xor (const GNUNET_HashCode * a,
- const GNUNET_HashCode * b, GNUNET_HashCode * result)
+ const GNUNET_HashCode * b, GNUNET_HashCode * result)
{
int i;
for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
*/
void
GNUNET_CRYPTO_hash_to_aes_key (const GNUNET_HashCode * hc,
- struct GNUNET_CRYPTO_AesSessionKey *skey,
- struct GNUNET_CRYPTO_AesInitializationVector
- *iv)
+ struct GNUNET_CRYPTO_AesSessionKey *skey,
+ struct GNUNET_CRYPTO_AesInitializationVector
+ *iv)
{
GNUNET_assert (sizeof (GNUNET_HashCode) >=
- GNUNET_CRYPTO_AES_KEY_LENGTH +
- sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
+ GNUNET_CRYPTO_AES_KEY_LENGTH +
+ sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
memcpy (skey, hc, GNUNET_CRYPTO_AES_KEY_LENGTH);
skey->crc32 =
htonl (GNUNET_CRYPTO_crc32_n (skey, GNUNET_CRYPTO_AES_KEY_LENGTH));
memcpy (iv, &((char *) hc)[GNUNET_CRYPTO_AES_KEY_LENGTH],
- sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
+ sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
}
/**
*/
int
GNUNET_CRYPTO_hash_cmp (const GNUNET_HashCode * h1,
- const GNUNET_HashCode * h2)
+ const GNUNET_HashCode * h2)
{
unsigned int *i1;
unsigned int *i2;
int i;
-
+
i1 = (unsigned int *) h1;
i2 = (unsigned int *) h2;
for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
i--)
{
if (i1[i] > i2[i])
- return 1;
+ return 1;
if (i1[i] < i2[i])
- return -1;
+ return -1;
}
return 0;
}
*/
int
GNUNET_CRYPTO_hash_xorcmp (const GNUNET_HashCode * h1,
- const GNUNET_HashCode * h2,
- const GNUNET_HashCode * target)
+ const GNUNET_HashCode * h2,
+ const GNUNET_HashCode * target)
{
int i;
unsigned int d1;
unsigned int d2;
-
+
for (i = sizeof (GNUNET_HashCode) / sizeof (unsigned int) - 1; i >= 0; i--)
{
d1 = ((unsigned int *) h1)[i] ^ ((unsigned int *) target)[i];
d2 = ((unsigned int *) h2)[i] ^ ((unsigned int *) target)[i];
if (d1 > d2)
- return 1;
+ return 1;
else if (d1 < d2)
- return -1;
+ return -1;
}
return 0;
}