github.com/graybobo/golang.org-package-offline-cache@v0.0.0-20200626051047-6608995c132f/x/net/ipv4/header.go (about)

     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  	"runtime"
    11  	"syscall"
    12  	"unsafe"
    13  )
    14  
    15  const (
    16  	Version      = 4  // protocol version
    17  	HeaderLen    = 20 // header length without extension headers
    18  	maxHeaderLen = 60 // sensible default, revisit if later RFCs define new usage of version and header length fields
    19  )
    20  
    21  type HeaderFlags int
    22  
    23  const (
    24  	MoreFragments HeaderFlags = 1 << iota // more fragments flag
    25  	DontFragment                          // don't fragment flag
    26  )
    27  
    28  // A Header represents an IPv4 header.
    29  type Header struct {
    30  	Version  int         // protocol version
    31  	Len      int         // header length
    32  	TOS      int         // type-of-service
    33  	TotalLen int         // packet total length
    34  	ID       int         // identification
    35  	Flags    HeaderFlags // flags
    36  	FragOff  int         // fragment offset
    37  	TTL      int         // time-to-live
    38  	Protocol int         // next protocol
    39  	Checksum int         // checksum
    40  	Src      net.IP      // source address
    41  	Dst      net.IP      // destination address
    42  	Options  []byte      // options, extension headers
    43  }
    44  
    45  func (h *Header) String() string {
    46  	if h == nil {
    47  		return "<nil>"
    48  	}
    49  	return fmt.Sprintf("ver=%d hdrlen=%d tos=%#x totallen=%d id=%#x flags=%#x fragoff=%#x ttl=%d proto=%d cksum=%#x src=%v dst=%v", h.Version, h.Len, h.TOS, h.TotalLen, h.ID, h.Flags, h.FragOff, h.TTL, h.Protocol, h.Checksum, h.Src, h.Dst)
    50  }
    51  
    52  // Marshal returns the binary encoding of the IPv4 header h.
    53  func (h *Header) Marshal() ([]byte, error) {
    54  	if h == nil {
    55  		return nil, syscall.EINVAL
    56  	}
    57  	if h.Len < HeaderLen {
    58  		return nil, errHeaderTooShort
    59  	}
    60  	hdrlen := HeaderLen + len(h.Options)
    61  	b := make([]byte, hdrlen)
    62  	b[0] = byte(Version<<4 | (hdrlen >> 2 & 0x0f))
    63  	b[1] = byte(h.TOS)
    64  	flagsAndFragOff := (h.FragOff & 0x1fff) | int(h.Flags<<13)
    65  	switch runtime.GOOS {
    66  	case "darwin", "dragonfly", "freebsd", "netbsd":
    67  		// TODO(mikio): fix potential misaligned memory access
    68  		*(*uint16)(unsafe.Pointer(&b[2:3][0])) = uint16(h.TotalLen)
    69  		*(*uint16)(unsafe.Pointer(&b[6:7][0])) = uint16(flagsAndFragOff)
    70  	default:
    71  		b[2], b[3] = byte(h.TotalLen>>8), byte(h.TotalLen)
    72  		b[6], b[7] = byte(flagsAndFragOff>>8), byte(flagsAndFragOff)
    73  	}
    74  	b[4], b[5] = byte(h.ID>>8), byte(h.ID)
    75  	b[8] = byte(h.TTL)
    76  	b[9] = byte(h.Protocol)
    77  	b[10], b[11] = byte(h.Checksum>>8), byte(h.Checksum)
    78  	if ip := h.Src.To4(); ip != nil {
    79  		copy(b[12:16], ip[:net.IPv4len])
    80  	}
    81  	if ip := h.Dst.To4(); ip != nil {
    82  		copy(b[16:20], ip[:net.IPv4len])
    83  	} else {
    84  		return nil, errMissingAddress
    85  	}
    86  	if len(h.Options) > 0 {
    87  		copy(b[HeaderLen:], h.Options)
    88  	}
    89  	return b, nil
    90  }
    91  
    92  // See http://www.freebsd.org/doc/en/books/porters-handbook/freebsd-versions.html.
    93  var freebsdVersion uint32
    94  
    95  // ParseHeader parses b as an IPv4 header.
    96  func ParseHeader(b []byte) (*Header, error) {
    97  	if len(b) < HeaderLen {
    98  		return nil, errHeaderTooShort
    99  	}
   100  	hdrlen := int(b[0]&0x0f) << 2
   101  	if hdrlen > len(b) {
   102  		return nil, errBufferTooShort
   103  	}
   104  	h := &Header{
   105  		Version:  int(b[0] >> 4),
   106  		Len:      hdrlen,
   107  		TOS:      int(b[1]),
   108  		ID:       int(b[4])<<8 | int(b[5]),
   109  		TTL:      int(b[8]),
   110  		Protocol: int(b[9]),
   111  		Checksum: int(b[10])<<8 | int(b[11]),
   112  		Src:      net.IPv4(b[12], b[13], b[14], b[15]),
   113  		Dst:      net.IPv4(b[16], b[17], b[18], b[19]),
   114  	}
   115  	switch runtime.GOOS {
   116  	case "darwin", "dragonfly", "netbsd":
   117  		// TODO(mikio): fix potential misaligned memory access
   118  		h.TotalLen = int(*(*uint16)(unsafe.Pointer(&b[2:3][0]))) + hdrlen
   119  		// TODO(mikio): fix potential misaligned memory access
   120  		h.FragOff = int(*(*uint16)(unsafe.Pointer(&b[6:7][0])))
   121  	case "freebsd":
   122  		// TODO(mikio): fix potential misaligned memory access
   123  		h.TotalLen = int(*(*uint16)(unsafe.Pointer(&b[2:3][0])))
   124  		if freebsdVersion < 1000000 {
   125  			h.TotalLen += hdrlen
   126  		}
   127  		// TODO(mikio): fix potential misaligned memory access
   128  		h.FragOff = int(*(*uint16)(unsafe.Pointer(&b[6:7][0])))
   129  	default:
   130  		h.TotalLen = int(b[2])<<8 | int(b[3])
   131  		h.FragOff = int(b[6])<<8 | int(b[7])
   132  	}
   133  	h.Flags = HeaderFlags(h.FragOff&0xe000) >> 13
   134  	h.FragOff = h.FragOff & 0x1fff
   135  	if hdrlen-HeaderLen > 0 {
   136  		h.Options = make([]byte, hdrlen-HeaderLen)
   137  		copy(h.Options, b[HeaderLen:])
   138  	}
   139  	return h, nil
   140  }