mirror of
https://github.com/ilyakooo0/urbit.git
synced 2024-12-17 20:01:32 +03:00
1622 lines
54 KiB
Plaintext
1622 lines
54 KiB
Plaintext
!: :: ames (4a), networking
|
|
::
|
|
|= pit=vase
|
|
=> =~
|
|
:: structures
|
|
=, ames
|
|
:: this number needs to be below 8
|
|
::
|
|
=+ protocol-version=3
|
|
|%
|
|
+= move [p=duct q=(wind note:able gift:able)] :: local move
|
|
:: |pact: internal packet structures
|
|
::
|
|
++ pact
|
|
|%
|
|
+$ full [lyf=[to=life from=life] law=(unit deed) txt=@]
|
|
+$ open [lyf=[to=~ from=life] law=(unit deed) txt=@]
|
|
--
|
|
--
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
:: section 4aA, identity logic ::
|
|
:: removed in favor of jael/ethereum ::
|
|
::
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
:: section 4aB, packet format ::
|
|
::
|
|
|%
|
|
++ bite :: packet to cake
|
|
|= pac=rock
|
|
^- (unit cake)
|
|
=+ [mag=(end 5 1 pac) bod=(rsh 5 1 pac)]
|
|
=+ :* vez=(end 0 3 mag) :: protocol version
|
|
chk=(cut 0 [3 20] mag) :: checksum
|
|
wix=(bex +((cut 0 [23 2] mag))) :: width of receiver
|
|
vix=(bex +((cut 0 [25 2] mag))) :: width of sender
|
|
tay=(cut 0 [27 5] mag) :: message type
|
|
==
|
|
:: XX these packets should be firewalled in vere so that they don't
|
|
:: make it into the event log
|
|
::
|
|
?. =(protocol-version vez) ~
|
|
?. =(chk (end 0 20 (mug bod))) ~
|
|
%- some
|
|
:+ [(end 3 wix bod) (cut 3 [wix vix] bod)]
|
|
(kins tay)
|
|
(rsh 3 (add wix vix) bod)
|
|
::
|
|
++ kins |=(tay=@ (snag tay `(list skin)`[%none %open %fast %full ~]))
|
|
++ ksin |=(sin=skin `@`?-(sin %none 0, %open 1, %fast 2, %full 3))
|
|
++ spit :: cake to packet
|
|
|= kec=cake ^- @
|
|
=+ wim=(met 3 p.p.kec)
|
|
=+ dum=(met 3 q.p.kec)
|
|
=+ yax=?:((lte wim 2) 0 ?:((lte wim 4) 1 ?:((lte wim 8) 2 3)))
|
|
=+ qax=?:((lte dum 2) 0 ?:((lte dum 4) 1 ?:((lte dum 8) 2 3)))
|
|
=+ wix=(bex +(yax))
|
|
=+ vix=(bex +(qax))
|
|
=+ bod=:(mix p.p.kec (lsh 3 wix q.p.kec) (lsh 3 (add wix vix) r.kec))
|
|
=+ tay=(ksin q.kec)
|
|
%+ mix
|
|
%+ can 0
|
|
:~ [3 protocol-version]
|
|
[20 (mug bod)]
|
|
[2 yax]
|
|
[2 qax]
|
|
[5 tay]
|
|
==
|
|
(lsh 5 1 bod)
|
|
--
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
:: section 4aC, PKI engine ::
|
|
::
|
|
|%
|
|
++ go :: go
|
|
|_ ton=town :: ames state
|
|
++ as :: as:go
|
|
|_ our=ship :: per server
|
|
++ lax :: lax:as:go
|
|
|_ [her=ship dur=dore] :: per client
|
|
++ cluy :: cluy:lax:as:go
|
|
^- [lyf=life cub=acru] :: client crypto
|
|
?> ?=(^ lew.wod.dur)
|
|
[life.u.lew.wod.dur (com:nu:crub:crypto pass.u.lew.wod.dur)]
|
|
::
|
|
++ clon
|
|
^- life
|
|
:: if we don't have a +deed for :her, we guess 1
|
|
::
|
|
?~(lew.wod.dur 1 life.u.lew.wod.dur)
|
|
::
|
|
++ griz :: griz:lax:as:go
|
|
|= now=@da :: generate key for
|
|
^- [p=code q=_+>]
|
|
=+ key=(shas %enty (mix now any.ton))
|
|
:- key
|
|
%= +>.$
|
|
any.ton (shax (mix now any.ton))
|
|
heg.caq.dur (~(put by heg.caq.dur) (shaf %hand key) key)
|
|
==
|
|
::
|
|
++ pode :: pode:lax:as:go
|
|
|= now=@da :: timeout route
|
|
^+ +>
|
|
?: (lth her 256) +>(lun.wod.dur [~ %if ~2000.1.1 0 (mix her .0.0.1.0)])
|
|
+>(lun.wod.dur ~)
|
|
::
|
|
++ kuch :: kuch:lax:as:go
|
|
|= had=hand :: hear key tag
|
|
^- (unit [code _+>])
|
|
=+ wey=(~(get by heg.caq.dur) had)
|
|
?^ wey
|
|
=+ key=u.wey
|
|
:+ ~ key
|
|
%= ..kuch
|
|
yed.caq.dur [~ had u.wey]
|
|
heg.caq.dur (~(del by heg.caq.dur) had)
|
|
qim.caq.dur (~(put by qim.caq.dur) had key)
|
|
==
|
|
=+ dyv=(~(get by qim.caq.dur) had)
|
|
?~ dyv ~
|
|
[~ u.dyv ..kuch]
|
|
::
|
|
++ wasc :: wasc:lax:as:go
|
|
|= key=code :: hear foreign code
|
|
^+ +>
|
|
=+ had=(shaf %hand key)
|
|
%_ ..wasc
|
|
yed.caq.dur [~ had key]
|
|
qim.caq.dur (~(put by qim.caq.dur) had key)
|
|
==
|
|
::
|
|
++ wast :: wast:lax:as:go
|
|
|= ryn=lane :: set route
|
|
^+ +>
|
|
%= +>
|
|
lun.wod.dur
|
|
?: ?=([%ix *] ryn)
|
|
?: ?| ?=(~ lun.wod.dur)
|
|
?=([%ix *] u.lun.wod.dur)
|
|
?& ?=([%if *] u.lun.wod.dur)
|
|
(gth p.ryn (add ~s10 p.u.lun.wod.dur))
|
|
==
|
|
==
|
|
[~ ryn]
|
|
lun.wod.dur
|
|
[~ ryn]
|
|
==
|
|
::
|
|
++ wist :: wist:lax:as:go
|
|
|= $: now=@da :: route via
|
|
waz=(list @p)
|
|
ryn=(unit lane)
|
|
pac=rock
|
|
==
|
|
^- (list boon)
|
|
?: =(our her) [[%ouzo *lane pac] ~]
|
|
?~ waz ~
|
|
=+ dyr=?:(=(her i.waz) dur (gur i.waz))
|
|
?. ?& !=(our i.waz)
|
|
?=(^ lun.wod.dyr)
|
|
==
|
|
$(waz t.waz)
|
|
:_ ?: ?=(%ix -.u.lun.wod.dyr)
|
|
$(waz t.waz)
|
|
~
|
|
:+ %ouzo u.lun.wod.dyr
|
|
?: &(=(i.waz her) =(~ ryn)) pac
|
|
=+ mal=(jam `meal`[%fore her ryn pac])
|
|
%- spit
|
|
^- cake
|
|
:* [our i.waz]
|
|
?~ yed.caq.dyr [%none mal]
|
|
:- %fast
|
|
%^ cat 7
|
|
p.u.yed.caq.dyr
|
|
(en:crub:crypto q.u.yed.caq.dyr mal)
|
|
==
|
|
::
|
|
++ zuul :: zuul:lax:as:go
|
|
|= [now=@da seg=ship ham=meal] :: encode message
|
|
^- [p=(list rock) q=_+>]
|
|
=< weft
|
|
|%
|
|
++ wasp :: null security
|
|
^-([p=skin q=@] [%none (jam ham)])
|
|
::
|
|
++ weft :: fragment message
|
|
^- [p=(list rock) q=_+>.$]
|
|
=^ gim ..weft wisp
|
|
:_ +>.$
|
|
^- (list rock)
|
|
=+ wit=(met 13 q.gim)
|
|
?< =(0 wit)
|
|
?: =(1 wit)
|
|
=+ yup=(spit [our her] p.gim q.gim)
|
|
[yup ~]
|
|
=+ ruv=(rip 13 q.gim)
|
|
=+ gom=(shaf %thug q.gim)
|
|
=+ inx=0
|
|
|- ^- (list rock)
|
|
?~ ruv ~
|
|
=+ ^= vie
|
|
%+ spit
|
|
[our her]
|
|
wasp(ham [%carp (ksin p.gim) inx wit gom i.ruv])
|
|
:- vie
|
|
$(ruv t.ruv, inx +(inx))
|
|
::
|
|
++ wisp :: generate message
|
|
^- [[p=skin q=@] q=_..wisp]
|
|
?: =(%carp -.ham)
|
|
[wasp ..wisp]
|
|
?: !=(~ yed.caq.dur)
|
|
?> ?=(^ yed.caq.dur)
|
|
:_ ..wisp
|
|
:- %fast
|
|
%^ cat 7
|
|
p.u.yed.caq.dur
|
|
(en:cub:cluy q.u.yed.caq.dur (jam ham))
|
|
?: &(=(~ lew.wod.dur) =(%back -.ham))
|
|
[wasp ..wisp]
|
|
:: we include our deed in asymmetric skins (%open and %full)
|
|
:: if we're a comet or moon, or if we're sponsoring her
|
|
::
|
|
=/ bil=(unit deed)
|
|
=/ rac (clan:title our)
|
|
?. ?| ?=(?(%earl %pawn) rac)
|
|
&(!?=(%czar rac) =(our seg))
|
|
==
|
|
~
|
|
`law.ton
|
|
=/ yig sen
|
|
=/ hom (jam ham)
|
|
?: =(~ lew.wod.dur)
|
|
:_ ..wisp
|
|
:- %open
|
|
%- jam
|
|
^- open:pact
|
|
:+ [~ lyf.yig]
|
|
bil
|
|
(sign:as:cub.yig hom)
|
|
=/ cay cluy
|
|
:: :tuy: symmetric key proposal
|
|
::
|
|
=^ tuy +>.$ (griz now)
|
|
:_ ..wisp
|
|
:- %full
|
|
%- jam
|
|
^- full:pact
|
|
:+ [lyf.cay lyf.yig]
|
|
bil
|
|
(seal:as:cub.yig pub:ex:cub.cay (jam tuy hom))
|
|
-- :: --zuul:lax:as:go
|
|
-- :: --lax:as:go
|
|
::
|
|
++ gur :: default dore
|
|
|= her=ship
|
|
^- dore
|
|
=+ def=?.((lth her 256) ~ [~ %if ~2000.1.1 0 (mix her .0.0.1.0)])
|
|
[[~2100.1.1 def ~] *clot]
|
|
::
|
|
++ myx :: dore by ship
|
|
|= her=ship
|
|
^+ lax
|
|
=/ fod=dore
|
|
(fall (~(get by hoc.ton) her) (gur her))
|
|
~(. lax [her fod])
|
|
::
|
|
++ nux :: install dore
|
|
|= new=_lax
|
|
^+ +>
|
|
+>(hoc.ton (~(put by hoc.ton) her.new dur.new))
|
|
::
|
|
++ sen :: current crypto
|
|
^- [lyf=life cub=acru]
|
|
?~(val.ton !! [p.i.val.ton r.i.val.ton])
|
|
::
|
|
++ sev :: crypto by life
|
|
|= mar=life
|
|
^- [p=? q=acru]
|
|
?~ val.ton !!
|
|
?: =(mar p.i.val.ton)
|
|
[& r.i.val.ton]
|
|
?> (lth mar p.i.val.ton)
|
|
:- |
|
|
|- ^- acru
|
|
?> ?=(^ t.val.ton)
|
|
?: =(mar p.i.t.val.ton)
|
|
r.i.t.val.ton
|
|
$(t.val.ton t.t.val.ton)
|
|
-- :: --as:go
|
|
::
|
|
++ su :: install safe
|
|
|=(new=_as `town`ton.new)
|
|
::
|
|
++ ti :: expire by time
|
|
|= now=@da
|
|
^- town
|
|
!!
|
|
::
|
|
++ us :: produce safe
|
|
|=(our=ship `_as`~(. as our))
|
|
-- :: --go
|
|
--
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
:: section 4aF, packet pump ::
|
|
|%
|
|
++ pu :: packet pump
|
|
|_ shed
|
|
++ abet +<
|
|
++ ahoy :: ahoy:pu
|
|
^+ . :: initialize
|
|
%_ .
|
|
rtt ~s1
|
|
rto ~s4
|
|
rtn ~
|
|
rue ~
|
|
nus 0
|
|
nif 0
|
|
nep 0
|
|
caw 2
|
|
cag 64
|
|
diq ~
|
|
pyz ~
|
|
puq ~
|
|
==
|
|
::
|
|
++ bick :: bick:pu
|
|
|= [now=@da fap=flap] :: ack by hash
|
|
^- [[p=(unit soup) q=(list rock)] _+>]
|
|
=+ sun=(~(get by diq) fap)
|
|
?~ sun
|
|
:: ~& [%bick-none `@p`(mug fap)] :: not a real error
|
|
[[~ ~] +>.$]
|
|
:: ~& [%bick-good `@p`(mug fap) u.sun]
|
|
=. diq (~(del by diq) fap)
|
|
=^ gub +>.$ (bock now u.sun)
|
|
=^ yop +>.$ (harv now)
|
|
[[gub yop] +>.$]
|
|
::
|
|
++ bilk :: bilk:pu
|
|
|= now=@da :: inbound packet
|
|
^+ +>
|
|
=+ trt=(mul 2 rtt)
|
|
%= +>.$
|
|
rue [~ now]
|
|
rto trt
|
|
rtn ?~(puq ~ [~ (add now trt)])
|
|
==
|
|
::
|
|
++ boom :: boom:pu
|
|
|= now=@da ^- ? :: address timeout
|
|
|(?=(~ rue) (gte (sub now u.rue) ~m1))
|
|
::
|
|
++ bust :: bust:pu
|
|
^- ? :: not responding
|
|
&(?=(^ rtn) (gte rto ~s16))
|
|
::
|
|
++ bike :: bike:pu
|
|
^+ . :: check stats
|
|
?> .= nif
|
|
|- ^- @
|
|
?~ puq 0
|
|
:(add !liv.q.n.puq $(puq l.puq) $(puq r.puq))
|
|
.
|
|
::
|
|
++ beet :: beet:pu
|
|
^+ . :: advance unacked
|
|
=- +(nep ?~(foh nus u.foh))
|
|
^= foh
|
|
|- ^- (unit @ud)
|
|
?~ puq ~
|
|
?: (lte p.n.puq nep) $(puq l.puq)
|
|
=+ rig=$(puq r.puq)
|
|
?^(rig rig [~ p.n.puq])
|
|
::
|
|
++ bine :: bine:pu
|
|
|= [now=@da num=@ud] :: apply ack
|
|
^- [(unit soup) _+>]
|
|
?~ puq !!
|
|
?. =(num p.n.puq)
|
|
?: (gth num p.n.puq)
|
|
=+ lef=$(puq l.puq)
|
|
[-.lef +.lef(puq [n.puq puq.lef r.puq])]
|
|
=+ rig=$(puq r.puq)
|
|
[-.rig +.rig(puq [n.puq l.puq puq.rig])]
|
|
=: rtt ?. &(liv.q.n.puq =(1 nux.q.n.puq)) rtt
|
|
=+ gap=(sub now lys.q.n.puq)
|
|
:: ~& [%bock-trip num (div gap (div ~s1 1.000))]
|
|
(div (add (mul 2 rtt) gap) 3)
|
|
nif (sub nif !liv.q.n.puq)
|
|
==
|
|
=+ lez=(dec (need (~(get by pyz) gom.q.n.puq)))
|
|
=^ gub pyz
|
|
?: =(0 lez)
|
|
[[~ gom.q.n.puq] (~(del by pyz) gom.q.n.puq)]
|
|
[~ (~(put by pyz) gom.q.n.puq lez)]
|
|
:- gub
|
|
+>.$(puq ~(nap to puq))
|
|
::
|
|
++ bock :: bock:pu
|
|
|= [now=@da num=@ud] :: ack by sequence
|
|
^- [(unit soup) _+>]
|
|
=^ gym +> (bine now num)
|
|
:- gym
|
|
?: (gth num nep)
|
|
=+ cam=(max 2 (div caw 2))
|
|
:: ~& [%bock-hole num nep cam]
|
|
beet:(wept(nep num, cag cam, caw cam) nep num)
|
|
=. caw ?: (lth caw cag) +(caw)
|
|
(add caw !=(0 (mod (mug now) caw)))
|
|
?: =(num nep)
|
|
:: ~& [%bock-fine num nif caw cag]
|
|
beet
|
|
:: ~& [%bock-fill num nif caw cag]
|
|
+>.$
|
|
::
|
|
++ harv :: harv:pu
|
|
|= now=@da :: harvest queue
|
|
^- [(list rock) _+>]
|
|
?: =(~ puq) [~ +>(rtn ~)]
|
|
?. (gth caw nif) [~ +>]
|
|
=+ wid=(sub caw nif)
|
|
=| rub=(list rock)
|
|
=< abet =< apse
|
|
|%
|
|
++ abet
|
|
?~ rub [~ +>.$]
|
|
[(flop rub) +>.$(rtn [~ (add rto now)])]
|
|
::
|
|
++ apse
|
|
^+ .
|
|
?~ puq .
|
|
?: =(0 wid) .
|
|
=> rigt =< left
|
|
?> ?=(^ puq)
|
|
?: =(0 wid) .
|
|
?. =(| liv.q.n.puq) .
|
|
:: ~& [%harv nux.q.n.puq p.n.puq]
|
|
%_ .
|
|
wid (dec wid)
|
|
rub [pac.q.n.puq rub]
|
|
nif +(nif)
|
|
liv.q.n.puq &
|
|
nux.q.n.puq +(nux.q.n.puq)
|
|
lys.q.n.puq now
|
|
==
|
|
::
|
|
++ left
|
|
?> ?=(^ puq)
|
|
^+(. =+(lef=apse(puq l.puq) lef(puq [n.puq puq.lef r.puq])))
|
|
++ rigt
|
|
?> ?=(^ puq)
|
|
^+(. =+(rig=apse(puq r.puq) rig(puq [n.puq l.puq puq.rig])))
|
|
--
|
|
::
|
|
++ wack :: wack:pu
|
|
|= now=@da :: wakeup (timeout)
|
|
^- [(list rock) _+>]
|
|
?. &(!=(~ rtn) ?>(?=(^ rtn) (gte now u.rtn))) [~ +>]
|
|
:: ~& [%slow (div rto (div ~s1 1.000))]
|
|
=. +> (wept 0 nus)
|
|
?> =(0 nif)
|
|
=: caw 2
|
|
rto ;: min
|
|
(mul 2 rto)
|
|
~m2
|
|
(mul ~s16 ?~(rue 1 +((div (sub now u.rue) ~d1))))
|
|
==
|
|
==
|
|
(harv now)
|
|
::
|
|
++ wept :: wept:pu
|
|
|= [fip=@ud lap=@ud] :: fip thru lap-1
|
|
=< abet =< apse
|
|
|%
|
|
++ abet +>.$
|
|
++ apse
|
|
^+ .
|
|
?~ puq .
|
|
?: (lth p.n.puq fip) ?~(l.puq . left)
|
|
?: (gte p.n.puq lap) ?~(r.puq . rigt)
|
|
=> rigt =< left
|
|
?> ?=(^ puq)
|
|
?.(liv.q.n.puq . .(nif (dec nif), liv.q.n.puq |))
|
|
::
|
|
++ left
|
|
?> ?=(^ puq)
|
|
^+(. =+(lef=apse(puq l.puq) lef(puq [n.puq puq.lef r.puq])))
|
|
++ rigt
|
|
?> ?=(^ puq)
|
|
^+(. =+(rig=apse(puq r.puq) rig(puq [n.puq l.puq puq.rig])))
|
|
--
|
|
::
|
|
++ whap :: whap:pu
|
|
|= [now=@da gom=soup wyv=(list rock)] :: send a message
|
|
^- [(list rock) _+>]
|
|
=. pyz (~(put by pyz) gom (lent wyv))
|
|
=. +>
|
|
|- ^+ +>.^$
|
|
?~ wyv +>.^$
|
|
%= $
|
|
wyv t.wyv
|
|
nus +(nus)
|
|
diq (~(put by diq) (shaf %flap i.wyv) nus)
|
|
puq (~(put to puq) [nus `soul`[gom 0 | ~2000.1.1 i.wyv]])
|
|
==
|
|
(harv now)
|
|
--
|
|
--
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
:: section 4aG, protocol engine ::
|
|
::
|
|
|%
|
|
++ am :: am
|
|
~% %ames-am ..is ~
|
|
|_ [our=ship now=@da fox=fort ski=sley] :: protocol engine
|
|
:: +deed-scry: for a +deed at a +life
|
|
::
|
|
++ deed-scry
|
|
~/ %deed-scry
|
|
|= [who=ship lyf=life]
|
|
^- (unit deed)
|
|
=; ded
|
|
?~(ded ~ u.ded)
|
|
;; (unit (unit deed))
|
|
%- (sloy-light ski)
|
|
=/ pur=spur
|
|
/(scot %ud lyf)/(scot %p who)
|
|
[[151 %noun] %j our %deed da+now pur]
|
|
:: +life-scry: for a +life
|
|
::
|
|
++ life-scry
|
|
~/ %life-scry
|
|
|= who=ship
|
|
^- (unit life)
|
|
=; lyf
|
|
?~(lyf ~ u.lyf)
|
|
;; (unit (unit life))
|
|
%- (sloy-light ski)
|
|
=/ pur=spur
|
|
/(scot %p who)
|
|
[[151 %noun] %j our %life da+now pur]
|
|
:: +sein-scry: for sponsor
|
|
::
|
|
++ sein-scry
|
|
~/ %sein
|
|
|= who=ship
|
|
;; ship
|
|
%- need %- need
|
|
%- (sloy-light ski)
|
|
[[151 %noun] %j our %sein da+now /(scot %p who)]
|
|
:: +saxo-scry: for sponsorship chain
|
|
::
|
|
++ saxo-scry
|
|
~/ %saxo
|
|
|= who=ship
|
|
;; (list ship)
|
|
%- need %- need
|
|
%- (sloy-light ski)
|
|
[[151 %noun] %j our %saxo da+now /(scot %p who)]
|
|
:: +turf-scry: for network domains
|
|
::
|
|
++ turf-scry
|
|
~/ %turf
|
|
;; (list turf)
|
|
%- need %- need
|
|
%- (sloy-light ski)
|
|
[[151 %noun] %j our %turf da+now ~]
|
|
::
|
|
++ vein :: vein:am
|
|
~/ %vein
|
|
|= [=life vein=(map life ring)] :: new private keys
|
|
^- fort
|
|
::
|
|
?. ?& (~(has by vein) life)
|
|
=(life (roll ~(tap in ~(key by vein)) max))
|
|
==
|
|
~| [%vein-mismatch +<] !!
|
|
%= fox
|
|
hoc.ton
|
|
:: reset connections
|
|
::
|
|
(~(run by hoc.ton.fox) |=(=dore dore(caq *clot)))
|
|
::
|
|
seh.ton
|
|
:: reset symmetric key cache
|
|
::
|
|
~
|
|
::
|
|
:: save our secrets, ready for action
|
|
law.ton
|
|
:: save our deed (for comet/moon communication)
|
|
::
|
|
(need (deed-scry our life))
|
|
::
|
|
val.ton
|
|
:: save our secrets, ready for action
|
|
::
|
|
^- wund
|
|
%+ turn
|
|
%+ sort
|
|
~(tap by vein)
|
|
|= [a=[=^life =ring] b=[=^life =ring]]
|
|
(gth life.a life.b)
|
|
|= [=^life =ring]
|
|
[life ring (nol:nu:crub:crypto ring)]
|
|
==
|
|
::
|
|
++ gnaw :: gnaw:am
|
|
~/ %gnaw
|
|
|= [kay=cape ryn=lane pac=rock] :: process packet
|
|
^- [p=(list boon) q=fort]
|
|
=/ kec=(unit cake) (bite pac)
|
|
?~ kec [~ fox]
|
|
?: (goop p.p.u.kec)
|
|
[~ fox]
|
|
?. =(our q.p.u.kec)
|
|
[~ fox]
|
|
=; zap=[p=(list boon) q=fort]
|
|
[(weld p.zap next) q.zap]
|
|
=< zork
|
|
=< zank
|
|
:: ~& [%hear p.p.u.kec ryn `@p`(mug (shaf %flap pac))]
|
|
%- ~(chew la:(ho:um p.p.u.kec) kay ryn %none (shaf %flap pac))
|
|
[q.u.kec r.u.kec]
|
|
::
|
|
++ goop :: blacklist
|
|
|= him=ship
|
|
|
|
|
::
|
|
++ kick :: kick:am
|
|
|= hen=duct :: refresh net
|
|
^- [p=(list boon) q=fort]
|
|
zork:(kick:um hen)
|
|
::
|
|
++ next
|
|
^- (list boon)
|
|
=/ doz=(unit @da) [~ (add now ~s32)]
|
|
=. doz
|
|
|- ^+ doz
|
|
?~ wab.zac.fox doz
|
|
=. doz $(wab.zac.fox l.wab.zac.fox)
|
|
=. doz $(wab.zac.fox r.wab.zac.fox)
|
|
=+ bah=q.n.wab.zac.fox
|
|
(hunt lth doz rtn.sop.bah)
|
|
=/ nex (hunt lth doz tim.fox)
|
|
?: =(tim.fox nex)
|
|
~
|
|
[%pito (need nex)]~
|
|
::
|
|
++ rack :: rack:am
|
|
~/ %rack
|
|
|= [her=ship cha=path cop=coop] :: e2e ack
|
|
=/ oh (ho:um her)
|
|
=^ gud oh (cook:oh cop cha ~)
|
|
?. gud oh
|
|
(cans:oh cha)
|
|
::
|
|
++ wake :: wake:am
|
|
~/ %wake
|
|
|= hen=duct :: harvest packets
|
|
^- [p=(list boon) q=fort]
|
|
=. tim.fox ~
|
|
=/ neb=(list ship) ~(tap in ~(key by wab.zac.fox))
|
|
=| bin=(list boon)
|
|
|- ^- [p=(list boon) q=fort]
|
|
?~ neb
|
|
=^ ban fox (kick hen)
|
|
[:(weld bin p.ban next) fox]
|
|
=/ fro=(list ship) (saxo-scry our)
|
|
=/ hoz (ho:um i.neb)
|
|
=^ bun fox zork:zank:(thaw:hoz fro)
|
|
$(neb t.neb, bin (weld p.bun bin))
|
|
::
|
|
++ wise :: wise:am
|
|
|= [hen=duct her=ship cha=path val=*] :: send a statement
|
|
^- [p=(list boon) q=fort]
|
|
=^ ban fox zork:zank:(wool:(ho:um her) hen cha val)
|
|
[(weld p.ban next) fox]
|
|
::
|
|
++ um :: per server
|
|
=/ gus (~(us go ton.fox) our)
|
|
=/ weg=corn zac.fox
|
|
=| bin=(list boon)
|
|
|%
|
|
++ ho :: ho:um:am
|
|
|= her=ship :: per friend
|
|
=+ diz=(myx:gus her)
|
|
=+ bah=(~(get by wab.weg) her)
|
|
=+ puz=?~(bah ahoy:pu %*(. pu +< sop.u.bah))
|
|
=> .(bah `bath`?~(bah [abet:puz ~ ~] u.bah))
|
|
|%
|
|
++ busk :: busk:ho:um:am
|
|
|= [waz=(list ship) pax=(list rock)] :: send packets
|
|
%_ +>
|
|
bin
|
|
|- ^+ bin
|
|
?~ pax bin
|
|
$(pax t.pax, bin (weld (flop (wist:diz now waz ~ i.pax)) bin))
|
|
==
|
|
::
|
|
++ cans :: cans:ho:um:am
|
|
|= cha=path
|
|
=+ rum=(need (~(get by raz.bah) cha))
|
|
=. rum
|
|
%= rum
|
|
did +(did.rum)
|
|
mis (~(del by mis.rum) did.rum)
|
|
==
|
|
(coat cha rum)
|
|
::
|
|
++ coat :: coat:ho:um:am
|
|
|= [cha=path rum=race] :: update input race
|
|
^+ +>
|
|
=+ cun=(~(get by mis.rum) did.rum)
|
|
?: |(!dod.rum ?=(~ cun))
|
|
::
|
|
:: if we have not yet received the current message,
|
|
:: or if we are not idle, just wait.
|
|
::
|
|
+>.$(raz.bah (~(put by raz.bah) cha rum))
|
|
?. =(%good p.u.cun)
|
|
::
|
|
:: if we are recording a failed message, acknowledge
|
|
:: it now, since it obviously won't be processed.
|
|
::
|
|
~& [%fail-ack did.rum]
|
|
=^ gud +>.$
|
|
(cook ``[%dead-message ~] cha `[q.u.cun r.u.cun])
|
|
?. gud +>.$
|
|
%= +>.$
|
|
raz.bah
|
|
%+ ~(put by raz.bah) cha
|
|
%= rum
|
|
did +(did.rum)
|
|
mis (~(del by mis.rum) did.rum)
|
|
==
|
|
==
|
|
::
|
|
:: the message is good. send it to be processed.
|
|
::
|
|
?> ?=(^ s.u.cun)
|
|
%= +>.$
|
|
raz.bah (~(put by raz.bah) cha rum(dod |))
|
|
bin
|
|
:_ bin
|
|
:^ %milk
|
|
her
|
|
`soap`[[lyf:sen:gus clon:diz] cha did.rum]
|
|
u.s.u.cun
|
|
==
|
|
::
|
|
++ cook :: cook:ho:um:am
|
|
|= [cop=coop cha=path ram=(unit [ryn=lane dam=flap])]
|
|
^- [gud=? con=_+>] :: acknowledgment
|
|
:: ~& [%ames-cook cop cha ram]
|
|
=+ rum=(need (~(get by raz.bah) cha))
|
|
=+ lat=(~(get by mis.rum) did.rum)
|
|
?: &(?=(~ lat) ?=(~ ram))
|
|
~& %ack-late-or-redundant
|
|
[%| +>.$]
|
|
:- %&
|
|
=+ ^- [ryn=lane dam=flap]
|
|
?^ ram [ryn.u.ram dam.u.ram]
|
|
?< ?=(~ lat)
|
|
[q r]:u.lat
|
|
=. raz.bah
|
|
?^ ram raz.bah
|
|
%+ ~(put by raz.bah) cha
|
|
rum(dod &, bum ?~(cop bum.rum (~(put by bum.rum) did.rum u.cop)))
|
|
=/ seg (sein-scry her)
|
|
=^ roc diz (zuul:diz now seg [%back cop dam ~s0])
|
|
=/ fro=(list ship) (saxo-scry our)
|
|
(busk(diz (wast:diz ryn)) (xong fro) roc)
|
|
:: XX move this logic into %zuse, namespaced under %jael?
|
|
::
|
|
++ deng :: deng:ho:um:am
|
|
|= law=(unit deed) :: accept inline deed
|
|
^+ diz
|
|
?: |(=(~ law) =(lew.wod.dur.diz law))
|
|
diz
|
|
~| [%deng-fail her]
|
|
?> ?=(^ law)
|
|
=* wed u.law
|
|
?> ^- ?
|
|
?- (clan:title her)
|
|
%earl
|
|
:: signed by parent
|
|
::
|
|
=/ seg (^sein:title her)
|
|
=/ yig
|
|
?: =(our seg)
|
|
sen:gus
|
|
cluy:(myx:gus seg)
|
|
?& =(lyf.yig life.wed)
|
|
?=(^ oath.wed)
|
|
.= (need (sure:as:cub.yig u.oath.wed))
|
|
(shaf %earl (sham [her life.wed pass.wed]))
|
|
==
|
|
::
|
|
%pawn
|
|
:: self-signed, life 1, address is fingerprint
|
|
::
|
|
=/ cub=acru (com:nu:crub:crypto pass.wed)
|
|
?& =(`@`fig:ex:cub her)
|
|
?=(%1 life.wed)
|
|
?=(^ oath.wed)
|
|
:: XX do we care about this signature at all?
|
|
::
|
|
.= (need (sure:as:cub u.oath.wed))
|
|
(shaf %self (sham [her life.wed pass.wed]))
|
|
==
|
|
::
|
|
*
|
|
:: our sponsor
|
|
::
|
|
?& !?=(%czar (clan:title our))
|
|
=(her (sein-scry our))
|
|
==
|
|
==
|
|
diz(lew.wod.dur law)
|
|
::
|
|
++ done :: done:ho:um:am
|
|
|= [cha=path num=@ud] :: complete outgoing
|
|
^- [(unit duct) _+>]
|
|
:: ~& [%ames-done cha num]
|
|
=+ rol=(need (~(get by ryl.bah) cha))
|
|
=+ rix=(~(get by san.rol) num)
|
|
?~ rix [~ +>.$]
|
|
:- rix
|
|
%_ +>.$
|
|
ryl.bah
|
|
(~(put by ryl.bah) cha rol(san (~(del by san.rol) num)))
|
|
==
|
|
::
|
|
++ la :: la:ho:um:am
|
|
|_ [kay=cape ryn=lane aut=skin dam=flap] :: per packet
|
|
::
|
|
++ chew :: chew:la:ho:um:am
|
|
|= [sin=skin msg=@] :: receive
|
|
^+ +>
|
|
=< abed
|
|
|%
|
|
:: +abed: check that we have the keys to communicate with :her
|
|
::
|
|
++ abed
|
|
^+ +>.$
|
|
:: if we don't have a deed, subscribe for public key updates
|
|
::
|
|
:: XX update state so we only ask once?
|
|
::
|
|
=? +>.$ ?=(~ lew.wod.dur.diz)
|
|
(emit %beer her)
|
|
:: if we don't have a deed, scry for it
|
|
:: (to avoid dropping the packet, if possible).
|
|
::
|
|
=? lew.wod.dur.diz ?=(~ lew.wod.dur.diz)
|
|
=/ life (life-scry her)
|
|
?~(life ~ (deed-scry her u.life))
|
|
:: if we have a deed, proceed
|
|
::
|
|
?^ lew.wod.dur.diz
|
|
apse
|
|
:: if :her is our initial sponsor, proceed (TOFU)
|
|
::
|
|
:: XX TOFU is unnecessary if we include keys
|
|
:: for the full sponsorship chain in the boot event
|
|
::
|
|
?: =(her (sein-scry our))
|
|
apse
|
|
:: if :her is a comet, or a moon of a known ship, proceed
|
|
::
|
|
=/ =rank:title (clan:title her)
|
|
?: ?| ?=(%pawn rank)
|
|
?& ?=(%earl rank)
|
|
!=(~ lew.wod.dur:(myx:gus (sein-scry her)))
|
|
== ==
|
|
apse
|
|
:: otherwise, drop the packet
|
|
::
|
|
+>.$
|
|
:: +apse: process the packet, notify if :her status changed
|
|
::
|
|
++ apse
|
|
^+ +>.$
|
|
=/ oub bust:puz
|
|
=/ neg =(~ yed.caq.dur.diz)
|
|
=. +>.$ east
|
|
=/ eng =(~ yed.caq.dur.diz)
|
|
=/ bou bust:puz
|
|
=? +>.$ &(oub !bou)
|
|
(emit [%wine her " is ok"])
|
|
:: the presence of a symmetric key indicates neighboring
|
|
:: XX use deed instead?
|
|
::
|
|
=? +>.$ &(neg !eng)
|
|
%- emir :~
|
|
[%wine her " is your neighbor"]
|
|
?> ?=(^ lew.wod.dur.diz)
|
|
[%raki her [life pass]:u.lew.wod.dur.diz]
|
|
==
|
|
+>.$
|
|
::
|
|
++ east
|
|
^+ +>.$
|
|
?- sin
|
|
%none
|
|
:: ~& %chew-none
|
|
=. puz (bilk:puz now)
|
|
(chow ;;(meal (cue msg)))
|
|
::
|
|
%fast
|
|
:: ~& %chew-fast
|
|
=+ [mag=`hand`(end 7 1 msg) bod=(rsh 7 1 msg)]
|
|
=/ dey (kuch:diz mag)
|
|
:: ignore unknown key
|
|
::
|
|
?~ dey +>.$
|
|
=. puz (bilk:puz now)
|
|
=^ key diz u.dey
|
|
(chow(aut sin) ;;(meal (cue (dy:cub:sen:gus key bod))))
|
|
::
|
|
%full
|
|
:: ~& %chew-full
|
|
=/ mex ;;(full:pact (cue msg))
|
|
=. diz (deng law.mex)
|
|
=/ wug cluy:diz
|
|
?> =(lyf.wug from.lyf.mex)
|
|
=/ gey (sev:gus to.lyf.mex)
|
|
=/ sem (need (tear:as:q.gey pub:ex:cub.wug txt.mex))
|
|
=/ mes ;;((pair @ @) (cue sem))
|
|
=. diz (wasc:diz p.mes)
|
|
=. puz (bilk:puz now)
|
|
(west(msg q.mes))
|
|
::
|
|
%open
|
|
:: ~& %chew-open
|
|
=/ mex ;;(open:pact (cue msg))
|
|
=. diz (deng law.mex)
|
|
=/ wug cluy:diz
|
|
?> =(lyf.wug from.lyf.mex)
|
|
=/ mes (need (sure:as:cub.wug txt.mex))
|
|
=. puz (bilk:puz now)
|
|
(west(msg mes))
|
|
==
|
|
++ west
|
|
|= ~
|
|
=+ vib=(cue msg)
|
|
=+ mal=(meal vib)
|
|
?. =(mal vib)
|
|
~& [%bad-meal her]
|
|
+>.^$
|
|
(chow(aut sin) mal)
|
|
--
|
|
::
|
|
++ chow :: chow:la:ho:um:am
|
|
|= fud=meal :: interpret meal
|
|
^+ +>
|
|
=. diz ?:(=(%none aut) diz (wast:diz ryn))
|
|
(dine fud)
|
|
::
|
|
++ cock :: cock:la:ho:um:am
|
|
^+ . :: send new ack
|
|
:: ~& [%back kay dam]
|
|
=* cop `coop`?:(=(%good kay) ~ ``[%dead-packet ~])
|
|
=/ seg (sein-scry her)
|
|
=^ pax diz (zuul:diz now seg [%back cop dam ~s0])
|
|
=/ fro=(list ship) (saxo-scry our)
|
|
..cock(+> (busk(diz (wast:diz ryn)) (xong fro) pax))
|
|
::
|
|
++ deer :: deer:la:ho:um:am
|
|
|= [cha=path num=@ud dut=(unit)] :: interpret message
|
|
^+ +>
|
|
=+ rum=(fall (~(get by raz.bah) cha) *race)
|
|
:: ~& [%rx kay cha num [dod.rum did.rum] ?=(~ dut)]
|
|
=* bad (~(has in bad.fox) her)
|
|
=. kay ?.((~(has in bad.fox) her) kay ~&(%blocked %dead))
|
|
%= +>.$
|
|
+>
|
|
?: (lth num did.rum)
|
|
::
|
|
:: this message already acknowledged; repeat old ack,
|
|
:: or negative ack if this ship is blocked
|
|
::
|
|
=* cop ^- coop
|
|
%+ fall
|
|
(~(get by bum.rum) num)
|
|
?:(bad ~ ``[%blocked ~])
|
|
con:(cook (~(get by bum.rum) num) cha `[ryn dam])
|
|
::
|
|
:: insert this message in unprocessed set
|
|
::
|
|
=. mis.rum (~(put by mis.rum) num [kay ryn dam dut])
|
|
::
|
|
:: if ship is blocked, advance pointer to latest message
|
|
::
|
|
=. did.rum ?.(bad did.rum num)
|
|
::
|
|
:: process update
|
|
::
|
|
(coat cha rum)
|
|
==
|
|
::
|
|
++ dine :: dine:la:ho:um:am
|
|
|= fud=meal :: interpret meal
|
|
^+ +>
|
|
?- -.fud
|
|
%back
|
|
=. +> ?.(=(%full aut) +> cock) :: finish handshake
|
|
+>(..la (tock p.fud q.fud r.fud))
|
|
::
|
|
%bond
|
|
:: ~& [%bond p.fud q.fud]
|
|
(deer p.fud q.fud ?-(kay %dead ~, %good [~ r.fud]))
|
|
::
|
|
%carp
|
|
:: =+ zol=(~(get by olz.weg) s.fud)
|
|
:: ?^ zol cock(kay u.zol)
|
|
=^ neb nys.weg
|
|
=+ neb=(~(get by nys.weg) s.fud)
|
|
?^ neb [u.neb nys.weg]
|
|
=+ neb=`bait`[(kins p.fud) 0 r.fud ~]
|
|
[neb (~(put by nys.weg) s.fud neb)]
|
|
?> (lth q.fud p.r.neb)
|
|
?> =((kins p.fud) p.neb)
|
|
?> =(r.fud p.r.neb)
|
|
=+ doy=`(unit @)`(~(get by q.r.neb) q.fud)
|
|
?^ doy cock
|
|
=> ^+ . %= .
|
|
q.r.neb (~(put by q.r.neb) q.fud t.fud)
|
|
q.neb +(q.neb)
|
|
==
|
|
:: ~& [%carp q.fud s.fud q.neb p.r.neb]
|
|
?: =(q.neb p.r.neb)
|
|
=: nys.weg (~(del by nys.weg) s.fud)
|
|
:: olz.weg (~(put by olz.weg) s.fud kay)
|
|
==
|
|
(golf p.neb r.neb)
|
|
=. +>.$ cock
|
|
+>.$(nys.weg (~(put by nys.weg) s.fud neb))
|
|
::
|
|
%fore
|
|
=+ ^= lyn ^- lane
|
|
?~ q.fud ryn
|
|
?. ?=(%if -.u.q.fud) u.q.fud
|
|
[%ix +.u.q.fud]
|
|
:: u.q.fud
|
|
?: =(our p.fud)
|
|
(emit %mead lyn r.fud)
|
|
=/ zid (myx:gus p.fud)
|
|
=/ zon %*(xong ..xong her p.fud)
|
|
=/ fro=(list ship) (saxo-scry our)
|
|
(emir (wist:zid now (zon fro) [~ lyn] r.fud))
|
|
==
|
|
::
|
|
++ emir :: emir:la:ho:um:am
|
|
|= ben=(list boon) :: emit boons
|
|
^+ +>
|
|
?~(ben +> $(ben t.ben, bin [i.ben bin]))
|
|
::
|
|
++ emit :: emit:la:ho:um:am
|
|
|= bun=boon :: emit a boon
|
|
+>(bin [bun bin])
|
|
::
|
|
++ golf :: golf:la:ho:um:am
|
|
|= [sin=skin duv=dove] :: assemble fragments
|
|
^+ +>
|
|
%+ chew sin
|
|
=+ [nix=0 rax=*(list @)]
|
|
|- ^- @
|
|
?: =(p.duv nix)
|
|
(can 13 (turn (flop rax) |=(a=@ [1 a])))
|
|
$(nix +(nix), rax [(need (~(get by q.duv) nix)) rax])
|
|
-- :: --la:ho:um:am
|
|
::
|
|
++ pong :: pong:ho:um:am
|
|
|= hen=duct :: test connection
|
|
^+ +>
|
|
?. ?& =(~ puq.puz)
|
|
?| bust:puz
|
|
?=(~ rue.puz)
|
|
(gth now (add ~s32 u.rue.puz))
|
|
(lth u.rue.puz hop.fox)
|
|
==
|
|
==
|
|
+>.$
|
|
(wool [/a/ping hen] /a/pi ~ |)
|
|
::
|
|
++ thaw :: thaw:ho:um:am
|
|
|= fro=(list ship)
|
|
^+ +> :: wakeup bomb
|
|
=+ oub=bust:puz
|
|
=^ yem puz (wack:puz now)
|
|
=+ bou=bust:puz
|
|
=. bin
|
|
?. &(bou !oub) bin
|
|
:_(bin [%wine her " not responding still trying"])
|
|
=. diz ?:((boom:puz now) (pode:diz now) diz)
|
|
(busk (xong fro) yem)
|
|
::
|
|
++ tock :: tock:ho:um:am
|
|
|= [cop=coop fap=flap cot=@dr] :: e2e ack by hash
|
|
^+ +>
|
|
=^ yoh puz (bick:puz now fap)
|
|
=. +>.$
|
|
?~ p.yoh +>.$
|
|
=^ hud +>.$
|
|
(done p.u.p.yoh q.u.p.yoh)
|
|
?~ hud +>.$
|
|
%= +>.$
|
|
bin
|
|
:_ bin
|
|
`boon`[%cake her [[lyf:sen:gus clon:diz] u.p.yoh] cop u.hud]
|
|
==
|
|
=/ fro=(list ship) (saxo-scry our)
|
|
(busk (xong fro) q.yoh)
|
|
::
|
|
++ wind :: wind:ho:um:am
|
|
|= [gom=soup ham=meal]
|
|
:: ~& [%wind her gom]
|
|
^+ +>
|
|
=/ seg (sein-scry her)
|
|
=^ wyv diz (zuul:diz now seg ham)
|
|
=^ feh puz (whap:puz now gom wyv)
|
|
=/ fro=(list ship) (saxo-scry our)
|
|
(busk (xong fro) feh)
|
|
::
|
|
++ wool :: wool:ho:um:am
|
|
|= [hen=duct cha=path val=*] :: send a statement
|
|
^+ +>
|
|
=/ rol=rill (fall (~(get by ryl.bah) cha) *rill)
|
|
=/ sex=@ud sed.rol
|
|
:: ~& [%tx [our her] cha sex]
|
|
:: if we don't have a public key for :her,
|
|
:: subscribe to %jael for keys and proceed
|
|
::
|
|
:: XX update state so we only ask once?
|
|
::
|
|
=? bin =(~ lew.wod.dur.diz) :_(bin [%beer her])
|
|
:: if we don't have a public key for :her,
|
|
:: scry into %jael for them.
|
|
:: (skin will only be %open if the scry is ~)
|
|
::
|
|
=? lew.wod.dur.diz =(~ lew.wod.dur.diz)
|
|
=/ life (life-scry her)
|
|
?~(life ~ (deed-scry her u.life))
|
|
=. ryl.bah
|
|
%+ ~(put by ryl.bah) cha
|
|
%= rol
|
|
sed +(sed.rol)
|
|
san (~(put by san.rol) sex hen)
|
|
==
|
|
%+ wind [cha sex]
|
|
[%bond cha sex val]
|
|
::
|
|
++ zest :: zest:ho:um:am
|
|
:~ :~ :* [%rtt rtt.sop.bah]
|
|
[%rto rto.sop.bah]
|
|
[%rtn rtn.sop.bah]
|
|
[%rue rue.sop.bah]
|
|
==
|
|
:* [%nus nus.sop.bah]
|
|
[%nif nif.sop.bah]
|
|
[%nep nep.sop.bah]
|
|
[%caw caw.sop.bah]
|
|
[%cag cag.sop.bah]
|
|
==
|
|
=+ qup=~(tap to puq.sop.bah)
|
|
:- %qup
|
|
%+ turn qup
|
|
|= [a=@ud b=soul]
|
|
:* a
|
|
nux.b
|
|
liv.b
|
|
lys.b
|
|
`@p`(mug (shaf %flap pac.b))
|
|
gom.b
|
|
==
|
|
==
|
|
::
|
|
:- %raz
|
|
=+ zar=~(tap by raz.bah)
|
|
%+ turn zar
|
|
|= [a=path b=race]
|
|
:+ a
|
|
did.b
|
|
=+ ciy=~(tap by mis.b)
|
|
%+ turn ciy
|
|
|= [c=@ud d=[p=cape q=lane r=flap s=(unit)]]
|
|
[c p.d r.d]
|
|
::
|
|
[%ryl ~(tap to ryl.bah)]
|
|
[%lun lun.wod.dur.diz]
|
|
[%caq caq.dur.diz]
|
|
[%lew lew.wod.dur.diz]
|
|
==
|
|
::
|
|
++ zank :: zank:ho:um:am
|
|
%= +>.$ :: resolve
|
|
gus (nux:gus diz)
|
|
wab.weg (~(put by wab.weg) her bah(sop abet:puz))
|
|
==
|
|
::
|
|
++ xong :: xong:ho:um:am
|
|
|= fro=(list ship)
|
|
^- (list ship) :: route unto
|
|
=/ too (saxo-scry her)
|
|
=+ ^= oot ^- (list ship)
|
|
=| oot=(list ship)
|
|
|- ^+ oot
|
|
?~ too ~
|
|
?: (lien fro |=(a=ship =(a i.too))) ~
|
|
[i.too $(too t.too)]
|
|
:: ~& [%xong-to [our her] (weld oot ?>(?=(^ fro) t.fro))]
|
|
(weld oot ?>(?=(^ fro) t.fro))
|
|
-- :: --ho:um:am
|
|
::
|
|
++ kick :: kick:um:am
|
|
|= hen=duct :: test connection
|
|
^+ +>
|
|
=/ hoy (tail (saxo-scry our))
|
|
|- ^+ +>.^$
|
|
?~ hoy
|
|
+>.^$
|
|
$(hoy t.hoy, +>.^$ (pong i.hoy hen))
|
|
::
|
|
++ pals :: pals:um:am
|
|
^- (list @p) :: active neighbors
|
|
%+ turn
|
|
%+ skim ~(tap by wab.weg)
|
|
|= [a=ship b=bath]
|
|
!(~(boom pu sop.b) now)
|
|
|=([a=ship b=bath] a)
|
|
::
|
|
++ pong :: pong:um:am
|
|
|= [her=ship hen=duct] :: test neighbor
|
|
^+ +>
|
|
zank:(pong:(ho her) hen)
|
|
::
|
|
++ zork :: zork:um:am
|
|
^- [p=(list boon) q=fort] :: resolve
|
|
:- (flop bin)
|
|
%_ fox
|
|
ton (~(su go ton.fox) gus)
|
|
zac weg
|
|
==
|
|
-- :: --um:am
|
|
-- :: --am
|
|
--
|
|
. ==
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
:: section 4aH, protocol vane ::
|
|
::
|
|
=| $: fox=fort :: kernel state
|
|
== ::
|
|
|= [our=ship now=@da eny=@uvJ ski=sley] :: current invocation
|
|
^? :: opaque core
|
|
=<
|
|
~% %ames-protocol ..is ~
|
|
|% :: vane interface
|
|
++ call :: handle request
|
|
~/ %call
|
|
|= $: hen=duct
|
|
type=*
|
|
wrapped-task=(hobo task:able)
|
|
==
|
|
^- [(list move) _..^$]
|
|
=/ task=task:able
|
|
?. ?=(%soft -.wrapped-task)
|
|
wrapped-task
|
|
;;(task:able p.wrapped-task)
|
|
=. any.ton.fox eny
|
|
=^ duy ..knob (knob hen task)
|
|
[duy ..^$]
|
|
::
|
|
++ load
|
|
|= old=fort
|
|
..^$(fox old)
|
|
::
|
|
++ scry
|
|
|= [fur=(unit (set monk)) ren=@tas why=shop syd=desk lot=coin tyl=path]
|
|
^- (unit (unit cage))
|
|
?. ?=(%& -.why) [~ ~]
|
|
?~ tyl [~ ~]
|
|
=+ hun=(slaw %p i.tyl)
|
|
?~ hun [~ ~]
|
|
?. =(`@`0 ren) ~
|
|
?. ?=([$$ %da @] lot)
|
|
~
|
|
?. =(now q.p.lot) ~
|
|
(temp u.hun [syd t.tyl])
|
|
::
|
|
++ stay fox
|
|
++ take :: accept response
|
|
~/ %take
|
|
|= [tea=wire hen=duct hin=(hypo sign:able)]
|
|
^- [(list move) _..^$]
|
|
=. any.ton.fox eny
|
|
=^ duy ..knap
|
|
(knap tea hen q.hin)
|
|
[duy ..^$]
|
|
--
|
|
~% %ames-impl ..is ~
|
|
|%
|
|
++ clop
|
|
~/ %clop
|
|
|= [now=@da hen=duct bon=boon]
|
|
^- [(list move) fort]
|
|
?- -.bon
|
|
%beer
|
|
=/ =wire /pubs/(scot %p p.bon)
|
|
:_ fox [hen [%pass wire %j %pubs p.bon]]~
|
|
::
|
|
%bock
|
|
:: ignore %turf if we haven't yet learned a unix duct
|
|
::
|
|
:: Only happens during first boot.
|
|
::
|
|
?~ gad.fox
|
|
[~ fox]
|
|
:_ fox
|
|
[gad.fox %give %turf tuf.fox]~
|
|
::
|
|
%brew
|
|
:_ fox [hen [%pass / %j %turf ~]]~
|
|
::
|
|
%cake
|
|
:: ~? ?=(^ r.bon) [%cake-woot-bad hen r.bon]
|
|
:_ fox
|
|
:~ [s.bon %give %woot p.bon r.bon]
|
|
==
|
|
::
|
|
%mead
|
|
=^ moz +>.$ (knob hen [%hear p.bon q.bon])
|
|
[moz fox]
|
|
::
|
|
%milk
|
|
:: ~& [%milk p.bon q.bon]
|
|
?> ?=([@ @ *] q.q.bon)
|
|
?> ?=(?(%a %c %e %g %j) i.q.q.bon)
|
|
=/ =wire [(scot %p our) (scot %p p.bon) q.q.bon]
|
|
:_ fox [hen %pass wire i.q.q.bon %west p.bon t.q.q.bon r.bon]~
|
|
::
|
|
%ouzo
|
|
:: drop packet if we haven't yet learned a unix duct
|
|
::
|
|
:: Only happens during first boot.
|
|
::
|
|
?~ gad.fox
|
|
[~ fox]
|
|
:: ~& [%send now p.bon `@p`(mug (shaf %flap q.bon))]
|
|
:_ fox
|
|
[[gad.fox [%give %send p.bon q.bon]] ~]
|
|
::
|
|
%pito
|
|
:_ fox(tim `p.bon)
|
|
%- flop
|
|
^- (list move)
|
|
:: XX should this be the unix duct (gad.fox)?
|
|
::
|
|
:: It seems far more important that the duct be always
|
|
:: predictable than that it be the unix duct, which
|
|
:: may change, or be unset during first boot.
|
|
::
|
|
:- [gad.fox %pass /ames %b %wait p.bon]
|
|
?~ tim.fox ~
|
|
[gad.fox %pass /ames %b %rest u.tim.fox]~
|
|
::
|
|
%raki
|
|
=* her p.bon
|
|
=/ moz=(list move)
|
|
[hen [%pass / %j %meet her life=q.bon pass=r.bon]]~
|
|
:: poke :dns with an indirect binding if her is a planet we're spnsoring
|
|
::
|
|
=? moz ?& ?=(%duke (clan:title her))
|
|
?=(%king (clan:title our))
|
|
=(our (~(sein-scry am [our now fox ski]) her))
|
|
==
|
|
=/ cmd [%meet her]
|
|
=/ pok [%dns %poke `cage`[%dns-command !>(cmd)]]
|
|
:_ moz [hen [%pass / %g %deal [our our] pok]]
|
|
[moz fox]
|
|
::
|
|
%sake
|
|
=/ =wire /our/(scot %p our)
|
|
:_ fox [hen [%pass wire %j %vein ~]]~
|
|
::
|
|
%wine
|
|
:_ fox
|
|
=+ fom=~(rend co %$ %p p.bon)
|
|
:~ :- hen
|
|
:+ %slip %d
|
|
:+ %flog %text
|
|
;: weld
|
|
"; "
|
|
fom
|
|
q.bon
|
|
==
|
|
==
|
|
==
|
|
::
|
|
++ knap
|
|
~/ %knap
|
|
|= [tea=wire hen=duct sih=sign:able]
|
|
^- [(list move) _+>]
|
|
:: if we got an error from behn, report it to %dill; TODO handle errors
|
|
::
|
|
?: ?=([%wake ^] +.sih)
|
|
=/ =flog:dill [%crud %wake u.error.sih]
|
|
[[hen %slip %d %flog flog]~ +>.$]
|
|
::
|
|
?- +<.sih
|
|
%crud [[[hen [%slip %d %flog +.sih]] ~] +>]
|
|
::
|
|
%mack ?~ +>.sih $(sih [%g %nice ~]) :: XX using old code
|
|
$(sih [%g %mean `[%mack +>+.sih]])
|
|
::
|
|
%pubs
|
|
?. ?=([%pubs @ ~] tea)
|
|
~& [%strange-pubs tea]
|
|
[~ +>]
|
|
=/ her=ship (slav %p i.t.tea)
|
|
=/ gus (~(us go ton.fox) our)
|
|
=/ diz (myx:gus her)
|
|
?: =(0 life.sih)
|
|
:: this should clear lew.wod.dur.diz because it means
|
|
:: we no longer trust that their public key came to
|
|
:: us honestly (becuse of a %jael snapshot restore).
|
|
:: in practice, that crashes in ++cluy:las:as:go, so
|
|
:: we ignore for now.
|
|
~& [%ames-hear-empty-pub her]
|
|
[~ +>.$]
|
|
=/ ded=deed
|
|
[life.sih (~(got by pubs.sih) life.sih) oath=~]
|
|
=. lew.wod.dur.diz `ded
|
|
=. ton.fox (~(su go ton.fox) (nux:gus diz))
|
|
[~ +>.$]
|
|
::
|
|
%unto [~ +>]
|
|
::
|
|
%vein
|
|
?. ?=([%our @ ~] tea)
|
|
~& [%strange-vein tea]
|
|
[~ +>]
|
|
=. fox (~(vein am [our now fox ski]) life.sih vein.sih)
|
|
[~ +>.$]
|
|
::
|
|
%woot [~ +>]
|
|
::
|
|
*
|
|
=+ ^= fuy
|
|
^- [p=(list boon) q=fort]
|
|
?- +<.sih
|
|
::
|
|
:: only handles the non-error %wake case; error case above
|
|
::
|
|
%wake
|
|
(~(wake am [our now fox ski]) hen)
|
|
::
|
|
%turf
|
|
?: =(tuf.fox turf.sih)
|
|
[~ fox]
|
|
=. tuf.fox turf.sih
|
|
[[%bock ~]~ fox]
|
|
::
|
|
?(%mean %nice) :: XX obsolete
|
|
?: ?=([%ye ~] tea)
|
|
[~ fox]
|
|
?> ?=([@ @ @ *] tea)
|
|
=/ her (slav %p i.t.tea)
|
|
=* pax t.t.tea
|
|
=< zork =< zank
|
|
%^ ~(rack am [our now fox ski]) her pax
|
|
:: ~& [%knap-ack ?-(+<.sih %mean `p.+.sih, %nice ~)]
|
|
?-(+<.sih %mean `p.+.sih, %nice ~)
|
|
==
|
|
=> %_(. fox q.fuy)
|
|
=| out=(list move)
|
|
|- ^- [p=(list move) q=_+>.^$]
|
|
?~ p.fuy
|
|
[(flop out) +>.^$]
|
|
=^ toe fox (clop now hen i.p.fuy)
|
|
$(p.fuy t.p.fuy, out (weld (flop toe) out))
|
|
==
|
|
::
|
|
++ knob
|
|
~/ %knob
|
|
|= [hen=duct kyz=task:able]
|
|
^- [(list move) _+>]
|
|
?: ?=(%crud -.kyz)
|
|
[[[hen [%slip %d %flog kyz]] ~] +>]
|
|
?: ?=(%west -.kyz)
|
|
?> ?=([%pi ~] q.kyz)
|
|
:_ +>.$
|
|
[[hen %give %mack ~] ~]
|
|
?: ?=(%wegh -.kyz)
|
|
~& %ames-weighing
|
|
[[hen %give %mass wegh]~ +>]
|
|
=+ ^= fuy
|
|
^- [p=(list boon) q=fort]
|
|
?- -.kyz
|
|
%barn
|
|
=: gad.fox hen
|
|
tuf.fox ~(turf-scry am [our now fox ski])
|
|
==
|
|
[[%bock ~]~ fox]
|
|
::
|
|
%bonk
|
|
:_ fox
|
|
?~ tim.fox
|
|
~& %ames-bonk-e
|
|
~
|
|
[%pito u.tim.fox]~
|
|
::
|
|
%hear
|
|
(~(gnaw am [our now fox ski]) %good p.kyz q.kyz)
|
|
::
|
|
%halo
|
|
(~(gnaw am [our now fox ski]) %dead p.kyz q.kyz)
|
|
::
|
|
%hole
|
|
(~(gnaw am [our now fox ski]) %dead p.kyz q.kyz)
|
|
::
|
|
%init
|
|
:_ fox [[%sake ~] [%brew ~] ~]
|
|
::
|
|
%kick
|
|
=^ ban fox (~(kick am [our now fox(hop p.kyz) ski]) hen)
|
|
:: +next:am called here because +wake calls +kick in a loop
|
|
::
|
|
[(weld p.ban ~(next am [our now fox ski])) fox]
|
|
::
|
|
%nuke
|
|
:- ~
|
|
?: (~(has in bad.fox) p.kyz)
|
|
~& [%unblock p.kyz]
|
|
fox(bad (~(del in bad.fox) p.kyz))
|
|
~& [%block p.kyz]
|
|
fox(bad (~(put in bad.fox) p.kyz))
|
|
::
|
|
%sunk
|
|
=* who p.kyz
|
|
=* lyf q.kyz
|
|
?: =(our who)
|
|
?: (lth lyf p:(head val.ton.fox))
|
|
:: replaying our old sinkage, ignore
|
|
:: XX review
|
|
::
|
|
[~ fox]
|
|
:: XX include some helpful instructions here
|
|
::
|
|
:_ fox
|
|
[%wine who ", you have sunk"]~
|
|
::
|
|
=: hoc.ton.fox (~(del by hoc.ton.fox) who)
|
|
wab.zac.fox (~(del by wab.zac.fox) who)
|
|
==
|
|
[[%wine who " has sunk"]~ fox]
|
|
::
|
|
%vega
|
|
:: re-initialize our cryptosuite B cores
|
|
::
|
|
=/ =wund
|
|
%+ turn
|
|
val.ton.fox
|
|
|= [=life =ring *]
|
|
[life ring (nol:nu:crub:crypto ring)]
|
|
[~ fox(val.ton wund)]
|
|
::
|
|
%wake
|
|
(~(wake am [our now fox ski]) hen)
|
|
::
|
|
%want
|
|
(~(wise am [our now fox ski]) hen p.kyz q.kyz r.kyz)
|
|
==
|
|
=> %_(. fox q.fuy)
|
|
=| out=(list move)
|
|
|- ^- [p=(list move) q=_+>.^$]
|
|
?~ p.fuy
|
|
[(flop out) +>.^$]
|
|
=^ toe fox (clop now hen i.p.fuy)
|
|
$(p.fuy t.p.fuy, out (weld (flop toe) out))
|
|
::
|
|
++ temp
|
|
~/ %temp
|
|
|= [his=ship tyl=path]
|
|
^- (unit (unit cage))
|
|
?: ?=([?(%show %tell) *] tyl)
|
|
?^ t.tyl [~ ~]
|
|
=+ zet=zest:(ho:~(um am [our now fox ski]) his)
|
|
``[%noun ?:(=(%show i.tyl) !>(>zet<) !>(zet))]
|
|
?: ?=([%pals ~] tyl)
|
|
?. =(our his)
|
|
~
|
|
``[%noun !>(pals:~(um am [our now fox ski]))]
|
|
?: ?=([%time ~] tyl)
|
|
?. =(our his)
|
|
~
|
|
``[%noun !>(tim.fox)]
|
|
~
|
|
::
|
|
++ wegh
|
|
^- mass
|
|
:+ %ames %|
|
|
:~ :+ %town %|
|
|
=> ton.fox
|
|
:~ wund+&+val
|
|
deed+&+law
|
|
fast+&+seh
|
|
them+&+hoc
|
|
==
|
|
:+ %corn %|
|
|
=> zac.fox
|
|
:~ incoming+&+nys
|
|
complete+&+olz
|
|
neighbor+&+wab
|
|
==
|
|
dot+&+fox
|
|
==
|
|
--
|