hunk.code_window: 	ClusterLogTimeoutMilliseconds                     *int
   	CloseUnusedDirectMessages                         *bool
   	EnablePreviewFeatures                             *bool
   	EnableTutorial                                    *bool
   	ExperimentalEnableDefaultChannelLeaveJoinMessages *bool
   	ImageProxyType                                    *string
   	ImageProxyURL                                     *string
   	ImageProxyOptions                                 *string
   }
  
hunk.labels: keep keep keep keep add keep keep keep keep keep
hunk.after_edit: 	ExperimentalGroupUnreadChannels                   *bool
  
hunk.file_path: model/config.go
hunk.type: add
file: // Copyright 2012 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 icmp provides basic functions for the manipulation of
  // messages used in the Internet Control Message Protocols,
  // ICMPv4 and ICMPv6.
  //
  // ICMPv4 and ICMPv6 are defined in RFC 792 and RFC 4443.
  // Multi-part message support for ICMP is defined in RFC 4884.
  // ICMP extensions for MPLS are defined in RFC 4950.
  // ICMP extensions for interface and next-hop identification are
  // defined in RFC 5837.
  package icmp // import "golang.org/x/net/icmp"
  
  import (
  	"encoding/binary"
  	"errors"
  	"net"
  	"syscall"
  
  	"golang.org/x/net/internal/iana"
  	"golang.org/x/net/ipv4"
  	"golang.org/x/net/ipv6"
  )
  
  // BUG(mikio): This package is not implemented on NaCl and Plan 9.
  
  var (
  	errMessageTooShort  = errors.New("message too short")
  	errHeaderTooShort   = errors.New("header too short")
  	errBufferTooShort   = errors.New("buffer too short")
  	errOpNoSupport      = errors.New("operation not supported")
  	errNoExtension      = errors.New("no extension")
  	errInvalidExtension = errors.New("invalid extension")
  )
  
  func checksum(b []byte) uint16 {
  	csumcv := len(b) - 1 // checksum coverage
  	s := uint32(0)
  	for i := 0; i < csumcv; i += 2 {
  		s += uint32(b[i+1])<<8 | uint32(b[i])
  	}
  	if csumcv&1 == 0 {
  		s += uint32(b[csumcv])
  	}
  	s = s>>16 + s&0xffff
  	s = s + s>>16
  	return ^uint16(s)
  }
  
  // A Type represents an ICMP message type.
  type Type interface {
  	Protocol() int
  }
  
  // A Message represents an ICMP message.
  type Message struct {
  	Type     Type        // type, either ipv4.ICMPType or ipv6.ICMPType
  	Code     int         // code
  	Checksum int         // checksum
  	Body     MessageBody // body
  }
  
  // Marshal returns the binary encoding of the ICMP message m.
  //
  // For an ICMPv4 message, the returned message always contains the
  // calculated checksum field.
  //
  // For an ICMPv6 message, the returned message contains the calculated
  // checksum field when psh is not nil, otherwise the kernel will
  // compute the checksum field during the message transmission.
  // When psh is not nil, it must be the pseudo header for IPv6.
  func (m *Message) Marshal(psh []byte) ([]byte, error) {
  	var mtype int
  	switch typ := m.Type.(type) {
  	case ipv4.ICMPType:
  		mtype = int(typ)
  	case ipv6.ICMPType:
  		mtype = int(typ)
  	default:
  		return nil, syscall.EINVAL
  	}
  	b := []byte{byte(mtype), byte(m.Code), 0, 0}
  	if m.Type.Protocol() == iana.ProtocolIPv6ICMP && psh != nil {
  		b = append(psh, b...)
  	}
  	if m.Body != nil && m.Body.Len(m.Type.Protocol()) != 0 {
  		mb, err := m.Body.Marshal(m.Type.Protocol())
  		if err != nil {
  			return nil, err
  		}
  		b = append(b, mb...)
  	}
  	if m.Type.Protocol() == iana.ProtocolIPv6ICMP {
  		if psh == nil { // cannot calculate checksum here
  			return b, nil
  		}
  		off, l := 2*net.IPv6len, len(b)-len(psh)
  		binary.BigEndian.PutUint32(b[off:off+4], uint32(l))
  	}
  	s := checksum(b)
  	// Place checksum back in header; using ^= avoids the
  	// assumption the checksum bytes are zero.
  	b[len(psh)+2] ^= byte(s)
  	b[len(psh)+3] ^= byte(s >> 8)
  	return b[len(psh):], nil
  }
  
  var parseFns = map[Type]func(int, []byte) (MessageBody, error){
  	ipv4.ICMPTypeDestinationUnreachable: parseDstUnreach,
  	ipv4.ICMPTypeTimeExceeded:           parseTimeExceeded,
  	ipv4.ICMPTypeParameterProblem:       parseParamProb,
  
  	ipv4.ICMPTypeEcho:      parseEcho,
  	ipv4.ICMPTypeEchoReply: parseEcho,
  
  	ipv6.ICMPTypeDestinationUnreachable: parseDstUnreach,
  	ipv6.ICMPTypePacketTooBig:           parsePacketTooBig,
  	ipv6.ICMPTypeTimeExceeded:           parseTimeExceeded,
  	ipv6.ICMPTypeParameterProblem:       parseParamProb,
  
  	ipv6.ICMPTypeEchoRequest: parseEcho,
  	ipv6.ICMPTypeEchoReply:   parseEcho,
  }
  
  // ParseMessage parses b as an ICMP message.
  // Proto must be either the ICMPv4 or ICMPv6 protocol number.
  func ParseMessage(proto int, b []byte) (*Message, error) {
  	if len(b) < 4 {
  		return nil, errMessageTooShort
  	}
  	var err error
  	m := &Message{Code: int(b[1]), Checksum: int(binary.BigEndian.Uint16(b[2:4]))}
  	switch proto {
  	case iana.ProtocolICMP:
  		m.Type = ipv4.ICMPType(b[0])
  	case iana.ProtocolIPv6ICMP:
  		m.Type = ipv6.ICMPType(b[0])
  	default:
  		return nil, syscall.EINVAL
  	}
  	if fn, ok := parseFns[m.Type]; !ok {
  		m.Body, err = parseDefaultMessageBody(proto, b[4:])
  	} else {
  		m.Body, err = fn(proto, b[4:])
  	}
  	if err != nil {
  		return nil, err
  	}
  	return m, nil
  }
  