func main() {
pid = os.Getpid()
log.Printf("%d starting", pid)
a, err := net.ResolveIPAddr("ip4", "127.0.0.1")
if err != nil {
log.Panic(err)
}
addr = a
conn, err := net.ListenIP("ip:253", addr)
if err != nil {
log.Panic(err)
}
buf := make([]byte, 9999)
i := 0
lim := 3
for {
n, ra, err := conn.ReadFromIP(buf)
if err != nil {
log.Panic(err)
}
s := string(buf[:n])
s = strings.TrimSpace(s)
log.Printf("received from %s: %s", ra.String(), s)
if i < lim {
i++
go send(fmt.Sprintf("%d:%d(%s)", pid, i, s))
}
}
}
func handlerResolve(w http.ResponseWriter, r *http.Request) {
lp, err := Localhost()
if err != nil {
panic(err)
}
ips := lp.String()
fmt.Println("ip:", ips) // 127.0.0.1
netaddr, err := net.ResolveIPAddr("ip4", ips)
if err != nil {
panic(err)
}
fmt.Println("netaddr:", netaddr.String()) // 127.0.0.1
conn, err := net.ListenIP("ip4:icmp", netaddr)
if err != nil {
panic(err)
}
buf := make([]byte, 1024)
num, _, _ := conn.ReadFrom(buf)
// build and ping localhost with sudo
fmt.Printf("ReadPacket: %X\n", buf[:num])
// ReadPacket: 0800FD6729...
}
// ListenEcho from routers in path
func ListenEcho(addresses chan string) {
localAddress, err := net.ResolveIPAddr(ICMP, LocalAddress)
Check(err)
c, err := net.ListenIP(ICMP, localAddress)
Check(err)
c.SetReadDeadline(time.Now().Add(time.Second * Deadline))
defer c.Close()
for {
buffer := make([]byte, BufferSize)
bytesRead, remoteAddress, err := c.ReadFromIP(buffer)
if e, ok := err.(net.Error); ok && e.Timeout() {
// if err were a timeout we don't raise panic
c.SetReadDeadline(time.Now().Add(time.Second * Deadline))
addresses <- ""
continue
} else {
Check(err)
}
if bytesRead > 0 {
addresses <- remoteAddress.String()
}
}
}
func receiveSynAck(localAddress, remoteAddress string) time.Time {
netaddr, err := net.ResolveIPAddr("ip4", localAddress)
if err != nil {
log.Fatalf("net.ResolveIPAddr: %s. %s\n", localAddress, netaddr)
}
conn, err := net.ListenIP("ip4:tcp", netaddr)
if err != nil {
log.Fatalf("ListenIP: %s\n", err)
}
var receiveTime time.Time
for {
buf := make([]byte, 1024)
numRead, raddr, err := conn.ReadFrom(buf)
if err != nil {
log.Fatalf("ReadFrom: %s\n", err)
}
if raddr.String() != remoteAddress {
// this is not the packet we are looking for
continue
}
receiveTime = time.Now()
//fmt.Printf("Received: % x\n", buf[:numRead])
tcp := NewTCPHeader(buf[:numRead])
// Closed port gets RST, open port gets SYN ACK
if tcp.HasFlag(RST) || (tcp.HasFlag(SYN) && tcp.HasFlag(ACK)) {
break
}
}
return receiveTime
}
// ListenMulticastIPv4 creates a net.IPConn to receive multicast messages for the given group
// address. laddr specifies which network interface to use when joining the group.
func ListenMulticastIPv4(gaddr, laddr net.IP) (*net.IPConn, error) {
gaddr = gaddr.To4()
laddr = laddr.To4()
c, err := net.ListenIP("ip4:112", &net.IPAddr{IP: gaddr})
if err != nil {
return nil, err
}
f, err := c.File()
if err != nil {
return nil, err
}
defer f.Close()
mreq := &syscall.IPMreq{
Multiaddr: [4]byte{gaddr[0], gaddr[1], gaddr[2], gaddr[3]},
Interface: [4]byte{laddr[0], laddr[1], laddr[2], laddr[3]},
}
err = syscall.SetsockoptIPMreq(int(f.Fd()), syscall.IPPROTO_IP, syscall.IP_ADD_MEMBERSHIP, mreq)
if err != nil {
return nil, err
}
return c, nil
}
// tcp guard
func tcpGuard() {
conn, err := net.ListenIP("ip4:tcp", &net.IPAddr{IP: serverIp})
if err != nil {
logMain(true, err.Error())
}
b := make([]byte, 1024)
var tcp TCPHeader
for {
numRead, remoteAddr, err := conn.ReadFromIP(b)
if err != nil {
logMain(false, "read from ip:%s", err.Error())
continue
}
NewTCPHeader(b[:numRead], &tcp)
/*nmap: Page 65 of RFC 793 says that “if the [destination] port state is
CLOSED .... an incoming segment not containing a RST causes a RST to be
sent in response.” Then the next page discusses packets sent to open
ports without the SYN, RST, or ACK bits set, stating that: “you are
unlikely to get here, but if you do, drop the segment, and return.”
*/
if tcp.HasFlag(RST) || tcp.HasFlag(ACK) {
continue
}
port := int(tcp.Destination)
ip := remoteAddr.IP
ipString := ip.String()
// is exclude port
if isExlcudePort(port) {
continue
}
// check ignore ip
if isIgnoredIP(ip) {
continue
}
// if blocked before
if isBlockedIP(ipString) {
continue
}
// verify port usage
if smartVerify(port) {
continue
}
logAlarm("attackalert: %s from host: %s to TCP port: %d",
*reportPacketType(tcp.Ctrl), ipString, port)
if checkStateEngine(ipString, port) {
logBlocked("Host: %s Port: %d TCP Blocked", ipString, port)
// run extern command
runExternalCommand(ipString, port)
}
}
}
func main() {
protocol := "icmp"
netaddr, _ := net.ResolveIPAddr("ip4", "127.0.0.1")
conn, _ := net.ListenIP("ip4:"+protocol, netaddr)
buf := make([]byte, 1024)
numRead, _, _ := conn.ReadFrom(buf)
fmt.Printf("% X\n", buf[:numRead])
}
func TestIPConnSpecificMethods(t *testing.T) {
switch runtime.GOOS {
case "plan9":
t.Logf("skipping read test on %q", runtime.GOOS)
return
}
if os.Getuid() != 0 {
t.Logf("skipping test; must be root")
return
}
la, err := net.ResolveIPAddr("ip4", "127.0.0.1")
if err != nil {
t.Fatalf("net.ResolveIPAddr failed: %v", err)
}
c, err := net.ListenIP("ip4:icmp", la)
if err != nil {
t.Fatalf("net.ListenIP failed: %v", err)
}
c.LocalAddr()
c.RemoteAddr()
c.SetDeadline(time.Now().Add(100 * time.Millisecond))
c.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
c.SetWriteDeadline(time.Now().Add(100 * time.Millisecond))
c.SetReadBuffer(2048)
c.SetWriteBuffer(2048)
defer c.Close()
id := os.Getpid() & 0xffff
wb := newICMPEchoRequest(id, 1, 128, []byte("IPCONN TEST "))
rb := make([]byte, 20+128)
if _, err := c.WriteToIP(wb, c.LocalAddr().(*net.IPAddr)); err != nil {
t.Errorf("net.IPConn.WriteToIP failed: %v", err)
return
}
if _, _, err := c.ReadFromIP(rb); err != nil {
t.Errorf("net.IPConn.ReadFromIP failed: %v", err)
return
}
if _, _, err := c.WriteMsgIP(wb, nil, c.LocalAddr().(*net.IPAddr)); err != nil {
condErrorf(t, "net.UDPConn.WriteMsgIP failed: %v", err)
return
}
if _, _, _, _, err := c.ReadMsgIP(rb, nil); err != nil {
condErrorf(t, "net.UDPConn.ReadMsgIP failed: %v", err)
return
}
if f, err := c.File(); err != nil {
condErrorf(t, "net.IPConn.File failed: %v", err)
return
} else {
f.Close()
}
}
func NewICMPClient(localAddr *net.IPAddr) (*ICMPClient, os.Error) {
client := new(ICMPClient)
client.localAddr = localAddr
conn, e := net.ListenIP("ip4:icmp", localAddr)
if e != nil {
fmt.Printf("%s\n", e)
return nil, e
}
client.conn = conn
return client, nil
}
func udpGuard() {
conn, err := net.ListenIP("ip4:udp", &net.IPAddr{IP: serverIp})
if err != nil {
logMain(true, err.Error())
}
b := make([]byte, 1024)
var udp UDPHeader
for {
numRead, remoteAddr, err := conn.ReadFromIP(b)
if err != nil {
logMain(false, "read from ip:%s", err.Error())
continue
}
NewUDPHeader(b[:numRead], &udp)
port := int(udp.Destination)
// ignore noisy port
if _, ok := cfgNoisyPorts[port]; ok {
continue
}
log.Printf("%v: %d->%d", remoteAddr, udp.Source, udp.Destination)
ip := remoteAddr.IP
ipString := ip.String()
// is exclude port
if isExlcudePort(port) {
continue
}
// check ignore ip
if isIgnoredIP(ip) {
continue
}
// if blocked before
if isBlockedIP(ipString) {
continue
}
// verify port usage
if smartVerify(port) {
continue
}
logAlarm("attackalert: UDP scan from host: %s to UDP port: %d", ipString, port)
if checkStateEngine(ipString, port) {
logBlocked("Host: %s Port: %d UDP Blocked", ipString, port)
// run extern command
runExternalCommand(ipString, port)
}
}
}
func main() {
name, err := os.Hostname()
checkError(err)
ipAddr, err := net.ResolveIPAddr("ipv4", name)
checkError(err)
conn, err := net.ListenIP("ip4:ip", ipAddr)
checkError(err)
for {
handleClient(conn)
}
}
func (p *Pinger) listen(netProto string) *net.IPConn {
conn, err := net.ListenIP(netProto, p.ListenAddr)
if err != nil {
p.mu.Lock()
p.ctx.err = err
p.mu.Unlock()
p.debugln("Run(): close(p.ctx.done)")
close(p.ctx.done)
return nil
}
return conn
}
func main() {
protocol := "icmp"
netaddr, _ := net.ResolveIPAddr("ip4", "127.0.0.1")
for {
conn, _ := net.ListenIP("ip4:"+protocol, netaddr)
buf := make([]byte, 1024)
numRead, _, _ := conn.ReadFrom(buf)
s := string(buf[:numRead])
fmt.Println(s)
}
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
bcastIP := "127.0.0.1"
flag.Parse()
if myID == -1 || nGroup == -1 {
log.Panic("usage")
}
log.Printf("upaxos id(%d) started in group of %d", myID, nGroup)
defer log.Printf("upaxos id(%d) ending", myID)
lfr, lfw := logfile(myID)
promises, accepts, learnings := loadLogData(lfr)
lfw.Printf("starting %d", myID)
// begin listening on my well known address
la, err := net.ResolveIPAddr("ip4", bcastIP)
if err != nil {
log.Panic(err)
}
conn, err := net.ListenIP(groupIPProto, la)
if err != nil {
log.Panic(err)
}
sendDest, err = net.ResolveIPAddr("ip4", bcastIP)
if err != nil {
log.Panic(err)
}
leadc := make(chan Msg)
acceptc := make(chan Msg)
learnc := make(chan Msg)
mainc := make(chan Msg)
receivers = []chan Msg{leadc, acceptc, learnc, mainc}
go lead(leadc)
go accept(acceptc, lfw, promises, accepts)
go learn(learnc, lfw, learnings)
go listen(conn)
loop:
for m := range mainc {
if len(m.f) > 0 {
switch m.f[0] {
case "quit":
fallthrough
case "exit":
fallthrough
case "bye":
log.Print("exiting")
break loop
}
}
}
}
func IcmpPing(addr string, timeout time.Duration) (time.Duration, error) {
raddr, err := net.ResolveIPAddr("ip4", addr) // *IPAddr
if err != nil {
return 0, err
}
ipconn, err := net.ListenIP("ip4:icmp", nil) // *IPConn (Conn 인터페이스 구현)
if err != nil {
return 0, err
}
sendid := os.Getpid() & 0xffff
sendseq := 1
pingpktlen := 64
sendpkt := makePingRequest(sendid, sendseq, pingpktlen, []byte("Go Ping"))
start := time.Now()
n, err := ipconn.WriteToIP(sendpkt, raddr)
if err != nil || n != pingpktlen {
return 0, err
}
ipconn.SetReadDeadline(start.Add(timeout)) // 0.5 second
resp := make([]byte, 1024)
for {
_, _, err := ipconn.ReadFrom(resp)
//fmt.Printf("%d bytes from %s: icmp_req=%d time=%.2f ms\n", n, dst, sendseq, elapsedTime(start))
if err != nil {
return 0, err
}
if resp[0] != ICMP_ECHO_REPLY {
continue
}
rcvid, rcvseq := parsePingReply(resp)
if rcvid != sendid || rcvseq != sendseq {
return 0, err
}
break
}
return time.Now().Sub(start), nil
}
func main() {
ipc, err := net.ListenIP("ip4:udp", &net.IPAddr{IP: net.ParseIP("127.0.0.1")})
if err != nil {
fmt.Printf("Error: %v\n", err)
return
}
bf := make([]byte, 8192)
for {
if n, err := ipc.Read(bf); err != nil {
fmt.Printf("Error: %v\n", err)
return
} else {
fmt.Printf("Recieve[127.0.0.1]:%v\n", bf[:n])
}
}
}
func main() {
la, err := net.ResolveIPAddr("ip4", "127.0.0.1")
if err != nil {
log.Panic(err)
}
conn, err := net.ListenIP("ip:253", la)
if err != nil {
log.Panic(err)
}
buf := make([]byte, 9999)
for {
n, ra, err := conn.ReadFromIP(buf)
if err != nil {
log.Panic(err)
}
log.Printf("received from %s: %s", ra.String(), string(buf[:n]))
}
}
func (s *Server) ListenAndServeICMPv6() {
ipAddr := &net.IPAddr{IP: net.IPv6linklocalallrouters, Zone: "tap" + s.name}
conn, err := net.ListenIP("ip6:58", ipAddr)
if err != nil {
l.Info("error: " + err.Error())
return
}
defer conn.Close()
if err = bindToDevice(conn, "tap"+s.name); err != nil {
l.Info("error: " + err.Error())
return
}
s.Lock()
s.ipv6conn = ipv6.NewPacketConn(conn)
s.Unlock()
if err = s.ipv6conn.SetControlMessage(ipv6.FlagDst, true); err != nil {
l.Info(err.Error())
return
}
buffer := make([]byte, 1500)
go s.Unsolicitated()
for {
select {
case <-s.done:
return
default:
s.ipv6conn.SetReadDeadline(time.Now().Add(1 * time.Second))
if _, _, src, err := s.ipv6conn.ReadFrom(buffer); err == nil {
req := &ICMPv6{}
if err = req.Unmarshal(buffer); err == nil {
if req.Type == uint8(ipv6.ICMPTypeRouterSolicitation) {
s.sendRA(src)
}
}
}
}
}
}
func main() {
// Resolve binding address
netaddr, err := net.ResolveIPAddr("ip6", "::")
if err != nil {
log.Fatal("Cannot resolve address\n")
}
fmt.Println("Listen on :", netaddr)
// listen on ICMPv6
conn, err := net.ListenIP("ip6:58", netaddr)
if err != nil {
log.Fatal("Cannot listen raw socket\n")
}
buf := make([]byte, 1024)
for {
// read data from raw socket
numRead, addr, _ := conn.ReadFrom(buf)
fmt.Printf("Read %d bytes from %s\n", numRead, addr)
}
}
func main() {
//ripa, err := net.ResolveIPAddr("ip", "192.168.135.253")
ripa, err := net.ResolveIPAddr("ip", "localhost")
if err != nil {
fmt.Printf("Error: %v\n", err)
return
}
lp, err1 := net.ListenIP("ip:icmp", ripa)
if err1 != nil {
fmt.Printf("Error1: %v\n", err1)
return
}
for {
buffer := make(myByte, 4096)
if n, addr, err := lp.ReadFrom(buffer); err != nil {
fmt.Printf("Error2: %v\n", err)
return
} else {
fmt.Printf("Revieve from %v => %v\n", addr, buffer[:n])
}
}
}
func main() {
var err error
// create redis connection pool
if db, err = pool.New("tcp", "localhost:6379", 10); err != nil {
panic(err)
}
defer db.Empty()
dbc, err := db.Get()
if err != nil {
fmt.Println(err)
}
for k, v := range defaultConfig {
dbc.PipeAppend("HSETNX", "fahrrad/config", k, v)
}
for k, _ := range defaultConfig {
dbc.PipeAppend("HGET", "fahrrad/config", k)
}
for _, _ = range defaultConfig {
dbc.PipeResp()
}
var v int
v, err = dbc.PipeResp().Int()
if err == nil {
AssignedPrefixLength = uint8(v)
}
v, err = dbc.PipeResp().Int()
if err == nil {
OnLinkPrefixLength = uint8(v)
}
v, err = dbc.PipeResp().Int()
if err == nil {
DefaultValidLifetime = uint32(v)
}
v, err = dbc.PipeResp().Int()
if err == nil {
DefaultPreferredLifetime = uint32(v)
}
v, err = dbc.PipeResp().Int()
if err == nil {
TickerDelay = time.Duration(v) * time.Second
}
defer db.Put(dbc)
// open listening connection
conn, err := net.ListenIP("ip6:ipv6-icmp", &net.IPAddr{net.IPv6unspecified, ""})
if err != nil {
panic(err)
}
defer conn.Close()
pc = ipv6.NewPacketConn(conn)
// RFC4861 requires the hop limit set to 255, but the default value in golang is 64
pc.SetHopLimit(255)
// only accept neighbor discovery messages
filter := new(ipv6.ICMPFilter)
filter.SetAll(true)
filter.Accept(ipv6.ICMPTypeRouterSolicitation)
filter.Accept(ipv6.ICMPTypeRouterAdvertisement)
filter.Accept(ipv6.ICMPTypeNeighborSolicitation)
filter.Accept(ipv6.ICMPTypeNeighborAdvertisement)
if err = pc.SetICMPFilter(filter); err != nil {
panic(err)
}
rschan = make(chan routerSolicitation)
go hostManager()
// read from socket
buf := make([]byte, 512)
for {
n, _, srcAddr, err := pc.ReadFrom(buf)
if err != nil {
panic(err)
}
go handleND(srcAddr, buf[:n])
}
}
func (s *Server) ListenAndServeUDPv4() {
ipAddr := &net.IPAddr{IP: net.IPv4zero}
conn, err := net.ListenIP("ip4:udp", ipAddr)
if err != nil {
l.Info(err.Error())
return
}
defer conn.Close()
if err = bindToDevice(conn, "tap"+s.name); err != nil {
l.Info(err.Error())
return
}
s.Lock()
s.ipv4conn, err = ipv4.NewRawConn(conn)
s.Unlock()
if err != nil {
l.Info(err.Error())
return
}
if err = s.ipv4conn.SetControlMessage(ipv4.FlagDst, true); err != nil {
l.Warning(err.Error())
return
}
buffer := make([]byte, 1500)
var gw net.IP
for _, addr := range s.metadata.Network.IP {
if addr.Family == "ipv4" && addr.Host == "true" && addr.Gateway == "true" {
gw = net.ParseIP(addr.Address)
}
}
iface, err := net.InterfaceByName("tap" + s.name)
if err != nil {
l.Info(fmt.Sprintf("failed to get iface: %s", err.Error()))
return
}
for {
select {
case <-s.done:
return
default:
s.ipv4conn.SetReadDeadline(time.Now().Add(time.Second))
hdr, _, _, err := s.ipv4conn.ReadFrom(buffer)
if err != nil {
switch v := err.(type) {
case *net.OpError:
if v.Timeout() {
continue
}
case *net.AddrError:
if v.Timeout() {
continue
}
case *net.UnknownNetworkError:
if v.Timeout() {
continue
}
default:
l.Warning(err.Error())
return
}
}
var ip4 layers.IPv4
var udp layers.UDP
var dhcp4req layers.DHCPv4
parser := gopacket.NewDecodingLayerParser(layers.LayerTypeIPv4, &ip4, &udp, &dhcp4req)
decoded := []gopacket.LayerType{}
err = parser.DecodeLayers(buffer, &decoded)
for _, layerType := range decoded {
switch layerType {
case layers.LayerTypeDHCPv4:
if dhcp4req.Operation == layers.DHCP_MSG_REQ {
dhcp4res, err := s.ServeUDPv4(&dhcp4req)
if err != nil {
l.Warning(err.Error())
continue
}
if dhcp4res == nil {
// ignore empty dhcp packets
continue
}
buf := gopacket.NewSerializeBuffer()
opts := gopacket.SerializeOptions{true, true}
gopacket.SerializeLayers(buf, opts,
&layers.UDP{SrcPort: 67, DstPort: 68},
dhcp4res)
wcm := ipv4.ControlMessage{TTL: 255}
wcm.Dst = net.IPv4bcast.To4()
wcm.Src = gw.To4()
wcm.IfIndex = iface.Index
err = s.ipv4conn.WriteTo(&ipv4.Header{Len: 20, TOS: hdr.TOS, TotalLen: 20 + int(len(buf.Bytes())), FragOff: 0, TTL: 255, Protocol: int(layers.IPProtocolUDP), Src: gw.To4(), Dst: net.IPv4bcast.To4()}, buf.Bytes(), &wcm)
if err != nil {
l.Warning(err.Error())
continue
}
} else {
continue
}
}
}
}
}
}
func PingPoller(service chan PingRequest) {
srchost := ""
for {
r := <-service
log.Printf("Received request for %s", r.dsthost)
var (
laddr *net.IPAddr
err error
)
raddr, err := net.ResolveIPAddr("ip", r.dsthost)
if err != nil {
log.Println(`net.ResolveIPAddr("%v") = %v, %v`, r.dsthost, raddr, err)
reply := PingResponse{r.dsthost, -1}
r.responseChannel <- reply
continue
}
c, err := net.ListenIP("ip4:icmp", laddr)
if err != nil {
log.Println(`net.ListenIP("ip4:icmp", %v) = %v, %v`, srchost, c, err)
reply := PingResponse{r.dsthost, -1}
r.responseChannel <- reply
continue
}
sendid := os.Getpid() & 0xffff
const sendseq = 61455
const pingpktlen = 128
sendpkt := makePingRequest(sendid, sendseq, pingpktlen, []byte("Go Go Gadget Ping!!!"))
start := time.Now()
n, err := c.WriteToIP(sendpkt, raddr)
if err != nil || n != pingpktlen {
log.Println(`net.WriteToIP(..., %v) = %v, %v`, raddr, n, err)
reply := PingResponse{r.dsthost, -1}
r.responseChannel <- reply
continue
}
c.SetReadDeadline(time.Now().Add(time.Second * 2))
resp := make([]byte, 1024)
for {
n, from, err := c.ReadFrom(resp)
if err != nil {
log.Println(`ReadFrom(...) = %v, %v, %v`, n, from, err)
reply := PingResponse{r.dsthost, -1}
r.responseChannel <- reply
break
}
if resp[0] != ICMP_ECHO_REPLY {
continue
}
rcvid, rcvseq := parsePingReply(resp)
end := time.Now()
if rcvid != sendid || rcvseq != sendseq {
log.Println(`Ping reply saw id,seq=0x%x,0x%x (expected 0x%x, 0x%x)`, rcvid, rcvseq, sendid, sendseq)
reply := PingResponse{r.dsthost, -1}
r.responseChannel <- reply
break
}
log.Println("response took %d nanoseconds.", end.Sub(start))
reply := PingResponse{r.dsthost, int64(end.Sub(start))}
r.responseChannel <- reply
break
}
log.Println("saw no ping return")
reply := PingResponse{r.dsthost, -1}
r.responseChannel <- reply
}
}
func createICMP4Connection() (*net.IPConn, error) {
return net.ListenIP("ip4:icmp", &net.IPAddr{IP: net.IPv4zero})
}
// IPConn creates a net.IPConn using the given local and remote addresses using IP protocol
// 112 (VRRP).
func IPConn(localAddr, remoteAddr net.IP) (*net.IPConn, error) {
c, err := net.ListenIP("ip:112", &net.IPAddr{IP: localAddr})
if err != nil {
return nil, err
}
f, err := c.File()
if err != nil {
return nil, err
}
defer f.Close()
ip4 := localAddr.To4()
switch {
case ip4 != nil && !remoteAddr.IsMulticast():
// IPv4 unicast
// TTL = 255 per VRRP spec
if err := setsockopt(f, syscall.IPPROTO_IP, syscall.IP_TTL, 255); err != nil {
return nil, err
}
case ip4 != nil && remoteAddr.IsMulticast():
// IPv4 multicast
// TTL = 255 per VRRP spec
if err := setsockopt(f, syscall.IPPROTO_IP, syscall.IP_MULTICAST_TTL, 255); err != nil {
return nil, err
}
// We don't want to receive our own messages.
if err := setsockopt(f, syscall.IPPROTO_IP, syscall.IP_MULTICAST_LOOP, 0); err != nil {
return nil, err
}
case ip4 == nil && !remoteAddr.IsMulticast():
// IPv6 unicast
// HOPLIMIT = 255 per VRRP spec
if err := setsockopt(f, syscall.IPPROTO_IPV6, syscall.IPV6_UNICAST_HOPS, 255); err != nil {
return nil, err
}
case ip4 == nil && remoteAddr.IsMulticast():
// IPv6 multicast
// HOPLIMIT = 255 per VRRP spec
if err := setsockopt(f, syscall.IPPROTO_IPV6, syscall.IPV6_MULTICAST_HOPS, 255); err != nil {
return nil, err
}
// We don't want to receive our own messages.
if err := setsockopt(f, syscall.IPPROTO_IPV6, syscall.IPV6_MULTICAST_LOOP, 0); err != nil {
return nil, err
}
}
if ip4 == nil {
// IPv6 unicast and multicast
// Request that the ancillary data for received packets include the hop limit and the
// destination address.
// TODO(angusc): syscall.IPV6_RECVHOPLIMIT and syscall.IPV6_RECVPKTINFO are prefered but they
// don't work on lucid.
if err := setsockopt(f, syscall.IPPROTO_IPV6, syscall.IPV6_2292HOPLIMIT, 1); err != nil {
return nil, err
}
if err := setsockopt(f, syscall.IPPROTO_IPV6, syscall.IPV6_2292PKTINFO, 1); err != nil {
return nil, err
}
}
log.Infof("ha.IPConn: laddr=%v, raddr=%v", localAddr, remoteAddr)
return c, nil
}
