cf_rv_t tomcrypt_digest_cleanup() {
const struct ltc_hash_descriptor **ptr = descriptors;
for (ptr; *ptr; *ptr++) {
unregister_hash(*ptr);
}
return CF_S_OK;
}
~CTomcryptInternals(void)
{
int ErrorCode;
ErrorCode = unregister_hash(&sha256_desc);
if (ErrorCode == -1)
{
std::cerr << "Cannot unregister SHA2 hash." << std::endl;
}
ErrorCode = fortuna_done(&mRandomGenerator);
if (ErrorCode != CRYPT_OK)
{
std::cerr << "Cannot close random generator: " << error_to_string(ErrorCode) << std::endl;
}
ErrorCode = unregister_prng(&fortuna_desc);
if (ErrorCode == -1)
{
std::cerr << "Cannot unregister random generator fortuna cipher." << std::endl;
}
ErrorCode = unregister_cipher(&rijndael_desc);
if (ErrorCode == -1)
{
std::cerr << "Cannot unregister AES cipher." << std::endl;
}
return;
}
int
trackfile(int sockfd, char *filename, char *range, uint16_t num_trackers,
in_addr_t *trackers, uint16_t maxpeers, uint16_t num_pkg_servers,
in_addr_t *pkg_servers, CURL *curlhandle)
{
#ifdef TIMEIT
struct timeval start_time, end_time;
unsigned long long s, e;
#endif
CURLcode curlcode;
uint64_t hash;
uint16_t i;
tracker_info_t *tracker_info, *infoptr;
int info_count;
char success;
#ifdef TIMEIT
gettimeofday(&start_time, NULL);
#endif
hash = hashit(filename);
#ifdef TIMEIT
gettimeofday(&end_time, NULL);
s = (start_time.tv_sec * 1000000) + start_time.tv_usec;
e = (end_time.tv_sec * 1000000) + end_time.tv_usec;
logmsg("trackfile:svc time1: %lld usec file (%s)\n", (e - s), filename);
#endif
#ifdef DEBUG
{
int j;
struct in_addr in;
for (j = 0 ; j < num_trackers ; ++j) {
in.s_addr = trackers[j];
logmsg("trackfile:trackers[%d] = (%s)\n", j, inet_ntoa(in));
}
for (j = 0 ; j < num_pkg_servers ; ++j) {
in.s_addr = pkg_servers[j];
logmsg("trackfile:pkg_servers[%d] = (%s)\n", j, inet_ntoa(in));
}
}
#endif
#ifdef TIMEIT
gettimeofday(&end_time, NULL);
s = (start_time.tv_sec * 1000000) + start_time.tv_usec;
e = (end_time.tv_sec * 1000000) + end_time.tv_usec;
logmsg("trackfile:svc time2: %lld usec file (%s)\n", (e - s), filename);
#endif
/*
* see if there is a prediction for this file
*/
tracker_info = NULL;
info_count = getprediction(hash, &tracker_info);
#ifdef TIMEIT
gettimeofday(&end_time, NULL);
s = (start_time.tv_sec * 1000000) + start_time.tv_usec;
e = (end_time.tv_sec * 1000000) + end_time.tv_usec;
logmsg("trackfile:svc time3: %lld usec file (%s)\n", (e - s), filename);
#endif
#ifdef DEBUG
if (info_count == 0) {
logmsg("trackfile:pred miss (0x%016llx)\n", hash);
} else {
logmsg("trackfile:pred hit (0x%016llx)\n", hash);
}
#endif
if (info_count == 0) {
/*
* no prediction. need to ask a tracker for peer info for
* this file.
*/
for (i = 0 ; i < num_trackers; ++i) {
#ifdef DEBUG
struct in_addr in;
in.s_addr = trackers[i];
logmsg("trackfile:sending lookup to tracker (%s)\n",
inet_ntoa(in));
#endif
info_count = lookup(sockfd, &trackers[i], hash,
&tracker_info);
if (info_count > 0) {
break;
}
/*
* lookup() mallocs space for 'tracker_info', so need to
* free it here since we'll call lookup() again in the
* next iteration
*/
if (tracker_info != NULL) {
free(tracker_info);
tracker_info = NULL;
}
}
}
#ifdef TIMEIT
gettimeofday(&end_time, NULL);
s = (start_time.tv_sec * 1000000) + start_time.tv_usec;
e = (end_time.tv_sec * 1000000) + end_time.tv_usec;
logmsg("trackfile:svc time4: %lld usec file (%s)\n", (e - s), filename);
#endif
#ifdef DEBUG
logmsg("trackfile:info_count (%d)\n", info_count);
#endif
success = 0;
infoptr = tracker_info;
if ((info_count > 0) && (infoptr->hash == hash)) {
/*
* write the prediction info to a file
*/
save_prediction_info(tracker_info, info_count);
#ifdef TIMEIT
gettimeofday(&end_time, NULL);
s = (start_time.tv_sec * 1000000) + start_time.tv_usec;
e = (end_time.tv_sec * 1000000) + end_time.tv_usec;
logmsg("trackfile:svc time5: %lld usec file (%s)\n", (e - s),
filename);
#endif
#ifdef DEBUG
logmsg("trackfile:hash (0x%llx) : numpeers (%d)\n",
infoptr->hash, infoptr->numpeers);
logmsg("trackfile:peers:\n");
for (i = 0 ; i < infoptr->numpeers; ++i) {
struct in_addr in;
in.s_addr = infoptr->peers[i].ip;
logmsg("\t%s : %c %d\n", inet_ntoa(in),
(infoptr->peers[i].state == DOWNLOADING ?
'd' : 'r'), infoptr->peers[i].state);
}
#endif
#ifdef TIMEIT
gettimeofday(&end_time, NULL);
s = (start_time.tv_sec * 1000000) + start_time.tv_usec;
e = (end_time.tv_sec * 1000000) + end_time.tv_usec;
logmsg("trackfile:svc time6: %lld usec file (%s)\n", (e - s),
filename);
#endif
for (i = 0 ; i < infoptr->numpeers; ++i) {
#ifdef DEBUG
{
struct in_addr in;
int k;
in.s_addr = infoptr->peers[i].ip;
if (strncmp(inet_ntoa(in), "10.", 3)) {
for (k = 0 ; i < num_trackers; ++k) {
send_msg(sockfd, &trackers[k],
STOP_SERVER);
}
logmsg("trackfile:bogus IP (%s)\n",
inet_ntoa(in));
exit(-1);
}
}
#endif
if (getremote(filename, &infoptr->peers[i], range,
curlhandle) == 0) {
/*
* successful download, exit this loop
*/
success = 1;
break;
} else {
/*
* mark the peer as 'bad'. we do this by
* telling the tracker server to 'unregister'
* this hash.
*/
tracker_info_t *info;
int len;
int j;
len = sizeof(*info) + sizeof(peer_t);
if ((info = (tracker_info_t *)malloc(len))
!= NULL) {
bzero(info, len);
info->hash = hash;
info->numpeers = 1;
info->peers[0].ip =
infoptr->peers[i].ip;
for (j = 0 ; j < num_trackers; ++j) {
unregister_hash(sockfd,
&trackers[j], 1, info);
}
free(info);
}
}
}
}
#ifdef TIMEIT
gettimeofday(&end_time, NULL);
s = (start_time.tv_sec * 1000000) + start_time.tv_usec;
e = (end_time.tv_sec * 1000000) + end_time.tv_usec;
logmsg("trackfile:svc time7: %lld usec file (%s)\n", (e - s), filename);
#endif
if (!success) {
/*
* unable to download the file from a peer, need to
* get it from one of the package servers
*/
for (i = 0 ; i < num_pkg_servers ; ++i) {
peer_t pkgpeer;
pkgpeer.ip = pkg_servers[i];
pkgpeer.state = READY;
/*
* if this is the last package server, then
* disable the connection timeout -- this is our
* last hope of getting the package.
*/
if (i == (num_pkg_servers - 1)) {
if ((curlcode = curl_easy_setopt(curlhandle,
CURLOPT_CONNECTTIMEOUT, 0)) !=
CURLE_OK) {
logmsg("getremote:curl_easy_setopt():failed:(%d)\n", curlcode);
}
}
if (getremote(filename, &pkgpeer, range,
curlhandle) == 0) {
success = 1;
}
/*
* reset the connection timeout
*/
if (i == (num_pkg_servers - 1)) {
if ((curlcode = curl_easy_setopt(curlhandle,
CURLOPT_CONNECTTIMEOUT, 2)) !=
CURLE_OK) {
logmsg("getremote:curl_easy_setopt():failed:(%d)\n", curlcode);
}
}
if (success) {
break;
}
}
}
#ifdef TIMEIT
gettimeofday(&end_time, NULL);
s = (start_time.tv_sec * 1000000) + start_time.tv_usec;
e = (end_time.tv_sec * 1000000) + end_time.tv_usec;
logmsg("trackfile:svc time8: %lld usec file (%s)\n", (e - s), filename);
#endif
if (success) {
tracker_info_t info[1];
bzero(info, sizeof(info));
info[0].hash = hash;
info[0].numpeers = 0;
for (i = 0 ; i < num_trackers; ++i) {
register_hash(sockfd, &trackers[i], 1, info);
}
}
/*
* lookup() and getprediction() mallocs tracker_info
*/
if (tracker_info != NULL) {
free(tracker_info);
}
#ifdef TIMEIT
gettimeofday(&end_time, NULL);
s = (start_time.tv_sec * 1000000) + start_time.tv_usec;
e = (end_time.tv_sec * 1000000) + end_time.tv_usec;
logmsg("trackfile:svc time: %lld usec file (%s)\n", (e - s), filename);
#endif
if (success) {
return(0);
}
return(-1);
}
/*
* unregister ciphers, hashes & prngs
*/
static void _unregister_all(void)
{
#ifdef LTC_RIJNDAEL
#ifdef ENCRYPT_ONLY
/* alternative would be
* unregister_cipher(&rijndael_enc_desc);
*/
unregister_cipher(&aes_enc_desc);
#else
/* alternative would be
* unregister_cipher(&rijndael_desc);
*/
unregister_cipher(&aes_desc);
#endif
#endif
#ifdef LTC_BLOWFISH
unregister_cipher(&blowfish_desc);
#endif
#ifdef LTC_XTEA
unregister_cipher(&xtea_desc);
#endif
#ifdef LTC_RC5
unregister_cipher(&rc5_desc);
#endif
#ifdef LTC_RC6
unregister_cipher(&rc6_desc);
#endif
#ifdef LTC_SAFERP
unregister_cipher(&saferp_desc);
#endif
#ifdef LTC_TWOFISH
unregister_cipher(&twofish_desc);
#endif
#ifdef LTC_SAFER
unregister_cipher(&safer_k64_desc);
unregister_cipher(&safer_sk64_desc);
unregister_cipher(&safer_k128_desc);
unregister_cipher(&safer_sk128_desc);
#endif
#ifdef LTC_RC2
unregister_cipher(&rc2_desc);
#endif
#ifdef LTC_DES
unregister_cipher(&des_desc);
unregister_cipher(&des3_desc);
#endif
#ifdef LTC_CAST5
unregister_cipher(&cast5_desc);
#endif
#ifdef LTC_NOEKEON
unregister_cipher(&noekeon_desc);
#endif
#ifdef LTC_SKIPJACK
unregister_cipher(&skipjack_desc);
#endif
#ifdef LTC_KHAZAD
unregister_cipher(&khazad_desc);
#endif
#ifdef LTC_ANUBIS
unregister_cipher(&anubis_desc);
#endif
#ifdef LTC_KSEED
unregister_cipher(&kseed_desc);
#endif
#ifdef LTC_KASUMI
unregister_cipher(&kasumi_desc);
#endif
#ifdef LTC_MULTI2
unregister_cipher(&multi2_desc);
#endif
#ifdef LTC_CAMELLIA
unregister_cipher(&camellia_desc);
#endif
#ifdef LTC_TIGER
unregister_hash(&tiger_desc);
#endif
#ifdef LTC_MD2
unregister_hash(&md2_desc);
#endif
#ifdef LTC_MD4
unregister_hash(&md4_desc);
#endif
#ifdef LTC_MD5
unregister_hash(&md5_desc);
#endif
#ifdef LTC_SHA1
unregister_hash(&sha1_desc);
#endif
#ifdef LTC_SHA224
unregister_hash(&sha224_desc);
#endif
#ifdef LTC_SHA256
unregister_hash(&sha256_desc);
#endif
#ifdef LTC_SHA384
unregister_hash(&sha384_desc);
#endif
#ifdef LTC_SHA512
unregister_hash(&sha512_desc);
#endif
#ifdef LTC_SHA512_224
unregister_hash(&sha512_224_desc);
#endif
#ifdef LTC_SHA512_256
unregister_hash(&sha512_256_desc);
#endif
#ifdef LTC_SHA3
unregister_hash(&sha3_224_desc);
unregister_hash(&sha3_256_desc);
unregister_hash(&sha3_384_desc);
unregister_hash(&sha3_512_desc);
#endif
#ifdef LTC_RIPEMD128
unregister_hash(&rmd128_desc);
#endif
#ifdef LTC_RIPEMD160
unregister_hash(&rmd160_desc);
#endif
#ifdef LTC_RIPEMD256
unregister_hash(&rmd256_desc);
#endif
#ifdef LTC_RIPEMD320
unregister_hash(&rmd320_desc);
#endif
#ifdef LTC_WHIRLPOOL
unregister_hash(&whirlpool_desc);
#endif
#ifdef LTC_BLAKE2S
unregister_hash(&blake2s_128_desc);
unregister_hash(&blake2s_160_desc);
unregister_hash(&blake2s_224_desc);
unregister_hash(&blake2s_256_desc);
#endif
#ifdef LTC_BLAKE2B
unregister_hash(&blake2b_160_desc);
unregister_hash(&blake2b_256_desc);
unregister_hash(&blake2b_384_desc);
unregister_hash(&blake2b_512_desc);
#endif
#ifdef LTC_CHC_HASH
unregister_hash(&chc_desc);
#endif
unregister_prng(&yarrow_desc);
#ifdef LTC_FORTUNA
unregister_prng(&fortuna_desc);
#endif
#ifdef LTC_RC4
unregister_prng(&rc4_desc);
#endif
#ifdef LTC_CHACHA20_PRNG
unregister_prng(&chacha20_prng_desc);
#endif
#ifdef LTC_SOBER128
unregister_prng(&sober128_desc);
#endif
#ifdef LTC_SPRNG
unregister_prng(&sprng_desc);
#endif
} /* _cleanup() */
int
main()
{
struct sockaddr_in from_addr;
socklen_t from_addr_len;
ssize_t recvbytes;
int sockfd;
char buf[64*1024];
char done;
#ifdef TIMEIT
#endif
struct timeval start_time, end_time;
unsigned long long s, e;
if ((sockfd = init_tracker_comm(TRACKER_PORT)) < 0) {
fprintf(stderr, "main:init_tracker_comm:failed\n");
abort();
}
if (init_hash_table(HASH_TABLE_ENTRIES) != 0) {
fprintf(stderr, "main:init_hash_table:failed\n");
abort();
}
#ifdef DEBUG
fprintf(stderr, "main:starting\n");
#endif
/*
* needed for shuffle()
*/
srand(time(NULL));
done = 0;
while (!done) {
from_addr_len = sizeof(from_addr);
recvbytes = tracker_recv(sockfd, buf, sizeof(buf),
(struct sockaddr *)&from_addr, &from_addr_len, NULL);
if (recvbytes > 0) {
tracker_header_t *p;
p = (tracker_header_t *)buf;
gettimeofday(&start_time, NULL);
#ifdef TIMEIT
#endif
fprintf(stderr, "%lld : main:op %d from %s seqno %d\n",
(long long int)start_time.tv_sec, p->op,
inet_ntoa(from_addr.sin_addr), p->seqno);
#ifdef DEBUG
#endif
switch(p->op) {
case LOOKUP:
{
tracker_lookup_req_t *req;
req = (tracker_lookup_req_t *)buf;
dolookup(sockfd, req->hash, req->header.seqno, &from_addr);
}
break;
case REGISTER:
register_hash(buf, &from_addr);
break;
case UNREGISTER:
unregister_hash(buf, &from_addr);
break;
case PEER_DONE:
unregister_all(buf, &from_addr);
break;
case STOP_SERVER:
fprintf(stderr,
"Received 'STOP_SERVER' from (%s)\n",
inet_ntoa(from_addr.sin_addr));
exit(0);
default:
fprintf(stderr, "Unknown op (%d)\n", p->op);
abort();
break;
}
gettimeofday(&end_time, NULL);
s = (start_time.tv_sec * 1000000) + start_time.tv_usec;
e = (end_time.tv_sec * 1000000) + end_time.tv_usec;
fprintf(stderr, "main:svc time: %lld\n", (e - s));
#ifdef TIMEIT
#endif
#ifdef LATER
verify_hash_table();
#endif
}
}
return(0);
}
