vendor/golang.org/x/net/ipv4/header.go

   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         "encoding/binary"
   9         "fmt"
  10         "net"
  11         "runtime"
  12         "syscall"
  13
  14         "golang.org/x/net/internal/socket"
  15 )
  16
  17 const (
  18         Version      = 4  // protocol version
  19         HeaderLen    = 20 // header length without extension headers
  20         maxHeaderLen = 60 // sensible default, revisit if later RFCs define new usage of version and header length fields
  21 )
  22
  23 type HeaderFlags int
  24
  25 const (
  26         MoreFragments HeaderFlags = 1 << iota // more fragments flag
  27         DontFragment                          // don't fragment flag
  28 )
  29
  30 // A Header represents an IPv4 header.
  31 type Header struct {
  32         Version  int         // protocol version
  33         Len      int         // header length
  34         TOS      int         // type-of-service
  35         TotalLen int         // packet total length
  36         ID       int         // identification
  37         Flags    HeaderFlags // flags
  38         FragOff  int         // fragment offset
  39         TTL      int         // time-to-live
  40         Protocol int         // next protocol
  41         Checksum int         // checksum
  42         Src      net.IP      // source address
  43         Dst      net.IP      // destination address
  44         Options  []byte      // options, extension headers
  45 }
  46
  47 func (h *Header) String() string {
  48         if h == nil {
  49                 return "<nil>"
  50         }
  51         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)
  52 }
  53
  54 // Marshal returns the binary encoding of h.
  55 func (h *Header) Marshal() ([]byte, error) {
  56         if h == nil {
  57                 return nil, syscall.EINVAL
  58         }
  59         if h.Len < HeaderLen {
  60                 return nil, errHeaderTooShort
  61         }
  62         hdrlen := HeaderLen + len(h.Options)
  63         b := make([]byte, hdrlen)
  64         b[0] = byte(Version<<4 | (hdrlen >> 2 & 0x0f))
  65         b[1] = byte(h.TOS)
  66         flagsAndFragOff := (h.FragOff & 0x1fff) | int(h.Flags<<13)
  67         switch runtime.GOOS {
  68         case "darwin", "dragonfly", "netbsd":
  69                 socket.NativeEndian.PutUint16(b[2:4], uint16(h.TotalLen))
  70                 socket.NativeEndian.PutUint16(b[6:8], uint16(flagsAndFragOff))
  71         case "freebsd":
  72                 if freebsdVersion < 1100000 {
  73                         socket.NativeEndian.PutUint16(b[2:4], uint16(h.TotalLen))
  74                         socket.NativeEndian.PutUint16(b[6:8], uint16(flagsAndFragOff))
  75                 } else {
  76                         binary.BigEndian.PutUint16(b[2:4], uint16(h.TotalLen))
  77                         binary.BigEndian.PutUint16(b[6:8], uint16(flagsAndFragOff))
  78                 }
  79         default:
  80                 binary.BigEndian.PutUint16(b[2:4], uint16(h.TotalLen))
  81                 binary.BigEndian.PutUint16(b[6:8], uint16(flagsAndFragOff))
  82         }
  83         binary.BigEndian.PutUint16(b[4:6], uint16(h.ID))
  84         b[8] = byte(h.TTL)
  85         b[9] = byte(h.Protocol)
  86         binary.BigEndian.PutUint16(b[10:12], uint16(h.Checksum))
  87         if ip := h.Src.To4(); ip != nil {
  88                 copy(b[12:16], ip[:net.IPv4len])
  89         }
  90         if ip := h.Dst.To4(); ip != nil {
  91                 copy(b[16:20], ip[:net.IPv4len])
  92         } else {
  93                 return nil, errMissingAddress
  94         }
  95         if len(h.Options) > 0 {
  96                 copy(b[HeaderLen:], h.Options)
  97         }
  98         return b, nil
  99 }
 100
 101 // Parse parses b as an IPv4 header and sotres the result in h.
 102 func (h *Header) Parse(b []byte) error {
 103         if h == nil || len(b) < HeaderLen {
 104                 return errHeaderTooShort
 105         }
 106         hdrlen := int(b[0]&0x0f) << 2
 107         if hdrlen > len(b) {
 108                 return errBufferTooShort
 109         }
 110         h.Version = int(b[0] >> 4)
 111         h.Len = hdrlen
 112         h.TOS = int(b[1])
 113         h.ID = int(binary.BigEndian.Uint16(b[4:6]))
 114         h.TTL = int(b[8])
 115         h.Protocol = int(b[9])
 116         h.Checksum = int(binary.BigEndian.Uint16(b[10:12]))
 117         h.Src = net.IPv4(b[12], b[13], b[14], b[15])
 118         h.Dst = net.IPv4(b[16], b[17], b[18], b[19])
 119         switch runtime.GOOS {
 120         case "darwin", "dragonfly", "netbsd":
 121                 h.TotalLen = int(socket.NativeEndian.Uint16(b[2:4])) + hdrlen
 122                 h.FragOff = int(socket.NativeEndian.Uint16(b[6:8]))
 123         case "freebsd":
 124                 if freebsdVersion < 1100000 {
 125                         h.TotalLen = int(socket.NativeEndian.Uint16(b[2:4]))
 126                         if freebsdVersion < 1000000 {
 127                                 h.TotalLen += hdrlen
 128                         }
 129                         h.FragOff = int(socket.NativeEndian.Uint16(b[6:8]))
 130                 } else {
 131                         h.TotalLen = int(binary.BigEndian.Uint16(b[2:4]))
 132                         h.FragOff = int(binary.BigEndian.Uint16(b[6:8]))
 133                 }
 134         default:
 135                 h.TotalLen = int(binary.BigEndian.Uint16(b[2:4]))
 136                 h.FragOff = int(binary.BigEndian.Uint16(b[6:8]))
 137         }
 138         h.Flags = HeaderFlags(h.FragOff&0xe000) >> 13
 139         h.FragOff = h.FragOff & 0x1fff
 140         optlen := hdrlen - HeaderLen
 141         if optlen > 0 && len(b) >= hdrlen {
 142                 if cap(h.Options) < optlen {
 143                         h.Options = make([]byte, optlen)
 144                 } else {
 145                         h.Options = h.Options[:optlen]
 146                 }
 147                 copy(h.Options, b[HeaderLen:hdrlen])
 148         }
 149         return nil
 150 }
 151
 152 // ParseHeader parses b as an IPv4 header.
 153 func ParseHeader(b []byte) (*Header, error) {
 154         h := new(Header)
 155         if err := h.Parse(b); err != nil {
 156                 return nil, err
 157         }
 158         return h, nil
 159 }