mirror of
https://git.zx2c4.com/wireguard-go
synced 2024-11-15 01:05:15 +01:00
3bb8fec7e4
Accept packet vectors for reading and writing in the tun.Device and conn.Bind interfaces, so that the internal plumbing between these interfaces now passes a vector of packets. Vectors move untouched between these interfaces, i.e. if 128 packets are received from conn.Bind.Read(), 128 packets are passed to tun.Device.Write(). There is no internal buffering. Currently, existing implementations are only adjusted to have vectors of length one. Subsequent patches will improve that. Also, as a related fixup, use the unix and windows packages rather than the syscall package when possible. Co-authored-by: James Tucker <james@tailscale.com> Signed-off-by: James Tucker <james@tailscale.com> Signed-off-by: Jordan Whited <jordan@tailscale.com> Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
61 lines
1.2 KiB
Go
61 lines
1.2 KiB
Go
package tun
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
)
|
|
|
|
var (
|
|
// ErrTooManySegments is returned by Device.Read() when segmentation
|
|
// overflows the length of supplied buffers. This error should not cause
|
|
// reads to cease.
|
|
ErrTooManySegments = errors.New("too many segments")
|
|
)
|
|
|
|
type errorBatch []error
|
|
|
|
// ErrorBatch takes a possibly nil or empty list of errors, and if the list is
|
|
// non-nil returns an error type that wraps all of the errors. Expected usage is
|
|
// to append to an []errors and coerce the set to an error using this method.
|
|
func ErrorBatch(errs []error) error {
|
|
if len(errs) == 0 {
|
|
return nil
|
|
}
|
|
return errorBatch(errs)
|
|
}
|
|
|
|
func (e errorBatch) Error() string {
|
|
if len(e) == 0 {
|
|
return ""
|
|
}
|
|
if len(e) == 1 {
|
|
return e[0].Error()
|
|
}
|
|
return fmt.Sprintf("batch operation: %v (and %d more errors)", e[0], len(e)-1)
|
|
}
|
|
|
|
func (e errorBatch) Is(target error) bool {
|
|
for _, err := range e {
|
|
if errors.Is(err, target) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (e errorBatch) As(target interface{}) bool {
|
|
for _, err := range e {
|
|
if errors.As(err, target) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (e errorBatch) Unwrap() error {
|
|
if len(e) == 0 {
|
|
return nil
|
|
}
|
|
return e[0]
|
|
}
|