"errors"
"os"
"sync"
+ "syscall"
+ "time"
"unsafe"
"golang.org/x/sys/windows"
packetExchangeAlignment uint32 = 16 // Number of bytes packets are aligned to in exchange buffers
packetSizeMax uint32 = 0xf000 - packetExchangeAlignment // Maximum packet size
packetExchangeSize uint32 = 0x100000 // Exchange buffer size (defaults to 1MiB)
+ retryRate = 4 // Number of retries per second to reopen device pipe
+ retryTimeout = 5 // Number of seconds to tolerate adapter unavailable
)
type exchgBufRead struct {
type NativeTun struct {
wt *wintun.Wintun
- tunName string
- tunFile *os.File
+ tunName *uint16
+ tunFile windows.Handle
tunLock sync.Mutex
+ close bool
rdBuff *exchgBufRead
wrBuff *exchgBufWrite
events chan TUNEvent
forcedMtu int
}
+//sys getOverlappedResult(handle windows.Handle, overlapped *windows.Overlapped, done *uint32, wait bool) (err error) = kernel32.GetOverlappedResult
+
func packetAlign(size uint32) uint32 {
return (size + (packetExchangeAlignment - 1)) &^ (packetExchangeAlignment - 1)
}
return nil, errors.New("Flushing interface failed: " + err.Error())
}
+ tunNameUTF16, err := windows.UTF16PtrFromString(wt.DataFileName())
+ if err != nil {
+ wt.DeleteInterface(0)
+ return nil, err
+ }
+
return &NativeTun{
wt: wt,
- tunName: wt.DataFileName(),
+ tunName: tunNameUTF16,
+ tunFile: windows.InvalidHandle,
rdBuff: &exchgBufRead{},
wrBuff: &exchgBufWrite{},
events: make(chan TUNEvent, 10),
}, nil
}
-func (tun *NativeTun) openTUN() {
+func (tun *NativeTun) openTUN() error {
+ retries := retryTimeout * retryRate
for {
- file, err := os.OpenFile(tun.tunName, os.O_RDWR, 0)
+ if tun.close {
+ return errors.New("Cancelled")
+ }
+
+ file, err := windows.CreateFile(tun.tunName, windows.GENERIC_READ|windows.GENERIC_WRITE, 0, nil, windows.OPEN_EXISTING, windows.FILE_ATTRIBUTE_NORMAL|windows.FILE_FLAG_OVERLAPPED|0x20000000 /*windows.FILE_FLAG_NO_BUFFERING*/, 0)
if err != nil {
- continue
+ if retries > 0 {
+ time.Sleep(time.Second / retryRate)
+ retries--
+ continue
+ }
+ return err
}
+
tun.tunFile = file
+ return nil
}
}
func (tun *NativeTun) closeTUN() (err error) {
- if tun.tunFile != nil {
+ if tun.tunFile != windows.InvalidHandle {
tun.tunLock.Lock()
defer tun.tunLock.Unlock()
- if tun.tunFile == nil {
+ if tun.tunFile == windows.InvalidHandle {
return
}
t := tun.tunFile
- tun.tunFile = nil
- err = t.Close()
+ tun.tunFile = windows.InvalidHandle
+ err = windows.CloseHandle(t)
}
return
}
-func (tun *NativeTun) getTUN() (*os.File, error) {
- if tun.tunFile == nil {
+func (tun *NativeTun) getTUN() (windows.Handle, error) {
+ if tun.tunFile == windows.InvalidHandle {
tun.tunLock.Lock()
defer tun.tunLock.Unlock()
- if tun.tunFile != nil {
+ if tun.tunFile != windows.InvalidHandle {
return tun.tunFile, nil
}
- tun.openTUN()
+ err := tun.openTUN()
+ if err != nil {
+ return windows.InvalidHandle, err
+ }
}
return tun.tunFile, nil
}
+func (tun *NativeTun) isIOCancelled(err error) bool {
+ // Read&WriteFile() return the same ERROR_OPERATION_ABORTED if we close the handle
+ // or the TUN device is put down. We need a "close" flag to distinguish.
+ en, ok := err.(syscall.Errno)
+ if tun.close && ok && en == windows.ERROR_OPERATION_ABORTED {
+ return true
+ }
+ return false
+}
+
func (tun *NativeTun) Name() (string, error) {
return tun.wt.GetInterfaceName()
}
}
func (tun *NativeTun) Close() error {
+ tun.close = true
err1 := tun.closeTUN()
if tun.events != nil {
}
// Fill queue.
- n, err := file.Read(tun.rdBuff.data[:])
+ var n uint32
+ overlapped := &windows.Overlapped{}
+ err = windows.ReadFile(file, tun.rdBuff.data[:], &n, overlapped)
if err != nil {
- if pe, ok := err.(*os.PathError); ok && pe.Err == os.ErrClosed {
- return 0, err
+ if en, ok := err.(syscall.Errno); ok && en == windows.ERROR_IO_PENDING {
+ err = getOverlappedResult(file, overlapped, &n, true)
+ }
+ if err != nil {
+ tun.rdBuff.avail = 0
+ if tun.isIOCancelled(err) {
+ return 0, err
+ }
+ tun.closeTUN()
+ continue
}
- // TUN interface stopped, failed, etc. Retry.
- tun.rdBuff.avail = 0
- tun.closeTUN()
- continue
}
tun.rdBuff.offset = 0
tun.rdBuff.avail = uint32(n)
}
// Flush write buffer.
- _, err = file.Write(tun.wrBuff.data[:tun.wrBuff.offset])
+ var n uint32
+ overlapped := &windows.Overlapped{}
+ err = windows.WriteFile(file, tun.wrBuff.data[:tun.wrBuff.offset], &n, overlapped)
tun.wrBuff.packetNum = 0
tun.wrBuff.offset = 0
if err != nil {
- // TUN interface stopped, failed, etc. Drop.
- tun.closeTUN()
- return err
+ if en, ok := err.(syscall.Errno); ok && en == windows.ERROR_IO_PENDING {
+ err = getOverlappedResult(file, overlapped, &n, true)
+ }
+ if err != nil {
+ if tun.isIOCancelled(err) {
+ return err
+ }
+ tun.closeTUN()
+ return nil
+ }
}
return nil
--- /dev/null
+// Code generated by 'go generate'; DO NOT EDIT.
+
+package tun
+
+import (
+ "syscall"
+ "unsafe"
+
+ "golang.org/x/sys/windows"
+)
+
+var _ unsafe.Pointer
+
+// Do the interface allocations only once for common
+// Errno values.
+const (
+ errnoERROR_IO_PENDING = 997
+)
+
+var (
+ errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
+)
+
+// errnoErr returns common boxed Errno values, to prevent
+// allocations at runtime.
+func errnoErr(e syscall.Errno) error {
+ switch e {
+ case 0:
+ return nil
+ case errnoERROR_IO_PENDING:
+ return errERROR_IO_PENDING
+ }
+ // TODO: add more here, after collecting data on the common
+ // error values see on Windows. (perhaps when running
+ // all.bat?)
+ return e
+}
+
+var (
+ modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
+
+ procGetOverlappedResult = modkernel32.NewProc("GetOverlappedResult")
+)
+
+func getOverlappedResult(handle windows.Handle, overlapped *windows.Overlapped, done *uint32, wait bool) (err error) {
+ var _p0 uint32
+ if wait {
+ _p0 = 1
+ } else {
+ _p0 = 0
+ }
+ r1, _, e1 := syscall.Syscall6(procGetOverlappedResult.Addr(), 4, uintptr(handle), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(done)), uintptr(_p0), 0, 0)
+ if r1 == 0 {
+ if e1 != 0 {
+ err = errnoErr(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
projects / thirdparty / wireguard-go.git / commitdiff
