backup temp

Author: hzane

channel.go

@@ -1,51 +1,154 @@
 package enet
 
 const channel_wnd_size = 256
-const enet_channel_id_none uint8 = 0xff
 
+type enet_channel_item struct {
+	header   enet_packet_header
+	fragment enet_packet_fragment // if header.cmd == enet_packet_fragment
+	payload  []uint8              // not include packet-header
+	retries  int                  // sent times for outgoing packet, acked times for incoming packet
+	acked    int                  // acked times
+	retrans  *enet_timer_item     // retrans timer
+}
+
+// outgoing: ->end ..untransfered.. next ..transfered.. begin ->
+// incoming: <-begin ..acked.. next ..unacked.. end<-
 type enet_channel struct {
-	_out_sn      uint16
-	_out_usn     uint16
-	expected_sn  uint16
-	expected_usn uint16
-	wnd          [channel_wnd_size]uint16
-	wnd_used     int
-	last_acked   uint16
-	last_intrans uint16
+	next_sn        uint32 // next reliable packet number for sent
+	next_usn       uint32 // next unsequenced packet number for sent
+	outgoing       [channel_wnd_size]*enet_channel_item
+	outgoing_used  uint32 // in trans packets not acked
+	outgoing_begin uint32 // the first one is not acked yet
+	outgoing_end   uint32 // the last one is not acked yet
+	outgoing_next  uint32 // the next one would be transfered
+	incoming       [channel_wnd_size]*enet_channel_item
+	incoming_used  uint32 // rcvd packet count in incoming window
+	incoming_begin uint32 // the first one has be received
+	incoming_end   uint32 // the last one has been received
+	//	incoming_next  uint32 // the next one will be acked
 }
 
