control.go

Documentation: golang.org/x/net/ipv4

     1  // Copyright 2012 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 ipv4
     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  type rawOpt struct {
    17  	sync.RWMutex
    18  	cflags ControlFlags
    19  }
    20  
    21  func (c *rawOpt) set(f ControlFlags)        { c.cflags |= f }
    22  func (c *rawOpt) clear(f ControlFlags)      { c.cflags &^= f }
    23  func (c *rawOpt) isset(f ControlFlags) bool { return c.cflags&f != 0 }
    24  
    25  type ControlFlags uint
    26  
    27  const (
    28  	FlagTTL       ControlFlags = 1 << iota // pass the TTL on the received packet
    29  	FlagSrc                                // pass the source address on the received packet
    30  	FlagDst                                // pass the destination address on the received packet
    31  	FlagInterface                          // pass the interface index on the received packet
    32  )
    33  
    34  // A ControlMessage represents per packet basis IP-level socket options.
    35  type ControlMessage struct {
    36  	// Receiving socket options: SetControlMessage allows to
    37  	// receive the options from the protocol stack using ReadFrom
    38  	// method of PacketConn or RawConn.
    39  	//
    40  	// Specifying socket options: ControlMessage for WriteTo
    41  	// method of PacketConn or RawConn allows to send the options
    42  	// to the protocol stack.
    43  	//
    44  	TTL     int    // time-to-live, receiving only
    45  	Src     net.IP // source address, specifying only
    46  	Dst     net.IP // destination address, receiving only
    47  	IfIndex int    // interface index, must be 1 <= value when specifying
    48  }
    49  
    50  func (cm *ControlMessage) String() string {
    51  	if cm == nil {
    52  		return "<nil>"
    53  	}
    54  	return fmt.Sprintf("ttl=%d src=%v dst=%v ifindex=%d", cm.TTL, cm.Src, cm.Dst, cm.IfIndex)
    55  }
    56  
    57  // Marshal returns the binary encoding of cm.
    58  func (cm *ControlMessage) Marshal() []byte {
    59  	if cm == nil {
    60  		return nil
    61  	}
    62  	var m socket.ControlMessage
    63  	if ctlOpts[ctlPacketInfo].name > 0 && (cm.Src.To4() != nil || cm.IfIndex > 0) {
    64  		m = socket.NewControlMessage([]int{ctlOpts[ctlPacketInfo].length})
    65  	}
    66  	if len(m) > 0 {
    67  		ctlOpts[ctlPacketInfo].marshal(m, cm)
    68  	}
    69  	return m
    70  }
    71  
    72  // Parse parses b as a control message and stores the result in cm.
    73  func (cm *ControlMessage) Parse(b []byte) error {
    74  	ms, err := socket.ControlMessage(b).Parse()
    75  	if err != nil {
    76  		return err
    77  	}
    78  	for _, m := range ms {
    79  		lvl, typ, l, err := m.ParseHeader()
    80  		if err != nil {
    81  			return err
    82  		}
    83  		if lvl != iana.ProtocolIP {
    84  			continue
    85  		}
    86  		switch {
    87  		case typ == ctlOpts[ctlTTL].name && l >= ctlOpts[ctlTTL].length:
    88  			ctlOpts[ctlTTL].parse(cm, m.Data(l))
    89  		case typ == ctlOpts[ctlDst].name && l >= ctlOpts[ctlDst].length:
    90  			ctlOpts[ctlDst].parse(cm, m.Data(l))
    91  		case typ == ctlOpts[ctlInterface].name && l >= ctlOpts[ctlInterface].length:
    92  			ctlOpts[ctlInterface].parse(cm, m.Data(l))
    93  		case typ == ctlOpts[ctlPacketInfo].name && l >= ctlOpts[ctlPacketInfo].length:
    94  			ctlOpts[ctlPacketInfo].parse(cm, m.Data(l))
    95  		}
    96  	}
    97  	return nil
    98  }
    99  
   100  // NewControlMessage returns a new control message.
   101  //
   102  // The returned message is large enough for options specified by cf.
   103  func NewControlMessage(cf ControlFlags) []byte {
   104  	opt := rawOpt{cflags: cf}
   105  	var l int
   106  	if opt.isset(FlagTTL) && ctlOpts[ctlTTL].name > 0 {
   107  		l += socket.ControlMessageSpace(ctlOpts[ctlTTL].length)
   108  	}
   109  	if ctlOpts[ctlPacketInfo].name > 0 {
   110  		if opt.isset(FlagSrc | FlagDst | FlagInterface) {
   111  			l += socket.ControlMessageSpace(ctlOpts[ctlPacketInfo].length)
   112  		}
   113  	} else {
   114  		if opt.isset(FlagDst) && ctlOpts[ctlDst].name > 0 {
   115  			l += socket.ControlMessageSpace(ctlOpts[ctlDst].length)
   116  		}
   117  		if opt.isset(FlagInterface) && ctlOpts[ctlInterface].name > 0 {
   118  			l += socket.ControlMessageSpace(ctlOpts[ctlInterface].length)
   119  		}
   120  	}
   121  	var b []byte
   122  	if l > 0 {
   123  		b = make([]byte, l)
   124  	}
   125  	return b
   126  }
   127  
   128  // Ancillary data socket options
   129  const (
   130  	ctlTTL        = iota // header field
   131  	ctlSrc               // header field
   132  	ctlDst               // header field
   133  	ctlInterface         // inbound or outbound interface
   134  	ctlPacketInfo        // inbound or outbound packet path
   135  	ctlMax
   136  )
   137  
   138  // A ctlOpt represents a binding for ancillary data socket option.
   139  type ctlOpt struct {
   140  	name    int // option name, must be equal or greater than 1
   141  	length  int // option length
   142  	marshal func([]byte, *ControlMessage) []byte
   143  	parse   func(*ControlMessage, []byte)
   144  }
   145
View as plain text