vendor/golang.org/x/net/ipv6/dgramopt.go

   1 // Copyright 2013 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 ipv6
   6
   7 import (
   8         "net"
   9         "syscall"
  10
  11         "golang.org/x/net/bpf"
  12 )
  13
  14 // MulticastHopLimit returns the hop limit field value for outgoing
  15 // multicast packets.
  16 func (c *dgramOpt) MulticastHopLimit() (int, error) {
  17         if !c.ok() {
  18                 return 0, syscall.EINVAL
  19         }
  20         so, ok := sockOpts[ssoMulticastHopLimit]
  21         if !ok {
  22                 return 0, errOpNoSupport
  23         }
  24         return so.GetInt(c.Conn)
  25 }
  26
  27 // SetMulticastHopLimit sets the hop limit field value for future
  28 // outgoing multicast packets.
  29 func (c *dgramOpt) SetMulticastHopLimit(hoplim int) error {
  30         if !c.ok() {
  31                 return syscall.EINVAL
  32         }
  33         so, ok := sockOpts[ssoMulticastHopLimit]
  34         if !ok {
  35                 return errOpNoSupport
  36         }
  37         return so.SetInt(c.Conn, hoplim)
  38 }
  39
  40 // MulticastInterface returns the default interface for multicast
  41 // packet transmissions.
  42 func (c *dgramOpt) MulticastInterface() (*net.Interface, error) {
  43         if !c.ok() {
  44                 return nil, syscall.EINVAL
  45         }
  46         so, ok := sockOpts[ssoMulticastInterface]
  47         if !ok {
  48                 return nil, errOpNoSupport
  49         }
  50         return so.getMulticastInterface(c.Conn)
  51 }
  52
  53 // SetMulticastInterface sets the default interface for future
  54 // multicast packet transmissions.
  55 func (c *dgramOpt) SetMulticastInterface(ifi *net.Interface) error {
  56         if !c.ok() {
  57                 return syscall.EINVAL
  58         }
  59         so, ok := sockOpts[ssoMulticastInterface]
  60         if !ok {
  61                 return errOpNoSupport
  62         }
  63         return so.setMulticastInterface(c.Conn, ifi)
  64 }
  65
  66 // MulticastLoopback reports whether transmitted multicast packets
  67 // should be copied and send back to the originator.
  68 func (c *dgramOpt) MulticastLoopback() (bool, error) {
  69         if !c.ok() {
  70                 return false, syscall.EINVAL
  71         }
  72         so, ok := sockOpts[ssoMulticastLoopback]
  73         if !ok {
  74                 return false, errOpNoSupport
  75         }
  76         on, err := so.GetInt(c.Conn)
  77         if err != nil {
  78                 return false, err
  79         }
  80         return on == 1, nil
  81 }
  82
  83 // SetMulticastLoopback sets whether transmitted multicast packets
  84 // should be copied and send back to the originator.
  85 func (c *dgramOpt) SetMulticastLoopback(on bool) error {
  86         if !c.ok() {
  87                 return syscall.EINVAL
  88         }
  89         so, ok := sockOpts[ssoMulticastLoopback]
  90         if !ok {
  91                 return errOpNoSupport
  92         }
  93         return so.SetInt(c.Conn, boolint(on))
  94 }
  95
  96 // JoinGroup joins the group address group on the interface ifi.
  97 // By default all sources that can cast data to group are accepted.
  98 // It's possible to mute and unmute data transmission from a specific
  99 // source by using ExcludeSourceSpecificGroup and
 100 // IncludeSourceSpecificGroup.
 101 // JoinGroup uses the system assigned multicast interface when ifi is
 102 // nil, although this is not recommended because the assignment
 103 // depends on platforms and sometimes it might require routing
 104 // configuration.
 105 func (c *dgramOpt) JoinGroup(ifi *net.Interface, group net.Addr) error {
 106         if !c.ok() {
 107                 return syscall.EINVAL
 108         }
 109         so, ok := sockOpts[ssoJoinGroup]
 110         if !ok {
 111                 return errOpNoSupport
 112         }
 113         grp := netAddrToIP16(group)
 114         if grp == nil {
 115                 return errMissingAddress
 116         }
 117         return so.setGroup(c.Conn, ifi, grp)
 118 }
 119
 120 // LeaveGroup leaves the group address group on the interface ifi
 121 // regardless of whether the group is any-source group or
 122 // source-specific group.
 123 func (c *dgramOpt) LeaveGroup(ifi *net.Interface, group net.Addr) error {
 124         if !c.ok() {
 125                 return syscall.EINVAL
 126         }
 127         so, ok := sockOpts[ssoLeaveGroup]
 128         if !ok {
 129                 return errOpNoSupport
 130         }
 131         grp := netAddrToIP16(group)
 132         if grp == nil {
 133                 return errMissingAddress
 134         }
 135         return so.setGroup(c.Conn, ifi, grp)
 136 }
 137
 138 // JoinSourceSpecificGroup joins the source-specific group comprising
 139 // group and source on the interface ifi.
 140 // JoinSourceSpecificGroup uses the system assigned multicast
 141 // interface when ifi is nil, although this is not recommended because
 142 // the assignment depends on platforms and sometimes it might require
 143 // routing configuration.
 144 func (c *dgramOpt) JoinSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error {
 145         if !c.ok() {
 146                 return syscall.EINVAL
 147         }
 148         so, ok := sockOpts[ssoJoinSourceGroup]
 149         if !ok {
 150                 return errOpNoSupport
 151         }
 152         grp := netAddrToIP16(group)
 153         if grp == nil {
 154                 return errMissingAddress
 155         }
 156         src := netAddrToIP16(source)
 157         if src == nil {
 158                 return errMissingAddress
 159         }
 160         return so.setSourceGroup(c.Conn, ifi, grp, src)
 161 }
 162
 163 // LeaveSourceSpecificGroup leaves the source-specific group on the
 164 // interface ifi.
 165 func (c *dgramOpt) LeaveSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error {
 166         if !c.ok() {
 167                 return syscall.EINVAL
 168         }
 169         so, ok := sockOpts[ssoLeaveSourceGroup]
 170         if !ok {
 171                 return errOpNoSupport
 172         }
 173         grp := netAddrToIP16(group)
 174         if grp == nil {
 175                 return errMissingAddress
 176         }
 177         src := netAddrToIP16(source)
 178         if src == nil {
 179                 return errMissingAddress
 180         }
 181         return so.setSourceGroup(c.Conn, ifi, grp, src)
 182 }
 183
 184 // ExcludeSourceSpecificGroup excludes the source-specific group from
 185 // the already joined any-source groups by JoinGroup on the interface
 186 // ifi.
 187 func (c *dgramOpt) ExcludeSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error {
 188         if !c.ok() {
 189                 return syscall.EINVAL
 190         }
 191         so, ok := sockOpts[ssoBlockSourceGroup]
 192         if !ok {
 193                 return errOpNoSupport
 194         }
 195         grp := netAddrToIP16(group)
 196         if grp == nil {
 197                 return errMissingAddress
 198         }
 199         src := netAddrToIP16(source)
 200         if src == nil {
 201                 return errMissingAddress
 202         }
 203         return so.setSourceGroup(c.Conn, ifi, grp, src)
 204 }
 205
 206 // IncludeSourceSpecificGroup includes the excluded source-specific
 207 // group by ExcludeSourceSpecificGroup again on the interface ifi.
 208 func (c *dgramOpt) IncludeSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error {
 209         if !c.ok() {
 210                 return syscall.EINVAL
 211         }
 212         so, ok := sockOpts[ssoUnblockSourceGroup]
 213         if !ok {
 214                 return errOpNoSupport
 215         }
 216         grp := netAddrToIP16(group)
 217         if grp == nil {
 218                 return errMissingAddress
 219         }
 220         src := netAddrToIP16(source)
 221         if src == nil {
 222                 return errMissingAddress
 223         }
 224         return so.setSourceGroup(c.Conn, ifi, grp, src)
 225 }
 226
 227 // Checksum reports whether the kernel will compute, store or verify a
 228 // checksum for both incoming and outgoing packets. If on is true, it
 229 // returns an offset in bytes into the data of where the checksum
 230 // field is located.
 231 func (c *dgramOpt) Checksum() (on bool, offset int, err error) {
 232         if !c.ok() {
 233                 return false, 0, syscall.EINVAL
 234         }
 235         so, ok := sockOpts[ssoChecksum]
 236         if !ok {
 237                 return false, 0, errOpNoSupport
 238         }
 239         offset, err = so.GetInt(c.Conn)
 240         if err != nil {
 241                 return false, 0, err
 242         }
 243         if offset < 0 {
 244                 return false, 0, nil
 245         }
 246         return true, offset, nil
 247 }
 248
 249 // SetChecksum enables the kernel checksum processing. If on is ture,
 250 // the offset should be an offset in bytes into the data of where the
 251 // checksum field is located.
 252 func (c *dgramOpt) SetChecksum(on bool, offset int) error {
 253         if !c.ok() {
 254                 return syscall.EINVAL
 255         }
 256         so, ok := sockOpts[ssoChecksum]
 257         if !ok {
 258                 return errOpNoSupport
 259         }
 260         if !on {
 261                 offset = -1
 262         }
 263         return so.SetInt(c.Conn, offset)
 264 }
 265
 266 // ICMPFilter returns an ICMP filter.
 267 func (c *dgramOpt) ICMPFilter() (*ICMPFilter, error) {
 268         if !c.ok() {
 269                 return nil, syscall.EINVAL
 270         }
 271         so, ok := sockOpts[ssoICMPFilter]
 272         if !ok {
 273                 return nil, errOpNoSupport
 274         }
 275         return so.getICMPFilter(c.Conn)
 276 }
 277
 278 // SetICMPFilter deploys the ICMP filter.
 279 func (c *dgramOpt) SetICMPFilter(f *ICMPFilter) error {
 280         if !c.ok() {
 281                 return syscall.EINVAL
 282         }
 283         so, ok := sockOpts[ssoICMPFilter]
 284         if !ok {
 285                 return errOpNoSupport
 286         }
 287         return so.setICMPFilter(c.Conn, f)
 288 }
 289
 290 // SetBPF attaches a BPF program to the connection.
 291 //
 292 // Only supported on Linux.
 293 func (c *dgramOpt) SetBPF(filter []bpf.RawInstruction) error {
 294         if !c.ok() {
 295                 return syscall.EINVAL
 296         }
 297         so, ok := sockOpts[ssoAttachFilter]
 298         if !ok {
 299                 return errOpNoSupport
 300         }
 301         return so.setBPF(c.Conn, filter)
 302 }