batch.go

Documentation: golang.org/x/net/ipv4

     1  // Copyright 2017 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  	"runtime"
    10  
    11  	"golang.org/x/net/internal/socket"
    12  )
    13  
    14  // BUG(mikio): On Windows, the ReadBatch and WriteBatch methods of
    15  // PacketConn are not implemented.
    16  
    17  // BUG(mikio): On Windows, the ReadBatch and WriteBatch methods of
    18  // RawConn are not implemented.
    19  
    20  // A Message represents an IO message.
    21  //
    22  //	type Message struct {
    23  //		Buffers [][]byte
    24  //		OOB     []byte
    25  //		Addr    net.Addr
    26  //		N       int
    27  //		NN      int
    28  //		Flags   int
    29  //	}
    30  //
    31  // The Buffers fields represents a list of contiguous buffers, which
    32  // can be used for vectored IO, for example, putting a header and a
    33  // payload in each slice.
    34  // When writing, the Buffers field must contain at least one byte to
    35  // write.
    36  // When reading, the Buffers field will always contain a byte to read.
    37  //
    38  // The OOB field contains protocol-specific control or miscellaneous
    39  // ancillary data known as out-of-band data.
    40  // It can be nil when not required.
    41  //
    42  // The Addr field specifies a destination address when writing.
    43  // It can be nil when the underlying protocol of the endpoint uses
    44  // connection-oriented communication.
    45  // After a successful read, it may contain the source address on the
    46  // received packet.
    47  //
    48  // The N field indicates the number of bytes read or written from/to
    49  // Buffers.
    50  //
    51  // The NN field indicates the number of bytes read or written from/to
    52  // OOB.
    53  //
    54  // The Flags field contains protocol-specific information on the
    55  // received message.
    56  type Message = socket.Message
    57  
    58  // ReadBatch reads a batch of messages.
    59  //
    60  // The provided flags is a set of platform-dependent flags, such as
    61  // syscall.MSG_PEEK.
    62  //
    63  // On a successful read it returns the number of messages received, up
    64  // to len(ms).
    65  //
    66  // On Linux, a batch read will be optimized.
    67  // On other platforms, this method will read only a single message.
    68  //
    69  // Unlike the ReadFrom method, it doesn't strip the IPv4 header
    70  // followed by option headers from the received IPv4 datagram when the
    71  // underlying transport is net.IPConn. Each Buffers field of Message
    72  // must be large enough to accommodate an IPv4 header and option
    73  // headers.
    74  func (c *payloadHandler) ReadBatch(ms []Message, flags int) (int, error) {
    75  	if !c.ok() {
    76  		return 0, errInvalidConn
    77  	}
    78  	switch runtime.GOOS {
    79  	case "linux":
    80  		n, err := c.RecvMsgs([]socket.Message(ms), flags)
    81  		if err != nil {
    82  			err = &net.OpError{Op: "read", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err}
    83  		}
    84  		return n, err
    85  	default:
    86  		n := 1
    87  		err := c.RecvMsg(&ms[0], flags)
    88  		if err != nil {
    89  			n = 0
    90  			err = &net.OpError{Op: "read", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err}
    91  		}
    92  		if compatFreeBSD32 && ms[0].NN > 0 {
    93  			adjustFreeBSD32(&ms[0])
    94  		}
    95  		return n, err
    96  	}
    97  }
    98  
    99  // WriteBatch writes a batch of messages.
   100  //
   101  // The provided flags is a set of platform-dependent flags, such as
   102  // syscall.MSG_DONTROUTE.
   103  //
   104  // It returns the number of messages written on a successful write.
   105  //
   106  // On Linux, a batch write will be optimized.
   107  // On other platforms, this method will write only a single message.
   108  func (c *payloadHandler) WriteBatch(ms []Message, flags int) (int, error) {
   109  	if !c.ok() {
   110  		return 0, errInvalidConn
   111  	}
   112  	switch runtime.GOOS {
   113  	case "linux":
   114  		n, err := c.SendMsgs([]socket.Message(ms), flags)
   115  		if err != nil {
   116  			err = &net.OpError{Op: "write", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err}
   117  		}
   118  		return n, err
   119  	default:
   120  		n := 1
   121  		err := c.SendMsg(&ms[0], flags)
   122  		if err != nil {
   123  			n = 0
   124  			err = &net.OpError{Op: "write", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err}
   125  		}
   126  		return n, err
   127  	}
   128  }
   129  
   130  // ReadBatch reads a batch of messages.
   131  //
   132  // The provided flags is a set of platform-dependent flags, such as
   133  // syscall.MSG_PEEK.
   134  //
   135  // On a successful read it returns the number of messages received, up
   136  // to len(ms).
   137  //
   138  // On Linux, a batch read will be optimized.
   139  // On other platforms, this method will read only a single message.
   140  func (c *packetHandler) ReadBatch(ms []Message, flags int) (int, error) {
   141  	if !c.ok() {
   142  		return 0, errInvalidConn
   143  	}
   144  	switch runtime.GOOS {
   145  	case "linux":
   146  		n, err := c.RecvMsgs([]socket.Message(ms), flags)
   147  		if err != nil {
   148  			err = &net.OpError{Op: "read", Net: c.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err}
   149  		}
   150  		return n, err
   151  	default:
   152  		n := 1
   153  		err := c.RecvMsg(&ms[0], flags)
   154  		if err != nil {
   155  			n = 0
   156  			err = &net.OpError{Op: "read", Net: c.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err}
   157  		}
   158  		if compatFreeBSD32 && ms[0].NN > 0 {
   159  			adjustFreeBSD32(&ms[0])
   160  		}
   161  		return n, err
   162  	}
   163  }
   164  
   165  // WriteBatch writes a batch of messages.
   166  //
   167  // The provided flags is a set of platform-dependent flags, such as
   168  // syscall.MSG_DONTROUTE.
   169  //
   170  // It returns the number of messages written on a successful write.
   171  //
   172  // On Linux, a batch write will be optimized.
   173  // On other platforms, this method will write only a single message.
   174  func (c *packetHandler) WriteBatch(ms []Message, flags int) (int, error) {
   175  	if !c.ok() {
   176  		return 0, errInvalidConn
   177  	}
   178  	switch runtime.GOOS {
   179  	case "linux":
   180  		n, err := c.SendMsgs([]socket.Message(ms), flags)
   181  		if err != nil {
   182  			err = &net.OpError{Op: "write", Net: c.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err}
   183  		}
   184  		return n, err
   185  	default:
   186  		n := 1
   187  		err := c.SendMsg(&ms[0], flags)
   188  		if err != nil {
   189  			n = 0
   190  			err = &net.OpError{Op: "write", Net: c.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err}
   191  		}
   192  		return n, err
   193  	}
   194  }
   195
View as plain text