mirror of
https://github.com/ilyakooo0/urbit.git
synced 2024-12-16 19:22:22 +03:00
2017 lines
41 KiB
C
2017 lines
41 KiB
C
/* v/loop.c
|
|
**
|
|
** This file is in the public domain.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <fcntl.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#include <setjmp.h>
|
|
#include <gmp.h>
|
|
#include <sigsegv.h>
|
|
#include <stdint.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <uv.h>
|
|
#include <errno.h>
|
|
#include <curses.h>
|
|
#include <termios.h>
|
|
#include <term.h>
|
|
|
|
#include "all.h"
|
|
#include "v/vere.h"
|
|
|
|
#define AMES
|
|
|
|
#if defined(U2_OS_linux)
|
|
#include <stdio_ext.h>
|
|
#define fpurge(fd) __fpurge(fd)
|
|
#define DEVRANDOM "/dev/urandom"
|
|
#else
|
|
#define DEVRANDOM "/dev/random"
|
|
#endif
|
|
|
|
static jmp_buf Signal_buf;
|
|
#ifndef SIGSTKSZ
|
|
# define SIGSTKSZ 16384
|
|
#endif
|
|
static uint8_t Sigstk[SIGSTKSZ];
|
|
|
|
typedef enum {
|
|
sig_none,
|
|
sig_overflow,
|
|
sig_interrupt,
|
|
sig_terminate,
|
|
sig_memory,
|
|
sig_assert,
|
|
sig_timer
|
|
} u2_kill;
|
|
|
|
volatile u2_kill Sigcause; // reasons for exception
|
|
|
|
static void
|
|
_lo_signal_handle_over(int emergency, stackoverflow_context_t scp)
|
|
{
|
|
if ( u2_Critical ) {
|
|
// Careful not to grow the stack during critical sections.
|
|
//
|
|
write(2, "stack disaster\n", strlen("stack disaster" + 2));
|
|
abort();
|
|
}
|
|
|
|
#if 0
|
|
if ( 1 == emergency ) {
|
|
write(2, "stack emergency\n", strlen("stack emergency" + 2));
|
|
abort();
|
|
} else
|
|
#endif
|
|
{
|
|
Sigcause = sig_overflow;
|
|
longjmp(Signal_buf, 1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
_lo_signal_handle_term(int x)
|
|
{
|
|
if ( !u2_Critical ) {
|
|
Sigcause = sig_terminate;
|
|
u2_Host.liv = u2_no;
|
|
longjmp(Signal_buf, 1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
_lo_signal_handle_intr(int x)
|
|
{
|
|
if ( !u2_Critical ) {
|
|
Sigcause = sig_interrupt;
|
|
longjmp(Signal_buf, 1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
_lo_signal_handle_alrm(int x)
|
|
{
|
|
if ( !u2_Critical ) {
|
|
Sigcause = sig_timer;
|
|
longjmp(Signal_buf, 1);
|
|
}
|
|
}
|
|
|
|
/* _lo_signal_done():
|
|
*/
|
|
static void
|
|
_lo_signal_done()
|
|
{
|
|
// signal(SIGINT, SIG_IGN);
|
|
signal(SIGTERM, SIG_IGN);
|
|
signal(SIGVTALRM, SIG_IGN);
|
|
|
|
stackoverflow_deinstall_handler();
|
|
{
|
|
struct itimerval itm_u;
|
|
|
|
timerclear(&itm_u.it_interval);
|
|
timerclear(&itm_u.it_value);
|
|
|
|
setitimer(ITIMER_VIRTUAL, &itm_u, 0);
|
|
}
|
|
u2_unix_ef_move();
|
|
}
|
|
|
|
/* _lo_signal_deep(): start deep processing; set timer for sec_w or 0.
|
|
*/
|
|
static void
|
|
_lo_signal_deep(c3_w sec_w)
|
|
{
|
|
u2_unix_ef_hold();
|
|
|
|
stackoverflow_install_handler(_lo_signal_handle_over, Sigstk, SIGSTKSZ);
|
|
signal(SIGINT, _lo_signal_handle_intr);
|
|
signal(SIGTERM, _lo_signal_handle_term);
|
|
|
|
{
|
|
struct itimerval itm_u;
|
|
|
|
timerclear(&itm_u.it_interval);
|
|
itm_u.it_value.tv_sec = sec_w;
|
|
itm_u.it_value.tv_usec = 0;
|
|
|
|
setitimer(ITIMER_VIRTUAL, &itm_u, 0);
|
|
}
|
|
signal(SIGVTALRM, _lo_signal_handle_alrm);
|
|
}
|
|
|
|
/* u2_loop_signal_memory(): end computation for out-of-memory.
|
|
*/
|
|
void
|
|
u2_loop_signal_memory()
|
|
{
|
|
fprintf(stderr, "\r\nout of memory\r\n");
|
|
Sigcause = sig_memory;
|
|
longjmp(Signal_buf, 1);
|
|
}
|
|
|
|
/* _lo_init(): initialize I/O across the process.
|
|
*/
|
|
static void
|
|
_lo_init()
|
|
{
|
|
u2_unix_io_init();
|
|
u2_ames_io_init();
|
|
u2_term_io_init();
|
|
u2_http_io_init();
|
|
u2_save_io_init();
|
|
u2_batz_io_init();
|
|
}
|
|
|
|
/* _lo_talk(): bring up listeners across the process.
|
|
*/
|
|
static void
|
|
_lo_talk()
|
|
{
|
|
u2_unix_io_talk();
|
|
u2_ames_io_talk();
|
|
u2_http_io_talk();
|
|
}
|
|
|
|
/* _lo_exit(): terminate I/O across the process.
|
|
*/
|
|
static void
|
|
_lo_exit(void)
|
|
{
|
|
u2_unix_io_exit();
|
|
u2_ames_io_exit();
|
|
u2_term_io_exit();
|
|
u2_http_io_exit();
|
|
u2_save_io_exit();
|
|
u2_batz_io_exit();
|
|
}
|
|
|
|
/* _lo_poll(): reset event flags across the process.
|
|
*/
|
|
static void
|
|
_lo_poll(void)
|
|
{
|
|
u2_ames_io_poll();
|
|
u2_http_io_poll();
|
|
u2_term_io_poll();
|
|
u2_save_io_poll();
|
|
u2_unix_io_poll();
|
|
u2_batz_io_poll();
|
|
}
|
|
|
|
#if 0
|
|
/* _lo_how(): print how.
|
|
*/
|
|
static const c3_c*
|
|
_lo_how(u2_noun how)
|
|
{
|
|
switch ( how ) {
|
|
default: c3_assert(0); break;
|
|
|
|
case c3__ames: return "ames";
|
|
case c3__batz: return "batz";
|
|
case c3__term: return "cons";
|
|
case c3__htcn: return "http-conn";
|
|
case c3__htls: return "http-lisn";
|
|
case c3__save: return "save";
|
|
case c3__unix: return "unix";
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* u2_lo_bail(): clean up all event state.
|
|
*/
|
|
void
|
|
u2_lo_bail(u2_reck* rec_u)
|
|
{
|
|
fflush(stdout);
|
|
_lo_exit();
|
|
|
|
exit(1);
|
|
}
|
|
int c3_cooked() { _lo_exit(); return 0; }
|
|
|
|
/* _lo_tape(): dump a tape, old style. Don't do this.
|
|
*/
|
|
static void
|
|
_lo_tape(u2_reck* rec_u, FILE* fil_u, u2_noun tep)
|
|
{
|
|
u2_noun tap = tep;
|
|
|
|
while ( u2_nul != tap ) {
|
|
c3_c car_c;
|
|
|
|
if ( u2h(tap) >= 127 ) {
|
|
car_c = '?';
|
|
} else car_c = u2h(tap);
|
|
|
|
putc(car_c, fil_u);
|
|
tap = u2t(tap);
|
|
}
|
|
u2z(tep);
|
|
}
|
|
|
|
/* _lo_wall(): dump a wall, old style. Don't do this.
|
|
*/
|
|
static void
|
|
_lo_wall(u2_reck* rec_u, u2_noun wol)
|
|
{
|
|
FILE* fil_u = u2_term_io_hija();
|
|
u2_noun wal = wol;
|
|
|
|
while ( u2_nul != wal ) {
|
|
_lo_tape(rec_u, fil_u, u2k(u2h(wal)));
|
|
|
|
putc(13, fil_u);
|
|
putc(10, fil_u);
|
|
|
|
wal = u2t(wal);
|
|
}
|
|
u2_term_io_loja(0);
|
|
u2z(wol);
|
|
}
|
|
|
|
/* u2_lo_tank(): dump single tank.
|
|
*/
|
|
void
|
|
u2_lo_tank(c3_l tab_l, u2_noun tac)
|
|
{
|
|
u2_lo_punt(tab_l, u2nc(tac, u2_nul));
|
|
}
|
|
|
|
/* u2_lo_punt(): dump tank list.
|
|
*/
|
|
void
|
|
u2_lo_punt(c3_l tab_l, u2_noun tac)
|
|
{
|
|
u2_noun blu = u2_term_get_blew(0);
|
|
c3_l col_l = u2h(blu);
|
|
u2_noun cat = tac;
|
|
|
|
// We are calling nock here, but hopefully need no protection.
|
|
//
|
|
while ( u2_yes == u2_cr_du(cat) ) {
|
|
u2_noun wol = u2_dc("wash", u2nc(tab_l, col_l), u2k(u2h(cat)));
|
|
|
|
_lo_wall(u2_Arv, wol);
|
|
cat = u2t(cat);
|
|
}
|
|
u2z(tac);
|
|
u2z(blu);
|
|
}
|
|
|
|
/* u2_lo_sway(): print trace.
|
|
*/
|
|
void
|
|
u2_lo_sway(c3_l tab_l, u2_noun tax)
|
|
{
|
|
u2_noun mok = u2_dc("mook", 2, tax);
|
|
|
|
u2_lo_punt(tab_l, u2k(u2t(mok)));
|
|
u2z(mok);
|
|
}
|
|
|
|
/* _lo_soft(): standard soft wrapper. unifies unix and nock errors.
|
|
**
|
|
** Produces [%$ result] or [%error (list tank)].
|
|
*/
|
|
static u2_noun
|
|
_lo_soft(u2_reck* rec_u, c3_w sec_w, u2_funk fun_f, u2_noun arg)
|
|
{
|
|
u2_noun hoe, pro, rop;
|
|
|
|
u2_rl_leap(u2_Wire, c3__rock);
|
|
|
|
// system level setjmp, for signals
|
|
//
|
|
c3_assert(u2_nul == u2_wire_tax(u2_Wire));
|
|
c3_assert(0 == u2_wire_kit_r(u2_Wire));
|
|
|
|
// stop signals
|
|
//
|
|
u2_unix_ef_hold();
|
|
_lo_signal_deep(sec_w);
|
|
|
|
if ( 0 != setjmp(Signal_buf) ) {
|
|
u2_noun tax, pre, mok;
|
|
|
|
// return to blank state
|
|
//
|
|
_lo_signal_done();
|
|
|
|
// acquire trace and reset memory
|
|
//
|
|
tax = u2_wire_tax(u2_Wire);
|
|
u2_rl_fall(u2_Wire);
|
|
u2z(arg);
|
|
|
|
tax = u2_rl_take(u2_Wire, tax);
|
|
u2_wire_tax(u2_Wire) = u2_nul;
|
|
mok = u2_dc("mook", 2, tax);
|
|
|
|
// other ugly disgusting cleanups
|
|
{
|
|
u2_wire_kit_r(u2_Wire) = 0;
|
|
|
|
u2_hevx_be(u2_wire_hev_r(u2_Wire), u2_pryr, god) = 0;
|
|
u2_hevx_at(u2_wire_hev_r(u2_Wire), lad) = 0;
|
|
}
|
|
|
|
switch ( Sigcause ) {
|
|
default: pre = c3__wyrd; break;
|
|
case sig_none: pre = c3__none; break;
|
|
case sig_overflow: pre = c3__over; break;
|
|
case sig_interrupt: pre = c3__intr; break;
|
|
case sig_terminate: pre = c3__term; break;
|
|
case sig_memory: pre = c3__full; break;
|
|
case sig_assert: pre = c3__lame; break;
|
|
case sig_timer: fprintf(stderr, "timer!!\r\n"); pre = c3__slow; break;
|
|
}
|
|
rop = u2nc(pre, u2k(u2t(mok)));
|
|
u2z(mok);
|
|
fprintf(stderr, "error computed\r\n");
|
|
return rop;
|
|
}
|
|
|
|
if ( 0 != (hoe = u2_cm_trap()) ) {
|
|
u2_noun mok;
|
|
|
|
u2_rl_fall(u2_Wire);
|
|
hoe = u2_rl_take(u2_Wire, hoe);
|
|
u2_rl_flog(u2_Wire);
|
|
|
|
mok = u2_dc("mook", 2, u2k(u2t(hoe)));
|
|
rop = u2nc(u2k(u2h(hoe)), u2k(u2t(mok)));
|
|
|
|
u2z(arg);
|
|
u2z(hoe);
|
|
u2z(mok);
|
|
}
|
|
else {
|
|
u2_noun pro = fun_f(rec_u, arg);
|
|
|
|
_lo_signal_done();
|
|
u2_cm_done();
|
|
|
|
u2_rl_fall(u2_Wire);
|
|
pro = u2_rl_take(u2_Wire, pro);
|
|
u2_rl_flog(u2_Wire);
|
|
|
|
u2z(arg);
|
|
rop = u2nc(u2_blip, pro);
|
|
}
|
|
pro = rop;
|
|
|
|
return pro;
|
|
}
|
|
|
|
#if 0
|
|
/* _lo_hard(): standard hard wrapper. Produces result and/or asserts.
|
|
*/
|
|
static u2_noun
|
|
_lo_hard(u2_reck* rec_u, u2_funk fun_f, u2_noun arg)
|
|
{
|
|
u2_noun pro = _lo_soft(rec_u, 0, fun_f, arg);
|
|
|
|
if ( u2_blip == u2h(pro) ) {
|
|
u2_noun poo = u2k(u2t(pro));
|
|
|
|
u2z(pro); return poo;
|
|
}
|
|
else {
|
|
u2_lo_punt(2, u2k(u2t(pro)));
|
|
u2z(pro);
|
|
c3_assert(0);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* _lo_mung(): formula wrapper with gate and sample.
|
|
*/
|
|
static u2_noun
|
|
_lo_mung_in(u2_reck* rec_u, u2_noun gam)
|
|
{
|
|
u2_noun pro = u2_cn_mung(u2k(u2h(gam)), u2k(u2t(gam)));
|
|
|
|
u2z(gam); return pro;
|
|
}
|
|
static u2_noun
|
|
_lo_mung(u2_reck* rec_u, c3_w sec_w, u2_noun gat, u2_noun sam)
|
|
{
|
|
u2_noun gam = u2nc(gat, sam);
|
|
|
|
return _lo_soft(rec_u, 0, _lo_mung_in, gam);
|
|
}
|
|
|
|
/* _lo_pack(): save an ovum at the present time. sync; sync; sync.
|
|
*/
|
|
static void
|
|
_lo_pack(u2_reck* rec_u, u2_noun ron)
|
|
{
|
|
u2_ulog* lug_u = &u2_Host.lug_u;
|
|
c3_w len_w;
|
|
c3_d tar_d;
|
|
c3_w* img_w;
|
|
u2_ular lar_u;
|
|
|
|
if ( rec_u->key ) {
|
|
ron = u2_dc("en:crya", u2k(rec_u->key), ron);
|
|
}
|
|
|
|
len_w = u2_cr_met(5, ron);
|
|
tar_d = (lug_u->len_d + len_w);
|
|
|
|
lar_u.syn_w = u2_mug((c3_w)tar_d);
|
|
lar_u.mug_w = u2_mug(ron);
|
|
lar_u.ent_w = rec_u->ent_w;
|
|
lar_u.len_w = len_w;
|
|
|
|
// XX: this is not in any way, shape or form a proper 2PC!
|
|
//
|
|
if ( -1 == lseek64(lug_u->fid_i, 4ULL * tar_d, SEEK_SET) ) {
|
|
perror("lseek");
|
|
uL(fprintf(uH, "lo_save: seek failed\n"));
|
|
c3_assert(0);
|
|
}
|
|
if ( sizeof(lar_u) != write(lug_u->fid_i, &lar_u, sizeof(lar_u)) ) {
|
|
perror("write");
|
|
uL(fprintf(uH, "lo_save: write failed\n"));
|
|
c3_assert(0);
|
|
}
|
|
if ( -1 == lseek64(lug_u->fid_i, 4ULL * lug_u->len_d, SEEK_SET) ) {
|
|
perror("lseek");
|
|
uL(fprintf(uH, "lo_save: seek failed\n"));
|
|
c3_assert(0);
|
|
}
|
|
#if 0
|
|
uL(fprintf(uH, "log: write: at %d, %d: lar ent %d, len %d, mug %x\n",
|
|
lug_u->len_w,
|
|
tar_w,
|
|
lar_u.ent_w,
|
|
lar_u.len_w,
|
|
lar_u.mug_w));
|
|
#endif
|
|
img_w = malloc(4 * len_w);
|
|
u2_cr_words(0, len_w, img_w, ron);
|
|
u2z(ron);
|
|
|
|
if ( (4 * len_w) != write(lug_u->fid_i, img_w, (4 * len_w)) ) {
|
|
perror("lseek");
|
|
uL(fprintf(uH, "lo_save: write failed\n"));
|
|
c3_assert(0);
|
|
}
|
|
lug_u->len_d += (c3_d)(lar_u.len_w + c3_wiseof(lar_u));
|
|
free(img_w);
|
|
|
|
// Sync. Or, what goes by sync.
|
|
{
|
|
fsync(lug_u->fid_i); // fsync is useless, F_FULLFSYNC too slow
|
|
}
|
|
}
|
|
|
|
/* _lo_save(): log an ovum at the present time.
|
|
*/
|
|
static void
|
|
_lo_save(u2_reck* rec_u, u2_noun ovo)
|
|
{
|
|
u2_noun ron = u2_cke_jam(u2nc(u2k(rec_u->now), ovo));
|
|
|
|
if ( u2_Host.lug_u.len_d ) {
|
|
_lo_pack(rec_u, ron);
|
|
rec_u->ent_w += 1;
|
|
} else {
|
|
rec_u->roe = u2nc(ron, rec_u->roe);
|
|
}
|
|
}
|
|
|
|
|
|
/* _lo_pike(): poke with floating core.
|
|
*/
|
|
static u2_noun
|
|
_lo_pike(u2_reck* rec_u, u2_noun ovo, u2_noun cor)
|
|
{
|
|
u2_noun fun = u2_cn_nock(cor, u2k(u2_cx_at(42, cor)));
|
|
u2_noun sam = u2nc(u2k(rec_u->now), ovo);
|
|
|
|
return _lo_mung(rec_u, 0, fun, sam);
|
|
}
|
|
|
|
/* _lo_sure(): apply and save an input ovum and its result.
|
|
*/
|
|
static void
|
|
_lo_sure(u2_reck* rec_u, u2_noun ovo, u2_noun vir, u2_noun cor)
|
|
{
|
|
// Whatever worked, save it. (XX - should be concurrent with execute.)
|
|
// We'd like more events that don't change the state but need work here.
|
|
{
|
|
u2_mug(cor);
|
|
u2_mug(rec_u->roc);
|
|
|
|
#if 0
|
|
if ( (c3__belt == u2h(u2t(ovo))) &&
|
|
(c3__ctl == u2h(u2t(u2t(ovo)))) &&
|
|
('g' == u2t(u2t(u2t(ovo)))) )
|
|
{
|
|
if ( u2_yes == u2_sing(cor, rec_u->roc) ) {
|
|
uL(fprintf(uH, "bell matches\n"));
|
|
} else {
|
|
uL(fprintf(uH, "bell does NOT match\n"));
|
|
}
|
|
}
|
|
|
|
if ( c3__noop == u2h(u2t(ovo)) ) {
|
|
if ( u2_yes == u2_sing(cor, rec_u->roc) ) {
|
|
uL(fprintf(uH, "noop matches\n"));
|
|
} else {
|
|
uL(fprintf(uH, "noop does NOT match\n"));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if ( u2_no == u2_sing(cor, rec_u->roc) ) {
|
|
_lo_save(rec_u, u2k(ovo));
|
|
|
|
u2z(rec_u->roc);
|
|
rec_u->roc = cor;
|
|
}
|
|
else {
|
|
u2z(cor);
|
|
}
|
|
u2z(ovo);
|
|
}
|
|
|
|
// Evaluate external side effects. Not allowed to fail.
|
|
//
|
|
{
|
|
while ( u2_nul != vir ) {
|
|
u2_noun ovo = u2k(u2h(vir));
|
|
u2_noun nex = u2k(u2t(vir));
|
|
// c3_c* hed_c = u2_cr_string(u2h(u2t(ovo)));
|
|
|
|
u2z(vir); vir = nex;
|
|
|
|
// uL(fprintf(uH, "kick: %s\n", hed_c));
|
|
u2_reck_kick(rec_u, ovo);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* _lo_lame(): handle an application failure.
|
|
*/
|
|
static void
|
|
_lo_lame(u2_reck* rec_u, u2_noun ovo, u2_noun why, u2_noun tan)
|
|
{
|
|
u2_noun bov, gon;
|
|
|
|
#if 1
|
|
{
|
|
c3_c* oik_c = u2_cr_string(u2h(u2t(ovo)));
|
|
|
|
// uL(fprintf(uH, "lame: %s\n", oik_c));
|
|
free(oik_c);
|
|
}
|
|
#endif
|
|
|
|
// Formal error in a network packet generates a hole card.
|
|
//
|
|
// There should be a separate path for crypto failures,
|
|
// to prevent timing attacks, but isn't right now. To deal
|
|
// with a crypto failure, just drop the packet.
|
|
//
|
|
if ( (c3__exit == why) && (c3__hear == u2h(u2t(ovo))) ) {
|
|
u2_lo_punt(2, u2_ckb_flop(u2k(tan)));
|
|
|
|
bov = u2nc(u2k(u2h(ovo)), u2nc(c3__hole, u2k(u2t(u2t(ovo)))));
|
|
u2z(why);
|
|
}
|
|
else {
|
|
bov = u2nc(u2k(u2h(ovo)), u2nt(c3__crud, why, u2k(tan)));
|
|
u2_hevn_at(lad) = u2_nul;
|
|
}
|
|
// u2_lo_show("data", u2k(u2t(u2t(ovo))));
|
|
|
|
u2z(ovo);
|
|
|
|
gon = _lo_soft(rec_u, 0, u2_reck_poke, u2k(bov));
|
|
if ( u2_blip == u2h(gon) ) {
|
|
_lo_sure(rec_u, bov, u2k(u2h(u2t(gon))), u2k(u2t(u2t(gon))));
|
|
|
|
u2z(gon);
|
|
}
|
|
else {
|
|
u2z(gon);
|
|
{
|
|
u2_noun vab = u2nc(u2k(u2h(bov)),
|
|
u2nc(c3__warn, u2_ci_tape("crude crash!")));
|
|
u2_noun nog = _lo_soft(rec_u, 0, u2_reck_poke, u2k(vab));
|
|
|
|
if ( u2_blip == u2h(nog) ) {
|
|
_lo_sure(rec_u, vab, u2k(u2h(u2t(nog))), u2k(u2t(u2t(nog))));
|
|
u2z(nog);
|
|
}
|
|
else {
|
|
u2z(nog);
|
|
u2z(vab);
|
|
|
|
uL(fprintf(uH, "crude: all delivery failed!\n"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void _lo_punk(u2_reck* rec_u, u2_noun ovo);
|
|
|
|
/* _lo_nick(): transform enveloped packets, [vir cor].
|
|
*/
|
|
static u2_noun
|
|
_lo_nick(u2_reck* rec_u, u2_noun vir, u2_noun cor)
|
|
{
|
|
if ( u2_nul == vir ) {
|
|
return u2nt(u2_blip, vir, cor);
|
|
}
|
|
else {
|
|
u2_noun i_vir = u2h(vir);
|
|
u2_noun pi_vir, qi_vir;
|
|
u2_noun vix;
|
|
|
|
if ( (u2_yes == u2_cr_cell((i_vir=u2h(vir)), &pi_vir, &qi_vir)) &&
|
|
(u2_yes == u2du(qi_vir)) &&
|
|
(c3__hear == u2h(qi_vir)) )
|
|
{
|
|
u2_noun gon;
|
|
|
|
gon = _lo_pike(rec_u, u2k(i_vir), cor);
|
|
if ( u2_blip != u2h(gon) ) {
|
|
u2z(vir);
|
|
return gon;
|
|
}
|
|
else {
|
|
u2_noun viz;
|
|
|
|
vix = u2k(u2h(u2t(gon)));
|
|
cor = u2k(u2t(u2t(gon)));
|
|
u2z(gon);
|
|
|
|
viz = u2_ckb_weld(vix, u2k(u2t(vir)));
|
|
u2z(vir);
|
|
|
|
return _lo_nick(rec_u, viz, cor);
|
|
}
|
|
}
|
|
else {
|
|
u2_noun nez = _lo_nick(rec_u, u2k(u2t(vir)), cor);
|
|
|
|
if ( u2_blip != u2h(nez) ) {
|
|
u2z(vir);
|
|
return nez;
|
|
} else {
|
|
u2_noun viz;
|
|
|
|
viz = u2nc(u2k(i_vir), u2k(u2h(u2t(nez))));
|
|
cor = u2k(u2t(u2t(nez)));
|
|
|
|
u2z(vir);
|
|
u2z(nez);
|
|
|
|
return u2nt(u2_blip, viz, cor);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* _lo_punk(): insert and apply an input ovum (unprotected).
|
|
*/
|
|
static void
|
|
_lo_punk(u2_reck* rec_u, u2_noun ovo)
|
|
{
|
|
// c3_c* txt_c = u2_cr_string(u2h(u2t(ovo)));
|
|
c3_w sec_w;
|
|
// static c3_w num_w;
|
|
u2_noun gon;
|
|
|
|
// uL(fprintf(uH, "punk: %s: %d\n", u2_cr_string(u2h(u2t(ovo))), num_w++));
|
|
|
|
// XX this is wrong - the timer should be on the original hose.
|
|
//
|
|
if ( (c3__term == u2h(u2t(u2h(ovo)))) ||
|
|
(c3__batz == u2h(u2t(u2h(ovo)))) ) {
|
|
sec_w = 0;
|
|
} else sec_w = 60;
|
|
|
|
// Control alarm loops.
|
|
//
|
|
if ( c3__wake != u2h(u2t(ovo)) ) {
|
|
u2_Host.beh_u.run_w = 0;
|
|
}
|
|
|
|
gon = _lo_soft(rec_u, sec_w, u2_reck_poke, u2k(ovo));
|
|
|
|
if ( u2_blip != u2h(gon) ) {
|
|
u2_noun why = u2k(u2h(gon));
|
|
u2_noun tan = u2k(u2t(gon));
|
|
|
|
u2z(gon);
|
|
_lo_lame(rec_u, ovo, why, tan);
|
|
}
|
|
else {
|
|
u2_noun vir = u2k(u2h(u2t(gon)));
|
|
u2_noun cor = u2k(u2t(u2t(gon)));
|
|
u2_noun nug;
|
|
|
|
u2z(gon);
|
|
nug = _lo_nick(rec_u, vir, cor);
|
|
|
|
if ( u2_blip != u2h(nug) ) {
|
|
u2_noun why = u2k(u2h(nug));
|
|
u2_noun tan = u2k(u2t(nug));
|
|
|
|
u2z(nug);
|
|
_lo_lame(rec_u, ovo, why, tan);
|
|
}
|
|
else {
|
|
vir = u2k(u2h(u2t(nug)));
|
|
cor = u2k(u2t(u2t(nug)));
|
|
|
|
u2z(nug);
|
|
_lo_sure(rec_u, ovo, vir, cor);
|
|
}
|
|
}
|
|
// uL(fprintf(uH, "punk oot %s\n", txt_c));
|
|
}
|
|
|
|
/* _lo_suck(): past failure.
|
|
*/
|
|
static void
|
|
_lo_suck(u2_reck* rec_u, u2_noun ovo, u2_noun gon)
|
|
{
|
|
uL(fprintf(uH, "sing: ovum failed!\n"));
|
|
{
|
|
c3_c* hed_c = u2_cr_string(u2h(u2t(ovo)));
|
|
|
|
uL(fprintf(uH, "fail %s\n", hed_c));
|
|
free(hed_c);
|
|
}
|
|
|
|
u2_lo_punt(2, u2_ckb_flop(u2k(u2t(gon))));
|
|
u2_loom_exit();
|
|
_lo_exit();
|
|
|
|
exit(1);
|
|
}
|
|
|
|
/* _lo_sing(): replay ovum from the past, time already set.
|
|
*/
|
|
static void
|
|
_lo_sing(u2_reck* rec_u, u2_noun ovo)
|
|
{
|
|
u2_noun gon = _lo_soft(rec_u, 0, u2_reck_poke, u2k(ovo));
|
|
|
|
if ( u2_blip != u2h(gon) ) {
|
|
_lo_suck(rec_u, ovo, gon);
|
|
}
|
|
else {
|
|
u2_noun vir = u2k(u2h(u2t(gon)));
|
|
u2_noun cor = u2k(u2t(u2t(gon)));
|
|
u2_noun nug;
|
|
|
|
u2z(gon);
|
|
nug = _lo_nick(rec_u, vir, cor);
|
|
|
|
if ( u2_blip != u2h(nug) ) {
|
|
_lo_suck(rec_u, ovo, nug);
|
|
}
|
|
else {
|
|
vir = u2h(u2t(nug));
|
|
cor = u2k(u2t(u2t(nug)));
|
|
|
|
while ( u2_nul != vir ) {
|
|
u2_noun fex = u2h(vir);
|
|
u2_noun fav = u2t(fex);
|
|
|
|
if ( (c3__init == u2h(fav)) || (c3__inuk == u2h(fav)) ) {
|
|
rec_u->own = u2nc(u2k(u2t(fav)), rec_u->own);
|
|
}
|
|
vir = u2t(vir);
|
|
}
|
|
u2z(nug);
|
|
u2z(rec_u->roc);
|
|
rec_u->roc = cor;
|
|
}
|
|
u2z(ovo);
|
|
}
|
|
}
|
|
|
|
/* _lo_work(): work in rec_u.
|
|
*/
|
|
static void
|
|
_lo_work(u2_reck* rec_u)
|
|
{
|
|
while ( rec_u->ova.egg_u ) {
|
|
u2_cart* egg_u = rec_u->ova.egg_u;
|
|
u2_noun egg = egg_u->egg;
|
|
|
|
rec_u->ova.egg_u = egg_u->nex_u;
|
|
if ( 0 == rec_u->ova.egg_u ) {
|
|
c3_assert(egg_u == rec_u->ova.geg_u);
|
|
rec_u->ova.geg_u = 0;
|
|
}
|
|
free(egg_u);
|
|
|
|
{
|
|
#if 0
|
|
// u2_noun old, new;
|
|
// c3_c* her_c = u2_cr_string(u2h(u2t(egg)));
|
|
// uint8_t her_t = (c3__hear == u2h(u2t(egg)));
|
|
|
|
if ( her_t ) {
|
|
u2_reck_time(u2A);
|
|
old = u2k(u2A->now);
|
|
// uL(fprintf(uH, "hear...\n"));
|
|
}
|
|
#endif
|
|
|
|
_lo_punk(rec_u, egg);
|
|
|
|
#if 0
|
|
if ( her_t ) {
|
|
c3_w tms_w;
|
|
|
|
u2_reck_time(u2A);
|
|
new = u2k(u2A->now);
|
|
|
|
tms_w = (c3_w)u2_time_gap_ms(old, new);
|
|
if ( tms_w >= 20 )
|
|
{
|
|
uL(fprintf(uH, "hear: %d ms\n", tms_w));
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
/* u2_lo_open(): begin callback processing.
|
|
*/
|
|
void
|
|
u2_lo_open(void)
|
|
{
|
|
// update time
|
|
//
|
|
u2_reck_time(u2A);
|
|
}
|
|
|
|
/* u2_lo_shut(): end callback processing.
|
|
*/
|
|
void
|
|
u2_lo_shut(u2_bean inn)
|
|
{
|
|
// u2_lo_grab("lo_shut a", u2_none);
|
|
|
|
// process actions
|
|
//
|
|
_lo_work(u2A);
|
|
|
|
// u2_lo_grab("lo_shut b", u2_none);
|
|
|
|
// update time
|
|
//
|
|
u2_reck_time(u2A);
|
|
|
|
// u2_lo_grab("lo_shut c", u2_none);
|
|
|
|
// for input operations, poll fs (XX not permanent)
|
|
//
|
|
if ( u2_yes == inn ) {
|
|
u2_unix_ef_look();
|
|
}
|
|
|
|
// u2_lo_grab("lo_shut d", u2_none);
|
|
|
|
// clean shutdown
|
|
//
|
|
if ( u2_no == u2_Host.liv ) {
|
|
// direct save and die
|
|
//
|
|
u2_cm_purge();
|
|
// u2_lo_grab("lo_exit", u2_none);
|
|
u2_loom_save(u2A->ent_w);
|
|
u2_loom_exit();
|
|
_lo_exit();
|
|
|
|
exit(0);
|
|
}
|
|
else {
|
|
// poll arvo to generate any event binding changes
|
|
//
|
|
_lo_poll();
|
|
}
|
|
}
|
|
|
|
/* _lo_home(): create ship directory.
|
|
*/
|
|
static void
|
|
_lo_home(u2_reck* rec_u)
|
|
{
|
|
c3_c ful_c[2048];
|
|
|
|
// Create subdirectories.
|
|
//
|
|
{
|
|
mkdir(u2_Host.cpu_c, 0700);
|
|
|
|
snprintf(ful_c, 2048, "%s/get", u2_Host.cpu_c);
|
|
if ( 0 != mkdir(ful_c, 0700) ) {
|
|
perror(ful_c);
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
|
|
snprintf(ful_c, 2048, "%s/put", u2_Host.cpu_c);
|
|
if ( 0 != mkdir(ful_c, 0700) ) {
|
|
perror(ful_c);
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
}
|
|
|
|
// Copy urbit.pill.
|
|
//
|
|
{
|
|
snprintf(ful_c, 2048, "cp %s/urbit.pill %s",
|
|
u2_Host.ops_u.hom_c, u2_Host.cpu_c);
|
|
if ( 0 != system(ful_c) ) {
|
|
uL(fprintf(uH, "could not %s\n", ful_c));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* _lo_cask(): ask for a passcode.
|
|
*/
|
|
static u2_noun
|
|
_lo_cask(u2_reck* rec_u, c3_c* dir_c, u2_bean nun)
|
|
{
|
|
c3_c paw_c[60];
|
|
u2_noun key;
|
|
|
|
uH;
|
|
while ( 1 ) {
|
|
printf("passcode for %s%s? ~", dir_c, (u2_yes == nun) ? " [none]" : "");
|
|
|
|
paw_c[0] = 0;
|
|
fpurge(stdin);
|
|
fgets(paw_c, 59, stdin);
|
|
|
|
if ( '\n' == paw_c[0] ) {
|
|
if ( u2_yes == nun ) {
|
|
key = 0; break;
|
|
}
|
|
else {
|
|
continue;
|
|
}
|
|
}
|
|
else {
|
|
c3_c* say_c = malloc(strlen(paw_c) + 2);
|
|
u2_noun say;
|
|
|
|
say_c[0] = '~';
|
|
say_c[1] = 0;
|
|
strncat(say_c, paw_c, strlen(paw_c) - 1);
|
|
|
|
say = u2_do("slay", u2_ci_string(say_c));
|
|
if ( (u2_nul == say) ||
|
|
(u2_blip != u2h(u2t(say))) ||
|
|
('p' != u2h(u2t(u2t(say)))) )
|
|
{
|
|
printf("invalid passcode\n");
|
|
continue;
|
|
}
|
|
key = u2k(u2t(u2t(u2t(say))));
|
|
|
|
u2z(say);
|
|
break;
|
|
}
|
|
}
|
|
uL(0);
|
|
return key;
|
|
}
|
|
|
|
/* _lo_text(): ask for a name string.
|
|
*/
|
|
static u2_noun
|
|
_lo_text(u2_reck* rec_u, c3_c* pom_c)
|
|
{
|
|
c3_c paw_c[60];
|
|
u2_noun say;
|
|
|
|
uH;
|
|
while ( 1 ) {
|
|
printf("%s: ", pom_c);
|
|
|
|
paw_c[0] = 0;
|
|
fpurge(stdin);
|
|
fgets(paw_c, 59, stdin);
|
|
|
|
if ( '\n' == paw_c[0] ) {
|
|
continue;
|
|
}
|
|
else {
|
|
c3_w len_w = strlen(paw_c);
|
|
|
|
if ( paw_c[len_w - 1] == '\n' ) {
|
|
paw_c[len_w-1] = 0;
|
|
}
|
|
say = u2_ci_string(paw_c);
|
|
break;
|
|
}
|
|
}
|
|
uL(0);
|
|
return say;
|
|
}
|
|
|
|
#if 0
|
|
/* _lo_bask(): ask a yes or no question.
|
|
*/
|
|
static u2_bean
|
|
_lo_bask(c3_c* pop_c, u2_bean may)
|
|
{
|
|
u2_bean yam;
|
|
|
|
uH;
|
|
while ( 1 ) {
|
|
c3_c ans_c[3];
|
|
|
|
printf("%s [y/n]? ", pop_c);
|
|
ans_c[0] = 0;
|
|
|
|
fpurge(stdin);
|
|
fgets(ans_c, 2, stdin);
|
|
|
|
if ( (ans_c[0] != 'y') && (ans_c[0] != 'n') ) {
|
|
continue;
|
|
} else {
|
|
yam = (ans_c[0] != 'n') ? u2_yes : u2_no;
|
|
break;
|
|
}
|
|
}
|
|
uL(0);
|
|
return yam;
|
|
}
|
|
#endif
|
|
|
|
/* _lo_rand(): fill a 256-bit (8-word) buffer.
|
|
*/
|
|
static void
|
|
_lo_rand(u2_reck* rec_u, c3_w* rad_w)
|
|
{
|
|
c3_i fid_i = open(DEVRANDOM, O_RDONLY);
|
|
|
|
if ( 32 != read(fid_i, (c3_y*) rad_w, 32) ) {
|
|
c3_assert(!"lo_rand");
|
|
}
|
|
close(fid_i);
|
|
}
|
|
|
|
/* _lo_fast(): offer to save passcode by mug in home directory.
|
|
*/
|
|
static void
|
|
_lo_fast(u2_reck* rec_u, u2_noun pas, c3_l key_l)
|
|
{
|
|
c3_c ful_c[2048];
|
|
c3_c* hom_c = getenv("HOME");
|
|
u2_noun gum = u2_dc("scot", 'p', key_l);
|
|
c3_c* gum_c = u2_cr_string(gum);
|
|
u2_noun yek = u2_dc("scot", 'p', pas);
|
|
c3_c* yek_c = u2_cr_string(yek);
|
|
|
|
printf("saving passcode in %s/.urbit/%s.txt\r\n", hom_c, gum_c);
|
|
printf("(for real security, write it down and delete the file...)\r\n");
|
|
{
|
|
c3_i fid_i;
|
|
|
|
snprintf(ful_c, 2048, "%s/.urbit", hom_c);
|
|
mkdir(ful_c, 0700);
|
|
|
|
snprintf(ful_c, 2048, "%s/.urbit/%s.txt", hom_c, gum_c);
|
|
if ( (fid_i = open(ful_c, O_CREAT | O_TRUNC | O_WRONLY, 0600)) < 0 ) {
|
|
uL(fprintf(uH, "fast: could not save %s\n", ful_c));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
write(fid_i, yek_c, strlen(yek_c));
|
|
close(fid_i);
|
|
}
|
|
free(gum_c);
|
|
u2z(gum);
|
|
|
|
free(yek_c);
|
|
u2z(yek);
|
|
}
|
|
|
|
/* _lo_staf(): try to load passcode by mug from home directory.
|
|
*/
|
|
static u2_noun
|
|
_lo_staf(u2_reck* rec_u, c3_l key_l)
|
|
{
|
|
c3_c ful_c[2048];
|
|
c3_c* hom_c = getenv("HOME");
|
|
u2_noun gum = u2_dc("scot", 'p', key_l);
|
|
c3_c* gum_c = u2_cr_string(gum);
|
|
u2_noun txt;
|
|
|
|
snprintf(ful_c, 2048, "%s/.urbit/%s.txt", hom_c, gum_c);
|
|
free(gum_c);
|
|
u2z(gum);
|
|
txt = u2_walk_safe(ful_c);
|
|
|
|
if ( 0 == txt ) {
|
|
uL(fprintf(uH, "staf: no passcode %s\n", ful_c));
|
|
return 0;
|
|
}
|
|
else {
|
|
// c3_c* txt_c = u2_cr_string(txt);
|
|
u2_noun say = u2_do("slay", txt);
|
|
u2_noun pas;
|
|
|
|
|
|
if ( (u2_nul == say) ||
|
|
(u2_blip != u2h(u2t(say))) ||
|
|
('p' != u2h(u2t(u2t(say)))) )
|
|
{
|
|
uL(fprintf(uH, "staf: %s is corrupt\n", ful_c));
|
|
u2z(say);
|
|
return 0;
|
|
}
|
|
uL(fprintf(uH, "loaded passcode from %s\n", ful_c));
|
|
pas = u2k(u2t(u2t(u2t(say))));
|
|
|
|
u2z(say);
|
|
return pas;
|
|
}
|
|
}
|
|
|
|
/* _lo_fatt(): stretch a 64-bit passcode to make a 128-bit key.
|
|
*/
|
|
static u2_noun
|
|
_lo_fatt(c3_l sal_l, u2_noun pas)
|
|
{
|
|
c3_w i_w;
|
|
u2_noun key = pas;
|
|
|
|
// XX use scrypt() - this is a stupid iterated hash
|
|
//
|
|
for ( i_w = 0; i_w < 32768; i_w++ ) {
|
|
key = u2_dc("shaf", sal_l, key);
|
|
}
|
|
return key;
|
|
}
|
|
|
|
/* _lo_zest(): create a new, empty record.
|
|
*/
|
|
static void
|
|
_lo_zest(u2_reck* rec_u)
|
|
{
|
|
struct stat buf_b;
|
|
c3_i fid_i;
|
|
c3_c ful_c[8193];
|
|
c3_l sal_l;
|
|
|
|
// Create the ship directory.
|
|
//
|
|
_lo_home(rec_u);
|
|
|
|
// Create the record file.
|
|
{
|
|
snprintf(ful_c, 2048, "%s/egz.hope", u2_Host.cpu_c);
|
|
|
|
if ( ((fid_i = open(ful_c, O_CREAT | O_WRONLY | O_EXCL, 0600)) < 0) ||
|
|
(fstat(fid_i, &buf_b) < 0) )
|
|
{
|
|
uL(fprintf(uH, "can't create record (%s)\n", ful_c));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
u2_Host.lug_u.fid_i = fid_i;
|
|
}
|
|
|
|
// Generate a 31-bit salt.
|
|
//
|
|
{
|
|
c3_w rad_w[8];
|
|
|
|
_lo_rand(rec_u, rad_w);
|
|
sal_l = (0x7fffffff & rad_w[0]);
|
|
}
|
|
|
|
// Create and save a passcode.
|
|
//
|
|
{
|
|
c3_w rad_w[8];
|
|
u2_noun pas;
|
|
|
|
_lo_rand(rec_u, rad_w);
|
|
pas = u2_ci_words(2, rad_w);
|
|
|
|
rec_u->key = _lo_fatt(sal_l, u2k(pas));
|
|
_lo_fast(rec_u, pas, u2_mug(rec_u->key));
|
|
}
|
|
|
|
// Write the header.
|
|
{
|
|
u2_uled led_u;
|
|
|
|
led_u.mag_l = u2_mug('f');
|
|
led_u.kno_w = rec_u->kno_w;
|
|
|
|
if ( 0 == rec_u->key ) {
|
|
led_u.key_l = 0;
|
|
} else {
|
|
led_u.key_l = u2_mug(rec_u->key);
|
|
|
|
c3_assert(!(led_u.key_l >> 31));
|
|
}
|
|
led_u.sal_l = sal_l;
|
|
led_u.sev_l = rec_u->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));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
|
|
u2_Host.lug_u.len_d = c3_wiseof(led_u);
|
|
}
|
|
|
|
// Save the boot events.
|
|
{
|
|
u2_noun nor = u2_ckb_flop(rec_u->roe);
|
|
|
|
rec_u->roe = nor;
|
|
|
|
while ( u2_nul != nor ) {
|
|
_lo_pack(rec_u, u2k(u2h(nor)));
|
|
rec_u->ent_w += 1;
|
|
nor = u2t(nor);
|
|
}
|
|
u2z(rec_u->roe);
|
|
rec_u->roe = 0;
|
|
}
|
|
|
|
#if 0
|
|
// Copy the egz into ham, the factory default.
|
|
{
|
|
snprintf(ful_c, 8193, "rm -f %s/~ham.hope; cp %s/~egz.hope %s/~ham.hope",
|
|
u2_Host.cpu_c, u2_Host.cpu_c, u2_Host.cpu_c);
|
|
|
|
if ( 0 != system(ful_c) ) {
|
|
uL(fprintf(uH, "zest: could not save ham\n"));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* _lo_make(): boot from scratch.
|
|
*/
|
|
static void
|
|
_lo_make(u2_reck* rec_u, u2_noun fav)
|
|
{
|
|
// Authenticate and initialize terminal.
|
|
//
|
|
u2_term_ef_bake(fav);
|
|
|
|
// Work through start sequence.
|
|
//
|
|
_lo_work(rec_u);
|
|
|
|
// Further server configuration.
|
|
//
|
|
{
|
|
u2_http_ef_bake();
|
|
}
|
|
|
|
// Work some more.
|
|
//
|
|
_lo_work(rec_u);
|
|
|
|
// Create the ship directory.
|
|
//
|
|
_lo_zest(rec_u);
|
|
}
|
|
|
|
/* _lo_rest(): restore from record, or exit.
|
|
*/
|
|
static void
|
|
_lo_rest(u2_reck* rec_u)
|
|
{
|
|
struct stat buf_b;
|
|
c3_i fid_i;
|
|
c3_c ful_c[2048];
|
|
c3_w old_w = rec_u->ent_w;
|
|
c3_w las_w = 0;
|
|
u2_noun roe = u2_nul;
|
|
u2_noun sev_l, tno_l, key_l, sal_l;
|
|
|
|
if ( 0 != rec_u->ent_w ) {
|
|
u2_noun ent = u2_dc("scot", c3__ud, rec_u->ent_w);
|
|
c3_c* ent_c = u2_cr_string(ent);
|
|
uL(fprintf(uH, "rest: checkpoint to event %s\n", ent_c));
|
|
free(ent_c);
|
|
}
|
|
|
|
// Open the fscking file. Does it even exist?
|
|
{
|
|
snprintf(ful_c, 2048, "%s/egz.hope", u2_Host.cpu_c);
|
|
|
|
if ( ((fid_i = open(ful_c, O_RDWR)) < 0) ||
|
|
(fstat(fid_i, &buf_b) < 0) )
|
|
{
|
|
uL(fprintf(uH, "rest: can't open record (%s)\n", ful_c));
|
|
u2_lo_bail(rec_u);
|
|
|
|
return;
|
|
}
|
|
u2_Host.lug_u.fid_i = fid_i;
|
|
u2_Host.lug_u.len_d = ((buf_b.st_size + 3ULL) >> 2ULL);
|
|
}
|
|
|
|
// Check the fscking header. It's probably corrupt.
|
|
{
|
|
u2_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));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
|
|
if ( u2_mug('f') != led_u.mag_l ) {
|
|
uL(fprintf(uH, "record (%s) is obsolete (or corrupt)\n", ful_c));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
|
|
if ( led_u.kno_w != rec_u->kno_w ) {
|
|
// XX perhaps we should actually do something here
|
|
//
|
|
uL(fprintf(uH, "rest: (not) translating events (old %d, now %d)\n",
|
|
led_u.kno_w,
|
|
rec_u->kno_w));
|
|
}
|
|
sev_l = led_u.sev_l;
|
|
sal_l = led_u.sal_l;
|
|
key_l = led_u.key_l;
|
|
tno_l = led_u.tno_l;
|
|
|
|
{
|
|
u2_noun old = u2_dc("scot", c3__uv, sev_l);
|
|
u2_noun nuu = u2_dc("scot", c3__uv, rec_u->sev_l);
|
|
c3_c* old_c = u2_cr_string(old);
|
|
c3_c* nuu_c = u2_cr_string(nuu);
|
|
|
|
uL(fprintf(uH, "rest: old %s, new %s\n", old_c, nuu_c));
|
|
free(old_c); free(nuu_c);
|
|
|
|
u2z(old); u2z(nuu);
|
|
}
|
|
c3_assert(sev_l != rec_u->sev_l); // 1 in 2 billion, just retry
|
|
}
|
|
|
|
// Oh, and let's hope you didn't forget the fscking passcode.
|
|
{
|
|
if ( 0 != key_l ) {
|
|
u2_noun pas = _lo_staf(rec_u, key_l);
|
|
u2_noun key;
|
|
|
|
while ( 1 ) {
|
|
pas = pas ? pas : _lo_cask(rec_u, u2_Host.cpu_c, u2_no);
|
|
|
|
key = _lo_fatt(sal_l, pas);
|
|
|
|
if ( u2_mug(key) != key_l ) {
|
|
uL(fprintf(uH, "incorrect passcode\n"));
|
|
u2z(key);
|
|
pas = 0;
|
|
}
|
|
else {
|
|
u2z(rec_u->key);
|
|
rec_u->key = key;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Read in the fscking events. These are probably corrupt as well.
|
|
{
|
|
c3_w ent_w;
|
|
c3_d end_d;
|
|
|
|
end_d = u2_Host.lug_u.len_d;
|
|
ent_w = 0;
|
|
|
|
if ( -1 == lseek64(fid_i, 4ULL * end_d, SEEK_SET) ) {
|
|
fprintf(stderr, "end_d %llx\n", end_d);
|
|
perror("lseek");
|
|
uL(fprintf(uH, "record (%s) is corrupt (c)\n", ful_c));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
|
|
while ( end_d != c3_wiseof(u2_uled) ) {
|
|
c3_d tar_d = (end_d - (c3_d)c3_wiseof(u2_ular));
|
|
u2_ular lar_u;
|
|
c3_w* img_w;
|
|
u2_noun ron;
|
|
|
|
// uL(fprintf(uH, "rest: reading event at %llx\n", end_d));
|
|
|
|
if ( -1 == lseek64(fid_i, 4ULL * tar_d, SEEK_SET) ) {
|
|
uL(fprintf(uH, "record (%s) is corrupt (d)\n", ful_c));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
if ( sizeof(u2_ular) != read(fid_i, &lar_u, sizeof(u2_ular)) ) {
|
|
uL(fprintf(uH, "record (%s) is corrupt (e)\n", ful_c));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
|
|
if ( lar_u.syn_w != u2_mug((c3_w)tar_d) ) {
|
|
uL(fprintf(uH, "record (%s) is corrupt (f)\n", ful_c));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
|
|
#if 0
|
|
uL(fprintf(uH, "log: read: at %d, %d: lar ent %d, len %d, mug %x\n",
|
|
(tar_w - lar_u.len_w),
|
|
tar_w,
|
|
lar_u.ent_w,
|
|
lar_u.len_w,
|
|
lar_u.mug_w));
|
|
#endif
|
|
img_w = malloc(4 * lar_u.len_w);
|
|
|
|
if ( end_d == u2_Host.lug_u.len_d ) {
|
|
ent_w = las_w = lar_u.ent_w;
|
|
}
|
|
else {
|
|
if ( lar_u.ent_w != (ent_w - 1) ) {
|
|
uL(fprintf(uH, "record (%s) is corrupt (g)\n", ful_c));
|
|
uL(fprintf(uH, "lar_u.ent_w %x, ent_w %x\n", lar_u.ent_w, ent_w));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
ent_w -= 1;
|
|
}
|
|
end_d = (tar_d - (c3_d)lar_u.len_w);
|
|
|
|
if ( ent_w < old_w ) {
|
|
free(img_w);
|
|
break;
|
|
}
|
|
|
|
if ( -1 == lseek64(fid_i, 4ULL * end_d, SEEK_SET) ) {
|
|
uL(fprintf(uH, "record (%s) is corrupt (h)\n", ful_c));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
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));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
|
|
ron = u2_ci_words(lar_u.len_w, img_w);
|
|
free(img_w);
|
|
|
|
if ( u2_mug(ron) != lar_u.mug_w ) {
|
|
uL(fprintf(uH, "record (%s) is corrupt (j)\n", ful_c));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
|
|
if ( rec_u->key ) {
|
|
u2_noun dep;
|
|
|
|
dep = u2_dc("de:crya", u2k(rec_u->key), ron);
|
|
if ( u2_no == u2du(dep) ) {
|
|
uL(fprintf(uH, "record (%s) is corrupt (k)\n", ful_c));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
else {
|
|
ron = u2k(u2t(dep));
|
|
u2z(dep);
|
|
}
|
|
}
|
|
roe = u2nc(u2_cke_cue(ron), roe);
|
|
}
|
|
rec_u->ent_w = c3_max(las_w + 1, old_w);
|
|
}
|
|
|
|
if ( u2_nul == roe ) {
|
|
// Nothing in the log that was not also in the checkpoint.
|
|
//
|
|
c3_assert(rec_u->ent_w == old_w);
|
|
c3_assert((las_w + 1) == old_w);
|
|
}
|
|
else {
|
|
u2_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 %d\n", las_w));
|
|
fprintf(uH, "---------------- playback starting----------------\n");
|
|
|
|
xno_w = 0;
|
|
while ( u2_nul != roe ) {
|
|
u2_noun i_roe = u2h(roe);
|
|
u2_noun t_roe = u2t(roe);
|
|
u2_noun now = u2h(i_roe);
|
|
u2_noun ovo = u2t(i_roe);
|
|
|
|
u2_reck_wind(rec_u, u2k(now));
|
|
if ( (u2_yes == u2_Host.ops_u.vno) &&
|
|
(c3__veer == u2h(u2t(ovo))) ) {
|
|
uL(fprintf(uH, "replay: skipped veer\n"));
|
|
}
|
|
else {
|
|
_lo_sing(rec_u, u2k(ovo));
|
|
}
|
|
|
|
fputc('.', stderr);
|
|
// uL(fprintf(uH, "playback: sing: %d\n", xno_w));
|
|
|
|
roe = t_roe;
|
|
xno_w++;
|
|
|
|
if ( 0 == (xno_w % 1000) ) {
|
|
uL(fprintf(uH, "{%d}\n", xno_w));
|
|
}
|
|
}
|
|
u2z(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 ( u2_nul == rec_u->own ) {
|
|
uL(fprintf(uH, "record did not install a master!\n"));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
rec_u->our = u2k(u2h(rec_u->own));
|
|
rec_u->pod = u2_dc("scot", 'p', u2k(rec_u->our)));
|
|
}
|
|
|
|
// Now, who the fsck are you? No, really.
|
|
{
|
|
u2_noun who;
|
|
c3_c* fil_c;
|
|
c3_c* who_c;
|
|
|
|
if ( (fil_c = strrchr(u2_Host.cpu_c, '/')) ) {
|
|
fil_c++;
|
|
} else fil_c = u2_Host.cpu_c;
|
|
|
|
who = u2_dc("scot", 'p', u2k(rec_u->our)));
|
|
who_c = u2_cr_string(who);
|
|
u2z(who);
|
|
|
|
if ( strncmp(fil_c, who_c + 1, strlen(fil_c)) ) {
|
|
uL(fprintf(uH, "record master (%s) does not match filename!\n", who_c));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
free(who_c);
|
|
}
|
|
#endif
|
|
|
|
// Rewrite the header. Will probably corrupt the record.
|
|
{
|
|
u2_uled led_u;
|
|
|
|
led_u.mag_l = u2_mug('f');
|
|
led_u.sal_l = sal_l;
|
|
led_u.sev_l = rec_u->sev_l;
|
|
led_u.key_l = rec_u->key ? u2_mug(rec_u->key) : 0;
|
|
led_u.kno_w = rec_u->kno_w; // 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));
|
|
u2_lo_bail(rec_u);
|
|
}
|
|
}
|
|
|
|
// Hey, fscker! It worked.
|
|
{
|
|
u2_term_ef_boil(tno_l);
|
|
}
|
|
}
|
|
|
|
/* _lo_zen(): get OS entropy.
|
|
*/
|
|
static u2_noun
|
|
_lo_zen(u2_reck* rec_u)
|
|
{
|
|
c3_w rad_w[8];
|
|
|
|
_lo_rand(rec_u, rad_w);
|
|
return u2_ci_words(8, rad_w);
|
|
}
|
|
|
|
/* _lo_boot(): restore or create.
|
|
*/
|
|
static void
|
|
_lo_boot(void)
|
|
{
|
|
if ( u2_yes == u2_Host.ops_u.nuu ) {
|
|
u2_noun pig;
|
|
|
|
if ( 0 == u2_Host.ops_u.imp_c ) {
|
|
c3_c get_c[2049];
|
|
snprintf(get_c, 2048, "%s/get", u2_Host.cpu_c);
|
|
if ( 0 == access(get_c, 0) ) {
|
|
uL(fprintf(uH, "pier: already built\n"));
|
|
exit(1);
|
|
}
|
|
u2_noun ten = _lo_zen(u2A);
|
|
uL(fprintf(uH, "generating 2048-bit RSA pair...\n"));
|
|
|
|
pig = u2nq(c3__make, u2_nul, 11, ten);
|
|
}
|
|
else {
|
|
u2_noun imp = u2_ci_string(u2_Host.ops_u.imp_c);
|
|
u2_noun whu = u2_dc("slaw", 'p', u2k(imp));
|
|
|
|
if ( (u2_nul == whu) ) {
|
|
fprintf(stderr, "czar: incorrect format\r\n");
|
|
exit(1);
|
|
}
|
|
else {
|
|
u2_noun gen = _lo_text(u2A, "generator");
|
|
u2_noun gun = u2_dc("slaw", c3__uw, gen);
|
|
|
|
if ( u2_nul == gun ) {
|
|
fprintf(stderr, "czar: incorrect format\r\n");
|
|
exit(1);
|
|
}
|
|
pig = u2nt(c3__sith, u2k(u2t(whu)), u2k(u2t(gun)));
|
|
|
|
u2z(whu); u2z(gun);
|
|
}
|
|
u2z(imp);
|
|
}
|
|
_lo_make(u2A, pig);
|
|
}
|
|
else {
|
|
_lo_rest(u2A);
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
// _lo_bench_noop(): benchmark no-op events.
|
|
//
|
|
static void
|
|
_lo_bench_noop(c3_w num_w)
|
|
{
|
|
c3_w i_w;
|
|
|
|
for ( i_w = 0; i_w < num_w; i_w++ ) {
|
|
u2_reck_plan(u2A, u2nq(c3__gold, c3__term, 1, u2_nul),
|
|
u2nc(c3__noop, u2_nul));
|
|
}
|
|
|
|
_lo_work(u2A);
|
|
}
|
|
|
|
// _lo_bench_scot_p(): benchmark prettyprint.
|
|
//
|
|
static void
|
|
_lo_bench_scot_p(c3_w num_w)
|
|
{
|
|
c3_w i_w;
|
|
|
|
for ( i_w = 0; i_w < num_w; i_w++ ) {
|
|
u2_noun soc = u2_dc("scot", 'p', u2k(u2A->now));
|
|
|
|
u2z(soc);
|
|
}
|
|
}
|
|
|
|
// _lo_bench_slay_p(): benchmark prettyprint.
|
|
//
|
|
static void
|
|
_lo_bench_slay_p(c3_w num_w)
|
|
{
|
|
c3_w i_w;
|
|
|
|
for ( i_w = 0; i_w < num_w; i_w++ ) {
|
|
u2_noun soc = u2_dc("scot", 'p', u2k(u2A->now));
|
|
u2_noun dub = u2_do("slay", soc);
|
|
|
|
u2z(dub);
|
|
}
|
|
}
|
|
|
|
// _lo_bench_scot_da(): benchmark prettyprint.
|
|
//
|
|
static void
|
|
_lo_bench_scot_da(c3_w num_w)
|
|
{
|
|
c3_w i_w;
|
|
|
|
for ( i_w = 0; i_w < num_w; i_w++ ) {
|
|
u2_noun soc = u2_dc("scot", c3__da, u2k(u2A->now));
|
|
|
|
u2z(soc);
|
|
}
|
|
}
|
|
|
|
// _lo_bench_dec(): benchmark decrement.
|
|
//
|
|
static void
|
|
_lo_bench_dec(c3_w num_w)
|
|
{
|
|
c3_w i_w;
|
|
|
|
for ( i_w = 0; i_w < num_w; i_w++ ) {
|
|
u2_noun soc = u2_do("dec", u2k(u2A->now));
|
|
|
|
u2z(soc);
|
|
}
|
|
}
|
|
|
|
// _lo_bench_scot_ud(): benchmark prettyprint.
|
|
//
|
|
static void
|
|
_lo_bench_scot_ud(c3_w num_w)
|
|
{
|
|
c3_w i_w;
|
|
|
|
for ( i_w = 0; i_w < num_w; i_w++ ) {
|
|
u2_noun soc = u2_dc("scot", c3__ud, u2k(u2A->now));
|
|
|
|
u2z(soc);
|
|
}
|
|
}
|
|
|
|
// _lo_bench(): lo-tech profiling.
|
|
//
|
|
static void
|
|
_lo_bench(const c3_c* lab_c, void (*fun)(c3_w), c3_w num_w)
|
|
{
|
|
u2_noun old, new;
|
|
|
|
uL(fprintf(uH, "bench: %s: start...\n", lab_c));
|
|
u2_reck_time(u2A);
|
|
old = u2k(u2A->now);
|
|
|
|
fun(num_w);
|
|
|
|
u2_reck_time(u2A);
|
|
new = u2k(u2A->now);
|
|
{
|
|
c3_w tms_w = (c3_w)u2_time_gap_ms(old, new);
|
|
|
|
if ( tms_w > (10 * num_w) ) {
|
|
uL(fprintf(uH, "bench: %s*%d: %d ms, %d ms each.\n",
|
|
lab_c, num_w, tms_w, (tms_w / num_w)));
|
|
}
|
|
else {
|
|
uL(fprintf(uH, "bench: %s*%d: %d ms, %d us each.\n",
|
|
lab_c, num_w, tms_w, ((tms_w * 1000) / num_w)));
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* u2_lo_show(): generic noun print.
|
|
*/
|
|
void
|
|
u2_lo_show(c3_c* cap_c, u2_noun nun)
|
|
{
|
|
u2_noun pav = u2_dc("pave", c3__noun, nun);
|
|
c3_c* txt_c = (c3_c*)u2_cr_tape(pav);
|
|
|
|
fprintf(stderr, "%s: %s\r\n", cap_c, txt_c);
|
|
u2z(pav);
|
|
free(txt_c);
|
|
}
|
|
|
|
static void
|
|
_lo_slow()
|
|
{
|
|
#if 0
|
|
_lo_bench("scot %p", _lo_bench_scot_p, 256);
|
|
_lo_bench("scot %da", _lo_bench_scot_da, 256);
|
|
_lo_bench("scot %ud", _lo_bench_scot_ud, 256);
|
|
_lo_bench("slay %p", _lo_bench_slay_p, 256);
|
|
_lo_bench("noop", _lo_bench_noop, 256);
|
|
#endif
|
|
}
|
|
|
|
/* u2_lo_boot(): restore or create pier.
|
|
*/
|
|
void
|
|
u2_lo_boot()
|
|
{
|
|
uv_loop_t* lup_u = uv_default_loop();
|
|
|
|
u2_Host.lup_u = lup_u;
|
|
|
|
signal(SIGPIPE, SIG_IGN); // pipe, schmipe
|
|
// signal(SIGIO, SIG_IGN); // linux is wont to produce for some reason
|
|
|
|
_lo_init();
|
|
_lo_boot();
|
|
}
|
|
|
|
/* u2_lo_loop(): begin main event loop.
|
|
*/
|
|
void
|
|
u2_lo_loop(u2_reck* rec_u)
|
|
{
|
|
_lo_talk();
|
|
{
|
|
u2_unix_ef_look();
|
|
u2_reck_plan(rec_u, u2nt(c3__gold, c3__ames, u2_nul),
|
|
u2nc(c3__kick, u2k(rec_u->now)));
|
|
}
|
|
_lo_poll();
|
|
|
|
#if 1
|
|
u2_loom_save(rec_u->ent_w);
|
|
|
|
u2_Host.sav_u.ent_w = rec_u->ent_w;
|
|
#endif
|
|
|
|
if ( u2_yes == u2_Host.ops_u.nuu ) {
|
|
u2_term_ef_boil(1);
|
|
}
|
|
|
|
#if 1
|
|
_lo_slow();
|
|
#endif
|
|
|
|
uv_run(u2L, UV_RUN_DEFAULT);
|
|
}
|
|
|
|
/* _lo_mark_reck(): mark a reck.
|
|
*/
|
|
static c3_w
|
|
_lo_mark_reck(u2_reck* rec_u)
|
|
{
|
|
c3_w siz_w = 0;
|
|
c3_w egg_w;
|
|
|
|
siz_w += u2_cm_mark_noun(rec_u->ken);
|
|
siz_w += u2_cm_mark_noun(rec_u->roc);
|
|
|
|
siz_w += u2_cm_mark_noun(rec_u->yot);
|
|
siz_w += u2_cm_mark_noun(rec_u->now);
|
|
siz_w += u2_cm_mark_noun(rec_u->wen);
|
|
siz_w += u2_cm_mark_noun(rec_u->sen);
|
|
siz_w += u2_cm_mark_noun(rec_u->own);
|
|
siz_w += u2_cm_mark_noun(rec_u->roe);
|
|
siz_w += u2_cm_mark_noun(rec_u->key);
|
|
|
|
{
|
|
u2_cart* egg_u;
|
|
|
|
egg_w = 0;
|
|
for ( egg_u = rec_u->ova.egg_u; egg_u; egg_u = egg_u->nex_u ) {
|
|
egg_w += u2_cm_mark_noun(egg_u->egg);
|
|
}
|
|
siz_w += egg_w;
|
|
}
|
|
#if 0
|
|
fprintf(stderr, "ken %d, roc %d, yot %d, roe %d, egg %d\r\n",
|
|
ken_w, roc_w, yot_w, roe_w, egg_w);
|
|
#endif
|
|
return siz_w;
|
|
}
|
|
|
|
/* _lo_mark(): mark the whole vere system.
|
|
*/
|
|
static c3_w
|
|
_lo_mark()
|
|
{
|
|
c3_w siz_w;
|
|
|
|
siz_w = u2_cm_mark_internal();
|
|
siz_w += _lo_mark_reck(u2_Host.arv_u);
|
|
|
|
return siz_w;
|
|
}
|
|
|
|
/* _lo_word(): print a word to stderr.
|
|
*/
|
|
static void
|
|
_lo_word(c3_w wod_w)
|
|
{
|
|
u2_bean top = u2_yes;
|
|
|
|
if ( wod_w / (1000 * 1000 * 1000) ) {
|
|
uL(fprintf(uH, "%u.", wod_w / (1000 * 1000 * 1000)));
|
|
wod_w %= (1000 * 1000 * 1000);
|
|
top = u2_no;
|
|
}
|
|
if ( wod_w / (1000 * 1000) ) {
|
|
uL(fprintf(uH, ((top == u2_yes) ? "%u." : "%03u."),
|
|
wod_w / (1000 * 1000)));
|
|
wod_w %= (1000 * 1000);
|
|
top = u2_no;
|
|
}
|
|
if ( wod_w / 1000 ) {
|
|
uL(fprintf(uH, ((top == u2_yes) ? "%u." : "%03u."), wod_w / 1000));
|
|
wod_w %= 1000;
|
|
top = u2_no;
|
|
}
|
|
uL(fprintf(uH, ((top == u2_yes) ? "%u" : "%03u"), wod_w));
|
|
}
|
|
|
|
/* u2_lo_grab(): garbage-collect the world, plus roots.
|
|
*/
|
|
void
|
|
u2_lo_grab(c3_c* cap_c, u2_noun som, ...)
|
|
{
|
|
c3_w siz_w, lec_w;
|
|
|
|
siz_w = _lo_mark();
|
|
{
|
|
va_list vap;
|
|
u2_noun tur;
|
|
|
|
va_start(vap, som);
|
|
|
|
if ( som != u2_none ) {
|
|
siz_w += u2_cm_mark_noun(som);
|
|
|
|
while ( u2_none != (tur = va_arg(vap, u2_noun)) ) {
|
|
siz_w += u2_cm_mark_noun(tur);
|
|
}
|
|
}
|
|
va_end(vap);
|
|
}
|
|
lec_w = u2_cm_sweep(siz_w);
|
|
|
|
// if ( lec_w || (u2_yes == u2_Flag_Verbose) )
|
|
if ( lec_w || !strcmp("init", cap_c) ) {
|
|
uL(fprintf(uH, "%s: gc: ", cap_c));
|
|
if ( lec_w ) {
|
|
_lo_word(4 * lec_w);
|
|
uL(fprintf(uH, " bytes shed; "));
|
|
}
|
|
_lo_word(4 * siz_w);
|
|
uL(fprintf(uH, " bytes live\n"));
|
|
|
|
#if 0
|
|
if ( lec_w ) {
|
|
uL(fprintf(uH, "zero garbage tolerance!\n"));
|
|
_lo_exit();
|
|
c3_assert(0);
|
|
exit(1);
|
|
}
|
|
#endif
|
|
}
|
|
u2_wire_lan(u2_Wire) = u2_yes;
|
|
}
|