mirror of
https://github.com/status-im/status-go.git
synced 2025-01-09 22:26:30 +00:00
b2580c79d7
Network disconnect is introduced by removing default gateway, easily reversible condition. On my local machine it takes 30 seconds for peers to reconnect after connectivity is restored. As you guess this is not an accident, and there is 30 seconds timeout for dial expiration. This dial expiration is used in p2p.Server to guarantee that peers are not dialed too often. Additionally I added small script to Makefile to run such tests in docker environment, usage example: ``` make docker-test ARGS="./t/destructive/ -v -network=4" ```
335 lines
7.7 KiB
Go
335 lines
7.7 KiB
Go
package nl
|
|
|
|
import (
|
|
"unsafe"
|
|
)
|
|
|
|
const (
|
|
SizeofXfrmUsersaId = 0x18
|
|
SizeofXfrmStats = 0x0c
|
|
SizeofXfrmUsersaInfo = 0xe0
|
|
SizeofXfrmUserSpiInfo = 0xe8
|
|
SizeofXfrmAlgo = 0x44
|
|
SizeofXfrmAlgoAuth = 0x48
|
|
SizeofXfrmAlgoAEAD = 0x48
|
|
SizeofXfrmEncapTmpl = 0x18
|
|
SizeofXfrmUsersaFlush = 0x8
|
|
SizeofXfrmReplayStateEsn = 0x18
|
|
)
|
|
|
|
const (
|
|
XFRM_STATE_NOECN = 1
|
|
XFRM_STATE_DECAP_DSCP = 2
|
|
XFRM_STATE_NOPMTUDISC = 4
|
|
XFRM_STATE_WILDRECV = 8
|
|
XFRM_STATE_ICMP = 16
|
|
XFRM_STATE_AF_UNSPEC = 32
|
|
XFRM_STATE_ALIGN4 = 64
|
|
XFRM_STATE_ESN = 128
|
|
)
|
|
|
|
// struct xfrm_usersa_id {
|
|
// xfrm_address_t daddr;
|
|
// __be32 spi;
|
|
// __u16 family;
|
|
// __u8 proto;
|
|
// };
|
|
|
|
type XfrmUsersaId struct {
|
|
Daddr XfrmAddress
|
|
Spi uint32 // big endian
|
|
Family uint16
|
|
Proto uint8
|
|
Pad byte
|
|
}
|
|
|
|
func (msg *XfrmUsersaId) Len() int {
|
|
return SizeofXfrmUsersaId
|
|
}
|
|
|
|
func DeserializeXfrmUsersaId(b []byte) *XfrmUsersaId {
|
|
return (*XfrmUsersaId)(unsafe.Pointer(&b[0:SizeofXfrmUsersaId][0]))
|
|
}
|
|
|
|
func (msg *XfrmUsersaId) Serialize() []byte {
|
|
return (*(*[SizeofXfrmUsersaId]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|
|
|
|
// struct xfrm_stats {
|
|
// __u32 replay_window;
|
|
// __u32 replay;
|
|
// __u32 integrity_failed;
|
|
// };
|
|
|
|
type XfrmStats struct {
|
|
ReplayWindow uint32
|
|
Replay uint32
|
|
IntegrityFailed uint32
|
|
}
|
|
|
|
func (msg *XfrmStats) Len() int {
|
|
return SizeofXfrmStats
|
|
}
|
|
|
|
func DeserializeXfrmStats(b []byte) *XfrmStats {
|
|
return (*XfrmStats)(unsafe.Pointer(&b[0:SizeofXfrmStats][0]))
|
|
}
|
|
|
|
func (msg *XfrmStats) Serialize() []byte {
|
|
return (*(*[SizeofXfrmStats]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|
|
|
|
// struct xfrm_usersa_info {
|
|
// struct xfrm_selector sel;
|
|
// struct xfrm_id id;
|
|
// xfrm_address_t saddr;
|
|
// struct xfrm_lifetime_cfg lft;
|
|
// struct xfrm_lifetime_cur curlft;
|
|
// struct xfrm_stats stats;
|
|
// __u32 seq;
|
|
// __u32 reqid;
|
|
// __u16 family;
|
|
// __u8 mode; /* XFRM_MODE_xxx */
|
|
// __u8 replay_window;
|
|
// __u8 flags;
|
|
// #define XFRM_STATE_NOECN 1
|
|
// #define XFRM_STATE_DECAP_DSCP 2
|
|
// #define XFRM_STATE_NOPMTUDISC 4
|
|
// #define XFRM_STATE_WILDRECV 8
|
|
// #define XFRM_STATE_ICMP 16
|
|
// #define XFRM_STATE_AF_UNSPEC 32
|
|
// #define XFRM_STATE_ALIGN4 64
|
|
// #define XFRM_STATE_ESN 128
|
|
// };
|
|
//
|
|
// #define XFRM_SA_XFLAG_DONT_ENCAP_DSCP 1
|
|
//
|
|
|
|
type XfrmUsersaInfo struct {
|
|
Sel XfrmSelector
|
|
Id XfrmId
|
|
Saddr XfrmAddress
|
|
Lft XfrmLifetimeCfg
|
|
Curlft XfrmLifetimeCur
|
|
Stats XfrmStats
|
|
Seq uint32
|
|
Reqid uint32
|
|
Family uint16
|
|
Mode uint8
|
|
ReplayWindow uint8
|
|
Flags uint8
|
|
Pad [7]byte
|
|
}
|
|
|
|
func (msg *XfrmUsersaInfo) Len() int {
|
|
return SizeofXfrmUsersaInfo
|
|
}
|
|
|
|
func DeserializeXfrmUsersaInfo(b []byte) *XfrmUsersaInfo {
|
|
return (*XfrmUsersaInfo)(unsafe.Pointer(&b[0:SizeofXfrmUsersaInfo][0]))
|
|
}
|
|
|
|
func (msg *XfrmUsersaInfo) Serialize() []byte {
|
|
return (*(*[SizeofXfrmUsersaInfo]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|
|
|
|
// struct xfrm_userspi_info {
|
|
// struct xfrm_usersa_info info;
|
|
// __u32 min;
|
|
// __u32 max;
|
|
// };
|
|
|
|
type XfrmUserSpiInfo struct {
|
|
XfrmUsersaInfo XfrmUsersaInfo
|
|
Min uint32
|
|
Max uint32
|
|
}
|
|
|
|
func (msg *XfrmUserSpiInfo) Len() int {
|
|
return SizeofXfrmUserSpiInfo
|
|
}
|
|
|
|
func DeserializeXfrmUserSpiInfo(b []byte) *XfrmUserSpiInfo {
|
|
return (*XfrmUserSpiInfo)(unsafe.Pointer(&b[0:SizeofXfrmUserSpiInfo][0]))
|
|
}
|
|
|
|
func (msg *XfrmUserSpiInfo) Serialize() []byte {
|
|
return (*(*[SizeofXfrmUserSpiInfo]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|
|
|
|
// struct xfrm_algo {
|
|
// char alg_name[64];
|
|
// unsigned int alg_key_len; /* in bits */
|
|
// char alg_key[0];
|
|
// };
|
|
|
|
type XfrmAlgo struct {
|
|
AlgName [64]byte
|
|
AlgKeyLen uint32
|
|
AlgKey []byte
|
|
}
|
|
|
|
func (msg *XfrmAlgo) Len() int {
|
|
return SizeofXfrmAlgo + int(msg.AlgKeyLen/8)
|
|
}
|
|
|
|
func DeserializeXfrmAlgo(b []byte) *XfrmAlgo {
|
|
ret := XfrmAlgo{}
|
|
copy(ret.AlgName[:], b[0:64])
|
|
ret.AlgKeyLen = *(*uint32)(unsafe.Pointer(&b[64]))
|
|
ret.AlgKey = b[68:ret.Len()]
|
|
return &ret
|
|
}
|
|
|
|
func (msg *XfrmAlgo) Serialize() []byte {
|
|
b := make([]byte, msg.Len())
|
|
copy(b[0:64], msg.AlgName[:])
|
|
copy(b[64:68], (*(*[4]byte)(unsafe.Pointer(&msg.AlgKeyLen)))[:])
|
|
copy(b[68:msg.Len()], msg.AlgKey[:])
|
|
return b
|
|
}
|
|
|
|
// struct xfrm_algo_auth {
|
|
// char alg_name[64];
|
|
// unsigned int alg_key_len; /* in bits */
|
|
// unsigned int alg_trunc_len; /* in bits */
|
|
// char alg_key[0];
|
|
// };
|
|
|
|
type XfrmAlgoAuth struct {
|
|
AlgName [64]byte
|
|
AlgKeyLen uint32
|
|
AlgTruncLen uint32
|
|
AlgKey []byte
|
|
}
|
|
|
|
func (msg *XfrmAlgoAuth) Len() int {
|
|
return SizeofXfrmAlgoAuth + int(msg.AlgKeyLen/8)
|
|
}
|
|
|
|
func DeserializeXfrmAlgoAuth(b []byte) *XfrmAlgoAuth {
|
|
ret := XfrmAlgoAuth{}
|
|
copy(ret.AlgName[:], b[0:64])
|
|
ret.AlgKeyLen = *(*uint32)(unsafe.Pointer(&b[64]))
|
|
ret.AlgTruncLen = *(*uint32)(unsafe.Pointer(&b[68]))
|
|
ret.AlgKey = b[72:ret.Len()]
|
|
return &ret
|
|
}
|
|
|
|
func (msg *XfrmAlgoAuth) Serialize() []byte {
|
|
b := make([]byte, msg.Len())
|
|
copy(b[0:64], msg.AlgName[:])
|
|
copy(b[64:68], (*(*[4]byte)(unsafe.Pointer(&msg.AlgKeyLen)))[:])
|
|
copy(b[68:72], (*(*[4]byte)(unsafe.Pointer(&msg.AlgTruncLen)))[:])
|
|
copy(b[72:msg.Len()], msg.AlgKey[:])
|
|
return b
|
|
}
|
|
|
|
// struct xfrm_algo_aead {
|
|
// char alg_name[64];
|
|
// unsigned int alg_key_len; /* in bits */
|
|
// unsigned int alg_icv_len; /* in bits */
|
|
// char alg_key[0];
|
|
// }
|
|
|
|
type XfrmAlgoAEAD struct {
|
|
AlgName [64]byte
|
|
AlgKeyLen uint32
|
|
AlgICVLen uint32
|
|
AlgKey []byte
|
|
}
|
|
|
|
func (msg *XfrmAlgoAEAD) Len() int {
|
|
return SizeofXfrmAlgoAEAD + int(msg.AlgKeyLen/8)
|
|
}
|
|
|
|
func DeserializeXfrmAlgoAEAD(b []byte) *XfrmAlgoAEAD {
|
|
ret := XfrmAlgoAEAD{}
|
|
copy(ret.AlgName[:], b[0:64])
|
|
ret.AlgKeyLen = *(*uint32)(unsafe.Pointer(&b[64]))
|
|
ret.AlgICVLen = *(*uint32)(unsafe.Pointer(&b[68]))
|
|
ret.AlgKey = b[72:ret.Len()]
|
|
return &ret
|
|
}
|
|
|
|
func (msg *XfrmAlgoAEAD) Serialize() []byte {
|
|
b := make([]byte, msg.Len())
|
|
copy(b[0:64], msg.AlgName[:])
|
|
copy(b[64:68], (*(*[4]byte)(unsafe.Pointer(&msg.AlgKeyLen)))[:])
|
|
copy(b[68:72], (*(*[4]byte)(unsafe.Pointer(&msg.AlgICVLen)))[:])
|
|
copy(b[72:msg.Len()], msg.AlgKey[:])
|
|
return b
|
|
}
|
|
|
|
// struct xfrm_encap_tmpl {
|
|
// __u16 encap_type;
|
|
// __be16 encap_sport;
|
|
// __be16 encap_dport;
|
|
// xfrm_address_t encap_oa;
|
|
// };
|
|
|
|
type XfrmEncapTmpl struct {
|
|
EncapType uint16
|
|
EncapSport uint16 // big endian
|
|
EncapDport uint16 // big endian
|
|
Pad [2]byte
|
|
EncapOa XfrmAddress
|
|
}
|
|
|
|
func (msg *XfrmEncapTmpl) Len() int {
|
|
return SizeofXfrmEncapTmpl
|
|
}
|
|
|
|
func DeserializeXfrmEncapTmpl(b []byte) *XfrmEncapTmpl {
|
|
return (*XfrmEncapTmpl)(unsafe.Pointer(&b[0:SizeofXfrmEncapTmpl][0]))
|
|
}
|
|
|
|
func (msg *XfrmEncapTmpl) Serialize() []byte {
|
|
return (*(*[SizeofXfrmEncapTmpl]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|
|
|
|
// struct xfrm_usersa_flush {
|
|
// __u8 proto;
|
|
// };
|
|
|
|
type XfrmUsersaFlush struct {
|
|
Proto uint8
|
|
}
|
|
|
|
func (msg *XfrmUsersaFlush) Len() int {
|
|
return SizeofXfrmUsersaFlush
|
|
}
|
|
|
|
func DeserializeXfrmUsersaFlush(b []byte) *XfrmUsersaFlush {
|
|
return (*XfrmUsersaFlush)(unsafe.Pointer(&b[0:SizeofXfrmUsersaFlush][0]))
|
|
}
|
|
|
|
func (msg *XfrmUsersaFlush) Serialize() []byte {
|
|
return (*(*[SizeofXfrmUsersaFlush]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|
|
|
|
// struct xfrm_replay_state_esn {
|
|
// unsigned int bmp_len;
|
|
// __u32 oseq;
|
|
// __u32 seq;
|
|
// __u32 oseq_hi;
|
|
// __u32 seq_hi;
|
|
// __u32 replay_window;
|
|
// __u32 bmp[0];
|
|
// };
|
|
|
|
type XfrmReplayStateEsn struct {
|
|
BmpLen uint32
|
|
OSeq uint32
|
|
Seq uint32
|
|
OSeqHi uint32
|
|
SeqHi uint32
|
|
ReplayWindow uint32
|
|
Bmp []uint32
|
|
}
|
|
|
|
func (msg *XfrmReplayStateEsn) Serialize() []byte {
|
|
// We deliberately do not pass Bmp, as it gets set by the kernel.
|
|
return (*(*[SizeofXfrmReplayStateEsn]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|