: n>cmd ( n -- addr ) cells >r
    o IF  token-table  ELSE  setup-table  THEN
    $@ r@ u<= !!function!! r> + ;

: cmd@ ( -- u ) buf-state 2@ over + >r p@+ r> over - buf-state 2! 64>n ;

standard:field
-6 cells 0 +field net2o.name
drop

: >net2o-name ( addr -- addr' u )
    net2o.name body> name>string ;
: >net2o-sig ( addr -- addr' u )
    net2o.name 3 cells + $@ ;
: .net2o-num ( off -- )  cell/ '<' emit 0 .r '>' emit space ;

    THEN ;

: send-cmd ( addr u dest -- size ) n64-swap { buf# }
    +send-cmd dest-addr 64@ 64>r set-dest
    cmd( <info> ." send: " outflag .dest-addr dup buf# net2o:see <default> cr )
    max-size^2 1+ 0 DO
	buf# min-size I lshift u<= IF
	    I outflag @ stateless# and IF  send0-xt ?punch-cmds
	    ELSE
		send-reply >r over buf# r@ 2! r> send-xt
	    THEN
	    min-size I lshift  UNLOOP
	    64r> dest-addr 64! EXIT  THEN
    LOOP  64r> dest-addr 64!  true !!commands!! ;

	ELSE  !!nokey!!  THEN
    update-key all-ivs ;
: reply-key ( -- ) crypt( ." Reply key: " tmpkey@ .nnb forth:cr )
    reply-key, ( cookie+request ) time-offset! context ]tmpnest
    push-cmd ;

+net2o: gen-reply ( -- ) \g generate a key request reply
    own-crypt? IF
	['] reply-key IS expect-reply?
	['] send-cX   IS send0-xt
	return-addr return-address $10 move
    THEN ;
+net2o: gen-punch-reply ( -- ) ( obsolete dummy ) ;

\ one-shot packets

+net2o: invite ( $:nick+sig $:pk -- ) \g invite someone
    $> ?keysize search-key 2drop
    $> tmp-crypt? dup invit:pend# and ulit, <invite-result>

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

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

: make-context ( pk u -- )
    ret0 net2o:new-context >o rdrop dest-pk ;

: pk:connect ( code data key u -- )
    connect( [: .time ." Connect to: " dup hex. cr ;] $err )
    make-context
    o to connection  setup!

    +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 )
    >r make-context  r> dest-addrs >stack
    o to connection  setup!
    ['] dests is send0-xt

    +resend-cmd net2o:connect
    +flow-control +resend
    connect( [: .time ." Connected, o=" o hex. cr ;] $err ) ;

Forward renat-all

event: :>renat ( -- )  renat-all ;

    swap .net2o:dispose-addr ;

: insert-host? ( flag o addr u -- flag' o )
    3 pick IF  2drop  EXIT  THEN
    check-host? IF  insert-host  ELSE  2drop false  THEN
    rot or swap ;




in net2o : pklookup? ( pkaddr u -- flag )
    2dup keysize2 safe/string hostc$ $! key2| 2dup pkc over str= to ?myself
    2dup >d#id { id }
    id .dht-host $[]# 0= IF  2dup pk-lookup  2dup >d#id to id  THEN
    2dup make-context
    false id dup .dht-host ['] insert-host? $[]map drop nip nip ;
in net2o : pklookup ( pkaddr u -- )

: rtdelay! ( time -- )
    timeouts @ IF \ don't update rtdelay if there were timeouts
	rtdelay 64@ init-delay# 64<> IF  64drop  EXIT  THEN
    THEN
    recv-tick 64@ 64swap 64-
    rtd( ." rtdelay: " 64dup 64>f .ns cr ) rtdelay 64! ;

User outflag  outflag off

: set-flags ( -- )
    0 outflag !@ outbuf hdrtags c!
    outbuf hdrflags le-uw@ dest-flags le-w! ;

: >send ( addr n -- )
    >r  r@ [ 64bit# qos3# or ]L or outbuf c!  set-flags
    outbuf packet-body min-size r> lshift move ;

forward send-code-packet
: send-cX ( addr n -- ) +sendX2  >send  send-code-packet ;

in net2o : new-context ( -- o )
    context-class new >o timeout( ." new context: " o hex. cr )
    my-key-default to my-key \ set default key
    o contexts !@ next-context !
    o to connection \ current connection
    context-table @ token-table ! \ copy pointer
    init-context# @ context# !  1 init-context# +!
    return-addr return-address $10 move
    ['] no-timeout is timeout-xt ['] .iperr is setip-xt
    ['] noop is punch-done-xt ['] noop is sync-done-xt
    ['] noop is sync-none-xt  ['] noop is ack-xt
    ['] send-cX is send0-xt
    -flow-control
    -1 blocksize !
    1 blockalign !
    config:timeouts# @ to max-timeouts
    end-semas start-semas DO  I 0 pthread_mutex_init drop
    1 pthread-mutexes +LOOP
    64#0 context-ticker 64!@ 64dup 64#0 64<> IF

: >dest ( addr -- ) outbuf destination $10 move ;
: set-dest ( target -- )
    64dup dest-addr 64!  outbuf mapaddr le-64! ;
: set-dest# ( resend# -- )
    n>64 dest-addr 64+!  dest-addr 64@ outbuf mapaddr le-64! ;







#90 Constant EMSGSIZE

: ?msgsize ( ior -- )
    0< IF
	errno EMSGSIZE <> ?ior
	max-size^2 1- to max-size^2  ." pmtu/2" cr
    THEN ;

    THEN   ret-addr >dest packet-to ;

: send-data-packet ( -- ) +sendX
    header( ." send data " outbuf .header )
    data-map  outbuf-encrypt
    ret-addr >dest packet-to ;





: bandwidth+ ( -- )
    ns/burst 64@ 1 tick-init 1+ 64*/ bandwidth-tick 64+! ;

: burst-end ( flag -- flag )
    ticker 64@ bandwidth-tick 64@ 64max next-tick 64! drop false ;



\ !!FIXME!! use ffz>, branchless with floating point

: 64ffz< ( 64b -- u / -1 )
    \G find first zero from the right, u is bit position
    64 0 DO
	64dup 64>n 1 and 0= IF  64drop I unloop  EXIT  THEN
	64-2/

Forward new-addr

: send-punch ( addr u -- addr u )
    check-addr1 0= IF  2drop  EXIT  THEN
    temp-addr ret-addr $10 move
    insert-address ret-addr ins-dest
    nat( ticks .ticks ."  send punch to: " ret-addr .addr-path cr )
    outflag @ >r  2dup send-cX  r> outflag ! ;

in net2o : punch ( addr u o:connection -- )
    o IF
	new-addr punch-addrs >stack
    ELSE  2drop  THEN ;

: punch-wrap ( xt -- )

: 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
    outflag off ;

\ send chunk

\ branchless version using floating point

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