in net2o : new-addr ( -- o )
    address-class new >o  address-table @ token-table ! o o> ;
in net2o : dispose-addr ( o:addr -- o:addr )
    host:id $free host:anchor $free host:route $free  host:revoke $free
    host:key sec-free  host:ekey sec-free
    dispose ;
in net2o : dispose-addrs ( addr -- )
    dup >r [: .net2o:dispose-addr ;] $[]o-map
    r> $free ;
:noname ( -- )
    dest-addrs  net2o:dispose-addrs
    punch-addrs net2o:dispose-addrs
    defers extra-dispose ; is extra-dispose

: new-addr ( addr u -- o ) \G create a new address object from string
    net2o:new-addr n:>o nest-cmd-loop o n:o> ;

also net2o-base
: o-genaddr ( o -- ) >o \G create new address string from object
    host:pri# @ ulit, addr-pri#

enum pend#
enum qr#
drop
}scope

cmd-class class
    \ callbacks
    defer: send0-xt      \ send out a stateless packet
    defer: timeout-xt    \ callback for timeout
    defer: setip-xt      \ callback for set-ip
    defer: ack-xt        \ callback for acknowledge
    defer: punch-done-xt \ callback for NAT traversal ok
    defer: sync-done-xt  \ callback for sync done
    defer: sync-none-xt  \ callback for sync not needed
    \ maps for data and code transfer
    0 +field start-maps
    value: code-map
    value: code-rmap
    value: data-map
    value: data-rmap
    0 +field end-maps
    \ strings
    0 +field start-strings
    field: resend0
    field: data-resend
    field: pubkey        \ other side official pubkey

    field: rqd-xts       \ callbacks for request done (array)
    field: my-error-id
    field: beacon-hash
    0 +field end-strings
    field: dest-addrs    \ list of destinations
    field: punch-addrs   \ list of punch destinations
    field: request-gen   \ pre-generated request number
    field: perm-mask
    \ secrets
    0 +field start-secrets
    field: crypto-key
    field: dest-0key     \ key for stateless connections
    0 +field end-secrets

# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.

# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

AC_INIT([net2o], [0.9.1-20191010], [bernd@net2o.de], [net2o], [https://fossil.net2o.de/net2o/reportlist])
AC_PREREQ([2.59])
AC_CONFIG_MACRO_DIR([m4])
AC_USE_SYSTEM_EXTENSIONS
LT_INIT

AC_MSG_CHECKING([for gforth])

\ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
\ GNU Affero General Public License for more details.

\ You should have received a copy of the GNU Affero General Public License
\ along with this program.  If not, see <http://www.gnu.org/licenses/>.

Forward >invitations
in net2o Forward dispose-addrs
Forward mynick$
Forward invite-me
Forward qr-invite-me
Defer <invite-result>

scope{ net2o-base
\ nat traversal functions

    ELSE  64drop
	<err> ." cookie: no owncrypt, un-cmd" <default> forth:cr
    THEN
    un-cmd ;
+net2o: punch-load, ( $:string -- ) \g use for punch payload: nest it
    $> $, nest  o IF
	nat( ." punch from: " return-address .addr-path forth:cr )
	['] punchs code-reply is send-xt
	punch-addrs net2o:dispose-addrs \ first punch load: empty addresses
    THEN ;
+net2o: punch ( $:string -- ) \g punch NAT traversal hole
    $> nat( ." punch to: " 2dup .addr$ forth:cr ) net2o:punch ;
+net2o: punch-done ( -- ) \g punch received
    o 0<> own-crypt? and IF
	o-beacon ret+beacon
	nat( ticks .ticks ."  punch done: " return-address .addr-path forth:cr )
    ELSE

#!/bin/bash

echo "This script builds net2o from scratch"

GFORTH=gforth-0.7.9_20191010

if [ "$(uname -o)" = "Cygwin" ]
then
    CONFOPT="--prefix=/usr $*"
else
    CONFOPT="$*"
fi

    lastaddr# 0<> to online?
    ind-addr off  !0key ;

: dhtroot-off ( --- )
    dhtroot-addr$ $off
    dhtroot-addr @ ?dup-IF  net2o:dispose-addr  THEN ;








: pk:connect ( code data key u -- )
    connect( [: .time ." Connect to: " dup hex. cr ;] $err )
    net2o:new-context >o rdrop o to connection  setup!
    dest-pk \ set our destination key
    +resend-cmd net2o:connect
    +flow-control +resend
    connect( [: .time ." Connected, o=" o hex. cr ;] $err ) ;

: pk-addr:connect ( code data key u addr -- )
    connect( [: .time ." Connect to: " dup hex. cr ;] $err )
    net2o:new-context >o rdrop o to connection  setup!
    ['] dests is send0-xt  dest-addrs >stack
    dest-pk \ set our destination key
    +resend-cmd net2o:connect
    +flow-control +resend
    connect( [: .time ." Connected, o=" o hex. cr ;] $err ) ;

Forward renat-all

event: :>renat ( -- )  renat-all ;
event: :>disconnect ( addr -- )  .disconnect-me ;
: dht-beacon ( addr u -- )
    <event :>renat main-up@ event> 2drop ;

: +dht-beacon ( -- )
    beacons# @ 0= IF  ret-addr be@ ['] dht-beacon 0 .add-beacon  THEN ;

: dht-connect ( -- )
    dht-connection ?dup-IF  >o o to connection rdrop  EXIT  THEN
    tick-adjust 64@ 64-0= IF  +get-time  THEN
    $8 $8 dhtnick $@ nick>pk dhtroot
    online? IF
	+dht-beacon
	dhtroot-addr@ pk-addr:connect  o to dht-connection
    ELSE  2drop 2drop  THEN ;
: dht-disconnect ( -- )
    0 addr dht-connection !@ ?dup-IF
	>o o to connection disconnect-me 0 to connection o>  THEN ;

Variable announced
: subme ( -- )  announced @ IF

	new-addr punch-addrs >stack
    ELSE  2drop  THEN ;

: punch-wrap ( xt -- )
    return-address { ret[ $10 ] }  catch
    ret[ return-address $10 move  throw ;

: addrs-loop ( addrs xt -- )
    [{: addrs xt :}l addrs $@ bounds ?DO
	    I @ xt addr>sock
	cell +LOOP ;] punch-wrap ;

: pings ( o:connection -- )
    \G ping all addresses (why except the first one?)
    punch-addrs ['] ping-addr1 addrs-loop ;

: punchs ( addr u o:connection -- )
    \G send a reply to all addresses
    punch-addrs ['] send-punch addrs-loop 2drop ;

: dests ( addr u o:connection -- )
    \G send a reply to all addresses
    dest-addrs ['] send-punch addrs-loop 2drop ;

\ send chunk

\ branchless version using floating point

: send-size ( u -- n )
    min-size umax maxdata umin 1-

# Commands #

Version 0.9.1-20191010.

net2o separates data and commands.  Data is passed through to higher
layers, commands are interpreted when they arrive.  For connection
requests, a special bit is set, and the address then isn't used as
address, but as IV for the opportunistic encoding.

The command interpreter is a stack machine with two data types: 64