mirror of https://github.com/gogits/gogs.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
378 lines
11 KiB
378 lines
11 KiB
// Copyright 2011 The Go Authors. All rights reserved. |
|
// Use of this source code is governed by a BSD-style |
|
// license that can be found in the LICENSE file. |
|
|
|
package windows |
|
|
|
import ( |
|
"sync" |
|
"sync/atomic" |
|
"syscall" |
|
"unsafe" |
|
) |
|
|
|
// DLLError describes reasons for DLL load failures. |
|
type DLLError struct { |
|
Err error |
|
ObjName string |
|
Msg string |
|
} |
|
|
|
func (e *DLLError) Error() string { return e.Msg } |
|
|
|
// Implemented in runtime/syscall_windows.goc; we provide jumps to them in our assembly file. |
|
func loadlibrary(filename *uint16) (handle uintptr, err syscall.Errno) |
|
func getprocaddress(handle uintptr, procname *uint8) (proc uintptr, err syscall.Errno) |
|
|
|
// A DLL implements access to a single DLL. |
|
type DLL struct { |
|
Name string |
|
Handle Handle |
|
} |
|
|
|
// LoadDLL loads DLL file into memory. |
|
// |
|
// Warning: using LoadDLL without an absolute path name is subject to |
|
// DLL preloading attacks. To safely load a system DLL, use LazyDLL |
|
// with System set to true, or use LoadLibraryEx directly. |
|
func LoadDLL(name string) (dll *DLL, err error) { |
|
namep, err := UTF16PtrFromString(name) |
|
if err != nil { |
|
return nil, err |
|
} |
|
h, e := loadlibrary(namep) |
|
if e != 0 { |
|
return nil, &DLLError{ |
|
Err: e, |
|
ObjName: name, |
|
Msg: "Failed to load " + name + ": " + e.Error(), |
|
} |
|
} |
|
d := &DLL{ |
|
Name: name, |
|
Handle: Handle(h), |
|
} |
|
return d, nil |
|
} |
|
|
|
// MustLoadDLL is like LoadDLL but panics if load operation failes. |
|
func MustLoadDLL(name string) *DLL { |
|
d, e := LoadDLL(name) |
|
if e != nil { |
|
panic(e) |
|
} |
|
return d |
|
} |
|
|
|
// FindProc searches DLL d for procedure named name and returns *Proc |
|
// if found. It returns an error if search fails. |
|
func (d *DLL) FindProc(name string) (proc *Proc, err error) { |
|
namep, err := BytePtrFromString(name) |
|
if err != nil { |
|
return nil, err |
|
} |
|
a, e := getprocaddress(uintptr(d.Handle), namep) |
|
if e != 0 { |
|
return nil, &DLLError{ |
|
Err: e, |
|
ObjName: name, |
|
Msg: "Failed to find " + name + " procedure in " + d.Name + ": " + e.Error(), |
|
} |
|
} |
|
p := &Proc{ |
|
Dll: d, |
|
Name: name, |
|
addr: a, |
|
} |
|
return p, nil |
|
} |
|
|
|
// MustFindProc is like FindProc but panics if search fails. |
|
func (d *DLL) MustFindProc(name string) *Proc { |
|
p, e := d.FindProc(name) |
|
if e != nil { |
|
panic(e) |
|
} |
|
return p |
|
} |
|
|
|
// Release unloads DLL d from memory. |
|
func (d *DLL) Release() (err error) { |
|
return FreeLibrary(d.Handle) |
|
} |
|
|
|
// A Proc implements access to a procedure inside a DLL. |
|
type Proc struct { |
|
Dll *DLL |
|
Name string |
|
addr uintptr |
|
} |
|
|
|
// Addr returns the address of the procedure represented by p. |
|
// The return value can be passed to Syscall to run the procedure. |
|
func (p *Proc) Addr() uintptr { |
|
return p.addr |
|
} |
|
|
|
//go:uintptrescapes |
|
|
|
// Call executes procedure p with arguments a. It will panic, if more then 15 arguments |
|
// are supplied. |
|
// |
|
// The returned error is always non-nil, constructed from the result of GetLastError. |
|
// Callers must inspect the primary return value to decide whether an error occurred |
|
// (according to the semantics of the specific function being called) before consulting |
|
// the error. The error will be guaranteed to contain windows.Errno. |
|
func (p *Proc) Call(a ...uintptr) (r1, r2 uintptr, lastErr error) { |
|
switch len(a) { |
|
case 0: |
|
return syscall.Syscall(p.Addr(), uintptr(len(a)), 0, 0, 0) |
|
case 1: |
|
return syscall.Syscall(p.Addr(), uintptr(len(a)), a[0], 0, 0) |
|
case 2: |
|
return syscall.Syscall(p.Addr(), uintptr(len(a)), a[0], a[1], 0) |
|
case 3: |
|
return syscall.Syscall(p.Addr(), uintptr(len(a)), a[0], a[1], a[2]) |
|
case 4: |
|
return syscall.Syscall6(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], 0, 0) |
|
case 5: |
|
return syscall.Syscall6(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], 0) |
|
case 6: |
|
return syscall.Syscall6(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5]) |
|
case 7: |
|
return syscall.Syscall9(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], 0, 0) |
|
case 8: |
|
return syscall.Syscall9(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], 0) |
|
case 9: |
|
return syscall.Syscall9(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]) |
|
case 10: |
|
return syscall.Syscall12(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], 0, 0) |
|
case 11: |
|
return syscall.Syscall12(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], 0) |
|
case 12: |
|
return syscall.Syscall12(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11]) |
|
case 13: |
|
return syscall.Syscall15(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], 0, 0) |
|
case 14: |
|
return syscall.Syscall15(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], 0) |
|
case 15: |
|
return syscall.Syscall15(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14]) |
|
default: |
|
panic("Call " + p.Name + " with too many arguments " + itoa(len(a)) + ".") |
|
} |
|
return |
|
} |
|
|
|
// A LazyDLL implements access to a single DLL. |
|
// It will delay the load of the DLL until the first |
|
// call to its Handle method or to one of its |
|
// LazyProc's Addr method. |
|
type LazyDLL struct { |
|
Name string |
|
|
|
// System determines whether the DLL must be loaded from the |
|
// Windows System directory, bypassing the normal DLL search |
|
// path. |
|
System bool |
|
|
|
mu sync.Mutex |
|
dll *DLL // non nil once DLL is loaded |
|
} |
|
|
|
// Load loads DLL file d.Name into memory. It returns an error if fails. |
|
// Load will not try to load DLL, if it is already loaded into memory. |
|
func (d *LazyDLL) Load() error { |
|
// Non-racy version of: |
|
// if d.dll != nil { |
|
if atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&d.dll))) != nil { |
|
return nil |
|
} |
|
d.mu.Lock() |
|
defer d.mu.Unlock() |
|
if d.dll != nil { |
|
return nil |
|
} |
|
|
|
// kernel32.dll is special, since it's where LoadLibraryEx comes from. |
|
// The kernel already special-cases its name, so it's always |
|
// loaded from system32. |
|
var dll *DLL |
|
var err error |
|
if d.Name == "kernel32.dll" { |
|
dll, err = LoadDLL(d.Name) |
|
} else { |
|
dll, err = loadLibraryEx(d.Name, d.System) |
|
} |
|
if err != nil { |
|
return err |
|
} |
|
|
|
// Non-racy version of: |
|
// d.dll = dll |
|
atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&d.dll)), unsafe.Pointer(dll)) |
|
return nil |
|
} |
|
|
|
// mustLoad is like Load but panics if search fails. |
|
func (d *LazyDLL) mustLoad() { |
|
e := d.Load() |
|
if e != nil { |
|
panic(e) |
|
} |
|
} |
|
|
|
// Handle returns d's module handle. |
|
func (d *LazyDLL) Handle() uintptr { |
|
d.mustLoad() |
|
return uintptr(d.dll.Handle) |
|
} |
|
|
|
// NewProc returns a LazyProc for accessing the named procedure in the DLL d. |
|
func (d *LazyDLL) NewProc(name string) *LazyProc { |
|
return &LazyProc{l: d, Name: name} |
|
} |
|
|
|
// NewLazyDLL creates new LazyDLL associated with DLL file. |
|
func NewLazyDLL(name string) *LazyDLL { |
|
return &LazyDLL{Name: name} |
|
} |
|
|
|
// NewLazySystemDLL is like NewLazyDLL, but will only |
|
// search Windows System directory for the DLL if name is |
|
// a base name (like "advapi32.dll"). |
|
func NewLazySystemDLL(name string) *LazyDLL { |
|
return &LazyDLL{Name: name, System: true} |
|
} |
|
|
|
// A LazyProc implements access to a procedure inside a LazyDLL. |
|
// It delays the lookup until the Addr method is called. |
|
type LazyProc struct { |
|
Name string |
|
|
|
mu sync.Mutex |
|
l *LazyDLL |
|
proc *Proc |
|
} |
|
|
|
// Find searches DLL for procedure named p.Name. It returns |
|
// an error if search fails. Find will not search procedure, |
|
// if it is already found and loaded into memory. |
|
func (p *LazyProc) Find() error { |
|
// Non-racy version of: |
|
// if p.proc == nil { |
|
if atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&p.proc))) == nil { |
|
p.mu.Lock() |
|
defer p.mu.Unlock() |
|
if p.proc == nil { |
|
e := p.l.Load() |
|
if e != nil { |
|
return e |
|
} |
|
proc, e := p.l.dll.FindProc(p.Name) |
|
if e != nil { |
|
return e |
|
} |
|
// Non-racy version of: |
|
// p.proc = proc |
|
atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&p.proc)), unsafe.Pointer(proc)) |
|
} |
|
} |
|
return nil |
|
} |
|
|
|
// mustFind is like Find but panics if search fails. |
|
func (p *LazyProc) mustFind() { |
|
e := p.Find() |
|
if e != nil { |
|
panic(e) |
|
} |
|
} |
|
|
|
// Addr returns the address of the procedure represented by p. |
|
// The return value can be passed to Syscall to run the procedure. |
|
func (p *LazyProc) Addr() uintptr { |
|
p.mustFind() |
|
return p.proc.Addr() |
|
} |
|
|
|
//go:uintptrescapes |
|
|
|
// Call executes procedure p with arguments a. It will panic, if more then 15 arguments |
|
// are supplied. |
|
// |
|
// The returned error is always non-nil, constructed from the result of GetLastError. |
|
// Callers must inspect the primary return value to decide whether an error occurred |
|
// (according to the semantics of the specific function being called) before consulting |
|
// the error. The error will be guaranteed to contain windows.Errno. |
|
func (p *LazyProc) Call(a ...uintptr) (r1, r2 uintptr, lastErr error) { |
|
p.mustFind() |
|
return p.proc.Call(a...) |
|
} |
|
|
|
var canDoSearchSystem32Once struct { |
|
sync.Once |
|
v bool |
|
} |
|
|
|
func initCanDoSearchSystem32() { |
|
// https://msdn.microsoft.com/en-us/library/ms684179(v=vs.85).aspx says: |
|
// "Windows 7, Windows Server 2008 R2, Windows Vista, and Windows |
|
// Server 2008: The LOAD_LIBRARY_SEARCH_* flags are available on |
|
// systems that have KB2533623 installed. To determine whether the |
|
// flags are available, use GetProcAddress to get the address of the |
|
// AddDllDirectory, RemoveDllDirectory, or SetDefaultDllDirectories |
|
// function. If GetProcAddress succeeds, the LOAD_LIBRARY_SEARCH_* |
|
// flags can be used with LoadLibraryEx." |
|
canDoSearchSystem32Once.v = (modkernel32.NewProc("AddDllDirectory").Find() == nil) |
|
} |
|
|
|
func canDoSearchSystem32() bool { |
|
canDoSearchSystem32Once.Do(initCanDoSearchSystem32) |
|
return canDoSearchSystem32Once.v |
|
} |
|
|
|
func isBaseName(name string) bool { |
|
for _, c := range name { |
|
if c == ':' || c == '/' || c == '\\' { |
|
return false |
|
} |
|
} |
|
return true |
|
} |
|
|
|
// loadLibraryEx wraps the Windows LoadLibraryEx function. |
|
// |
|
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms684179(v=vs.85).aspx |
|
// |
|
// If name is not an absolute path, LoadLibraryEx searches for the DLL |
|
// in a variety of automatic locations unless constrained by flags. |
|
// See: https://msdn.microsoft.com/en-us/library/ff919712%28VS.85%29.aspx |
|
func loadLibraryEx(name string, system bool) (*DLL, error) { |
|
loadDLL := name |
|
var flags uintptr |
|
if system { |
|
if canDoSearchSystem32() { |
|
const LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800 |
|
flags = LOAD_LIBRARY_SEARCH_SYSTEM32 |
|
} else if isBaseName(name) { |
|
// WindowsXP or unpatched Windows machine |
|
// trying to load "foo.dll" out of the system |
|
// folder, but LoadLibraryEx doesn't support |
|
// that yet on their system, so emulate it. |
|
windir, _ := Getenv("WINDIR") // old var; apparently works on XP |
|
if windir == "" { |
|
return nil, errString("%WINDIR% not defined") |
|
} |
|
loadDLL = windir + "\\System32\\" + name |
|
} |
|
} |
|
h, err := LoadLibraryEx(loadDLL, 0, flags) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return &DLL{Name: name, Handle: h}, nil |
|
} |
|
|
|
type errString string |
|
|
|
func (s errString) Error() string { return string(s) }
|
|
|