mirror of
https://github.com/status-im/status-go.git
synced 2025-02-02 01:47:44 +00:00
707221954f
This change adds adds an ability to use different source of time for whisper: when envelope is created it is used to set expiry to track when envelope needs to be expired This time is then used to check validity of the envelope when it is received. Currently If we receive an envelope that is sent from future - peer will get disconnected. If envelope that was received has an expiry less then now it will be simply dropped, if expiry is less than now + 10*2 seconds peer will get dropped. So, it is clear that whisper depends on time. And any time we get a skew with peers that is > 20s reliability will be grealy reduced. In this change another source of time for whisper will be used. This time source will use ntp servers from pool.ntp.org to compute offset. When whisper queries time - this offset will be added/substracted from current time. Query is executed every 2 mins, queries 5 different servers, cut offs min and max and the computes mean value. pool.ntp.org is resolved to different servers and according to documentation you will rarely hit the same. Closes: #687
245 lines
7.8 KiB
Go
245 lines
7.8 KiB
Go
// Copyright 2012 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package ipv4 implements IP-level socket options for the Internet
|
|
// Protocol version 4.
|
|
//
|
|
// The package provides IP-level socket options that allow
|
|
// manipulation of IPv4 facilities.
|
|
//
|
|
// The IPv4 protocol and basic host requirements for IPv4 are defined
|
|
// in RFC 791 and RFC 1122.
|
|
// Host extensions for multicasting and socket interface extensions
|
|
// for multicast source filters are defined in RFC 1112 and RFC 3678.
|
|
// IGMPv1, IGMPv2 and IGMPv3 are defined in RFC 1112, RFC 2236 and RFC
|
|
// 3376.
|
|
// Source-specific multicast is defined in RFC 4607.
|
|
//
|
|
//
|
|
// Unicasting
|
|
//
|
|
// The options for unicasting are available for net.TCPConn,
|
|
// net.UDPConn and net.IPConn which are created as network connections
|
|
// that use the IPv4 transport. When a single TCP connection carrying
|
|
// a data flow of multiple packets needs to indicate the flow is
|
|
// important, Conn is used to set the type-of-service field on the
|
|
// IPv4 header for each packet.
|
|
//
|
|
// ln, err := net.Listen("tcp4", "0.0.0.0:1024")
|
|
// if err != nil {
|
|
// // error handling
|
|
// }
|
|
// defer ln.Close()
|
|
// for {
|
|
// c, err := ln.Accept()
|
|
// if err != nil {
|
|
// // error handling
|
|
// }
|
|
// go func(c net.Conn) {
|
|
// defer c.Close()
|
|
//
|
|
// The outgoing packets will be labeled DiffServ assured forwarding
|
|
// class 1 low drop precedence, known as AF11 packets.
|
|
//
|
|
// if err := ipv4.NewConn(c).SetTOS(0x28); err != nil {
|
|
// // error handling
|
|
// }
|
|
// if _, err := c.Write(data); err != nil {
|
|
// // error handling
|
|
// }
|
|
// }(c)
|
|
// }
|
|
//
|
|
//
|
|
// Multicasting
|
|
//
|
|
// The options for multicasting are available for net.UDPConn and
|
|
// net.IPconn which are created as network connections that use the
|
|
// IPv4 transport. A few network facilities must be prepared before
|
|
// you begin multicasting, at a minimum joining network interfaces and
|
|
// multicast groups.
|
|
//
|
|
// en0, err := net.InterfaceByName("en0")
|
|
// if err != nil {
|
|
// // error handling
|
|
// }
|
|
// en1, err := net.InterfaceByIndex(911)
|
|
// if err != nil {
|
|
// // error handling
|
|
// }
|
|
// group := net.IPv4(224, 0, 0, 250)
|
|
//
|
|
// First, an application listens to an appropriate address with an
|
|
// appropriate service port.
|
|
//
|
|
// c, err := net.ListenPacket("udp4", "0.0.0.0:1024")
|
|
// if err != nil {
|
|
// // error handling
|
|
// }
|
|
// defer c.Close()
|
|
//
|
|
// Second, the application joins multicast groups, starts listening to
|
|
// the groups on the specified network interfaces. Note that the
|
|
// service port for transport layer protocol does not matter with this
|
|
// operation as joining groups affects only network and link layer
|
|
// protocols, such as IPv4 and Ethernet.
|
|
//
|
|
// p := ipv4.NewPacketConn(c)
|
|
// if err := p.JoinGroup(en0, &net.UDPAddr{IP: group}); err != nil {
|
|
// // error handling
|
|
// }
|
|
// if err := p.JoinGroup(en1, &net.UDPAddr{IP: group}); err != nil {
|
|
// // error handling
|
|
// }
|
|
//
|
|
// The application might set per packet control message transmissions
|
|
// between the protocol stack within the kernel. When the application
|
|
// needs a destination address on an incoming packet,
|
|
// SetControlMessage of PacketConn is used to enable control message
|
|
// transmissions.
|
|
//
|
|
// if err := p.SetControlMessage(ipv4.FlagDst, true); err != nil {
|
|
// // error handling
|
|
// }
|
|
//
|
|
// The application could identify whether the received packets are
|
|
// of interest by using the control message that contains the
|
|
// destination address of the received packet.
|
|
//
|
|
// b := make([]byte, 1500)
|
|
// for {
|
|
// n, cm, src, err := p.ReadFrom(b)
|
|
// if err != nil {
|
|
// // error handling
|
|
// }
|
|
// if cm.Dst.IsMulticast() {
|
|
// if cm.Dst.Equal(group) {
|
|
// // joined group, do something
|
|
// } else {
|
|
// // unknown group, discard
|
|
// continue
|
|
// }
|
|
// }
|
|
//
|
|
// The application can also send both unicast and multicast packets.
|
|
//
|
|
// p.SetTOS(0x0)
|
|
// p.SetTTL(16)
|
|
// if _, err := p.WriteTo(data, nil, src); err != nil {
|
|
// // error handling
|
|
// }
|
|
// dst := &net.UDPAddr{IP: group, Port: 1024}
|
|
// for _, ifi := range []*net.Interface{en0, en1} {
|
|
// if err := p.SetMulticastInterface(ifi); err != nil {
|
|
// // error handling
|
|
// }
|
|
// p.SetMulticastTTL(2)
|
|
// if _, err := p.WriteTo(data, nil, dst); err != nil {
|
|
// // error handling
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
//
|
|
// More multicasting
|
|
//
|
|
// An application that uses PacketConn or RawConn may join multiple
|
|
// multicast groups. For example, a UDP listener with port 1024 might
|
|
// join two different groups across over two different network
|
|
// interfaces by using:
|
|
//
|
|
// c, err := net.ListenPacket("udp4", "0.0.0.0:1024")
|
|
// if err != nil {
|
|
// // error handling
|
|
// }
|
|
// defer c.Close()
|
|
// p := ipv4.NewPacketConn(c)
|
|
// if err := p.JoinGroup(en0, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 248)}); err != nil {
|
|
// // error handling
|
|
// }
|
|
// if err := p.JoinGroup(en0, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 249)}); err != nil {
|
|
// // error handling
|
|
// }
|
|
// if err := p.JoinGroup(en1, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 249)}); err != nil {
|
|
// // error handling
|
|
// }
|
|
//
|
|
// It is possible for multiple UDP listeners that listen on the same
|
|
// UDP port to join the same multicast group. The net package will
|
|
// provide a socket that listens to a wildcard address with reusable
|
|
// UDP port when an appropriate multicast address prefix is passed to
|
|
// the net.ListenPacket or net.ListenUDP.
|
|
//
|
|
// c1, err := net.ListenPacket("udp4", "224.0.0.0:1024")
|
|
// if err != nil {
|
|
// // error handling
|
|
// }
|
|
// defer c1.Close()
|
|
// c2, err := net.ListenPacket("udp4", "224.0.0.0:1024")
|
|
// if err != nil {
|
|
// // error handling
|
|
// }
|
|
// defer c2.Close()
|
|
// p1 := ipv4.NewPacketConn(c1)
|
|
// if err := p1.JoinGroup(en0, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 248)}); err != nil {
|
|
// // error handling
|
|
// }
|
|
// p2 := ipv4.NewPacketConn(c2)
|
|
// if err := p2.JoinGroup(en0, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 248)}); err != nil {
|
|
// // error handling
|
|
// }
|
|
//
|
|
// Also it is possible for the application to leave or rejoin a
|
|
// multicast group on the network interface.
|
|
//
|
|
// if err := p.LeaveGroup(en0, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 248)}); err != nil {
|
|
// // error handling
|
|
// }
|
|
// if err := p.JoinGroup(en0, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 250)}); err != nil {
|
|
// // error handling
|
|
// }
|
|
//
|
|
//
|
|
// Source-specific multicasting
|
|
//
|
|
// An application that uses PacketConn or RawConn on IGMPv3 supported
|
|
// platform is able to join source-specific multicast groups.
|
|
// The application may use JoinSourceSpecificGroup and
|
|
// LeaveSourceSpecificGroup for the operation known as "include" mode,
|
|
//
|
|
// ssmgroup := net.UDPAddr{IP: net.IPv4(232, 7, 8, 9)}
|
|
// ssmsource := net.UDPAddr{IP: net.IPv4(192, 168, 0, 1)})
|
|
// if err := p.JoinSourceSpecificGroup(en0, &ssmgroup, &ssmsource); err != nil {
|
|
// // error handling
|
|
// }
|
|
// if err := p.LeaveSourceSpecificGroup(en0, &ssmgroup, &ssmsource); err != nil {
|
|
// // error handling
|
|
// }
|
|
//
|
|
// or JoinGroup, ExcludeSourceSpecificGroup,
|
|
// IncludeSourceSpecificGroup and LeaveGroup for the operation known
|
|
// as "exclude" mode.
|
|
//
|
|
// exclsource := net.UDPAddr{IP: net.IPv4(192, 168, 0, 254)}
|
|
// if err := p.JoinGroup(en0, &ssmgroup); err != nil {
|
|
// // error handling
|
|
// }
|
|
// if err := p.ExcludeSourceSpecificGroup(en0, &ssmgroup, &exclsource); err != nil {
|
|
// // error handling
|
|
// }
|
|
// if err := p.LeaveGroup(en0, &ssmgroup); err != nil {
|
|
// // error handling
|
|
// }
|
|
//
|
|
// Note that it depends on each platform implementation what happens
|
|
// when an application which runs on IGMPv3 unsupported platform uses
|
|
// JoinSourceSpecificGroup and LeaveSourceSpecificGroup.
|
|
// In general the platform tries to fall back to conversations using
|
|
// IGMPv1 or IGMPv2 and starts to listen to multicast traffic.
|
|
// In the fallback case, ExcludeSourceSpecificGroup and
|
|
// IncludeSourceSpecificGroup may return an error.
|
|
package ipv4 // import "golang.org/x/net/ipv4"
|
|
|
|
// BUG(mikio): This package is not implemented on NaCl and Plan 9.
|