lkn
/
pcloudcc-lneely
mirror of https://github.com/lneely/pcloudcc-lneely.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
pcloudcc-lneely/pclsync/prand.c

208 lines
6.5 KiB
C
Raw Permalink Blame History

#include <unistd.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/sysinfo.h>
#include <sys/utsname.h>
#include "plibs.h"
#include "pmem.h"
#include "ppath.h"
#include "prand.h"
#include "psettings.h"
#include "psql.h"
static void add_file(const char *fn, psync_lhash_ctx *hctx, size_t max) {
char buff[4096];
ssize_t rd;
int fd, mode;
mode = O_RDONLY;
#if defined(O_NONBLOCK)
mode += O_NONBLOCK;
#elif defined(O_NDELAY)
mode += O_NDELAY;
#endif
fd = open(fn, mode);
if (fd != -1) {
if (!max || max > sizeof(buff))
max = sizeof(buff);
rd = read(fd, buff, max);
if (rd > 0)
psync_lhash_update(hctx, buff, rd);
close(fd);
}
}
static void load_sql(psync_lhash_ctx *hctx, psync_sql_res *res) {
psync_variant_row row;
struct timespec tm;
int i;
while ((row = psql_fetch(res))) {
for (i = 0; i < res->column_count; i++)
if (row[i].type == PSYNC_TSTRING)
psync_lhash_update(hctx, row[i].str, row[i].length);
psync_lhash_update(hctx, row, sizeof(psync_variant) * res->column_count);
}
psql_free(res);
clock_gettime(CLOCK_REALTIME, &tm);
psync_lhash_update(hctx, &tm, sizeof(tm));
}
static void rehash_cnt(unsigned char *hashbin, unsigned long cnt) {
psync_lhash_ctx hctx;
unsigned long i;
struct timespec tm;
for (i = 0; i < cnt; i++) {
psync_lhash_init(&hctx);
if ((i & 511) == 0) {
clock_gettime(CLOCK_REALTIME, &tm);
psync_lhash_update(&hctx, &tm, sizeof(tm));
} else
psync_lhash_update(&hctx, &i, sizeof(i));
psync_lhash_update(&hctx, hashbin, PSYNC_LHASH_DIGEST_LEN);
psync_lhash_final(hashbin, &hctx);
}
}
void prand_seed(unsigned char *seed, const void *addent, size_t aelen,
int fast) {
static unsigned char lastseed[PSYNC_LHASH_DIGEST_LEN];
static pthread_mutex_t lastseed_mutex = PTHREAD_MUTEX_INITIALIZER;
psync_lhash_ctx hctx;
struct timespec tm;
struct stat st;
struct sysinfo si;
char *home;
void *ptr;
unsigned long i, j;
int64_t i64;
pthread_t threadid;
unsigned char lsc[64][PSYNC_LHASH_DIGEST_LEN];
pdbg_logf(D_NOTICE, "in");
struct utsname un;
struct statvfs stfs;
char **env;
pid_t pid;
clock_gettime(CLOCK_REALTIME, &tm);
psync_lhash_init(&hctx);
psync_lhash_update(&hctx, &tm, sizeof(tm));
if (pdbg_likely(!uname(&un)))
psync_lhash_update(&hctx, &un, sizeof(un));
pid = getpid();
psync_lhash_update(&hctx, &pid, sizeof(pid));
if (!statvfs("/", &stfs))
psync_lhash_update(&hctx, &stfs, sizeof(stfs));
for (env = environ; *env != NULL; env++)
psync_lhash_update(&hctx, *env, strlen(*env));
#if defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0 && \
defined(_POSIX_MONOTONIC_CLOCK)
if (pdbg_likely(!clock_gettime(CLOCK_MONOTONIC, &tm)))
psync_lhash_update(&hctx, &tm, sizeof(tm));
#endif
add_file("/dev/urandom", &hctx, PSYNC_HASH_DIGEST_LEN);
if (pdbg_likely(!sysinfo(&si))) {
psync_lhash_update(&hctx, &si, sizeof(si));
}
add_file("/proc/stat", &hctx, 0);
add_file("/proc/vmstat", &hctx, 0);
add_file("/proc/meminfo", &hctx, 0);
add_file("/proc/modules", &hctx, 0);
add_file("/proc/mounts", &hctx, 0);
add_file("/proc/diskstats", &hctx, 0);
add_file("/proc/interrupts", &hctx, 0);
add_file("/proc/net/dev", &hctx, 0);
add_file("/proc/net/arp", &hctx, 0);
threadid = pthread_self();
psync_lhash_update(&hctx, &threadid, sizeof(threadid));
ptr = (void *)&ptr;
psync_lhash_update(&hctx, &ptr, sizeof(ptr));
ptr = (void *)prand_seed;
psync_lhash_update(&hctx, &ptr, sizeof(ptr));
ptr = (void *)pthread_self;
psync_lhash_update(&hctx, &ptr, sizeof(ptr));
ptr = (void *)malloc;
psync_lhash_update(&hctx, &ptr, sizeof(ptr));
ptr = (void *)&lastseed;
psync_lhash_update(&hctx, &ptr, sizeof(ptr));
home = ppath_home();
if (home) {
i64 = ppath_free_space(home);
psync_lhash_update(&hctx, &i64, sizeof(i64));
psync_lhash_update(&hctx, home, strlen(home));
if (pdbg_likely(!stat(home, &st)))
psync_lhash_update(&hctx, &st, sizeof(st));
pmem_free(PMEM_SUBSYS_OTHER, home);
}
if (!fast) {
pdbg_logf(D_NOTICE, "getting seed from database");
psync_sql_res *res;
struct timespec tm;
unsigned char rnd[PSYNC_LHASH_DIGEST_LEN];
clock_gettime(CLOCK_REALTIME, &tm);
psync_lhash_update(&hctx, &tm, sizeof(tm));
res = psql_query_rdlock("SELECT * FROM setting ORDER BY RANDOM()");
load_sql(&hctx, res);
res = psql_query_rdlock(
"SELECT * FROM resolver ORDER BY RANDOM() LIMIT 50");
load_sql(&hctx, res);
psql_statement(
"REPLACE INTO setting (id, value) VALUES ('random', RANDOM())");
clock_gettime(CLOCK_REALTIME, &tm);
psync_lhash_update(&hctx, &tm, sizeof(tm));
psql_sync();
clock_gettime(CLOCK_REALTIME, &tm);
psync_lhash_update(&hctx, &tm, sizeof(tm));
sqlite3_randomness(sizeof(rnd), rnd);
psync_lhash_update(&hctx, rnd, sizeof(rnd));
pdbg_logf(D_NOTICE, "got seed from database");
}
if (aelen)
psync_lhash_update(&hctx, addent, aelen);
pdbg_logf(D_NOTICE, "adding bulk data");
pthread_mutex_lock(&lastseed_mutex);
for (i = 0; i < ARRAY_SIZE(lsc); i++) {
memcpy(&lsc[i], lastseed, PSYNC_LHASH_DIGEST_LEN);
for (j = 0; j < PSYNC_LHASH_DIGEST_LEN; j++)
lsc[i][j] ^= (unsigned char)i;
}
for (j = fast ? 3 : 0; j < 5; j++) {
for (i = 0; i < 100; i++) {
psync_lhash_update(&hctx, &i, sizeof(i));
psync_lhash_update(&hctx, &j, sizeof(j));
psync_lhash_update(&hctx, lsc, sizeof(lsc));
}
clock_gettime(CLOCK_REALTIME, &tm);
psync_lhash_update(&hctx, &tm, sizeof(tm));
}
psync_lhash_final(seed, &hctx);
memcpy(lastseed, seed, PSYNC_LHASH_DIGEST_LEN);
pthread_mutex_unlock(&lastseed_mutex);
pdbg_logf(D_NOTICE, "storing in db");
psync_sql_res *res;
unsigned char hashbin[PSYNC_LHASH_DIGEST_LEN];
char hashhex[PSYNC_LHASH_DIGEST_HEXLEN], nm[16];
memcpy(hashbin, seed, PSYNC_LHASH_DIGEST_LEN);
rehash_cnt(hashbin, 2000);
psync_binhex(hashhex, hashbin, PSYNC_LHASH_DIGEST_LEN);
res = psql_prepare(
"REPLACE INTO setting (id, value) VALUES ('randomhash', ?)");
psql_bind_lstr(res, 1, hashhex, PSYNC_LHASH_DIGEST_HEXLEN);
psql_run_free(res);
rehash_cnt(hashbin, 2000);
psync_binhex(hashhex, hashbin, PSYNC_LHASH_DIGEST_LEN);
memcpy(nm, "randomhash", 10);
nm[10] = hashhex[0];
nm[11] = 0;
res = psql_prepare(
"REPLACE INTO setting (id, value) VALUES (?, ?)");
psql_bind_lstr(res, 1, nm, 11);
psql_bind_lstr(res, 2, hashhex, PSYNC_LHASH_DIGEST_HEXLEN);
psql_run_free(res);
pdbg_logf(D_NOTICE, "out");
}
Reference in New Issue View Git Blame Copy Permalink