state[5] += f;
state[6] += g;
state[7] += h;
-
- /* erase our data */
- a = b = c = d = e = f = g = h = t1 = t2 = 0;
- memset (W, 0, 80 * sizeof (unsigned long long));
}
static void
static unsigned char padding[128] = { 0x80, };
unsigned int t;
- unsigned long long t2;
unsigned char bits[128];
- unsigned int index, pad_len;
+ unsigned int index;
+ unsigned int pad_len;
+ unsigned long long t2;
int i, j;
- index = pad_len = t = i = j = 0;
- t2 = 0;
-
/* Save number of bits */
t = sctx->count[0];
bits[15] = t;
memset (sctx, 0, sizeof (struct sha512_ctx));
}
+
/**
* Hash block of given size.
*
* @param ret pointer to where to write the hashcode
*/
void
-GNUNET_CRYPTO_hash (const void *block, unsigned int size,
- GNUNET_HashCode * ret)
+GNUNET_CRYPTO_hash (const void *block, size_t size, GNUNET_HashCode * ret)
{
struct sha512_ctx ctx;
/**
* Size of the file.
*/
- unsigned long long fsize;
+ uint64_t fsize;
/**
* Current offset.
*/
- unsigned long long offset;
-
- /**
- * Run on shutdown?
- */
- int run_on_shutdown;
+ uint64_t offset;
/**
* File descriptor.
*/
- struct GNUNET_IO_Handle *fh;
+ struct GNUNET_DISK_FileHandle *fh;
};
fhc->callback (fhc->callback_cls, res);
GNUNET_free (fhc->filename);
if (!GNUNET_DISK_handle_invalid (fhc->fh))
- GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (&fhc->fh));
+ GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fhc->fh));
GNUNET_free (fhc); /* also frees fhc->buffer */
}
return;
}
GNUNET_SCHEDULER_add_after (tc->sched,
- fhc->run_on_shutdown,
- GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
- &file_hash_task, fhc);
+ 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
void
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,
file_hash_finish (fhc, NULL);
return;
}
- fhc->run_on_shutdown = run_on_shutdown;
fhc->fh = GNUNET_DISK_file_open (filename,
- GNUNET_DISK_OPEN_READ);
+ GNUNET_DISK_OPEN_READ,
+ GNUNET_DISK_PERM_NONE);
if (!fhc->fh)
{
file_hash_finish (fhc, NULL);
return;
}
- GNUNET_SCHEDULER_add_after (sched,
- run_on_shutdown,
- priority,
- GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
- &file_hash_task, fhc);
+ GNUNET_SCHEDULER_add_with_priority (sched, priority, &file_hash_task, fhc);
}
* small number of characters. The GNUnet encoding uses 102
* characters plus a null terminator.
*
- * @param block the GNUNET_CRYPTO_hash code
+ * @param block the hash code
* @param result where to store the encoding (struct GNUNET_CRYPTO_HashAsciiEncoded can be
- * safely cast to char*, a '\0' termination is set).
+ * safely cast to char*, a '\\0' termination is set).
*/
void
GNUNET_CRYPTO_hash_to_enc (const GNUNET_HashCode * block,
}
void
-GNUNET_CRYPTO_hash_create_random (GNUNET_HashCode * result)
+GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode,
+ GNUNET_HashCode * result)
{
int i;
- for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
- i--)
- result->bits[i] = rand ();
+ for (i = (sizeof (GNUNET_HashCode) / sizeof (uint32_t)) - 1; i >= 0; i--)
+ result->bits[i] = GNUNET_CRYPTO_random_u32 (mode, (uint32_t) - 1);
}
void
* Convert a hashcode into a key.
*/
void
-GNUNET_CRYPTO_hash_to_AES_key (const GNUNET_HashCode * hc,
+GNUNET_CRYPTO_hash_to_aes_key (const GNUNET_HashCode * hc,
struct GNUNET_CRYPTO_AesSessionKey *skey,
struct GNUNET_CRYPTO_AesInitializationVector
*iv)
return 0;
}
-/* end of hashing.c */
+/* end of crypto_hash.c */