-func (ch enet_channel) wnd_is_full() bool {
-	return ch.wnd_used >= channel_wnd_size
+func (ch *enet_channel) outgoing_trans(item *enet_channel_item) {
+	idx := item.header.sn % channel_wnd_size
+	v := ch.outgoing[idx]
+	assert(v == nil && item.header.sn == ch.outgoing_end)
+	ch.outgoing[idx] = item
+	if ch.outgoing_end <= item.header.sn {
+		ch.outgoing_end = item.header.sn + 1
+	}
+	item.retries++
+	ch.outgoing_used++
 }
 
-func (ch *enet_channel) wnd_put_in(sn uint16) {
+func (ch *enet_channel) outgoing_ack(sn uint32) {
+	if sn < ch.outgoing_begin || sn >= ch.outgoing_end { // already acked or error
+		return
+	}
 	idx := sn % channel_wnd_size
-	v := ch.wnd[idx]
-	if v == 0 {
-		ch.wnd_used++
-		ch.last_intrans = sn
+	v := ch.outgoing[idx]
+	assert(v != nil && v.header.sn == sn)
+
+	v.acked++
+}
+
+func (ch *enet_channel) outgoing_do_trans() (item *enet_channel_item) {
+	assert(ch.outgoing_next <= ch.outgoing_end)
+	if ch.outgoing_next >= ch.outgoing_end {
+		return
 	}
-	ch.wnd[idx]++
+	idx := ch.outgoing_next % channel_wnd_size
+	item = ch.outgoing[idx]
+	assert(item != nil)
+	ch.outgoing_next++
+	return
 }
 
-func (ch *enet_channel) wnd_pop_out(sn uint16) {
-	idx := sn % channel_wnd_size
-	v := ch.wnd[idx]
-	if v <= 0 {
+// may be retransed packet
+func (ch *enet_channel) incoming_trans(item *enet_channel_item) {
+	if item.header.sn < ch.incoming_begin {
+		return
+	}
+	idx := item.header.sn % channel_wnd_size
+	v := ch.incoming[idx]
+	// duplicated packet
+	if v != nil {
 		return
 	}
-	ch.wnd_used--
-	ch.wnd[idx] = 0
-	ch.last_acked = sn
+	assert(v == nil || v.header.sn == item.header.sn)
+
+	ch.incoming[idx] = item
+	ch.incoming_used++
+	if ch.incoming_end <= item.header.sn {
+		ch.incoming_end = item.header.sn + 1
+	}
 }
-func (ch *enet_channel) out_sn() uint16 {
-	v := ch._out_sn
-	ch._out_sn++
-	return v
+
+// when do ack incoming packets
+func (ch *enet_channel) incoming_ack(sn uint32) {
+	if sn < ch.incoming_begin || sn >= ch.incoming_end { // reack packet not in wnd
+		return
+	}
+	idx := sn % channel_wnd_size
+	v := ch.incoming[idx]
+	assert(v != nil && v.header.sn == sn)
+	v.acked++
+}
+
+// called after incoming-ack
+func (ch *enet_channel) incoming_slide() (item *enet_channel_item) { // return value may be ignored
+	if ch.incoming_begin >= ch.incoming_end {
+		return
+	}
+	idx := ch.incoming_begin % channel_wnd_size
+	v := ch.incoming[idx]
+	if v == nil || v.acked <= 0 { // not received yet
+		return
+	}
+	assert(v.header.sn == ch.incoming_begin)
+
+	if v.header.cmd == enet_packet_type_fragment {
+		all := true
+		for i := uint32(1); i < v.fragment.count; i++ {
+			n := ch.incoming[idx+i]
+			if n == nil || n.header.sn != v.header.sn+i || n.fragment.sn != v.header.sn {
+				all = false
+				break
+			}
+		}
+		if !all {
+			return
+		}
+
+		item = v
+		ch.incoming_begin += v.fragment.count
+		ch.incoming_used -= v.fragment.count
+		for i := uint32(1); i < v.fragment.count; i++ {
+			item.payload = append(item.payload, ch.incoming[idx+1].payload...)
+			ch.incoming[idx+i] = nil
+		}
+		ch.incoming[idx] = nil
+
+		return
+	}
+	item = v
+	ch.incoming_begin++
+	ch.incoming_used--
+	ch.incoming[idx] = nil
+	return
 }
 
-func (ch *enet_channel) out_usn() uint16 {
-	v := ch._out_usn
-	ch._out_usn++
-	return v
+func (ch enet_channel) is_outgoing_full() bool {
+	return ch.outgoing_end-ch.outgoing_begin >= channel_wnd_size
+}
+func (ch enet_channel) is_incoming_full() bool {
+	return ch.incoming_end-ch.incoming_begin >= channel_wnd_size
+}
+func (ch enet_channel) is_outgoing_null() bool {
+	return ch.outgoing_end <= ch.outgoing_begin
+}
+func (ch enet_channel) is_incoming_null() bool {
+	return ch.incoming_end <= ch.incoming_begin
+}
+func (ch enet_channel) outgoing_intrans() int {
+	return int(ch.outgoing_next - ch.outgoing_begin)
 }

command.go

@@ -1,62 +1,76 @@
 package enet
 
-import "net"
-
-const (
-	enet_cmd_none uint8 = iota
-	enet_cmd_ack
-	enet_cmd_syn      // with ack flag, connect
-	enet_cmd_synack   //
-	enet_cmd_fin      // ack when under connected or disconnect-later state, else use unseq
-	enet_cmd_ping     // ack
-	enet_cmd_reliable // ack
-	enet_cmd_unreliable
-	enet_cmd_fragment       // ack
-	enet_cmd_unsequenced    // +unseq flag
-	enet_cmd_bandwidthlimit // ack flag
-	enet_cmd_throttle       // ack flag
-	enet_cmd_unreliable_fragment
-	enet_cmds_count
-)
-const (
-	enet_cmd_mask       uint8 = 0x0f
-	enet_cmd_flag_ack         = 1 << 7
-	enet_cmd_flag_unseq       = 1 << 6
-)
-
-const (
-	enet_peerid_flag_compressed uint16 = 1 << 14
-	enet_peerid_flag_time              = 1 << 15
-	enet_peerid_session_mask           = 3 << 12
-	enet_peerid_session_shift          = 12
-	enet_peerid_mask                   = 0x0fff
-)
-
-const (
-	enet_wnd_size_min          uint32 = 4096
-	enet_wnd_size_max                 = 65536
-	enet_wnd_size_default             = 65536
-	enet_mtu_min                      = 576
-	enet_mtu_max                      = 4096
-	enet_mtu_default                  = 1400
-	enet_channel_count_min            = 1
-	enet_channel_count_max            = 255
-	enet_channel_count_default        = 16
-)
-const (
-	enet_wnd_count                 uint16 = 64
-	enet_rtt_default               int64  = 500
-	enet_throttle_default          uint32 = 32
-	enet_throttle_scale                   = 32
-	enet_throttle_acce_default            = 2
-	enet_throttle_dece_default            = 2
-	enet_throttle_interval_default        = 5000
-)
-
-const (
-	enet_timeout_limit int64 = 32
-	enet_timeout_min         = 5000
-	enet_timeout_max         = 30000
-)
-
-type enet_address *net.UDPAddr
+/*
+udp_header | protocol_header | crc32_header? | ( packet_header | payload )+
+*/
+type enet_protocol_header struct {
+	peerid   uint16 // target peerid, not used
+	flags    uint8  // 0xcc if crc or 0
+	packet_n uint8
+	time     uint32 // milli-second, sent-time
+	clientid uint32 // client-id?
+}
+type enet_crc32_header struct {
+	crc32 uint32
+}
+type enet_packet_header struct {
+	cmd    uint8
+	flags  uint8 // _needack, _forcefin_
+	chanid uint8
+	rsv    uint8
+	size   uint32 // including packet_header
+	sn     uint32
+}
+
+//cmd_type_ack = 1
+// flags must be zero
+type enet_packet_ack struct {
+	sn uint32 // rcvd-sn // not the next sn
+	tm uint32 // rcvd sent time
+}
+
+//cmd_type_syn = 2
+// flags = enet_packet_needack
+type enet_packet_syn struct { // ack by conack
+	peerid            uint16 // zero, whose id write the packet
+	mtu               uint16 // default = 1200
+	wnd_size          uint32 // local recv window size, 0x8000
+	channel_n         uint32 // channels count, default = 2
+	rcv_bandwidth     uint32 // local receiving bandwith bps, 0 means no limit
+	snd_bandwidth     uint32 // local sending bandwidth , 0 means no limit
+	throttle_interval uint32 // = 0x1388 = 5000ms
+	throttle_acce     uint32 // = 2
+	throttle_dece     uint32 // = 2
+}
+
+//cmd_type_synack = 3
+// flags = enet_packet_needack
+type enet_packet_synack enet_packet_syn
+
+//cmd_type_fin = 4
+// flags = enet_packet_flags_forcefin_ if disconnect unconnected peer
+type enet_packet_fin struct{}
+
+// cmd_type = 5
+type enet_packet_ping struct{}
+
+//cmd_type_reliable = 6
+// flags= enet_packet_header_flags_needack
+type enet_packet_reliable struct{}
+
+//cmd_type_unreliable = 7
+// flags = enet_packet_header_flags_none
+type enet_packet_unreliable struct {
+	usn uint32 // unreliable sequence number
+}
+
+//cmd_type_fragment = 8
+// [offset, length) of the packet sn
+// packet was splitted into fragment_count parts
+type enet_packet_fragment struct {
+	sn     uint32 // start sequence number
+	count  uint32 // fragment counts
+	index  uint32 // index of current fragment
+	length uint32 // total length of all fragments
+	offset uint32
+}

enet.go

@@ -0,0 +1,21 @@
+package enet
+
+import (
+	"os"
+)
+
+type PeerEventHandler func(Peer, ret int)
+type DataEventHandler func(Peer, chanid uint8, payload []uint8)
+
+type Host interface {
+	SetConnectionHandler(PeerEventHandler)
+	SetDisconnectionHandler(PeerEventHandler)
+	SetDataHandler(DataEventHandler)
+	Connect(dest string)
+	Run(chan os.Signal)
+}
+
+type Peer interface {
+	Disconnect()
+	Write(chanid uint8, dat []byte)
+}