mirror of
https://github.com/KusakabeShi/EtherGuard-VPN.git
synced 2025-02-23 02:30:46 +01:00
shrink header to inc MTU to 1416
This commit is contained in:
KusakabeSi
parent
72e4ebc91d
commit
29b53884ba
@ -37,11 +37,18 @@ type SuperConfig struct {
|
||||
ListenPort int
|
||||
LogLevel LoggerInfo
|
||||
RePushConfigInterval float64
|
||||
StatePassword string
|
||||
Passwords Passwords
|
||||
GraphRecalculateSetting GraphRecalculateSetting
|
||||
EdgeTemplate string
|
||||
Peers []SuperPeerInfo
|
||||
}
|
||||
|
||||
type Passwords struct {
|
||||
ShowState string
|
||||
AddPeer string
|
||||
DelPeer string
|
||||
}
|
||||
|
||||
type InterfaceConf struct {
|
||||
Itype string
|
||||
Name string
|
||||
|
||||
@ -11,6 +11,7 @@ import (
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/KusakabeSi/EtherGuardVPN/path"
|
||||
"golang.org/x/crypto/blake2s"
|
||||
"golang.org/x/crypto/chacha20poly1305"
|
||||
)
|
||||
@ -154,7 +155,7 @@ func (st *CookieChecker) CreateReply(
|
||||
smac1 := smac2 - blake2s.Size128
|
||||
|
||||
reply := new(MessageCookieReply)
|
||||
reply.Type = MessageCookieReplyType
|
||||
reply.Type = path.MessageCookieReplyType
|
||||
reply.Receiver = recv
|
||||
|
||||
_, err := rand.Read(reply.Nonce[:])
|
||||
|
||||
@ -6,6 +6,7 @@
|
||||
package device
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"runtime"
|
||||
@ -392,7 +393,7 @@ func (device *Device) LookupPeerIDAtConfig(pk NoisePublicKey) (ID config.Vertex,
|
||||
return 0, errors.New("Superconfig is nil")
|
||||
}
|
||||
peerlist = device.SuperConfig.Peers
|
||||
pkstr := PubKey2Str(pk)
|
||||
pkstr := pk.ToString()
|
||||
for _, peerinfo := range peerlist {
|
||||
if peerinfo.PubKey == pkstr {
|
||||
return peerinfo.NodeID, nil
|
||||
@ -404,7 +405,7 @@ func (device *Device) LookupPeerIDAtConfig(pk NoisePublicKey) (ID config.Vertex,
|
||||
return 0, errors.New("EdgeConfig is nil")
|
||||
}
|
||||
peerlist = device.EdgeConfig.Peers
|
||||
pkstr := PubKey2Str(pk)
|
||||
pkstr := pk.ToString()
|
||||
for _, peerinfo := range peerlist {
|
||||
if peerinfo.PubKey == pkstr {
|
||||
return peerinfo.NodeID, nil
|
||||
@ -429,34 +430,51 @@ func (device *Device) LookupPeerByStr(pks string) *Peer {
|
||||
return device.LookupPeer(pk)
|
||||
}
|
||||
|
||||
func PubKey2Str(pk NoisePublicKey) (result string) {
|
||||
result = string(base64.StdEncoding.EncodeToString(pk[:]))
|
||||
return
|
||||
func (pk *NoisePublicKey) ToString() string {
|
||||
if bytes.Equal(pk[:], make([]byte, len(pk))) {
|
||||
return ""
|
||||
}
|
||||
return string(base64.StdEncoding.EncodeToString(pk[:]))
|
||||
}
|
||||
|
||||
func PriKey2Str(pk NoisePrivateKey) (result string) {
|
||||
result = string(base64.StdEncoding.EncodeToString(pk[:]))
|
||||
return
|
||||
func (pk *NoisePrivateKey) ToString() (result string) {
|
||||
if bytes.Equal(pk[:], make([]byte, len(pk))) {
|
||||
return ""
|
||||
}
|
||||
return string(base64.StdEncoding.EncodeToString(pk[:]))
|
||||
}
|
||||
func PSKeyStr(pk NoisePresharedKey) (result string) {
|
||||
result = string(base64.StdEncoding.EncodeToString(pk[:]))
|
||||
return
|
||||
func (pk *NoisePresharedKey) ToString() (result string) {
|
||||
if bytes.Equal(pk[:], make([]byte, len(pk))) {
|
||||
return ""
|
||||
}
|
||||
return string(base64.StdEncoding.EncodeToString(pk[:]))
|
||||
}
|
||||
|
||||
func Str2PubKey(k string) (pk NoisePublicKey) {
|
||||
sk_slice, _ := base64.StdEncoding.DecodeString(k)
|
||||
func Str2PubKey(k string) (pk NoisePublicKey, err error) {
|
||||
if k == "" {
|
||||
err = errors.New("Empty public key string")
|
||||
return
|
||||
}
|
||||
sk_slice, err := base64.StdEncoding.DecodeString(k)
|
||||
copy(pk[:], sk_slice)
|
||||
return
|
||||
}
|
||||
|
||||
func Str2PriKey(k string) (pk NoisePrivateKey) {
|
||||
sk_slice, _ := base64.StdEncoding.DecodeString(k)
|
||||
func Str2PriKey(k string) (pk NoisePrivateKey, err error) {
|
||||
if k == "" {
|
||||
err = errors.New("Empty private key string")
|
||||
return
|
||||
}
|
||||
sk_slice, err := base64.StdEncoding.DecodeString(k)
|
||||
copy(pk[:], sk_slice)
|
||||
return
|
||||
}
|
||||
|
||||
func Str2PSKey(k string) (pk NoisePresharedKey) {
|
||||
sk_slice, _ := base64.StdEncoding.DecodeString(k)
|
||||
func Str2PSKey(k string) (pk NoisePresharedKey, err error) {
|
||||
if k == "" {
|
||||
return
|
||||
}
|
||||
sk_slice, err := base64.StdEncoding.DecodeString(k)
|
||||
copy(pk[:], sk_slice)
|
||||
return
|
||||
}
|
||||
|
||||
@ -15,6 +15,7 @@ import (
|
||||
"golang.org/x/crypto/chacha20poly1305"
|
||||
"golang.org/x/crypto/poly1305"
|
||||
|
||||
"github.com/KusakabeSi/EtherGuardVPN/path"
|
||||
"github.com/KusakabeSi/EtherGuardVPN/tai64n"
|
||||
)
|
||||
|
||||
@ -53,26 +54,19 @@ const (
|
||||
)
|
||||
|
||||
const (
|
||||
MessageInitiationType = 1
|
||||
MessageResponseType = 2
|
||||
MessageCookieReplyType = 3
|
||||
MessageTransportType = 4
|
||||
)
|
||||
|
||||
const (
|
||||
MessageInitiationSize = 148 // size of handshake initiation message
|
||||
MessageResponseSize = 92 // size of response message
|
||||
MessageCookieReplySize = 64 // size of cookie reply message
|
||||
MessageTransportHeaderSize = 16 // size of data preceding content in transport message
|
||||
MessageInitiationSize = 145 // size of handshake initiation message
|
||||
MessageResponseSize = 89 // size of response message
|
||||
MessageCookieReplySize = 61 // size of cookie reply message
|
||||
MessageTransportHeaderSize = 13 // size of data preceding content in transport message
|
||||
MessageTransportSize = MessageTransportHeaderSize + poly1305.TagSize // size of empty transport
|
||||
MessageKeepaliveSize = MessageTransportSize // size of keepalive
|
||||
MessageHandshakeSize = MessageInitiationSize // size of largest handshake related message
|
||||
)
|
||||
|
||||
const (
|
||||
MessageTransportOffsetReceiver = 4
|
||||
MessageTransportOffsetCounter = 8
|
||||
MessageTransportOffsetContent = 16
|
||||
MessageTransportOffsetReceiver = 1
|
||||
MessageTransportOffsetCounter = 5
|
||||
MessageTransportOffsetContent = 13
|
||||
)
|
||||
|
||||
/* Type is an 8-bit field, followed by 3 nul bytes,
|
||||
@ -82,7 +76,7 @@ const (
|
||||
*/
|
||||
|
||||
type MessageInitiation struct {
|
||||
Type uint32
|
||||
Type path.Usage
|
||||
Sender uint32
|
||||
Ephemeral NoisePublicKey
|
||||
Static [NoisePublicKeySize + poly1305.TagSize]byte
|
||||
@ -92,7 +86,7 @@ type MessageInitiation struct {
|
||||
}
|
||||
|
||||
type MessageResponse struct {
|
||||
Type uint32
|
||||
Type path.Usage
|
||||
Sender uint32
|
||||
Receiver uint32
|
||||
Ephemeral NoisePublicKey
|
||||
@ -102,14 +96,14 @@ type MessageResponse struct {
|
||||
}
|
||||
|
||||
type MessageTransport struct {
|
||||
Type uint32
|
||||
Type path.Usage
|
||||
Receiver uint32
|
||||
Counter uint64
|
||||
Content []byte
|
||||
}
|
||||
|
||||
type MessageCookieReply struct {
|
||||
Type uint32
|
||||
Type path.Usage
|
||||
Receiver uint32
|
||||
Nonce [chacha20poly1305.NonceSizeX]byte
|
||||
Cookie [blake2s.Size128 + poly1305.TagSize]byte
|
||||
@ -196,7 +190,7 @@ func (device *Device) CreateMessageInitiation(peer *Peer) (*MessageInitiation, e
|
||||
handshake.mixHash(handshake.remoteStatic[:])
|
||||
|
||||
msg := MessageInitiation{
|
||||
Type: MessageInitiationType,
|
||||
Type: path.MessageInitiationType,
|
||||
Ephemeral: handshake.localEphemeral.publicKey(),
|
||||
}
|
||||
|
||||
@ -252,7 +246,7 @@ func (device *Device) ConsumeMessageInitiation(msg *MessageInitiation) *Peer {
|
||||
chainKey [blake2s.Size]byte
|
||||
)
|
||||
|
||||
if msg.Type != MessageInitiationType {
|
||||
if msg.Type != path.MessageInitiationType {
|
||||
return nil
|
||||
}
|
||||
|
||||
@ -370,7 +364,7 @@ func (device *Device) CreateMessageResponse(peer *Peer) (*MessageResponse, error
|
||||
}
|
||||
|
||||
var msg MessageResponse
|
||||
msg.Type = MessageResponseType
|
||||
msg.Type = path.MessageResponseType
|
||||
msg.Sender = handshake.localIndex
|
||||
msg.Receiver = handshake.remoteIndex
|
||||
|
||||
@ -418,7 +412,7 @@ func (device *Device) CreateMessageResponse(peer *Peer) (*MessageResponse, error
|
||||
}
|
||||
|
||||
func (device *Device) ConsumeMessageResponse(msg *MessageResponse) *Peer {
|
||||
if msg.Type != MessageResponseType {
|
||||
if msg.Type != path.MessageResponseType {
|
||||
return nil
|
||||
}
|
||||
|
||||
|
||||
@ -8,7 +8,6 @@ package device
|
||||
import (
|
||||
"bytes"
|
||||
"container/list"
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
@ -18,6 +17,7 @@ import (
|
||||
|
||||
"github.com/KusakabeSi/EtherGuardVPN/config"
|
||||
"github.com/KusakabeSi/EtherGuardVPN/conn"
|
||||
orderedmap "github.com/KusakabeSi/EtherGuardVPN/orderdmap"
|
||||
"gopkg.in/yaml.v2"
|
||||
)
|
||||
|
||||
@ -28,7 +28,7 @@ type Peer struct {
|
||||
handshake Handshake
|
||||
device *Device
|
||||
endpoint conn.Endpoint
|
||||
endpoint_trylist sync.Map //map[string]time.Time
|
||||
endpoint_trylist orderedmap.OrderedMap //map[string]time.Time
|
||||
LastPingReceived time.Time
|
||||
stopping sync.WaitGroup // routines pending stop
|
||||
|
||||
@ -95,7 +95,7 @@ func (device *Device) NewPeer(pk NoisePublicKey, id config.Vertex) (*Peer, error
|
||||
|
||||
// create peer
|
||||
if device.LogLevel.LogControl {
|
||||
fmt.Println("Control: Create peer with ID : " + id.ToString() + " and PubKey:" + base64.StdEncoding.EncodeToString(pk[:]))
|
||||
fmt.Println("Control: Create peer with ID : " + id.ToString() + " and PubKey:" + pk.ToString())
|
||||
}
|
||||
peer := new(Peer)
|
||||
peer.Lock()
|
||||
@ -103,6 +103,7 @@ func (device *Device) NewPeer(pk NoisePublicKey, id config.Vertex) (*Peer, error
|
||||
|
||||
peer.cookieGenerator.Init(pk)
|
||||
peer.device = device
|
||||
peer.endpoint_trylist = orderedmap.New()
|
||||
peer.queue.outbound = newAutodrainingOutboundQueue(device)
|
||||
peer.queue.inbound = newAutodrainingInboundQueue(device)
|
||||
peer.queue.staged = make(chan *QueueOutboundElement, QueueStagedSize)
|
||||
@ -342,8 +343,8 @@ func (device *Device) SaveToConfig(peer *Peer, endpoint conn.Endpoint) {
|
||||
|
||||
url := endpoint.DstToString()
|
||||
foundInFile := false
|
||||
pubkeystr := PubKey2Str(peer.handshake.remoteStatic)
|
||||
pskstr := PSKeyStr(peer.handshake.presharedKey)
|
||||
pubkeystr := peer.handshake.remoteStatic.ToString()
|
||||
pskstr := peer.handshake.presharedKey.ToString()
|
||||
if bytes.Equal(peer.handshake.presharedKey[:], make([]byte, 32)) {
|
||||
pskstr = ""
|
||||
}
|
||||
|
||||
@ -25,13 +25,14 @@ import (
|
||||
)
|
||||
|
||||
type QueueHandshakeElement struct {
|
||||
msgType uint32
|
||||
msgType path.Usage
|
||||
packet []byte
|
||||
endpoint conn.Endpoint
|
||||
buffer *[MaxMessageSize]byte
|
||||
}
|
||||
|
||||
type QueueInboundElement struct {
|
||||
Type path.Usage
|
||||
sync.Mutex
|
||||
buffer *[MaxMessageSize]byte
|
||||
packet []byte
|
||||
@ -122,15 +123,19 @@ func (device *Device) RoutineReceiveIncoming(recv conn.ReceiveFunc) {
|
||||
// check size of packet
|
||||
|
||||
packet := buffer[:size]
|
||||
msgType := binary.LittleEndian.Uint32(packet[:4])
|
||||
msgType := path.Usage(packet[0])
|
||||
msgType_wg := msgType
|
||||
if msgType >= path.MessageTransportType {
|
||||
msgType_wg = path.MessageTransportType
|
||||
}
|
||||
|
||||
var okay bool
|
||||
|
||||
switch msgType {
|
||||
switch msgType_wg {
|
||||
|
||||
// check if transport
|
||||
|
||||
case MessageTransportType:
|
||||
case path.MessageTransportType:
|
||||
|
||||
// check size
|
||||
|
||||
@ -158,6 +163,7 @@ func (device *Device) RoutineReceiveIncoming(recv conn.ReceiveFunc) {
|
||||
// create work element
|
||||
peer := value.peer
|
||||
elem := device.GetInboundElement()
|
||||
elem.Type = msgType
|
||||
elem.packet = packet
|
||||
elem.buffer = buffer
|
||||
elem.keypair = keypair
|
||||
@ -178,13 +184,13 @@ func (device *Device) RoutineReceiveIncoming(recv conn.ReceiveFunc) {
|
||||
|
||||
// otherwise it is a fixed size & handshake related packet
|
||||
|
||||
case MessageInitiationType:
|
||||
case path.MessageInitiationType:
|
||||
okay = len(packet) == MessageInitiationSize
|
||||
|
||||
case MessageResponseType:
|
||||
case path.MessageResponseType:
|
||||
okay = len(packet) == MessageResponseSize
|
||||
|
||||
case MessageCookieReplyType:
|
||||
case path.MessageCookieReplyType:
|
||||
okay = len(packet) == MessageCookieReplySize
|
||||
|
||||
default:
|
||||
@ -250,7 +256,7 @@ func (device *Device) RoutineHandshake(id int) {
|
||||
|
||||
switch elem.msgType {
|
||||
|
||||
case MessageCookieReplyType:
|
||||
case path.MessageCookieReplyType:
|
||||
|
||||
// unmarshal packet
|
||||
|
||||
@ -281,7 +287,7 @@ func (device *Device) RoutineHandshake(id int) {
|
||||
|
||||
goto skip
|
||||
|
||||
case MessageInitiationType, MessageResponseType:
|
||||
case path.MessageInitiationType, path.MessageResponseType:
|
||||
|
||||
// check mac fields and maybe ratelimit
|
||||
|
||||
@ -316,7 +322,7 @@ func (device *Device) RoutineHandshake(id int) {
|
||||
// handle handshake initiation/response content
|
||||
|
||||
switch elem.msgType {
|
||||
case MessageInitiationType:
|
||||
case path.MessageInitiationType:
|
||||
|
||||
// unmarshal
|
||||
|
||||
@ -349,7 +355,7 @@ func (device *Device) RoutineHandshake(id int) {
|
||||
|
||||
peer.SendHandshakeResponse()
|
||||
|
||||
case MessageResponseType:
|
||||
case path.MessageResponseType:
|
||||
|
||||
// unmarshal
|
||||
|
||||
@ -454,7 +460,7 @@ func (peer *Peer) RoutineSequentialReceiver() {
|
||||
src_nodeID = EgHeader.GetSrc()
|
||||
dst_nodeID = EgHeader.GetDst()
|
||||
elem.packet = elem.packet[:EgHeader.GetPacketLength()+path.EgHeaderLen] // EG header + true packet
|
||||
packet_type = EgHeader.GetUsage()
|
||||
packet_type = elem.Type
|
||||
|
||||
if device.IsSuperNode {
|
||||
peer.LastPingReceived = time.Now()
|
||||
@ -506,12 +512,12 @@ func (peer *Peer) RoutineSequentialReceiver() {
|
||||
} else {
|
||||
EgHeader.SetTTL(l2ttl - 1)
|
||||
if dst_nodeID == config.Boardcast { //Regular transfer algorithm
|
||||
device.TransitBoardcastPacket(src_nodeID, peer.ID, elem.packet, MessageTransportOffsetContent)
|
||||
device.TransitBoardcastPacket(src_nodeID, peer.ID, elem.Type, elem.packet, MessageTransportOffsetContent)
|
||||
} else if dst_nodeID == config.ControlMessage { // Control Message will try send to every know node regardless the connectivity
|
||||
skip_list := make(map[config.Vertex]bool)
|
||||
skip_list[src_nodeID] = true //Don't send to conimg peer and source peer
|
||||
skip_list[peer.ID] = true
|
||||
device.SpreadPacket(skip_list, elem.packet, MessageTransportOffsetContent)
|
||||
device.SpreadPacket(skip_list, elem.Type, elem.packet, MessageTransportOffsetContent)
|
||||
|
||||
} else {
|
||||
next_id := device.graph.Next(device.ID, dst_nodeID)
|
||||
@ -520,7 +526,7 @@ func (peer *Peer) RoutineSequentialReceiver() {
|
||||
if device.LogLevel.LogTransit {
|
||||
fmt.Printf("Transit: Transfer packet from %d through %d to %d\n", peer.ID, device.ID, peer_out.ID)
|
||||
}
|
||||
device.SendPacket(peer_out, elem.packet, MessageTransportOffsetContent)
|
||||
device.SendPacket(peer_out, elem.Type, elem.packet, MessageTransportOffsetContent)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -2,7 +2,6 @@ package device
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
@ -17,7 +16,7 @@ import (
|
||||
"github.com/KusakabeSi/EtherGuardVPN/path"
|
||||
)
|
||||
|
||||
func (device *Device) SendPacket(peer *Peer, packet []byte, offset int) {
|
||||
func (device *Device) SendPacket(peer *Peer, usage path.Usage, packet []byte, offset int) {
|
||||
if peer == nil {
|
||||
return
|
||||
} else if peer.endpoint == nil {
|
||||
@ -25,16 +24,15 @@ func (device *Device) SendPacket(peer *Peer, packet []byte, offset int) {
|
||||
}
|
||||
if device.LogLevel.LogNormal {
|
||||
EgHeader, _ := path.NewEgHeader(packet[:path.EgHeaderLen])
|
||||
if EgHeader.GetUsage() == path.NornalPacket {
|
||||
if usage == path.NornalPacket {
|
||||
dst_nodeID := EgHeader.GetDst()
|
||||
fmt.Println("Normal: Send Normal packet To:" + peer.GetEndpointDstStr() + " SrcID:" + device.ID.ToString() + " DstID:" + dst_nodeID.ToString() + " Len:" + strconv.Itoa(len(packet)))
|
||||
}
|
||||
}
|
||||
if device.LogLevel.LogControl {
|
||||
EgHeader, _ := path.NewEgHeader(packet[:path.EgHeaderLen])
|
||||
if EgHeader.GetUsage() != path.NornalPacket {
|
||||
if usage != path.NornalPacket {
|
||||
if peer.GetEndpointDstStr() != "" {
|
||||
fmt.Println("Control: Send To:" + peer.GetEndpointDstStr() + " " + device.sprint_received(EgHeader.GetUsage(), packet[path.EgHeaderLen:]))
|
||||
fmt.Println("Control: Send To:" + peer.GetEndpointDstStr() + " " + device.sprint_received(usage, packet[path.EgHeaderLen:]))
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -42,6 +40,7 @@ func (device *Device) SendPacket(peer *Peer, packet []byte, offset int) {
|
||||
var elem *QueueOutboundElement
|
||||
elem = device.NewOutboundElement()
|
||||
copy(elem.buffer[offset:offset+len(packet)], packet)
|
||||
elem.Type = usage
|
||||
elem.packet = elem.buffer[offset : offset+len(packet)]
|
||||
if peer.isRunning.Get() {
|
||||
peer.StagePacket(elem)
|
||||
@ -50,7 +49,7 @@ func (device *Device) SendPacket(peer *Peer, packet []byte, offset int) {
|
||||
}
|
||||
}
|
||||
|
||||
func (device *Device) BoardcastPacket(skip_list map[config.Vertex]bool, packet []byte, offset int) { // Send packet to all connected peers
|
||||
func (device *Device) BoardcastPacket(skip_list map[config.Vertex]bool, usage path.Usage, packet []byte, offset int) { // Send packet to all connected peers
|
||||
send_list := device.graph.GetBoardcastList(device.ID)
|
||||
for node_id, _ := range skip_list {
|
||||
send_list[node_id] = false
|
||||
@ -58,13 +57,13 @@ func (device *Device) BoardcastPacket(skip_list map[config.Vertex]bool, packet [
|
||||
device.peers.RLock()
|
||||
for node_id, should_send := range send_list {
|
||||
if should_send {
|
||||
device.SendPacket(device.peers.IDMap[node_id], packet, offset)
|
||||
device.SendPacket(device.peers.IDMap[node_id], usage, packet, offset)
|
||||
}
|
||||
}
|
||||
device.peers.RUnlock()
|
||||
}
|
||||
|
||||
func (device *Device) SpreadPacket(skip_list map[config.Vertex]bool, packet []byte, offset int) { // Send packet to all peers no matter it is alive
|
||||
func (device *Device) SpreadPacket(skip_list map[config.Vertex]bool, usage path.Usage, packet []byte, offset int) { // Send packet to all peers no matter it is alive
|
||||
device.peers.RLock()
|
||||
for peer_id, peer_out := range device.peers.IDMap {
|
||||
if _, ok := skip_list[peer_id]; ok {
|
||||
@ -73,12 +72,12 @@ func (device *Device) SpreadPacket(skip_list map[config.Vertex]bool, packet []by
|
||||
}
|
||||
continue
|
||||
}
|
||||
device.SendPacket(peer_out, packet, MessageTransportOffsetContent)
|
||||
device.SendPacket(peer_out, usage, packet, MessageTransportOffsetContent)
|
||||
}
|
||||
device.peers.RUnlock()
|
||||
}
|
||||
|
||||
func (device *Device) TransitBoardcastPacket(src_nodeID config.Vertex, in_id config.Vertex, packet []byte, offset int) {
|
||||
func (device *Device) TransitBoardcastPacket(src_nodeID config.Vertex, in_id config.Vertex, usage path.Usage, packet []byte, offset int) {
|
||||
node_boardcast_list := device.graph.GetBoardcastThroughList(device.ID, in_id, src_nodeID)
|
||||
device.peers.RLock()
|
||||
for peer_id := range node_boardcast_list {
|
||||
@ -86,19 +85,19 @@ func (device *Device) TransitBoardcastPacket(src_nodeID config.Vertex, in_id con
|
||||
if device.LogLevel.LogTransit {
|
||||
fmt.Printf("Transit: Transfer packet from %d through %d to %d\n", in_id, device.ID, peer_out.ID)
|
||||
}
|
||||
device.SendPacket(peer_out, packet, offset)
|
||||
device.SendPacket(peer_out, usage, packet, offset)
|
||||
}
|
||||
device.peers.RUnlock()
|
||||
}
|
||||
|
||||
func (device *Device) Send2Super(packet []byte, offset int) {
|
||||
func (device *Device) Send2Super(usage path.Usage, packet []byte, offset int) {
|
||||
device.peers.RLock()
|
||||
if device.DRoute.SuperNode.UseSuperNode {
|
||||
for _, peer_out := range device.peers.SuperPeer {
|
||||
/*if device.LogTransit {
|
||||
fmt.Printf("Send to supernode %s\n", peer_out.endpoint.DstToString())
|
||||
}*/
|
||||
device.SendPacket(peer_out, packet, offset)
|
||||
device.SendPacket(peer_out, usage, packet, offset)
|
||||
}
|
||||
}
|
||||
device.peers.RUnlock()
|
||||
@ -236,11 +235,10 @@ func (device *Device) server_process_RegisterMsg(peer *Peer, content path.Regist
|
||||
header, err := path.NewEgHeader(buf[:path.EgHeaderLen])
|
||||
header.SetSrc(device.ID)
|
||||
header.SetTTL(device.DefaultTTL)
|
||||
header.SetUsage(path.UpdateError)
|
||||
header.SetPacketLength(uint16(len(body)))
|
||||
copy(buf[path.EgHeaderLen:], body)
|
||||
header.SetDst(peer.ID)
|
||||
device.SendPacket(peer, buf, MessageTransportOffsetContent)
|
||||
device.SendPacket(peer, path.UpdateError, buf, MessageTransportOffsetContent)
|
||||
return nil
|
||||
}
|
||||
device.Event_server_register <- content
|
||||
@ -270,16 +268,15 @@ func (device *Device) process_ping(peer *Peer, content path.PingMsg) error {
|
||||
header, err := path.NewEgHeader(buf[:path.EgHeaderLen])
|
||||
header.SetSrc(device.ID)
|
||||
header.SetTTL(device.DefaultTTL)
|
||||
header.SetUsage(path.PongPacket)
|
||||
header.SetPacketLength(uint16(len(body)))
|
||||
copy(buf[path.EgHeaderLen:], body)
|
||||
if device.DRoute.SuperNode.UseSuperNode {
|
||||
header.SetDst(config.SuperNodeMessage)
|
||||
device.Send2Super(buf, MessageTransportOffsetContent)
|
||||
device.Send2Super(path.PongPacket, buf, MessageTransportOffsetContent)
|
||||
}
|
||||
if device.DRoute.P2P.UseP2P {
|
||||
header.SetDst(config.ControlMessage)
|
||||
device.SpreadPacket(make(map[config.Vertex]bool), buf, MessageTransportOffsetContent)
|
||||
device.SpreadPacket(make(map[config.Vertex]bool), path.PongPacket, buf, MessageTransportOffsetContent)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@ -301,10 +298,9 @@ func (device *Device) process_pong(peer *Peer, content path.PongMsg) error {
|
||||
header, err := path.NewEgHeader(buf[:path.EgHeaderLen])
|
||||
header.SetSrc(device.ID)
|
||||
header.SetTTL(device.DefaultTTL)
|
||||
header.SetUsage(path.QueryPeer)
|
||||
header.SetPacketLength(uint16(len(body)))
|
||||
copy(buf[path.EgHeaderLen:], body)
|
||||
device.SendPacket(peer, buf, MessageTransportOffsetContent)
|
||||
device.SendPacket(peer, path.QueryPeer, buf, MessageTransportOffsetContent)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
@ -327,7 +323,7 @@ func (device *Device) process_UpdatePeerMsg(peer *Peer, content path.UpdatePeerM
|
||||
return nil
|
||||
}
|
||||
|
||||
downloadurl := device.DRoute.SuperNode.APIUrl + "/peerinfo?PubKey=" + url.QueryEscape(PubKey2Str(device.staticIdentity.publicKey)) + "&State=" + url.QueryEscape(string(content.State_hash[:]))
|
||||
downloadurl := device.DRoute.SuperNode.APIUrl + "/peerinfo?PubKey=" + url.QueryEscape(device.staticIdentity.publicKey.ToString()) + "&State=" + url.QueryEscape(string(content.State_hash[:]))
|
||||
if device.LogLevel.LogControl {
|
||||
fmt.Println("Control: Download peerinfo from :" + downloadurl)
|
||||
}
|
||||
@ -353,11 +349,33 @@ func (device *Device) process_UpdatePeerMsg(peer *Peer, content path.UpdatePeerM
|
||||
return err
|
||||
}
|
||||
|
||||
for nodeID, thepeer := range device.peers.IDMap {
|
||||
pk := thepeer.handshake.remoteStatic
|
||||
psk := thepeer.handshake.presharedKey
|
||||
if val, ok := peer_infos[pk.ToString()]; ok {
|
||||
if val.NodeID != nodeID {
|
||||
device.RemovePeer(pk)
|
||||
continue
|
||||
} else if val.PSKey != psk.ToString() {
|
||||
device.RemovePeer(pk)
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
device.RemovePeer(pk)
|
||||
continue
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
for pubkey, peerinfo := range peer_infos {
|
||||
if len(peerinfo.Connurl) == 0 {
|
||||
return nil
|
||||
}
|
||||
sk := Str2PubKey(pubkey)
|
||||
sk, err := Str2PubKey(pubkey)
|
||||
if err != nil {
|
||||
device.log.Errorf("Error decode base64:", err)
|
||||
return err
|
||||
}
|
||||
if bytes.Equal(sk[:], device.staticIdentity.publicKey[:]) {
|
||||
continue
|
||||
}
|
||||
@ -375,7 +393,11 @@ func (device *Device) process_UpdatePeerMsg(peer *Peer, content path.UpdatePeerM
|
||||
device.NewPeer(sk, peerinfo.NodeID)
|
||||
thepeer = device.LookupPeer(sk)
|
||||
if peerinfo.PSKey != "" {
|
||||
pk := Str2PSKey(peerinfo.PSKey)
|
||||
pk, err := Str2PSKey(peerinfo.PSKey)
|
||||
if err != nil {
|
||||
device.log.Errorf("Error decode base64:", err)
|
||||
return err
|
||||
}
|
||||
thepeer.handshake.presharedKey = pk
|
||||
}
|
||||
}
|
||||
@ -383,7 +405,9 @@ func (device *Device) process_UpdatePeerMsg(peer *Peer, content path.UpdatePeerM
|
||||
if thepeer.LastPingReceived.Add(path.S2TD(device.DRoute.P2P.PeerAliveTimeout)).Before(time.Now()) {
|
||||
//Peer died, try to switch to this new endpoint
|
||||
for url, _ := range peerinfo.Connurl {
|
||||
thepeer.endpoint_trylist.Store(url, time.Time{}) //another gorouting will process it
|
||||
thepeer.Lock()
|
||||
thepeer.endpoint_trylist.Set(url, time.Time{}) //another gorouting will process it
|
||||
thepeer.Unlock()
|
||||
send_signal = true
|
||||
}
|
||||
}
|
||||
@ -415,7 +439,7 @@ func (device *Device) process_UpdateNhTableMsg(peer *Peer, content path.UpdateNh
|
||||
if bytes.Equal(device.graph.NhTableHash[:], content.State_hash[:]) {
|
||||
return nil
|
||||
}
|
||||
downloadurl := device.DRoute.SuperNode.APIUrl + "/nhtable?PubKey=" + url.QueryEscape(PubKey2Str(device.staticIdentity.publicKey)) + "&State=" + url.QueryEscape(string(content.State_hash[:]))
|
||||
downloadurl := device.DRoute.SuperNode.APIUrl + "/nhtable?PubKey=" + url.QueryEscape(device.staticIdentity.publicKey.ToString()) + "&State=" + url.QueryEscape(string(content.State_hash[:]))
|
||||
if device.LogLevel.LogControl {
|
||||
fmt.Println("Control: Download NhTable from :" + downloadurl)
|
||||
}
|
||||
@ -471,37 +495,51 @@ func (device *Device) RoutineSetEndpoint() {
|
||||
for _, thepeer := range device.peers.IDMap {
|
||||
if thepeer.LastPingReceived.Add(path.S2TD(device.DRoute.P2P.PeerAliveTimeout)).After(time.Now()) {
|
||||
//Peer alives
|
||||
thepeer.endpoint_trylist.Range(func(key, value interface{}) bool {
|
||||
thepeer.Lock()
|
||||
for _, key := range thepeer.endpoint_trylist.Keys() { // delete whole endpoint_trylist
|
||||
thepeer.endpoint_trylist.Delete(key)
|
||||
return true
|
||||
})
|
||||
}
|
||||
thepeer.Unlock()
|
||||
} else {
|
||||
thepeer.endpoint_trylist.Range(func(key interface{}, value interface{}) bool {
|
||||
url := key.(string)
|
||||
trytime := value.(time.Time)
|
||||
if trytime.Sub(time.Time{}) != time.Duration(0) && time.Now().Sub(trytime) > path.S2TD(device.DRoute.ConnTimeOut) {
|
||||
thepeer.RLock()
|
||||
trylist := thepeer.endpoint_trylist.Keys()
|
||||
thepeer.RUnlock()
|
||||
for _, key := range trylist { // try next endpoint
|
||||
connurl := key
|
||||
thepeer.RLock()
|
||||
val, hasval := thepeer.endpoint_trylist.Get(key)
|
||||
thepeer.RUnlock()
|
||||
if !hasval {
|
||||
continue
|
||||
}
|
||||
trytime := val.(time.Time)
|
||||
if trytime.Sub(time.Time{}) != time.Duration(0) && time.Now().Sub(trytime) > path.S2TD(device.DRoute.ConnTimeOut) { // tried before, but no response
|
||||
thepeer.Lock()
|
||||
thepeer.endpoint_trylist.Delete(key)
|
||||
thepeer.Unlock()
|
||||
} else {
|
||||
endpoint, err := device.Bind().ParseEndpoint(url) //trying to bind first url in the list and wait device.DRoute.P2P.PeerAliveTimeout seconds
|
||||
endpoint, err := device.Bind().ParseEndpoint(connurl) //trying to bind first url in the list and wait device.DRoute.P2P.PeerAliveTimeout seconds
|
||||
if err != nil {
|
||||
device.log.Errorf("Can't bind " + url)
|
||||
thepeer.endpoint_trylist.Delete(url)
|
||||
return true
|
||||
device.log.Errorf("Can't bind " + connurl)
|
||||
thepeer.Lock()
|
||||
thepeer.endpoint_trylist.Delete(connurl)
|
||||
thepeer.Unlock()
|
||||
continue
|
||||
}
|
||||
if device.LogLevel.LogControl {
|
||||
fmt.Println("Control: Set endpoint to " + endpoint.DstToString() + " for NodeID:" + thepeer.ID.ToString())
|
||||
}
|
||||
thepeer.SetEndpointFromPacket(endpoint)
|
||||
NextRun = true
|
||||
thepeer.endpoint_trylist.Store(key, time.Now())
|
||||
thepeer.Lock()
|
||||
thepeer.endpoint_trylist.Set(key, time.Now())
|
||||
thepeer.Unlock()
|
||||
//Send Ping message to it
|
||||
packet, err := device.GeneratePingPacket(device.ID)
|
||||
device.SendPacket(thepeer, packet, MessageTransportOffsetContent)
|
||||
|
||||
return false
|
||||
packet, usage, err := device.GeneratePingPacket(device.ID)
|
||||
device.SendPacket(thepeer, usage, packet, MessageTransportOffsetContent)
|
||||
break
|
||||
}
|
||||
return true
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
ClearChanLoop:
|
||||
@ -524,8 +562,8 @@ func (device *Device) RoutineSendPing() {
|
||||
return
|
||||
}
|
||||
for {
|
||||
packet, _ := device.GeneratePingPacket(device.ID)
|
||||
device.SpreadPacket(make(map[config.Vertex]bool), packet, MessageTransportOffsetContent)
|
||||
packet, usage, _ := device.GeneratePingPacket(device.ID)
|
||||
device.SpreadPacket(make(map[config.Vertex]bool), usage, packet, MessageTransportOffsetContent)
|
||||
time.Sleep(path.S2TD(device.DRoute.SendPingInterval))
|
||||
}
|
||||
}
|
||||
@ -547,10 +585,9 @@ func (device *Device) RoutineRegister() {
|
||||
header.SetDst(config.SuperNodeMessage)
|
||||
header.SetTTL(0)
|
||||
header.SetSrc(device.ID)
|
||||
header.SetUsage(path.Register)
|
||||
header.SetPacketLength(uint16(len(body)))
|
||||
copy(buf[path.EgHeaderLen:], body)
|
||||
device.Send2Super(buf, MessageTransportOffsetContent)
|
||||
device.Send2Super(path.Register, buf, MessageTransportOffsetContent)
|
||||
time.Sleep(path.S2TD(device.DRoute.SendPingInterval))
|
||||
}
|
||||
}
|
||||
@ -612,26 +649,25 @@ func (device *Device) RoutineResetConn() {
|
||||
}
|
||||
}
|
||||
|
||||
func (device *Device) GeneratePingPacket(src_nodeID config.Vertex) ([]byte, error) {
|
||||
func (device *Device) GeneratePingPacket(src_nodeID config.Vertex) ([]byte, path.Usage, error) {
|
||||
body, err := path.GetByte(&path.PingMsg{
|
||||
Src_nodeID: src_nodeID,
|
||||
Time: device.graph.GetCurrentTime(),
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
return nil, path.PingPacket, err
|
||||
}
|
||||
buf := make([]byte, path.EgHeaderLen+len(body))
|
||||
header, _ := path.NewEgHeader(buf[0:path.EgHeaderLen])
|
||||
if err != nil {
|
||||
return nil, err
|
||||
return nil, path.PingPacket, err
|
||||
}
|
||||
header.SetDst(config.ControlMessage)
|
||||
header.SetTTL(0)
|
||||
header.SetSrc(device.ID)
|
||||
header.SetUsage(path.PingPacket)
|
||||
header.SetPacketLength(uint16(len(body)))
|
||||
copy(buf[path.EgHeaderLen:], body)
|
||||
return buf, nil
|
||||
return buf, path.PingPacket, nil
|
||||
}
|
||||
|
||||
func (device *Device) process_RequestPeerMsg(content path.QueryPeerMsg) error { //Send all my peers to all my peers
|
||||
@ -663,10 +699,9 @@ func (device *Device) process_RequestPeerMsg(content path.QueryPeerMsg) error {
|
||||
header.SetDst(config.ControlMessage)
|
||||
header.SetTTL(device.DefaultTTL)
|
||||
header.SetSrc(device.ID)
|
||||
header.SetUsage(path.BoardcastPeer)
|
||||
header.SetPacketLength(uint16(len(body)))
|
||||
copy(buf[path.EgHeaderLen:], body)
|
||||
device.SpreadPacket(make(map[config.Vertex]bool), buf, MessageTransportOffsetContent)
|
||||
device.SpreadPacket(make(map[config.Vertex]bool), path.BoardcastPeer, buf, MessageTransportOffsetContent)
|
||||
}
|
||||
device.peers.RUnlock()
|
||||
}
|
||||
@ -675,18 +710,18 @@ func (device *Device) process_RequestPeerMsg(content path.QueryPeerMsg) error {
|
||||
|
||||
func (device *Device) process_BoardcastPeerMsg(peer *Peer, content path.BoardcastPeerMsg) error {
|
||||
if device.DRoute.P2P.UseP2P {
|
||||
var sk NoisePublicKey
|
||||
var pk NoisePublicKey
|
||||
if content.Request_ID == uint32(device.ID) {
|
||||
peer.AskedForNeighbor = true
|
||||
}
|
||||
if bytes.Equal(content.PubKey[:], device.staticIdentity.publicKey[:]) {
|
||||
return nil
|
||||
}
|
||||
copy(sk[:], content.PubKey[:])
|
||||
thepeer := device.LookupPeer(sk)
|
||||
copy(pk[:], content.PubKey[:])
|
||||
thepeer := device.LookupPeer(pk)
|
||||
if thepeer == nil { //not exist in local
|
||||
if device.LogLevel.LogControl {
|
||||
fmt.Println("Control: Add new peer to local ID:" + content.NodeID.ToString() + " PubKey:" + base64.StdEncoding.EncodeToString(content.PubKey[:]))
|
||||
fmt.Println("Control: Add new peer to local ID:" + content.NodeID.ToString() + " PubKey:" + pk.ToString())
|
||||
}
|
||||
if device.graph.Weight(device.ID, content.NodeID) == path.Infinity { // add node to graph
|
||||
device.graph.UpdateLentancy(device.ID, content.NodeID, path.S2TD(path.Infinity), true, false)
|
||||
@ -694,15 +729,17 @@ func (device *Device) process_BoardcastPeerMsg(peer *Peer, content path.Boardcas
|
||||
if device.graph.Weight(content.NodeID, device.ID) == path.Infinity { // add node to graph
|
||||
device.graph.UpdateLentancy(content.NodeID, device.ID, path.S2TD(path.Infinity), true, false)
|
||||
}
|
||||
device.NewPeer(sk, content.NodeID)
|
||||
thepeer = device.LookupPeer(sk)
|
||||
device.NewPeer(pk, content.NodeID)
|
||||
thepeer = device.LookupPeer(pk)
|
||||
var pk NoisePresharedKey
|
||||
copy(pk[:], content.PSKey[:])
|
||||
thepeer.handshake.presharedKey = pk
|
||||
}
|
||||
if thepeer.LastPingReceived.Add(path.S2TD(device.DRoute.P2P.PeerAliveTimeout)).Before(time.Now()) {
|
||||
//Peer died, try to switch to this new endpoint
|
||||
thepeer.endpoint_trylist.Store(content.ConnURL, time.Time{}) //another gorouting will process it
|
||||
thepeer.Lock()
|
||||
thepeer.endpoint_trylist.Set(content.ConnURL, time.Time{}) //another gorouting will process it
|
||||
thepeer.Unlock()
|
||||
device.event_tryendpoint <- struct{}{}
|
||||
}
|
||||
|
||||
|
||||
@ -47,6 +47,7 @@ import (
|
||||
*/
|
||||
|
||||
type QueueOutboundElement struct {
|
||||
Type path.Usage
|
||||
sync.Mutex
|
||||
buffer *[MaxMessageSize]byte // slice holding the packet data
|
||||
packet []byte // slice of "buffer" (always!)
|
||||
@ -263,7 +264,7 @@ func (device *Device) RoutineReadFromTUN() {
|
||||
EgBody.SetDst(dst_nodeID)
|
||||
EgBody.SetPacketLength(uint16(len(elem.packet) - path.EgHeaderLen))
|
||||
EgBody.SetTTL(device.DefaultTTL)
|
||||
EgBody.SetUsage(path.NornalPacket)
|
||||
elem.Type = path.NornalPacket
|
||||
|
||||
if dst_nodeID != config.Boardcast {
|
||||
var peer *Peer
|
||||
@ -283,7 +284,7 @@ func (device *Device) RoutineReadFromTUN() {
|
||||
}
|
||||
}
|
||||
} else {
|
||||
device.BoardcastPacket(make(map[config.Vertex]bool, 0), elem.packet, offset)
|
||||
device.BoardcastPacket(make(map[config.Vertex]bool, 0),elem.Type, elem.packet, offset)
|
||||
}
|
||||
|
||||
}
|
||||
@ -388,11 +389,10 @@ func (device *Device) RoutineEncryption(id int) {
|
||||
// populate header fields
|
||||
header := elem.buffer[:MessageTransportHeaderSize]
|
||||
|
||||
fieldType := header[0:4]
|
||||
fieldReceiver := header[4:8]
|
||||
fieldNonce := header[8:16]
|
||||
fieldReceiver := header[1:5]
|
||||
fieldNonce := header[5:13]
|
||||
|
||||
binary.LittleEndian.PutUint32(fieldType, MessageTransportType)
|
||||
header[0] = uint8(elem.Type)
|
||||
binary.LittleEndian.PutUint32(fieldReceiver, elem.keypair.remoteIndex)
|
||||
binary.LittleEndian.PutUint64(fieldNonce, elem.nonce)
|
||||
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap1
|
||||
vppifaceid: 1
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4001
|
||||
sendaddr: 127.0.0.1:5001
|
||||
l2headermode: kbdbg
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap2
|
||||
vppifaceid: 2
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4002
|
||||
sendaddr: 127.0.0.1:5002
|
||||
l2headermode: kbdbg
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap3
|
||||
vppifaceid: 3
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4003
|
||||
sendaddr: 127.0.0.1:5003
|
||||
l2headermode: kbdbg
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap4
|
||||
vppifaceid: 4
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4004
|
||||
sendaddr: 127.0.0.1:5004
|
||||
l2headermode: kbdbg
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap5
|
||||
vppifaceid: 5
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4005
|
||||
sendaddr: 127.0.0.1:5005
|
||||
l2headermode: kbdbg
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap6
|
||||
vppifaceid: 6
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4006
|
||||
sendaddr: 127.0.0.1:5006
|
||||
l2headermode: kbdbg
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap1
|
||||
vppifaceid: 1
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4001
|
||||
sendaddr: 127.0.0.1:5001
|
||||
l2headermode: kbdbg
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap2
|
||||
vppifaceid: 2
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4002
|
||||
sendaddr: 127.0.0.1:5002
|
||||
l2headermode: kbdbg
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap3
|
||||
vppifaceid: 3
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4003
|
||||
sendaddr: 127.0.0.1:5003
|
||||
l2headermode: kbdbg
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap4
|
||||
vppifaceid: 4
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4004
|
||||
sendaddr: 127.0.0.1:5004
|
||||
l2headermode: kbdbg
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap5
|
||||
vppifaceid: 5
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4005
|
||||
sendaddr: 127.0.0.1:5005
|
||||
l2headermode: kbdbg
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap6
|
||||
vppifaceid: 6
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4006
|
||||
sendaddr: 127.0.0.1:5006
|
||||
l2headermode: kbdbg
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap1
|
||||
vppifaceid: 1
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4001
|
||||
sendaddr: 127.0.0.1:5001
|
||||
l2headermode: kbdbg
|
||||
@ -20,7 +20,7 @@ loglevel:
|
||||
lognormal: true
|
||||
logntp: true
|
||||
dynamicroute:
|
||||
sendpinginterval: 20
|
||||
sendpinginterval: 16
|
||||
dupchecktimeout: 40
|
||||
conntimeout: 30
|
||||
savenewpeers: true
|
||||
@ -28,10 +28,10 @@ dynamicroute:
|
||||
usesupernode: true
|
||||
connurlv4: 127.0.0.1:3000
|
||||
pubkeyv4: LJ8KKacUcIoACTGB/9Ed9w0osrJ3WWeelzpL2u4oUic=
|
||||
connurlv6: ''
|
||||
connurlv6: '[::1]:3000'
|
||||
pubkeyv6: HCfL6YJtpJEGHTlJ2LgVXIWKB/K95P57LHTJ42ZG8VI=
|
||||
apiurl: http://127.0.0.1:3000/api
|
||||
supernodeinfotimeout: 40
|
||||
supernodeinfotimeout: 50
|
||||
p2p:
|
||||
usep2p: false
|
||||
sendpeerinterval: 20
|
||||
|
||||
@ -3,8 +3,8 @@ interface:
|
||||
name: tap2
|
||||
vppifaceid: 2
|
||||
vppbridgeid: 4242
|
||||
macaddrprefix: AA:BB:CC:DD:EE
|
||||
mtu: 1404
|
||||
macaddrprefix: AA:BB:CC:DD
|
||||
mtu: 1416
|
||||
recvaddr: 127.0.0.1:4002
|
||||
sendaddr: 127.0.0.1:5002
|
||||
l2headermode: kbdbg
|
||||
@ -20,7 +20,7 @@ loglevel:
|
||||
lognormal: true
|
||||
logntp: true
|
||||
dynamicroute:
|
||||
sendpinginterval: 20
|
||||
sendpinginterval: 16
|
||||
dupchecktimeout: 40
|
||||
conntimeout: 30
|
||||
savenewpeers: true
|
||||
@ -28,10 +28,10 @@ dynamicroute:
|
||||
usesupernode: true
|
||||
connurlv4: 127.0.0.1:3000
|
||||
pubkeyv4: LJ8KKacUcIoACTGB/9Ed9w0osrJ3WWeelzpL2u4oUic=
|
||||
connurlv6: ''
|
||||
connurlv6: '[::1]:3000'
|
||||
pubkeyv6: HCfL6YJtpJEGHTlJ2LgVXIWKB/K95P57LHTJ42ZG8VI=
|
||||
apiurl: http://127.0.0.1:3000/api
|
||||
supernodeinfotimeout: 40
|
||||
supernodeinfotimeout: 50
|
||||
p2p:
|
||||
usep2p: false
|
||||
sendpeerinterval: 20
|
||||
|
||||
@ -2,7 +2,10 @@ nodename: NodeSuper
|
||||
privkeyv4: mL5IW0GuqbjgDeOJuPHBU2iJzBPNKhaNEXbIGwwYWWk=
|
||||
privkeyv6: +EdOKIoBp/EvIusHDsvXhV1RJYbyN3Qr8nxlz35wl3I=
|
||||
listenport: 3000
|
||||
statepassword: passwd
|
||||
passwords:
|
||||
showstate: passwd
|
||||
addpeer: passwd_addpeer
|
||||
delpeer: passwd_delpeer
|
||||
loglevel:
|
||||
loglevel: normal
|
||||
logtransit: true
|
||||
@ -12,8 +15,9 @@ repushconfiginterval: 30
|
||||
graphrecalculatesetting:
|
||||
jittertolerance: 5
|
||||
jittertolerancemultiplier: 1.01
|
||||
nodereporttimeout: 40
|
||||
nodereporttimeout: 50
|
||||
recalculatecooldown: 5
|
||||
edgetemplate: "example_config/super_mode/s1.yaml"
|
||||
peers:
|
||||
- nodeid: 1
|
||||
name: "Node_01"
|
||||
@ -22,4 +26,4 @@ peers:
|
||||
- nodeid: 2
|
||||
name: "Node_02"
|
||||
pubkey: dHeWQtlTPQGy87WdbUARS4CtwVaR2y7IQ1qcX4GKSXk=
|
||||
pskey: ""
|
||||
pskey: ""
|
||||
|
||||
2
main.go
2
main.go
@ -55,7 +55,7 @@ var (
|
||||
func main() {
|
||||
flag.Parse()
|
||||
if *version == true {
|
||||
fmt.Printf("etherguard-go v%s\n%s\n\nA full mesh VPN %s-%s.\nInformation available at https://github.com/KusakabeSi/EtherGuardVPN.\nCopyright (C) Kusakabe Si <si@kskb.eu.org>.\n", Version, tap.VPP_SUPPORT, runtime.GOOS, runtime.GOARCH)
|
||||
fmt.Printf("etherguard-go %s\n%s\n\nA full mesh VPN %s-%s.\nInformation available at https://github.com/KusakabeSi/EtherGuardVPN.\nCopyright (C) Kusakabe Si <si@kskb.eu.org>.\n", Version, tap.VPP_SUPPORT, runtime.GOOS, runtime.GOARCH)
|
||||
return
|
||||
}
|
||||
if *help == true {
|
||||
|
||||
41
main_edge.go
41
main_edge.go
@ -8,7 +8,6 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
@ -210,24 +209,29 @@ func Edge(configPath string, useUAPI bool, printExample bool) (err error) {
|
||||
graph := path.NewGraph(3, false, econfig.DynamicRoute.P2P.GraphRecalculateSetting, econfig.DynamicRoute.NTPconfig, econfig.LogLevel.LogNTP)
|
||||
graph.SetNHTable(econfig.NextHopTable, [32]byte{})
|
||||
|
||||
the_device := device.NewDevice(thetap, econfig.NodeID, conn.NewDefaultBind(), logger, graph, false, configPath, &econfig, nil, nil,Version)
|
||||
the_device := device.NewDevice(thetap, econfig.NodeID, conn.NewDefaultBind(), logger, graph, false, configPath, &econfig, nil, nil, Version)
|
||||
defer the_device.Close()
|
||||
var sk [32]byte
|
||||
sk_slice, _ := base64.StdEncoding.DecodeString(econfig.PrivKey)
|
||||
copy(sk[:], sk_slice)
|
||||
the_device.SetPrivateKey(sk)
|
||||
pk, err := device.Str2PriKey(econfig.PrivKey)
|
||||
if err != nil {
|
||||
fmt.Println("Error decode base64 ", err)
|
||||
return err
|
||||
}
|
||||
the_device.SetPrivateKey(pk)
|
||||
the_device.IpcSet("fwmark=0\n")
|
||||
the_device.IpcSet("listen_port=" + strconv.Itoa(econfig.ListenPort) + "\n")
|
||||
the_device.IpcSet("replace_peers=true\n")
|
||||
for _, peerconf := range econfig.Peers {
|
||||
sk_slice, _ = base64.StdEncoding.DecodeString(peerconf.PubKey)
|
||||
copy(sk[:], sk_slice)
|
||||
pk, err := device.Str2PubKey(peerconf.PubKey)
|
||||
if err != nil {
|
||||
fmt.Println("Error decode base64 ", err)
|
||||
return err
|
||||
}
|
||||
if peerconf.NodeID >= config.SuperNodeMessage {
|
||||
return errors.New(fmt.Sprintf("Invalid Node_id at peer %s\n", peerconf.PubKey))
|
||||
}
|
||||
the_device.NewPeer(sk, peerconf.NodeID)
|
||||
the_device.NewPeer(pk, peerconf.NodeID)
|
||||
if peerconf.EndPoint != "" {
|
||||
peer := the_device.LookupPeer(sk)
|
||||
peer := the_device.LookupPeer(pk)
|
||||
endpoint, err := the_device.Bind().ParseEndpoint(peerconf.EndPoint)
|
||||
if err != nil {
|
||||
logger.Errorf("Failed to set endpoint %v: %w", peerconf.EndPoint, err)
|
||||
@ -241,13 +245,16 @@ func Edge(configPath string, useUAPI bool, printExample bool) (err error) {
|
||||
|
||||
if econfig.DynamicRoute.SuperNode.UseSuperNode {
|
||||
if econfig.DynamicRoute.SuperNode.ConnURLV4 != "" {
|
||||
sk_slice, _ = base64.StdEncoding.DecodeString(econfig.DynamicRoute.SuperNode.PubKeyV4)
|
||||
copy(sk[:], sk_slice)
|
||||
pk, err := device.Str2PubKey(econfig.DynamicRoute.SuperNode.PubKeyV4)
|
||||
if err != nil {
|
||||
fmt.Println("Error decode base64 ", err)
|
||||
return err
|
||||
}
|
||||
endpoint, err := the_device.Bind().ParseEndpoint(econfig.DynamicRoute.SuperNode.ConnURLV4)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
peer, err := the_device.NewPeer(sk, config.SuperNodeMessage)
|
||||
peer, err := the_device.NewPeer(pk, config.SuperNodeMessage)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@ -256,13 +263,15 @@ func Edge(configPath string, useUAPI bool, printExample bool) (err error) {
|
||||
peer.SetEndpointFromPacket(endpoint)
|
||||
}
|
||||
if econfig.DynamicRoute.SuperNode.ConnURLV6 != "" {
|
||||
sk_slice, _ = base64.StdEncoding.DecodeString(econfig.DynamicRoute.SuperNode.PubKeyV6)
|
||||
copy(sk[:], sk_slice)
|
||||
pk, err := device.Str2PubKey(econfig.DynamicRoute.SuperNode.PubKeyV6)
|
||||
if err != nil {
|
||||
fmt.Println("Error decode base64 ", err)
|
||||
}
|
||||
endpoint, err := the_device.Bind().ParseEndpoint(econfig.DynamicRoute.SuperNode.ConnURLV6)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
peer, err := the_device.NewPeer(sk, config.SuperNodeMessage)
|
||||
peer, err := the_device.NewPeer(pk, config.SuperNodeMessage)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
119
main_super.go
119
main_super.go
@ -10,7 +10,6 @@ package main
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/md5"
|
||||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
@ -105,52 +104,54 @@ func Super(configPath string, useUAPI bool, printExample bool) (err error) {
|
||||
http_PeerID2Map = make(map[config.Vertex]string)
|
||||
http_PeerInfos = make(map[string]config.HTTP_Peerinfo)
|
||||
http_HashSalt = []byte(config.RandomStr(32, "Salt generate failed"))
|
||||
http_StatePWD = sconfig.StatePassword
|
||||
http_StatePWD = sconfig.Passwords.ShowState
|
||||
|
||||
super_chains := path.SUPER_Events{
|
||||
Event_server_pong: make(chan path.PongMsg, 1<<5),
|
||||
Event_server_register: make(chan path.RegisterMsg, 1<<5),
|
||||
Event_server_NhTable_changed: make(chan struct{}, 1<<4),
|
||||
}
|
||||
http_graph = path.NewGraph(3, true, sconfig.GraphRecalculateSetting, config.NTPinfo{}, sconfig.LogLevel.LogNTP)
|
||||
|
||||
thetap4, _ := tap.CreateDummyTAP()
|
||||
thetap6, _ := tap.CreateDummyTAP()
|
||||
http_graph = path.NewGraph(3, true, sconfig.GraphRecalculateSetting, config.NTPinfo{}, sconfig.LogLevel.LogNTP)
|
||||
http_device4 = device.NewDevice(thetap4, config.SuperNodeMessage, conn.NewCustomBind(true, false), logger4, http_graph, true, configPath, nil, &sconfig, &super_chains, Version)
|
||||
http_device6 = device.NewDevice(thetap6, config.SuperNodeMessage, conn.NewCustomBind(false, true), logger6, http_graph, true, configPath, nil, &sconfig, &super_chains, Version)
|
||||
defer http_device4.Close()
|
||||
thetap6, _ := tap.CreateDummyTAP()
|
||||
http_device6 = device.NewDevice(thetap6, config.SuperNodeMessage, conn.NewCustomBind(false, true), logger6, http_graph, true, configPath, nil, &sconfig, &super_chains, Version)
|
||||
defer http_device6.Close()
|
||||
var sk [32]byte
|
||||
sk_slice, err := base64.StdEncoding.DecodeString(sconfig.PrivKeyV4)
|
||||
if err != nil {
|
||||
fmt.Printf("Can't decode base64:%v\n", sconfig.PrivKeyV4)
|
||||
return err
|
||||
if sconfig.PrivKeyV4 != "" {
|
||||
pk4, err := device.Str2PriKey(sconfig.PrivKeyV4)
|
||||
if err != nil {
|
||||
fmt.Println("Error decode base64 ", err)
|
||||
return err
|
||||
}
|
||||
http_device4.SetPrivateKey(pk4)
|
||||
http_device4.IpcSet("fwmark=0\n")
|
||||
http_device4.IpcSet("listen_port=" + strconv.Itoa(sconfig.ListenPort) + "\n")
|
||||
http_device4.IpcSet("replace_peers=true\n")
|
||||
}
|
||||
copy(sk[:], sk_slice)
|
||||
http_device4.SetPrivateKey(sk)
|
||||
sk_slice, err = base64.StdEncoding.DecodeString(sconfig.PrivKeyV6)
|
||||
if err != nil {
|
||||
fmt.Printf("Can't decode base64:%v\n", sconfig.PrivKeyV6)
|
||||
return err
|
||||
|
||||
if sconfig.PrivKeyV6 != "" {
|
||||
|
||||
pk6, err := device.Str2PriKey(sconfig.PrivKeyV6)
|
||||
if err != nil {
|
||||
fmt.Println("Error decode base64 ", err)
|
||||
return err
|
||||
}
|
||||
http_device6.SetPrivateKey(pk6)
|
||||
http_device6.IpcSet("fwmark=0\n")
|
||||
http_device6.IpcSet("listen_port=" + strconv.Itoa(sconfig.ListenPort) + "\n")
|
||||
http_device6.IpcSet("replace_peers=true\n")
|
||||
}
|
||||
copy(sk[:], sk_slice)
|
||||
http_device6.SetPrivateKey(sk)
|
||||
http_device4.IpcSet("fwmark=0\n")
|
||||
http_device6.IpcSet("fwmark=0\n")
|
||||
http_device4.IpcSet("listen_port=" + strconv.Itoa(sconfig.ListenPort) + "\n")
|
||||
http_device6.IpcSet("listen_port=" + strconv.Itoa(sconfig.ListenPort) + "\n")
|
||||
http_device4.IpcSet("replace_peers=true\n")
|
||||
http_device6.IpcSet("replace_peers=true\n")
|
||||
|
||||
for _, peerconf := range sconfig.Peers {
|
||||
http_peerinfos.Store(peerconf.NodeID, peerconf.Name)
|
||||
var pk device.NoisePublicKey
|
||||
|
||||
pk_slice, err := base64.StdEncoding.DecodeString(peerconf.PubKey)
|
||||
pk, err := device.Str2PubKey(peerconf.PubKey)
|
||||
if err != nil {
|
||||
fmt.Println("Error decode base64 ", err)
|
||||
return err
|
||||
}
|
||||
copy(pk[:], pk_slice)
|
||||
|
||||
if peerconf.NodeID >= config.SuperNodeMessage {
|
||||
return errors.New(fmt.Sprintf("Invalid Node_id at peer %s\n", peerconf.PubKey))
|
||||
}
|
||||
@ -161,31 +162,43 @@ func Super(configPath string, useUAPI bool, printExample bool) (err error) {
|
||||
PSKey: peerconf.PSKey,
|
||||
Connurl: make(map[string]bool),
|
||||
}
|
||||
peer4, err := http_device4.NewPeer(pk, peerconf.NodeID)
|
||||
if err != nil {
|
||||
fmt.Printf("Error create peer id %v\n", peerconf.NodeID)
|
||||
return err
|
||||
}
|
||||
peer4.StaticConn = true
|
||||
peer6, err := http_device6.NewPeer(pk, peerconf.NodeID)
|
||||
if err != nil {
|
||||
fmt.Printf("Error create peer id %v\n", peerconf.NodeID)
|
||||
return err
|
||||
}
|
||||
peer6.StaticConn = true
|
||||
if peerconf.PSKey != "" {
|
||||
var psk device.NoisePresharedKey
|
||||
psk_slice, err := base64.StdEncoding.DecodeString(peerconf.PSKey)
|
||||
if sconfig.PrivKeyV4 != "" {
|
||||
peer4, err := http_device4.NewPeer(pk, peerconf.NodeID)
|
||||
if err != nil {
|
||||
fmt.Println("Error decode base64 ", err)
|
||||
fmt.Printf("Error create peer id %v\n", peerconf.NodeID)
|
||||
return err
|
||||
}
|
||||
peer4.StaticConn = true
|
||||
if peerconf.PSKey != "" {
|
||||
psk, err := device.Str2PSKey(peerconf.PSKey)
|
||||
if err != nil {
|
||||
fmt.Println("Error decode base64 ", err)
|
||||
return err
|
||||
}
|
||||
peer4.SetPSK(psk)
|
||||
}
|
||||
copy(psk[:], psk_slice)
|
||||
peer4.SetPSK(psk)
|
||||
peer6.SetPSK(psk)
|
||||
}
|
||||
if sconfig.PrivKeyV6 != "" {
|
||||
peer6, err := http_device6.NewPeer(pk, peerconf.NodeID)
|
||||
if err != nil {
|
||||
fmt.Printf("Error create peer id %v\n", peerconf.NodeID)
|
||||
return err
|
||||
}
|
||||
peer6.StaticConn = true
|
||||
if peerconf.PSKey != "" {
|
||||
psk, err := device.Str2PSKey(peerconf.PSKey)
|
||||
if err != nil {
|
||||
fmt.Println("Error decode base64 ", err)
|
||||
return err
|
||||
}
|
||||
peer6.SetPSK(psk)
|
||||
}
|
||||
}
|
||||
|
||||
http_PeerState[peerconf.PubKey] = &PeerState{}
|
||||
}
|
||||
logger4.Verbosef("Device started")
|
||||
logger4.Verbosef("Device4 started")
|
||||
logger6.Verbosef("Device6 started")
|
||||
|
||||
errs := make(chan error, 1<<3)
|
||||
term := make(chan os.Signal, 1)
|
||||
@ -290,14 +303,13 @@ func PushNhTable() {
|
||||
header.SetPacketLength(uint16(len(body)))
|
||||
header.SetSrc(config.SuperNodeMessage)
|
||||
header.SetTTL(0)
|
||||
header.SetUsage(path.UpdateNhTable)
|
||||
copy(buf[path.EgHeaderLen:], body)
|
||||
for pkstr, _ := range http_PeerState {
|
||||
if peer := http_device4.LookupPeerByStr(pkstr); peer != nil && peer.GetEndpointDstStr() != "" {
|
||||
http_device4.SendPacket(peer, buf, device.MessageTransportOffsetContent)
|
||||
http_device4.SendPacket(peer, path.UpdateNhTable, buf, device.MessageTransportOffsetContent)
|
||||
}
|
||||
if peer := http_device6.LookupPeerByStr(pkstr); peer != nil && peer.GetEndpointDstStr() != "" {
|
||||
http_device6.SendPacket(peer, buf, device.MessageTransportOffsetContent)
|
||||
http_device6.SendPacket(peer, path.UpdateNhTable, buf, device.MessageTransportOffsetContent)
|
||||
}
|
||||
|
||||
}
|
||||
@ -317,15 +329,14 @@ func PushUpdate() {
|
||||
header.SetPacketLength(uint16(len(body)))
|
||||
header.SetSrc(config.SuperNodeMessage)
|
||||
header.SetTTL(0)
|
||||
header.SetUsage(path.UpdatePeer)
|
||||
copy(buf[path.EgHeaderLen:], body)
|
||||
for pkstr, peerstate := range http_PeerState {
|
||||
if peerstate.PeerInfoState != http_PeerInfo_hash {
|
||||
if peer := http_device4.LookupPeerByStr(pkstr); peer != nil {
|
||||
http_device4.SendPacket(peer, buf, device.MessageTransportOffsetContent)
|
||||
http_device4.SendPacket(peer, path.UpdatePeer, buf, device.MessageTransportOffsetContent)
|
||||
}
|
||||
if peer := http_device6.LookupPeerByStr(pkstr); peer != nil {
|
||||
http_device6.SendPacket(peer, buf, device.MessageTransportOffsetContent)
|
||||
http_device6.SendPacket(peer, path.UpdatePeer, buf, device.MessageTransportOffsetContent)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -34,12 +34,12 @@ type OrderedMap struct {
|
||||
escapeHTML bool
|
||||
}
|
||||
|
||||
func New() *OrderedMap {
|
||||
func New() OrderedMap {
|
||||
o := OrderedMap{}
|
||||
o.keys = []string{}
|
||||
o.values = map[string]interface{}{}
|
||||
o.escapeHTML = true
|
||||
return &o
|
||||
return o
|
||||
}
|
||||
|
||||
func (o *OrderedMap) SetEscapeHTML(on bool) {
|
||||
@ -77,7 +77,11 @@ func (o *OrderedMap) Delete(key string) {
|
||||
}
|
||||
|
||||
func (o *OrderedMap) Keys() []string {
|
||||
return o.keys
|
||||
ret := make([]string, len(o.keys))
|
||||
for i, v := range o.keys {
|
||||
ret[i] = v
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
// SortKeys Sort the map keys using your sort func
|
||||
|
||||
@ -7,7 +7,7 @@ import (
|
||||
"github.com/KusakabeSi/EtherGuardVPN/config"
|
||||
)
|
||||
|
||||
const EgHeaderLen = 8
|
||||
const EgHeaderLen = 7
|
||||
|
||||
type EgHeader struct {
|
||||
buf []byte
|
||||
@ -16,8 +16,13 @@ type EgHeader struct {
|
||||
type Usage uint8
|
||||
|
||||
const (
|
||||
NornalPacket Usage = iota
|
||||
Register //Register to server
|
||||
MessageInitiationType Usage = iota
|
||||
MessageResponseType
|
||||
MessageCookieReplyType
|
||||
MessageTransportType
|
||||
|
||||
NornalPacket
|
||||
Register //Register to server
|
||||
|
||||
UpdatePeer //Comes from server
|
||||
UpdateNhTable
|
||||
@ -56,20 +61,12 @@ func (e EgHeader) GetTTL() uint8 {
|
||||
return e.buf[4]
|
||||
}
|
||||
func (e EgHeader) SetTTL(ttl uint8) {
|
||||
|
||||
e.buf[4] = ttl
|
||||
}
|
||||
|
||||
func (e EgHeader) GetUsage() Usage {
|
||||
return Usage(e.buf[5])
|
||||
}
|
||||
func (e EgHeader) SetUsage(usage Usage) {
|
||||
e.buf[5] = uint8(usage)
|
||||
}
|
||||
|
||||
func (e EgHeader) GetPacketLength() uint16 {
|
||||
return binary.BigEndian.Uint16(e.buf[6:8])
|
||||
return binary.BigEndian.Uint16(e.buf[5:7])
|
||||
}
|
||||
func (e EgHeader) SetPacketLength(length uint16) {
|
||||
binary.BigEndian.PutUint16(e.buf[6:8], length)
|
||||
binary.BigEndian.PutUint16(e.buf[5:7], length)
|
||||
}
|
||||
|
||||
@ -17,7 +17,7 @@ func (g *IG) InitNTP() {
|
||||
g.ntp_info.UseNTP = false
|
||||
return
|
||||
}
|
||||
g.ntp_servers = *orderedmap.New()
|
||||
g.ntp_servers = orderedmap.New()
|
||||
for _, url := range g.ntp_info.Servers {
|
||||
g.ntp_servers.Set(url, ntp.Response{
|
||||
RTT: forever,
|
||||
|
||||
@ -9,7 +9,7 @@ import (
|
||||
)
|
||||
|
||||
const (
|
||||
VPP_SUPPORT = "No VPP support"
|
||||
VPP_SUPPORT = "VPP support disabled"
|
||||
)
|
||||
|
||||
type VppTap struct {
|
||||
@ -18,8 +18,8 @@ type VppTap struct {
|
||||
}
|
||||
|
||||
// New creates and returns a new TUN interface for the application.
|
||||
func CreateVppTAP(iconfig config.InterfaceConf,NodeID config.Vertex, loglevel string) (tapdev Device, err error) {
|
||||
return nil, errors.New("VPP module not compiled.")
|
||||
func CreateVppTAP(iconfig config.InterfaceConf, NodeID config.Vertex, loglevel string) (tapdev Device, err error) {
|
||||
return nil, errors.New("VPP support disabled.")
|
||||
}
|
||||
|
||||
func (tap *VppTap) Read([]byte, int) (int, error) {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user