Symlinks in Windows - check, read, create - golang

go-windows-symlinks.go

package main

import(
	"fmt"
	"path/filepath"
	"syscall"
	"unicode/utf16"
	"unsafe"
	"os"
)

var (
	modkernel32 = syscall.NewLazyDLL("kernel32.dll")
	procDeviceIoControl = modkernel32.NewProc("DeviceIoControl")
	procCreateSymbolicLink = modkernel32.NewProc("CreateSymbolicLinkW")
	procGetFinalPathNameByHandle = modkernel32.NewProc("GetFinalPathNameByHandleW")

	base = "C:\\temp\\symtest"
)

func main(){

	stat, err := os.Stat(filepath.Join(base, "f4.lnk"))
	fmt.Printf("%#v\n%s\n", stat, err)

	filepath.Walk(base, func(path string, i os.FileInfo, err error) error {
		fmt.Println(path)
		return nil
	} )
	os.Remove(filepath.Join(base, "s1"))
	mklink(filepath.Join(base, "s1"), filepath.Join(base, "f1"))
	for _, f := range []string{"f1", "f2", "f3", "s1", "f4"} {
		path := filepath.Join(base, f)
		ptr, err := syscall.UTF16PtrFromString(path)
		if err != nil {
			fmt.Println(err)
			return
		}
		attrs, err := syscall.GetFileAttributes(ptr)
		if err != nil {
			fmt.Println(err)
			return
		}
		_ = attrs
		//fmt.Println(attrs)

		link, err := readlink2(path)
		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Println(link)
		}

	}
}

const (
	FSCTL_GET_REPARSE_POINT = 0x900a8
	FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000
	IO_REPARSE_TAG_SYMLINK = 0xA000000C
)

type ReparseDataBuffer struct {
	ReparseTag uint32
	ReparseDataLength uint16
	Reserved uint16
	SubstitueNameOffset uint16
	SubstitueNameLength uint16
	PrintNameOffset uint16
	PrintNameLength uint16
	Flags uint32
	// SubstituteName - 264 widechars = 528 bytes
	// PrintName      - 260 widechars = 520 bytes
	//                                = 1048 bytes total
	buffer [1048]uint16
}

func (r *ReparseDataBuffer) PrintName() string {
	offset := r.PrintNameOffset/2
	length := r.PrintNameLength/2
	return string(utf16.Decode(r.buffer[offset:offset+length]))
}

func (r *ReparseDataBuffer) SubstituteName() string {
	offset := r.SubstitueNameOffset/2
	length := r.SubstitueNameLength/2
	return string(utf16.Decode(r.buffer[offset:offset+length]))
}

func readlink(input string) (path string, err error) {
	ptr, err := syscall.UTF16PtrFromString(input)
	if err != nil {
		return
	}
	handle, err := syscall.CreateFile(ptr, 0, 0, nil, syscall.OPEN_EXISTING, syscall.FILE_FLAG_BACKUP_SEMANTICS|FILE_FLAG_OPEN_REPARSE_POINT, 0)
	if err != nil || handle == syscall.InvalidHandle {
		return
	}
	var ret uint16
	var data ReparseDataBuffer

	r1, _, err := syscall.Syscall9(procDeviceIoControl.Addr(), 8, uintptr(handle), FSCTL_GET_REPARSE_POINT, 0, 0, uintptr(unsafe.Pointer(&data)), unsafe.Sizeof(data), uintptr(unsafe.Pointer(&ret)), 0, 0)
	if r1 == 0 {
		return
	}
	return data.PrintName(), nil
}

func mklink(source, target string) error {
	srcp, err := syscall.UTF16PtrFromString(source)
	if err != nil {
		return err
	}
	trgp, err := syscall.UTF16PtrFromString(source)

	r0, _, err := syscall.Syscall(procCreateSymbolicLink.Addr(), 3, uintptr(unsafe.Pointer(srcp)), uintptr(unsafe.Pointer(trgp)), 0)
	if r0 != 1 {
		return err
	}
	return nil
}

func readlink2(input string) (path string, err error) {
    ptr, err := syscall.UTF16PtrFromString(input)
	if err != nil {
		return
	}
	handle, err := syscall.CreateFile(ptr, 0, 0, nil, syscall.OPEN_EXISTING, syscall.FILE_FLAG_BACKUP_SEMANTICS|FILE_FLAG_OPEN_REPARSE_POINT, 0)
	if err != nil || handle == syscall.InvalidHandle {
		return
	}
	var	buf [528]uint16
	r0, _, err := syscall.Syscall6(procGetFinalPathNameByHandle.Addr(), 3, uintptr(handle), uintptr(unsafe.Pointer(&buf)), unsafe.Sizeof(buf), 0, 0, 0)
	if r0 == 22 {
		return syscall.UTF16ToString(buf[4:]), nil
	}
	return "", err
}

func issymlink(path string) (bool, error) {
	ptr, err := syscall.UTF16PtrFromString(path)
	if err != nil {
		return false, err
	}

	attr, err := syscall.GetFileAttributes(ptr)
	if err != nil {
		return false, err
	}
	return attr&FILE_ATTRIBUTE_REPARSE_POINT != 0, nil
}