control.go

Documentation: golang.org/x/net/ipv6

     1  // Copyright 2013 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
     6  
     7  import (
     8  	"fmt"
     9  	"net"
    10  	"sync"
    11  
    12  	"golang.org/x/net/internal/iana"
    13  	"golang.org/x/net/internal/socket"
    14  )
    15  
    16  // Note that RFC 3542 obsoletes RFC 2292 but OS X Snow Leopard and the
    17  // former still support RFC 2292 only. Please be aware that almost
    18  // all protocol implementations prohibit using a combination of RFC
    19  // 2292 and RFC 3542 for some practical reasons.
    20  
    21  type rawOpt struct {
    22  	sync.RWMutex
    23  	cflags ControlFlags
    24  }
    25  
    26  func (c *rawOpt) set(f ControlFlags)        { c.cflags |= f }
    27  func (c *rawOpt) clear(f ControlFlags)      { c.cflags &^= f }
    28  func (c *rawOpt) isset(f ControlFlags) bool { return c.cflags&f != 0 }
    29  
    30  // A ControlFlags represents per packet basis IP-level socket option
    31  // control flags.
    32  type ControlFlags uint
    33  
    34  const (
    35  	FlagTrafficClass ControlFlags = 1 << iota // pass the traffic class on the received packet
    36  	FlagHopLimit                              // pass the hop limit on the received packet
    37  	FlagSrc                                   // pass the source address on the received packet
    38  	FlagDst                                   // pass the destination address on the received packet
    39  	FlagInterface                             // pass the interface index on the received packet
    40  	FlagPathMTU                               // pass the path MTU on the received packet path
    41  )
    42  
    43  const flagPacketInfo = FlagDst | FlagInterface
    44  
    45  // A ControlMessage represents per packet basis IP-level socket
    46  // options.
    47  type ControlMessage struct {
    48  	// Receiving socket options: SetControlMessage allows to
    49  	// receive the options from the protocol stack using ReadFrom
    50  	// method of PacketConn.
    51  	//
    52  	// Specifying socket options: ControlMessage for WriteTo
    53  	// method of PacketConn allows to send the options to the
    54  	// protocol stack.
    55  	//
    56  	TrafficClass int    // traffic class, must be 1 <= value <= 255 when specifying
    57  	HopLimit     int    // hop limit, must be 1 <= value <= 255 when specifying
    58  	Src          net.IP // source address, specifying only
    59  	Dst          net.IP // destination address, receiving only
    60  	IfIndex      int    // interface index, must be 1 <= value when specifying
    61  	NextHop      net.IP // next hop address, specifying only
    62  	MTU          int    // path MTU, receiving only
    63  }
    64  
    65  func (cm *ControlMessage) String() string {
    66  	if cm == nil {
    67  		return "<nil>"
    68  	}
    69  	return fmt.Sprintf("tclass=%#x hoplim=%d src=%v dst=%v ifindex=%d nexthop=%v mtu=%d", cm.TrafficClass, cm.HopLimit, cm.Src, cm.Dst, cm.IfIndex, cm.NextHop, cm.MTU)
    70  }
    71  
    72  // Marshal returns the binary encoding of cm.
    73  func (cm *ControlMessage) Marshal() []byte {
    74  	if cm == nil {
    75  		return nil
    76  	}
    77  	var l int
    78  	tclass := false
    79  	if ctlOpts[ctlTrafficClass].name > 0 && cm.TrafficClass > 0 {
    80  		tclass = true
    81  		l += socket.ControlMessageSpace(ctlOpts[ctlTrafficClass].length)
    82  	}
    83  	hoplimit := false
    84  	if ctlOpts[ctlHopLimit].name > 0 && cm.HopLimit > 0 {
    85  		hoplimit = true
    86  		l += socket.ControlMessageSpace(ctlOpts[ctlHopLimit].length)
    87  	}
    88  	pktinfo := false
    89  	if ctlOpts[ctlPacketInfo].name > 0 && (cm.Src.To16() != nil && cm.Src.To4() == nil || cm.IfIndex > 0) {
    90  		pktinfo = true
    91  		l += socket.ControlMessageSpace(ctlOpts[ctlPacketInfo].length)
    92  	}
    93  	nexthop := false
    94  	if ctlOpts[ctlNextHop].name > 0 && cm.NextHop.To16() != nil && cm.NextHop.To4() == nil {
    95  		nexthop = true
    96  		l += socket.ControlMessageSpace(ctlOpts[ctlNextHop].length)
    97  	}
    98  	var b []byte
    99  	if l > 0 {
   100  		b = make([]byte, l)
   101  		bb := b
   102  		if tclass {
   103  			bb = ctlOpts[ctlTrafficClass].marshal(bb, cm)
   104  		}
   105  		if hoplimit {
   106  			bb = ctlOpts[ctlHopLimit].marshal(bb, cm)
   107  		}
   108  		if pktinfo {
   109  			bb = ctlOpts[ctlPacketInfo].marshal(bb, cm)
   110  		}
   111  		if nexthop {
   112  			bb = ctlOpts[ctlNextHop].marshal(bb, cm)
   113  		}
   114  	}
   115  	return b
   116  }
   117  
   118  // Parse parses b as a control message and stores the result in cm.
   119  func (cm *ControlMessage) Parse(b []byte) error {
   120  	ms, err := socket.ControlMessage(b).Parse()
   121  	if err != nil {
   122  		return err
   123  	}
   124  	for _, m := range ms {
   125  		lvl, typ, l, err := m.ParseHeader()
   126  		if err != nil {
   127  			return err
   128  		}
   129  		if lvl != iana.ProtocolIPv6 {
   130  			continue
   131  		}
   132  		switch {
   133  		case typ == ctlOpts[ctlTrafficClass].name && l >= ctlOpts[ctlTrafficClass].length:
   134  			ctlOpts[ctlTrafficClass].parse(cm, m.Data(l))
   135  		case typ == ctlOpts[ctlHopLimit].name && l >= ctlOpts[ctlHopLimit].length:
   136  			ctlOpts[ctlHopLimit].parse(cm, m.Data(l))
   137  		case typ == ctlOpts[ctlPacketInfo].name && l >= ctlOpts[ctlPacketInfo].length:
   138  			ctlOpts[ctlPacketInfo].parse(cm, m.Data(l))
   139  		case typ == ctlOpts[ctlPathMTU].name && l >= ctlOpts[ctlPathMTU].length:
   140  			ctlOpts[ctlPathMTU].parse(cm, m.Data(l))
   141  		}
   142  	}
   143  	return nil
   144  }
   145  
   146  // NewControlMessage returns a new control message.
   147  //
   148  // The returned message is large enough for options specified by cf.
   149  func NewControlMessage(cf ControlFlags) []byte {
   150  	opt := rawOpt{cflags: cf}
   151  	var l int
   152  	if opt.isset(FlagTrafficClass) && ctlOpts[ctlTrafficClass].name > 0 {
   153  		l += socket.ControlMessageSpace(ctlOpts[ctlTrafficClass].length)
   154  	}
   155  	if opt.isset(FlagHopLimit) && ctlOpts[ctlHopLimit].name > 0 {
   156  		l += socket.ControlMessageSpace(ctlOpts[ctlHopLimit].length)
   157  	}
   158  	if opt.isset(flagPacketInfo) && ctlOpts[ctlPacketInfo].name > 0 {
   159  		l += socket.ControlMessageSpace(ctlOpts[ctlPacketInfo].length)
   160  	}
   161  	if opt.isset(FlagPathMTU) && ctlOpts[ctlPathMTU].name > 0 {
   162  		l += socket.ControlMessageSpace(ctlOpts[ctlPathMTU].length)
   163  	}
   164  	var b []byte
   165  	if l > 0 {
   166  		b = make([]byte, l)
   167  	}
   168  	return b
   169  }
   170  
   171  // Ancillary data socket options
   172  const (
   173  	ctlTrafficClass = iota // header field
   174  	ctlHopLimit            // header field
   175  	ctlPacketInfo          // inbound or outbound packet path
   176  	ctlNextHop             // nexthop
   177  	ctlPathMTU             // path mtu
   178  	ctlMax
   179  )
   180  
   181  // A ctlOpt represents a binding for ancillary data socket option.
   182  type ctlOpt struct {
   183  	name    int // option name, must be equal or greater than 1
   184  	length  int // option length
   185  	marshal func([]byte, *ControlMessage) []byte
   186  	parse   func(*ControlMessage, []byte)
   187  }
   188
View as plain text