// Copyright 2013 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 ipv6

import (
	
	
	

	
	
)

// Note that RFC 3542 obsoletes RFC 2292 but OS X Snow Leopard and the
// former still support RFC 2292 only. Please be aware that almost
// all protocol implementations prohibit using a combination of RFC
// 2292 and RFC 3542 for some practical reasons.

type rawOpt struct {
	sync.RWMutex
	cflags ControlFlags
}

func ( *rawOpt) ( ControlFlags)        { .cflags |=  }
func ( *rawOpt) ( ControlFlags)      { .cflags &^=  }
func ( *rawOpt) ( ControlFlags) bool { return .cflags& != 0 }

// A ControlFlags represents per packet basis IP-level socket option
// control flags.
type ControlFlags uint

const (
	FlagTrafficClass ControlFlags = 1 << iota // pass the traffic class on the received packet
	FlagHopLimit                              // pass the hop limit on the received packet
	FlagSrc                                   // pass the source address on the received packet
	FlagDst                                   // pass the destination address on the received packet
	FlagInterface                             // pass the interface index on the received packet
	FlagPathMTU                               // pass the path MTU on the received packet path
)

const flagPacketInfo = FlagDst | FlagInterface

// A ControlMessage represents per packet basis IP-level socket
// options.
type ControlMessage struct {
	// Receiving socket options: SetControlMessage allows to
	// receive the options from the protocol stack using ReadFrom
	// method of PacketConn.
	//
	// Specifying socket options: ControlMessage for WriteTo
	// method of PacketConn allows to send the options to the
	// protocol stack.
	//
	TrafficClass int    // traffic class, must be 1 <= value <= 255 when specifying
	HopLimit     int    // hop limit, must be 1 <= value <= 255 when specifying
	Src          net.IP // source address, specifying only
	Dst          net.IP // destination address, receiving only
	IfIndex      int    // interface index, must be 1 <= value when specifying
	NextHop      net.IP // next hop address, specifying only
	MTU          int    // path MTU, receiving only
}

func ( *ControlMessage) () string {
	if  == nil {
		return "<nil>"
	}
	return fmt.Sprintf("tclass=%#x hoplim=%d src=%v dst=%v ifindex=%d nexthop=%v mtu=%d", .TrafficClass, .HopLimit, .Src, .Dst, .IfIndex, .NextHop, .MTU)
}

// Marshal returns the binary encoding of cm.
func ( *ControlMessage) () []byte {
	if  == nil {
		return nil
	}
	var  int
	 := false
	if ctlOpts[ctlTrafficClass].name > 0 && .TrafficClass > 0 {
		 = true
		 += socket.ControlMessageSpace(ctlOpts[ctlTrafficClass].length)
	}
	 := false
	if ctlOpts[ctlHopLimit].name > 0 && .HopLimit > 0 {
		 = true
		 += socket.ControlMessageSpace(ctlOpts[ctlHopLimit].length)
	}
	 := false
	if ctlOpts[ctlPacketInfo].name > 0 && (.Src.To16() != nil && .Src.To4() == nil || .IfIndex > 0) {
		 = true
		 += socket.ControlMessageSpace(ctlOpts[ctlPacketInfo].length)
	}
	 := false
	if ctlOpts[ctlNextHop].name > 0 && .NextHop.To16() != nil && .NextHop.To4() == nil {
		 = true
		 += socket.ControlMessageSpace(ctlOpts[ctlNextHop].length)
	}
	var  []byte
	if  > 0 {
		 = make([]byte, )
		 := 
		if  {
			 = ctlOpts[ctlTrafficClass].marshal(, )
		}
		if  {
			 = ctlOpts[ctlHopLimit].marshal(, )
		}
		if  {
			 = ctlOpts[ctlPacketInfo].marshal(, )
		}
		if  {
			 = ctlOpts[ctlNextHop].marshal(, )
		}
	}
	return 
}

// Parse parses b as a control message and stores the result in cm.
func ( *ControlMessage) ( []byte) error {
	,  := socket.ControlMessage().Parse()
	if  != nil {
		return 
	}
	for ,  := range  {
		, , ,  := .ParseHeader()
		if  != nil {
			return 
		}
		if  != iana.ProtocolIPv6 {
			continue
		}
		switch {
		case  == ctlOpts[ctlTrafficClass].name &&  >= ctlOpts[ctlTrafficClass].length:
			ctlOpts[ctlTrafficClass].parse(, .Data())
		case  == ctlOpts[ctlHopLimit].name &&  >= ctlOpts[ctlHopLimit].length:
			ctlOpts[ctlHopLimit].parse(, .Data())
		case  == ctlOpts[ctlPacketInfo].name &&  >= ctlOpts[ctlPacketInfo].length:
			ctlOpts[ctlPacketInfo].parse(, .Data())
		case  == ctlOpts[ctlPathMTU].name &&  >= ctlOpts[ctlPathMTU].length:
			ctlOpts[ctlPathMTU].parse(, .Data())
		}
	}
	return nil
}

// NewControlMessage returns a new control message.
//
// The returned message is large enough for options specified by cf.
func ( ControlFlags) []byte {
	 := rawOpt{cflags: }
	var  int
	if .isset(FlagTrafficClass) && ctlOpts[ctlTrafficClass].name > 0 {
		 += socket.ControlMessageSpace(ctlOpts[ctlTrafficClass].length)
	}
	if .isset(FlagHopLimit) && ctlOpts[ctlHopLimit].name > 0 {
		 += socket.ControlMessageSpace(ctlOpts[ctlHopLimit].length)
	}
	if .isset(flagPacketInfo) && ctlOpts[ctlPacketInfo].name > 0 {
		 += socket.ControlMessageSpace(ctlOpts[ctlPacketInfo].length)
	}
	if .isset(FlagPathMTU) && ctlOpts[ctlPathMTU].name > 0 {
		 += socket.ControlMessageSpace(ctlOpts[ctlPathMTU].length)
	}
	var  []byte
	if  > 0 {
		 = make([]byte, )
	}
	return 
}

// Ancillary data socket options
const (
	ctlTrafficClass = iota // header field
	ctlHopLimit            // header field
	ctlPacketInfo          // inbound or outbound packet path
	ctlNextHop             // nexthop
	ctlPathMTU             // path mtu
	ctlMax
)

// A ctlOpt represents a binding for ancillary data socket option.
type ctlOpt struct {
	name    int // option name, must be equal or greater than 1
	length  int // option length
	marshal func([]byte, *ControlMessage) []byte
	parse   func(*ControlMessage, []byte)
}