wireguard-go/tun/tun_windows.go
2019-03-21 14:45:41 -06:00

361 lines
8.8 KiB
Go

/* SPDX-License-Identifier: MIT
*
* Copyright (C) 2018-2019 WireGuard LLC. All Rights Reserved.
*/
package tun
import (
"errors"
"os"
"sync"
"syscall"
"time"
"unsafe"
"golang.org/x/sys/windows"
"golang.zx2c4.com/wireguard/tun/wintun"
)
const (
packetExchangeMax uint32 = 256 // Number of packets that may be written at a time
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 {
data [packetExchangeSize]byte
offset uint32
avail uint32
}
type exchgBufWrite struct {
data [packetExchangeSize]byte
offset uint32
packetNum uint32
}
type NativeTun struct {
wt *wintun.Wintun
tunName *uint16
tunFile windows.Handle
tunLock sync.Mutex
close bool
rdBuff *exchgBufRead
wrBuff *exchgBufWrite
rdEvent windows.Handle
wrEvent windows.Handle
events chan TUNEvent
errors chan error
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)
}
//
// CreateTUN creates a Wintun adapter with the given name. Should a Wintun
// adapter with the same name exist, it is reused.
//
func CreateTUN(ifname string) (TUNDevice, error) {
// Does an interface with this name already exist?
wt, err := wintun.GetInterface(ifname, 0)
if wt == nil {
// Interface does not exist or an error occured. Create one.
wt, _, err = wintun.CreateInterface("WireGuard Tunnel Adapter", 0)
if err != nil {
return nil, errors.New("Creating Wintun adapter failed: " + err.Error())
}
} else if err != nil {
// Foreign interface with the same name found.
// We could create a Wintun interface under a temporary name. But, should our
// proces die without deleting this interface first, the interface would remain
// orphaned.
return nil, err
}
err = wt.SetInterfaceName(ifname)
if err != nil {
wt.DeleteInterface(0)
return nil, errors.New("Setting interface name failed: " + err.Error())
}
err = wt.FlushInterface()
if err != nil {
wt.DeleteInterface(0)
return nil, errors.New("Flushing interface failed: " + err.Error())
}
tunNameUTF16, err := windows.UTF16PtrFromString(wt.DataFileName())
if err != nil {
wt.DeleteInterface(0)
return nil, err
}
rde, err := windows.CreateEvent(nil, 1 /*TRUE*/, 0 /*FALSE*/, nil)
if err != nil {
wt.DeleteInterface(0)
return nil, err
}
wre, err := windows.CreateEvent(nil, 1 /*TRUE*/, 0 /*FALSE*/, nil)
if err != nil {
windows.CloseHandle(rde)
wt.DeleteInterface(0)
return nil, err
}
return &NativeTun{
wt: wt,
tunName: tunNameUTF16,
tunFile: windows.InvalidHandle,
rdBuff: &exchgBufRead{},
wrBuff: &exchgBufWrite{},
rdEvent: rde,
wrEvent: wre,
events: make(chan TUNEvent, 10),
errors: make(chan error, 1),
forcedMtu: 1500,
}, nil
}
func (tun *NativeTun) openTUN() error {
retries := retryTimeout * retryRate
for {
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|windows.FILE_FLAG_NO_BUFFERING, 0)
if err != nil {
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 != windows.InvalidHandle {
tun.tunLock.Lock()
defer tun.tunLock.Unlock()
if tun.tunFile == windows.InvalidHandle {
return
}
t := tun.tunFile
tun.tunFile = windows.InvalidHandle
err = windows.CloseHandle(t)
}
return
}
func (tun *NativeTun) getTUN() (windows.Handle, error) {
if tun.tunFile == windows.InvalidHandle {
tun.tunLock.Lock()
defer tun.tunLock.Unlock()
if tun.tunFile != windows.InvalidHandle {
return tun.tunFile, nil
}
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) File() *os.File {
return nil
}
func (tun *NativeTun) Events() chan TUNEvent {
return tun.events
}
func (tun *NativeTun) Close() error {
tun.close = true
err1 := tun.closeTUN()
if tun.events != nil {
close(tun.events)
}
_, _, err2 := tun.wt.DeleteInterface(0)
if err1 == nil {
err1 = err2
}
windows.CloseHandle(tun.rdEvent)
windows.CloseHandle(tun.wrEvent)
return err1
}
func (tun *NativeTun) MTU() (int, error) {
return tun.forcedMtu, nil
}
//TODO: This is a temporary hack. We really need to be monitoring the interface in real time and adapting to MTU changes.
func (tun *NativeTun) ForceMtu(mtu int) {
tun.forcedMtu = mtu
}
func (tun *NativeTun) Read(buff []byte, offset int) (int, error) {
select {
case err := <-tun.errors:
return 0, err
default:
}
for {
if tun.rdBuff.offset+packetExchangeAlignment <= tun.rdBuff.avail {
// Get packet from the exchange buffer.
packet := tun.rdBuff.data[tun.rdBuff.offset:]
size := *(*uint32)(unsafe.Pointer(&packet[0]))
pSize := packetAlign(packetExchangeAlignment + size)
if packetSizeMax < size || tun.rdBuff.avail < tun.rdBuff.offset+pSize {
// Invalid packet size.
tun.rdBuff.avail = 0
continue
}
packet = packet[packetExchangeAlignment : packetExchangeAlignment+size]
// Copy data.
copy(buff[offset:], packet)
tun.rdBuff.offset += pSize
return int(size), nil
}
// Get TUN data pipe.
file, err := tun.getTUN()
if err != nil {
return 0, err
}
// Fill queue.
var n uint32
overlapped := &windows.Overlapped{HEvent: tun.rdEvent}
err = windows.ReadFile(file, tun.rdBuff.data[:], &n, overlapped)
if err != nil {
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.rdBuff.offset = 0
tun.rdBuff.avail = uint32(n)
}
}
// Note: flush() and putTunPacket() assume the caller comes only from a single thread; there's no locking.
func (tun *NativeTun) Flush() error {
if tun.wrBuff.offset == 0 {
return nil
}
// Get TUN data pipe.
file, err := tun.getTUN()
if err != nil {
return err
}
// Flush write buffer.
var n uint32
overlapped := &windows.Overlapped{HEvent: tun.wrEvent}
err = windows.WriteFile(file, tun.wrBuff.data[:tun.wrBuff.offset], &n, overlapped)
tun.wrBuff.packetNum = 0
tun.wrBuff.offset = 0
if err != nil {
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
}
func (tun *NativeTun) putTunPacket(buff []byte) error {
size := uint32(len(buff))
if size == 0 {
return errors.New("Empty packet")
}
if size > packetSizeMax {
return errors.New("Packet too big")
}
pSize := packetAlign(packetExchangeAlignment + size)
if tun.wrBuff.packetNum >= packetExchangeMax || tun.wrBuff.offset+pSize >= packetExchangeSize {
// Exchange buffer is full -> flush first.
err := tun.Flush()
if err != nil {
return err
}
}
// Write packet to the exchange buffer.
packet := tun.wrBuff.data[tun.wrBuff.offset : tun.wrBuff.offset+pSize]
*(*uint32)(unsafe.Pointer(&packet[0])) = size
packet = packet[packetExchangeAlignment : packetExchangeAlignment+size]
copy(packet, buff)
tun.wrBuff.packetNum++
tun.wrBuff.offset += pSize
return nil
}
func (tun *NativeTun) Write(buff []byte, offset int) (int, error) {
err := tun.putTunPacket(buff[offset:])
if err != nil {
return 0, err
}
return len(buff) - offset, nil
}
//
// GUID returns Windows adapter instance ID.
//
func (tun *NativeTun) GUID() windows.GUID {
return *(*windows.GUID)(tun.wt)
}