example_test.go

Documentation: golang.org/x/net/ipv6

     1  // Copyright 2014 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package ipv6_test
     6  
     7  import (
     8  	"fmt"
     9  	"log"
    10  	"net"
    11  	"os"
    12  	"time"
    13  
    14  	"golang.org/x/net/icmp"
    15  	"golang.org/x/net/ipv6"
    16  )
    17  
    18  func ExampleConn_markingTCP() {
    19  	ln, err := net.Listen("tcp", "[::]:1024")
    20  	if err != nil {
    21  		log.Fatal(err)
    22  	}
    23  	defer ln.Close()
    24  
    25  	for {
    26  		c, err := ln.Accept()
    27  		if err != nil {
    28  			log.Fatal(err)
    29  		}
    30  		go func(c net.Conn) {
    31  			defer c.Close()
    32  			if c.RemoteAddr().(*net.TCPAddr).IP.To16() != nil && c.RemoteAddr().(*net.TCPAddr).IP.To4() == nil {
    33  				p := ipv6.NewConn(c)
    34  				if err := p.SetTrafficClass(0x28); err != nil { // DSCP AF11
    35  					log.Fatal(err)
    36  				}
    37  				if err := p.SetHopLimit(128); err != nil {
    38  					log.Fatal(err)
    39  				}
    40  			}
    41  			if _, err := c.Write([]byte("HELLO-R-U-THERE-ACK")); err != nil {
    42  				log.Fatal(err)
    43  			}
    44  		}(c)
    45  	}
    46  }
    47  
    48  func ExamplePacketConn_servingOneShotMulticastDNS() {
    49  	c, err := net.ListenPacket("udp6", "[::]:5353") // mDNS over UDP
    50  	if err != nil {
    51  		log.Fatal(err)
    52  	}
    53  	defer c.Close()
    54  	p := ipv6.NewPacketConn(c)
    55  
    56  	en0, err := net.InterfaceByName("en0")
    57  	if err != nil {
    58  		log.Fatal(err)
    59  	}
    60  	mDNSLinkLocal := net.UDPAddr{IP: net.ParseIP("ff02::fb")}
    61  	if err := p.JoinGroup(en0, &mDNSLinkLocal); err != nil {
    62  		log.Fatal(err)
    63  	}
    64  	defer p.LeaveGroup(en0, &mDNSLinkLocal)
    65  	if err := p.SetControlMessage(ipv6.FlagDst|ipv6.FlagInterface, true); err != nil {
    66  		log.Fatal(err)
    67  	}
    68  
    69  	var wcm ipv6.ControlMessage
    70  	b := make([]byte, 1500)
    71  	for {
    72  		_, rcm, peer, err := p.ReadFrom(b)
    73  		if err != nil {
    74  			log.Fatal(err)
    75  		}
    76  		if !rcm.Dst.IsMulticast() || !rcm.Dst.Equal(mDNSLinkLocal.IP) {
    77  			continue
    78  		}
    79  		wcm.IfIndex = rcm.IfIndex
    80  		answers := []byte("FAKE-MDNS-ANSWERS") // fake mDNS answers, you need to implement this
    81  		if _, err := p.WriteTo(answers, &wcm, peer); err != nil {
    82  			log.Fatal(err)
    83  		}
    84  	}
    85  }
    86  
    87  func ExamplePacketConn_tracingIPPacketRoute() {
    88  	// Tracing an IP packet route to www.google.com.
    89  
    90  	const host = "www.google.com"
    91  	ips, err := net.LookupIP(host)
    92  	if err != nil {
    93  		log.Fatal(err)
    94  	}
    95  	var dst net.IPAddr
    96  	for _, ip := range ips {
    97  		if ip.To16() != nil && ip.To4() == nil {
    98  			dst.IP = ip
    99  			fmt.Printf("using %v for tracing an IP packet route to %s\n", dst.IP, host)
   100  			break
   101  		}
   102  	}
   103  	if dst.IP == nil {
   104  		log.Fatal("no AAAA record found")
   105  	}
   106  
   107  	c, err := net.ListenPacket("ip6:58", "::") // ICMP for IPv6
   108  	if err != nil {
   109  		log.Fatal(err)
   110  	}
   111  	defer c.Close()
   112  	p := ipv6.NewPacketConn(c)
   113  
   114  	if err := p.SetControlMessage(ipv6.FlagHopLimit|ipv6.FlagSrc|ipv6.FlagDst|ipv6.FlagInterface, true); err != nil {
   115  		log.Fatal(err)
   116  	}
   117  	wm := icmp.Message{
   118  		Type: ipv6.ICMPTypeEchoRequest, Code: 0,
   119  		Body: &icmp.Echo{
   120  			ID:   os.Getpid() & 0xffff,
   121  			Data: []byte("HELLO-R-U-THERE"),
   122  		},
   123  	}
   124  	var f ipv6.ICMPFilter
   125  	f.SetAll(true)
   126  	f.Accept(ipv6.ICMPTypeTimeExceeded)
   127  	f.Accept(ipv6.ICMPTypeEchoReply)
   128  	if err := p.SetICMPFilter(&f); err != nil {
   129  		log.Fatal(err)
   130  	}
   131  
   132  	var wcm ipv6.ControlMessage
   133  	rb := make([]byte, 1500)
   134  	for i := 1; i <= 64; i++ { // up to 64 hops
   135  		wm.Body.(*icmp.Echo).Seq = i
   136  		wb, err := wm.Marshal(nil)
   137  		if err != nil {
   138  			log.Fatal(err)
   139  		}
   140  
   141  		// In the real world usually there are several
   142  		// multiple traffic-engineered paths for each hop.
   143  		// You may need to probe a few times to each hop.
   144  		begin := time.Now()
   145  		wcm.HopLimit = i
   146  		if _, err := p.WriteTo(wb, &wcm, &dst); err != nil {
   147  			log.Fatal(err)
   148  		}
   149  		if err := p.SetReadDeadline(time.Now().Add(3 * time.Second)); err != nil {
   150  			log.Fatal(err)
   151  		}
   152  		n, rcm, peer, err := p.ReadFrom(rb)
   153  		if err != nil {
   154  			if err, ok := err.(net.Error); ok && err.Timeout() {
   155  				fmt.Printf("%v\t*\n", i)
   156  				continue
   157  			}
   158  			log.Fatal(err)
   159  		}
   160  		rm, err := icmp.ParseMessage(58, rb[:n])
   161  		if err != nil {
   162  			log.Fatal(err)
   163  		}
   164  		rtt := time.Since(begin)
   165  
   166  		// In the real world you need to determine whether the
   167  		// received message is yours using ControlMessage.Src,
   168  		// ControlMesage.Dst, icmp.Echo.ID and icmp.Echo.Seq.
   169  		switch rm.Type {
   170  		case ipv6.ICMPTypeTimeExceeded:
   171  			names, _ := net.LookupAddr(peer.String())
   172  			fmt.Printf("%d\t%v %+v %v\n\t%+v\n", i, peer, names, rtt, rcm)
   173  		case ipv6.ICMPTypeEchoReply:
   174  			names, _ := net.LookupAddr(peer.String())
   175  			fmt.Printf("%d\t%v %+v %v\n\t%+v\n", i, peer, names, rtt, rcm)
   176  			return
   177  		}
   178  	}
   179  }
   180  
   181  func ExamplePacketConn_advertisingOSPFHello() {
   182  	c, err := net.ListenPacket("ip6:89", "::") // OSPF for IPv6
   183  	if err != nil {
   184  		log.Fatal(err)
   185  	}
   186  	defer c.Close()
   187  	p := ipv6.NewPacketConn(c)
   188  
   189  	en0, err := net.InterfaceByName("en0")
   190  	if err != nil {
   191  		log.Fatal(err)
   192  	}
   193  	allSPFRouters := net.IPAddr{IP: net.ParseIP("ff02::5")}
   194  	if err := p.JoinGroup(en0, &allSPFRouters); err != nil {
   195  		log.Fatal(err)
   196  	}
   197  	defer p.LeaveGroup(en0, &allSPFRouters)
   198  
   199  	hello := make([]byte, 24) // fake hello data, you need to implement this
   200  	ospf := make([]byte, 16)  // fake ospf header, you need to implement this
   201  	ospf[0] = 3               // version 3
   202  	ospf[1] = 1               // hello packet
   203  	ospf = append(ospf, hello...)
   204  	if err := p.SetChecksum(true, 12); err != nil {
   205  		log.Fatal(err)
   206  	}
   207  
   208  	cm := ipv6.ControlMessage{
   209  		TrafficClass: 0xc0, // DSCP CS6
   210  		HopLimit:     1,
   211  		IfIndex:      en0.Index,
   212  	}
   213  	if _, err := p.WriteTo(ospf, &cm, &allSPFRouters); err != nil {
   214  		log.Fatal(err)
   215  	}
   216  }
   217
View as plain text