dgramopt.go

Documentation: golang.org/x/net/ipv4

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