/* functions
*/
u3_noun
u3qc_muk(u3_atom seed,
u3_atom len,
u3_atom key)
{
c3_w seed_w;
c3_w len_w;
c3_y *key_y;
c3_w out_w;
c3_assert(u3r_met(5, seed) <= 1);
c3_assert(u3r_met(0, len) <= 31);
c3_assert(u3r_met(3, key) <= len);
seed_w = u3r_word(0, seed);
len_w = u3r_word(0, len);
if (len_w > 0) { /* can't u3a_calloc 0 bytes */
key_y = u3a_calloc(sizeof(c3_y), len);
} else {
key_y = 0;
}
u3r_bytes(0, len, key_y, key);
MurmurHash3_x86_32(key_y, len, seed_w, &out_w);
u3a_free(key_y);
return u3i_words(1, &out_w);
}
/* _sist_zen(): get OS entropy.
*/
static u3_noun
_sist_zen()
{
c3_w rad_w[8];
c3_rand(rad_w);
return u3i_words(8, rad_w);
}
/* _term_it_show_wide(): show wide text, retaining.
*/
static void
_term_it_show_wide(u3_utty* uty_u, c3_w len_w, c3_w* txt_w)
{
u3_noun wad = u3i_words(len_w, txt_w);
u3_noun txt = u3do("tuft", wad);
c3_c* txt_c = u3r_string(txt);
_term_it_write_str(uty_u, txt_c);
free(txt_c);
u3z(txt);
uty_u->tat_u.mir.cus_w += len_w;
}
/* _http_request(): dispatch http request, returning null if async.
*/
static void
_http_request(u3_hreq* req_u)
{
u3_noun req = _http_request_to_noun(req_u);
if ( u3_none != req ) {
u3_noun pox = _http_pox_to_noun(req_u->hon_u->htp_u->sev_l,
req_u->hon_u->coq_l,
req_u->seq_l);
u3v_plan(pox,
u3nq(c3__this,
req_u->hon_u->htp_u->sec,
u3nc(c3y, u3i_words(1, &req_u->ipf_w)),
req));
}
}
/* functions
*/
u3_noun
u3qc_met(u3_atom a,
u3_atom b)
{
if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
if ( 0 == b ) {
return 0;
} else return 1;
}
else {
c3_w met_w = u3r_met(a, b);
if ( !_(u3a_is_cat(met_w)) ) {
return u3i_words(1, &met_w);
}
else return u3r_met(a, b);
}
}
// apply
//
static void
_lune(u3_loss* loc_u,
c3_w inx_w,
c3_w goy_w)
{
u3_noun kad;
kad = u3nc(u3i_words(1, &goy_w),
(inx_w == 0) ? u3_nul
: u3k(loc_u->kad[inx_w - 1]));
if ( loc_u->kct_w == inx_w ) {
c3_assert(loc_u->kct_w < (1 << 31));
loc_u->kct_w++;
} else {
u3z(loc_u->kad[inx_w]);
}
loc_u->kad[inx_w] = kad;
}
// initialize loss object
//
static void
_lemp(u3_loss* loc_u,
u3_noun hel,
u3_noun hev)
{
loc_u->hel = hel;
loc_u->lel_w = u3kb_lent(u3k(hel));
// Read hev into array.
{
c3_w i_w;
loc_u->hev = c3_malloc(u3kb_lent(u3k(hev)) * sizeof(u3_noun));
for ( i_w = 0; u3_nul != hev; i_w++ ) {
loc_u->hev[i_w] = u3h(hev);
hev = u3t(hev);
}
loc_u->lev_w = i_w;
}
loc_u->kct_w = 0;
loc_u->kad = c3_malloc(
(1 + c3_min(loc_u->lev_w, loc_u->lel_w)) *
sizeof(u3_noun));
// Compute equivalence classes.
//
loc_u->sev = u3_nul;
{
c3_w i_w;
for ( i_w = 0; i_w < loc_u->lev_w; i_w++ ) {
u3_noun how = loc_u->hev[i_w];
u3_noun hav;
u3_noun teg;
hav = u3kdb_get(u3k(loc_u->sev), u3k(how));
teg = u3nc(u3i_words(1, &i_w),
(hav == u3_none) ? u3_nul : hav);
loc_u->sev = u3kdb_put(loc_u->sev, u3k(how), teg);
}
}
}
/* _sist_rest(): restore from record, or exit.
*/
static void
_sist_rest()
{
struct stat buf_b;
c3_i fid_i;
c3_c ful_c[2048];
c3_d old_d = u3A->ent_d;
c3_d las_d = 0;
u3_noun roe = u3_nul;
u3_noun sev_l, key_l, sal_l;
u3_noun ohh = c3n;
if ( 0 != u3A->ent_d ) {
u3_noun ent;
c3_c* ent_c;
ent = u3i_chubs(1, &u3A->ent_d);
ent = u3dc("scot", c3__ud, ent);
ent_c = u3r_string(ent);
uL(fprintf(uH, "rest: checkpoint to event %s\n", ent_c));
free(ent_c);
u3z(ent);
}
// Open the fscking file. Does it even exist?
{
c3_i pig_i = O_RDWR;
#ifdef O_DSYNC
pig_i |= O_DSYNC;
#endif
snprintf(ful_c, 2048, "%s/.urb/egz.hope", u3_Host.dir_c);
if ( ((fid_i = open(ful_c, pig_i)) < 0) || (fstat(fid_i, &buf_b) < 0) ) {
uL(fprintf(uH, "rest: can't open record (%s)\n", ful_c));
u3_lo_bail();
return;
}
#ifdef F_NOCACHE
if ( -1 == fcntl(fid_i, F_NOCACHE, 1) ) {
uL(fprintf(uH, "rest: can't uncache %s: %s\n", ful_c, strerror(errno)));
u3_lo_bail();
return;
}
#endif
u3Z->lug_u.fid_i = fid_i;
u3Z->lug_u.len_d = ((buf_b.st_size + 3ULL) >> 2ULL);
}
// Check the fscking header. It's probably corrupt.
{
u3_uled led_u;
if ( sizeof(led_u) != read(fid_i, &led_u, sizeof(led_u)) ) {
uL(fprintf(uH, "record (%s) is corrupt (a)\n", ful_c));
u3_lo_bail();
}
if ( u3r_mug('f') == led_u.mag_l ) {
_sist_rest_nuu(&u3Z->lug_u, led_u, ful_c);
fid_i = u3Z->lug_u.fid_i;
}
else if (u3r_mug('g') != led_u.mag_l ) {
uL(fprintf(uH, "record (%s) is obsolete (or corrupt)\n", ful_c));
u3_lo_bail();
}
if ( led_u.kno_w != 163 ) {
// XX perhaps we should actually do something here
//
uL(fprintf(uH, "rest: (not) translating events (old %d, now %d)\n",
led_u.kno_w,
163));
}
sev_l = led_u.sev_l;
sal_l = led_u.sal_l;
key_l = led_u.key_l;
{
u3_noun old = u3dc("scot", c3__uv, sev_l);
u3_noun nuu = u3dc("scot", c3__uv, u3A->sev_l);
c3_c* old_c = u3r_string(old);
c3_c* nuu_c = u3r_string(nuu);
uL(fprintf(uH, "rest: old %s, new %s\n", old_c, nuu_c));
free(old_c); free(nuu_c);
u3z(old); u3z(nuu);
}
c3_assert(sev_l != u3A->sev_l); // 1 in 2 billion, just retry
}
// Oh, and let's hope you didn't forget the fscking passcode.
{
if ( 0 != key_l ) {
u3_noun pas = _sist_staf(key_l);
u3_noun key;
while ( 1 ) {
pas = pas ? pas : _sist_cask(u3_Host.dir_c, c3n);
key = _sist_fatt(sal_l, pas);
if ( u3r_mug(key) != key_l ) {
uL(fprintf(uH, "incorrect passcode\n"));
u3z(key);
pas = 0;
}
else {
u3z(u3A->key);
u3A->key = key;
break;
}
}
}
}
// Read in the fscking events. These are probably corrupt as well.
{
c3_d ent_d;
c3_d end_d;
u3_noun rup = c3n;
end_d = u3Z->lug_u.len_d;
ent_d = 0;
if ( -1 == lseek64(fid_i, 4ULL * end_d, SEEK_SET) ) {
fprintf(stderr, "end_d %" PRIu64 "\n", end_d);
perror("lseek");
uL(fprintf(uH, "record (%s) is corrupt (c)\n", ful_c));
u3_lo_bail();
}
while ( end_d != c3_wiseof(u3_uled) ) {
c3_d tar_d = (end_d - (c3_d)c3_wiseof(u3_ular));
u3_ular lar_u;
c3_w* img_w;
u3_noun ron;
// uL(fprintf(uH, "rest: reading event at %" PRIx64 "\n", end_d));
if ( -1 == lseek64(fid_i, 4ULL * tar_d, SEEK_SET) ) {
uL(fprintf(uH, "record (%s) is corrupt (d)\n", ful_c));
u3_lo_bail();
}
if ( sizeof(u3_ular) != read(fid_i, &lar_u, sizeof(u3_ular)) ) {
uL(fprintf(uH, "record (%s) is corrupt (e)\n", ful_c));
u3_lo_bail();
}
if ( lar_u.syn_w != u3r_mug((c3_w)tar_d) ) {
if ( c3n == rup ) {
uL(fprintf(uH, "corruption detected; attempting to fix\n"));
rup = c3y;
}
uL(fprintf(uH, "lar:%x mug:%x\n", lar_u.syn_w, u3r_mug((c3_w)tar_d)));
end_d--; u3Z->lug_u.len_d--;
continue;
}
else if ( c3y == rup ) {
uL(fprintf(uH, "matched at %x\n", lar_u.syn_w));
rup = c3n;
}
if ( lar_u.ent_d == 0 ) {
ohh = c3y;
}
#if 0
uL(fprintf(uH, "log: read: at %d, %d: lar ent %" PRIu64 ", len %d, mug %x\n",
(tar_w - lar_u.len_w),
tar_w,
lar_u.ent_d,
lar_u.len_w,
lar_u.mug_w));
#endif
if ( end_d == u3Z->lug_u.len_d ) {
ent_d = las_d = lar_u.ent_d;
}
else {
if ( lar_u.ent_d != (ent_d - 1ULL) ) {
uL(fprintf(uH, "record (%s) is corrupt (g)\n", ful_c));
uL(fprintf(uH, "lar_u.ent_d %" PRIx64 ", ent_d %" PRIx64 "\n", lar_u.ent_d, ent_d));
u3_lo_bail();
}
ent_d -= 1ULL;
}
end_d = (tar_d - (c3_d)lar_u.len_w);
if ( ent_d < old_d ) {
// XX this could be a break if we didn't want to see the sequence
// number of the first event.
continue;
}
img_w = c3_malloc(4 * lar_u.len_w);
if ( -1 == lseek64(fid_i, 4ULL * end_d, SEEK_SET) ) {
uL(fprintf(uH, "record (%s) is corrupt (h)\n", ful_c));
u3_lo_bail();
}
if ( (4 * lar_u.len_w) != read(fid_i, img_w, (4 * lar_u.len_w)) ) {
uL(fprintf(uH, "record (%s) is corrupt (i)\n", ful_c));
u3_lo_bail();
}
ron = u3i_words(lar_u.len_w, img_w);
free(img_w);
if ( lar_u.mug_w !=
u3r_mug_both(u3r_mug(ron),
u3r_mug_both(u3r_mug(lar_u.tem_w),
u3r_mug(lar_u.typ_w))) )
{
uL(fprintf(uH, "record (%s) is corrupt (j)\n", ful_c));
u3_lo_bail();
}
if ( c3__ov != lar_u.typ_w ) {
u3z(ron);
continue;
}
if ( u3A->key ) {
u3_noun dep;
dep = u3dc("de:crua", u3k(u3A->key), ron);
if ( c3n == u3du(dep) ) {
uL(fprintf(uH, "record (%s) is corrupt (k)\n", ful_c));
u3_lo_bail();
}
else {
ron = u3k(u3t(dep));
u3z(dep);
}
}
roe = u3nc(u3ke_cue(ron), roe);
}
u3A->ent_d = c3_max(las_d + 1ULL, old_d);
}
if ( u3_nul == roe ) {
// Nothing in the log that was not also in the checkpoint.
//
c3_assert(u3A->ent_d == old_d);
if ( las_d + 1 != old_d ) {
uL(fprintf(uH, "checkpoint and log disagree! las:%" PRIu64 " old:%" PRIu64 "\n",
las_d + 1, old_d));
uL(fprintf(uH, "Some events appear to be missing from the log.\n"
"Please contact the authorities, "
"and do not delete your pier!\n"));
u3_lo_bail();
}
}
else {
u3_noun rou = roe;
c3_w xno_w;
// Execute the fscking things. This is pretty much certain to crash.
//
uL(fprintf(uH, "rest: replaying through event %" PRIu64 "\n", las_d));
fprintf(uH, "---------------- playback starting----------------\n");
xno_w = 0;
while ( u3_nul != roe ) {
u3_noun i_roe = u3h(roe);
u3_noun t_roe = u3t(roe);
u3_noun now = u3h(i_roe);
u3_noun ovo = u3t(i_roe);
u3v_time(u3k(now));
if ( (c3y == u3_Host.ops_u.vno) &&
( (c3__veer == u3h(u3t(ovo)) ||
(c3__vega == u3h(u3t(ovo)))) ) )
{
fprintf(stderr, "replay: skipped veer\n");
}
else if ( c3y == u3_Host.ops_u.fog &&
u3_nul == t_roe ) {
fprintf(stderr, "replay: -Xwtf, skipped last event\n");
}
else {
_sist_sing(u3k(ovo));
fputc('.', stderr);
}
// fprintf(stderr, "playback: sing: %d\n", xno_w));
roe = t_roe;
xno_w++;
if ( 0 == (xno_w % 1000) ) {
uL(fprintf(uH, "{%d}\n", xno_w));
// u3_lo_grab("rest", rou, u3_none);
}
}
u3z(rou);
}
uL(fprintf(stderr, "\n---------------- playback complete----------------\n"));
#if 0
// If you see this error, your record is totally fscking broken!
// Which probably serves you right. Please consult a consultant.
{
if ( u3_nul == u3A->own ) {
uL(fprintf(uH, "record did not install a master!\n"));
u3_lo_bail();
}
u3A->our = u3k(u3h(u3A->own));
u3A->pod = u3dc("scot", 'p', u3k(u3A->our)));
}
// Now, who the fsck are you? No, really.
{
u3_noun who;
c3_c* fil_c;
c3_c* who_c;
if ( (fil_c = strrchr(u3_Host.dir_c, '/')) ) {
fil_c++;
} else fil_c = u3_Host.dir_c;
who = u3dc("scot", 'p', u3k(u3A->our)));
who_c = u3r_string(who);
u3z(who);
if ( strncmp(fil_c, who_c + 1, strlen(fil_c)) ) {
uL(fprintf(uH, "record master (%s) does not match filename!\n", who_c));
u3_lo_bail();
}
free(who_c);
}
#endif
// Increment sequence numbers. New logs start at 1.
if ( c3y == ohh ) {
uL(fprintf(uH, "rest: bumping ent_d, don't panic.\n"));
u3_ular lar_u;
c3_d end_d;
c3_d tar_d;
u3A->ent_d++;
end_d = u3Z->lug_u.len_d;
while ( end_d != c3_wiseof(u3_uled) ) {
tar_d = end_d - c3_wiseof(u3_ular);
if ( -1 == lseek64(fid_i, 4ULL * tar_d, SEEK_SET) ) {
uL(fprintf(uH, "bumping sequence numbers failed (a)\n"));
u3_lo_bail();
}
if ( sizeof(lar_u) != read(fid_i, &lar_u, sizeof(lar_u)) ) {
uL(fprintf(uH, "bumping sequence numbers failed (b)\n"));
u3_lo_bail();
}
lar_u.ent_d++;
if ( -1 == lseek64(fid_i, 4ULL * tar_d, SEEK_SET) ) {
uL(fprintf(uH, "bumping sequence numbers failed (c)\n"));
u3_lo_bail();
}
if ( sizeof(lar_u) != write(fid_i, &lar_u, sizeof(lar_u)) ) {
uL(fprintf(uH, "bumping sequence numbers failed (d)\n"));
u3_lo_bail();
}
end_d = tar_d - lar_u.len_w;
}
}
// Rewrite the header. Will probably corrupt the record.
{
u3_uled led_u;
led_u.mag_l = u3r_mug('g');
led_u.sal_l = sal_l;
led_u.sev_l = u3A->sev_l;
led_u.key_l = u3A->key ? u3r_mug(u3A->key) : 0;
led_u.kno_w = 163; // may need actual translation!
led_u.tno_l = 1;
if ( (-1 == lseek64(fid_i, 0, SEEK_SET)) ||
(sizeof(led_u) != write(fid_i, &led_u, sizeof(led_u))) )
{
uL(fprintf(uH, "record (%s) failed to rewrite\n", ful_c));
u3_lo_bail();
}
}
// Hey, fscker! It worked.
{
u3_term_ef_boil();
}
}
/* _sist_rest_nuu(): upgrade log from previous format.
*/
static void
_sist_rest_nuu(u3_ulog* lug_u, u3_uled led_u, c3_c* old_c)
{
c3_c nuu_c[2048];
u3_noun roe = u3_nul;
c3_i fid_i = lug_u->fid_i;
c3_i fud_i;
c3_i ret_i;
c3_d end_d = lug_u->len_d;
uL(fprintf(uH, "rest: converting log from prior format\n"));
c3_assert(led_u.mag_l == u3r_mug('f'));
if ( -1 == lseek64(fid_i, 4ULL * end_d, SEEK_SET) ) {
uL(fprintf(uH, "rest_nuu failed (a)\n"));
perror("lseek64");
u3_lo_bail();
}
while ( end_d != c3_wiseof(u3_uled) ) {
c3_d tar_d;
u3_olar lar_u;
c3_w* img_w;
u3_noun ron;
tar_d = (end_d - (c3_d)c3_wiseof(u3_olar));
if ( -1 == lseek64(fid_i, 4ULL * tar_d, SEEK_SET) ) {
uL(fprintf(uH, "rest_nuu failed (b)\n"));
perror("lseek64");
u3_lo_bail();
}
if ( sizeof(u3_olar) != read(fid_i, &lar_u, sizeof(u3_olar)) ) {
uL(fprintf(uH, "rest_nuu failed (c)\n"));
perror("read");
u3_lo_bail();
}
if ( lar_u.syn_w != u3r_mug((c3_w)tar_d) ) {
uL(fprintf(uH, "rest_nuu failed (d)\n"));
u3_lo_bail();
}
img_w = c3_malloc(4 * lar_u.len_w);
end_d = (tar_d - (c3_d)lar_u.len_w);
if ( -1 == lseek64(fid_i, 4ULL * end_d, SEEK_SET) ) {
uL(fprintf(uH, "rest_nuu failed (e)\n"));
perror("lseek64");
u3_lo_bail();
}
if ( (4 * lar_u.len_w) != read(fid_i, img_w, (4 * lar_u.len_w)) ) {
uL(fprintf(uH, "rest_nuu failed (f)\n"));
perror("read");
u3_lo_bail();
}
ron = u3i_words(lar_u.len_w, img_w);
free(img_w);
if ( lar_u.mug_w != u3r_mug(ron) ) {
uL(fprintf(uH, "rest_nuu failed (g)\n"));
u3_lo_bail();
}
roe = u3nc(ron, roe);
}
if ( 0 != close(fid_i) ) {
uL(fprintf(uH, "rest: could not close\n"));
perror("close");
u3_lo_bail();
}
ret_i = snprintf(nuu_c, 2048, "%s/.urb/ham.hope", u3_Host.dir_c);
c3_assert(ret_i < 2048);
if ( (fud_i = open(nuu_c, O_CREAT | O_TRUNC | O_RDWR, 0600)) < 0 ) {
uL(fprintf(uH, "rest: can't open record (%s)\n", nuu_c));
perror("open");
u3_lo_bail();
}
led_u.mag_l = u3r_mug('g');
if ( (sizeof(led_u) != write(fud_i, &led_u, sizeof(led_u))) ) {
uL(fprintf(uH, "rest: can't write header\n"));
perror("write");
u3_lo_bail();
}
{
c3_d ent_d = 1;
c3_assert(end_d == c3_wiseof(u3_uled));
while ( u3_nul != roe ) {
u3_noun ovo = u3k(u3h(roe));
u3_noun nex = u3k(u3t(roe));
u3_ular lar_u;
c3_w* img_w;
c3_d tar_d;
lar_u.len_w = u3r_met(5, ovo);
tar_d = end_d + lar_u.len_w;
lar_u.syn_w = u3r_mug(tar_d);
lar_u.ent_d = ent_d;
lar_u.tem_w = 0;
lar_u.typ_w = c3__ov;
lar_u.mug_w = u3r_mug_both(u3r_mug(ovo),
u3r_mug_both(u3r_mug(0),
u3r_mug(c3__ov)));
img_w = c3_malloc(lar_u.len_w << 2);
u3r_words(0, lar_u.len_w, img_w, ovo);
u3z(ovo);
if ( (lar_u.len_w << 2) != write(fud_i, img_w, lar_u.len_w << 2) ) {
uL(fprintf(uH, "rest_nuu failed (h)\n"));
perror("write");
u3_lo_bail();
}
if ( sizeof(u3_ular) != write(fud_i, &lar_u, sizeof(u3_ular)) ) {
uL(fprintf(uH, "rest_nuu failed (i)\n"));
perror("write");
u3_lo_bail();
}
ent_d++;
end_d = tar_d + c3_wiseof(u3_ular);
u3z(roe); roe = nex;
}
}
if ( 0 != rename(nuu_c, old_c) ) {
uL(fprintf(uH, "rest_nuu failed (k)\n"));
perror("rename");
u3_lo_bail();
}
if ( -1 == lseek64(fud_i, sizeof(u3_uled), SEEK_SET) ) {
uL(fprintf(uH, "rest_nuu failed (l)\n"));
perror("lseek64");
u3_lo_bail();
}
lug_u->fid_i = fud_i;
lug_u->len_d = end_d;
}
/* _sist_zest(): create a new, empty record.
*/
static void
_sist_zest()
{
struct stat buf_b;
c3_i fid_i;
c3_c ful_c[8193];
c3_l sal_l;
// Create the ship directory.
//
_sist_home();
// Create the record file.
{
c3_i pig_i = O_CREAT | O_WRONLY | O_EXCL;
#ifdef O_DSYNC
pig_i |= O_DSYNC;
#endif
snprintf(ful_c, 2048, "%s/.urb/egz.hope", u3_Host.dir_c);
if ( ((fid_i = open(ful_c, pig_i, 0600)) < 0) ||
(fstat(fid_i, &buf_b) < 0) )
{
uL(fprintf(uH, "can't create record (%s)\n", ful_c));
u3_lo_bail();
}
#ifdef F_NOCACHE
if ( -1 == fcntl(fid_i, F_NOCACHE, 1) ) {
uL(fprintf(uH, "zest: can't uncache %s: %s\n", ful_c, strerror(errno)));
u3_lo_bail();
}
#endif
u3Z->lug_u.fid_i = fid_i;
}
// Generate a 31-bit salt.
//
{
c3_w rad_w[8];
c3_rand(rad_w);
sal_l = (0x7fffffff & rad_w[0]);
}
// Create and save a passcode.
//
{
c3_w rad_w[8];
u3_noun pas;
c3_rand(rad_w);
pas = u3i_words(2, rad_w);
u3A->key = _sist_fatt(sal_l, u3k(pas));
_sist_fast(pas, u3r_mug(u3A->key));
}
// Write the header.
{
u3_uled led_u;
led_u.mag_l = u3r_mug('g');
led_u.kno_w = 163;
if ( 0 == u3A->key ) {
led_u.key_l = 0;
} else {
led_u.key_l = u3r_mug(u3A->key);
c3_assert(!(led_u.key_l >> 31));
}
led_u.sal_l = sal_l;
led_u.sev_l = u3A->sev_l;
led_u.tno_l = 1;
if ( sizeof(led_u) != write(fid_i, &led_u, sizeof(led_u)) ) {
uL(fprintf(uH, "can't write record (%s)\n", ful_c));
u3_lo_bail();
}
u3Z->lug_u.len_d = c3_wiseof(led_u);
}
// Work through the boot events.
u3_raft_work();
}
