github.com/bir3/gocompiler@v0.9.2202/src/xvendor/golang.org/x/sys/windows/dll_windows.go (about) 1 // Copyright 2011 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package windows 6 7 import ( 8 "sync" 9 "sync/atomic" 10 "syscall" 11 "unsafe" 12 ) 13 14 // We need to use LoadLibrary and GetProcAddress from the Go runtime, because 15 // the these symbols are loaded by the system linker and are required to 16 // dynamically load additional symbols. Note that in the Go runtime, these 17 // return syscall.Handle and syscall.Errno, but these are the same, in fact, 18 // as windows.Handle and windows.Errno, and we intend to keep these the same. 19 20 //go:linkname syscall_loadlibrary syscall.loadlibrary 21 func syscall_loadlibrary(filename *uint16) (handle Handle, err Errno) 22 23 //go:linkname syscall_getprocaddress syscall.getprocaddress 24 func syscall_getprocaddress(handle Handle, procname *uint8) (proc uintptr, err Errno) 25 26 // DLLError describes reasons for DLL load failures. 27 type DLLError struct { 28 Err error 29 ObjName string 30 Msg string 31 } 32 33 func (e *DLLError) Error() string { return e.Msg } 34 35 func (e *DLLError) Unwrap() error { return e.Err } 36 37 // A DLL implements access to a single DLL. 38 type DLL struct { 39 Name string 40 Handle Handle 41 } 42 43 // LoadDLL loads DLL file into memory. 44 // 45 // Warning: using LoadDLL without an absolute path name is subject to 46 // DLL preloading attacks. To safely load a system DLL, use LazyDLL 47 // with System set to true, or use LoadLibraryEx directly. 48 func LoadDLL(name string) (dll *DLL, err error) { 49 namep, err := UTF16PtrFromString(name) 50 if err != nil { 51 return nil, err 52 } 53 h, e := syscall_loadlibrary(namep) 54 if e != 0 { 55 return nil, &DLLError{ 56 Err: e, 57 ObjName: name, 58 Msg: "Failed to load " + name + ": " + e.Error(), 59 } 60 } 61 d := &DLL{ 62 Name: name, 63 Handle: h, 64 } 65 return d, nil 66 } 67 68 // MustLoadDLL is like LoadDLL but panics if load operation failes. 69 func MustLoadDLL(name string) *DLL { 70 d, e := LoadDLL(name) 71 if e != nil { 72 panic(e) 73 } 74 return d 75 } 76 77 // FindProc searches DLL d for procedure named name and returns *Proc 78 // if found. It returns an error if search fails. 79 func (d *DLL) FindProc(name string) (proc *Proc, err error) { 80 namep, err := BytePtrFromString(name) 81 if err != nil { 82 return nil, err 83 } 84 a, e := syscall_getprocaddress(d.Handle, namep) 85 if e != 0 { 86 return nil, &DLLError{ 87 Err: e, 88 ObjName: name, 89 Msg: "Failed to find " + name + " procedure in " + d.Name + ": " + e.Error(), 90 } 91 } 92 p := &Proc{ 93 Dll: d, 94 Name: name, 95 addr: a, 96 } 97 return p, nil 98 } 99 100 // MustFindProc is like FindProc but panics if search fails. 101 func (d *DLL) MustFindProc(name string) *Proc { 102 p, e := d.FindProc(name) 103 if e != nil { 104 panic(e) 105 } 106 return p 107 } 108 109 // FindProcByOrdinal searches DLL d for procedure by ordinal and returns *Proc 110 // if found. It returns an error if search fails. 111 func (d *DLL) FindProcByOrdinal(ordinal uintptr) (proc *Proc, err error) { 112 a, e := GetProcAddressByOrdinal(d.Handle, ordinal) 113 name := "#" + itoa(int(ordinal)) 114 if e != nil { 115 return nil, &DLLError{ 116 Err: e, 117 ObjName: name, 118 Msg: "Failed to find " + name + " procedure in " + d.Name + ": " + e.Error(), 119 } 120 } 121 p := &Proc{ 122 Dll: d, 123 Name: name, 124 addr: a, 125 } 126 return p, nil 127 } 128 129 // MustFindProcByOrdinal is like FindProcByOrdinal but panics if search fails. 130 func (d *DLL) MustFindProcByOrdinal(ordinal uintptr) *Proc { 131 p, e := d.FindProcByOrdinal(ordinal) 132 if e != nil { 133 panic(e) 134 } 135 return p 136 } 137 138 // Release unloads DLL d from memory. 139 func (d *DLL) Release() (err error) { 140 return FreeLibrary(d.Handle) 141 } 142 143 // A Proc implements access to a procedure inside a DLL. 144 type Proc struct { 145 Dll *DLL 146 Name string 147 addr uintptr 148 } 149 150 // Addr returns the address of the procedure represented by p. 151 // The return value can be passed to Syscall to run the procedure. 152 func (p *Proc) Addr() uintptr { 153 return p.addr 154 } 155 156 //go:uintptrescapes 157 158 // Call executes procedure p with arguments a. It will panic, if more than 15 arguments 159 // are supplied. 160 // 161 // The returned error is always non-nil, constructed from the result of GetLastError. 162 // Callers must inspect the primary return value to decide whether an error occurred 163 // (according to the semantics of the specific function being called) before consulting 164 // the error. The error will be guaranteed to contain windows.Errno. 165 func (p *Proc) Call(a ...uintptr) (r1, r2 uintptr, lastErr error) { 166 switch len(a) { 167 case 0: 168 return syscall.Syscall(p.Addr(), uintptr(len(a)), 0, 0, 0) 169 case 1: 170 return syscall.Syscall(p.Addr(), uintptr(len(a)), a[0], 0, 0) 171 case 2: 172 return syscall.Syscall(p.Addr(), uintptr(len(a)), a[0], a[1], 0) 173 case 3: 174 return syscall.Syscall(p.Addr(), uintptr(len(a)), a[0], a[1], a[2]) 175 case 4: 176 return syscall.Syscall6(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], 0, 0) 177 case 5: 178 return syscall.Syscall6(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], 0) 179 case 6: 180 return syscall.Syscall6(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5]) 181 case 7: 182 return syscall.Syscall9(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], 0, 0) 183 case 8: 184 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) 185 case 9: 186 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]) 187 case 10: 188 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) 189 case 11: 190 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) 191 case 12: 192 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]) 193 case 13: 194 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) 195 case 14: 196 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) 197 case 15: 198 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]) 199 default: 200 panic("Call " + p.Name + " with too many arguments " + itoa(len(a)) + ".") 201 } 202 } 203 204 // A LazyDLL implements access to a single DLL. 205 // It will delay the load of the DLL until the first 206 // call to its Handle method or to one of its 207 // LazyProc's Addr method. 208 type LazyDLL struct { 209 Name string 210 211 // System determines whether the DLL must be loaded from the 212 // Windows System directory, bypassing the normal DLL search 213 // path. 214 System bool 215 216 mu sync.Mutex 217 dll *DLL // non nil once DLL is loaded 218 } 219 220 // Load loads DLL file d.Name into memory. It returns an error if fails. 221 // Load will not try to load DLL, if it is already loaded into memory. 222 func (d *LazyDLL) Load() error { 223 // Non-racy version of: 224 // if d.dll != nil { 225 if atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&d.dll))) != nil { 226 return nil 227 } 228 d.mu.Lock() 229 defer d.mu.Unlock() 230 if d.dll != nil { 231 return nil 232 } 233 234 // kernel32.dll is special, since it's where LoadLibraryEx comes from. 235 // The kernel already special-cases its name, so it's always 236 // loaded from system32. 237 var dll *DLL 238 var err error 239 if d.Name == "kernel32.dll" { 240 dll, err = LoadDLL(d.Name) 241 } else { 242 dll, err = loadLibraryEx(d.Name, d.System) 243 } 244 if err != nil { 245 return err 246 } 247 248 // Non-racy version of: 249 // d.dll = dll 250 atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&d.dll)), unsafe.Pointer(dll)) 251 return nil 252 } 253 254 // mustLoad is like Load but panics if search fails. 255 func (d *LazyDLL) mustLoad() { 256 e := d.Load() 257 if e != nil { 258 panic(e) 259 } 260 } 261 262 // Handle returns d's module handle. 263 func (d *LazyDLL) Handle() uintptr { 264 d.mustLoad() 265 return uintptr(d.dll.Handle) 266 } 267 268 // NewProc returns a LazyProc for accessing the named procedure in the DLL d. 269 func (d *LazyDLL) NewProc(name string) *LazyProc { 270 return &LazyProc{l: d, Name: name} 271 } 272 273 // NewLazyDLL creates new LazyDLL associated with DLL file. 274 func NewLazyDLL(name string) *LazyDLL { 275 return &LazyDLL{Name: name} 276 } 277 278 // NewLazySystemDLL is like NewLazyDLL, but will only 279 // search Windows System directory for the DLL if name is 280 // a base name (like "advapi32.dll"). 281 func NewLazySystemDLL(name string) *LazyDLL { 282 return &LazyDLL{Name: name, System: true} 283 } 284 285 // A LazyProc implements access to a procedure inside a LazyDLL. 286 // It delays the lookup until the Addr method is called. 287 type LazyProc struct { 288 Name string 289 290 mu sync.Mutex 291 l *LazyDLL 292 proc *Proc 293 } 294 295 // Find searches DLL for procedure named p.Name. It returns 296 // an error if search fails. Find will not search procedure, 297 // if it is already found and loaded into memory. 298 func (p *LazyProc) Find() error { 299 // Non-racy version of: 300 // if p.proc == nil { 301 if atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&p.proc))) == nil { 302 p.mu.Lock() 303 defer p.mu.Unlock() 304 if p.proc == nil { 305 e := p.l.Load() 306 if e != nil { 307 return e 308 } 309 proc, e := p.l.dll.FindProc(p.Name) 310 if e != nil { 311 return e 312 } 313 // Non-racy version of: 314 // p.proc = proc 315 atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&p.proc)), unsafe.Pointer(proc)) 316 } 317 } 318 return nil 319 } 320 321 // mustFind is like Find but panics if search fails. 322 func (p *LazyProc) mustFind() { 323 e := p.Find() 324 if e != nil { 325 panic(e) 326 } 327 } 328 329 // Addr returns the address of the procedure represented by p. 330 // The return value can be passed to Syscall to run the procedure. 331 // It will panic if the procedure cannot be found. 332 func (p *LazyProc) Addr() uintptr { 333 p.mustFind() 334 return p.proc.Addr() 335 } 336 337 //go:uintptrescapes 338 339 // Call executes procedure p with arguments a. It will panic, if more than 15 arguments 340 // are supplied. It will also panic if the procedure cannot be found. 341 // 342 // The returned error is always non-nil, constructed from the result of GetLastError. 343 // Callers must inspect the primary return value to decide whether an error occurred 344 // (according to the semantics of the specific function being called) before consulting 345 // the error. The error will be guaranteed to contain windows.Errno. 346 func (p *LazyProc) Call(a ...uintptr) (r1, r2 uintptr, lastErr error) { 347 p.mustFind() 348 return p.proc.Call(a...) 349 } 350 351 var canDoSearchSystem32Once struct { 352 sync.Once 353 v bool 354 } 355 356 func initCanDoSearchSystem32() { 357 // https://msdn.microsoft.com/en-us/library/ms684179(v=vs.85).aspx says: 358 // "Windows 7, Windows Server 2008 R2, Windows Vista, and Windows 359 // Server 2008: The LOAD_LIBRARY_SEARCH_* flags are available on 360 // systems that have KB2533623 installed. To determine whether the 361 // flags are available, use GetProcAddress to get the address of the 362 // AddDllDirectory, RemoveDllDirectory, or SetDefaultDllDirectories 363 // function. If GetProcAddress succeeds, the LOAD_LIBRARY_SEARCH_* 364 // flags can be used with LoadLibraryEx." 365 canDoSearchSystem32Once.v = (modkernel32.NewProc("AddDllDirectory").Find() == nil) 366 } 367 368 func canDoSearchSystem32() bool { 369 canDoSearchSystem32Once.Do(initCanDoSearchSystem32) 370 return canDoSearchSystem32Once.v 371 } 372 373 func isBaseName(name string) bool { 374 for _, c := range name { 375 if c == ':' || c == '/' || c == '\\' { 376 return false 377 } 378 } 379 return true 380 } 381 382 // loadLibraryEx wraps the Windows LoadLibraryEx function. 383 // 384 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms684179(v=vs.85).aspx 385 // 386 // If name is not an absolute path, LoadLibraryEx searches for the DLL 387 // in a variety of automatic locations unless constrained by flags. 388 // See: https://msdn.microsoft.com/en-us/library/ff919712%28VS.85%29.aspx 389 func loadLibraryEx(name string, system bool) (*DLL, error) { 390 loadDLL := name 391 var flags uintptr 392 if system { 393 if canDoSearchSystem32() { 394 flags = LOAD_LIBRARY_SEARCH_SYSTEM32 395 } else if isBaseName(name) { 396 // WindowsXP or unpatched Windows machine 397 // trying to load "foo.dll" out of the system 398 // folder, but LoadLibraryEx doesn't support 399 // that yet on their system, so emulate it. 400 systemdir, err := GetSystemDirectory() 401 if err != nil { 402 return nil, err 403 } 404 loadDLL = systemdir + "\\" + name 405 } 406 } 407 h, err := LoadLibraryEx(loadDLL, 0, flags) 408 if err != nil { 409 return nil, err 410 } 411 return &DLL{Name: name, Handle: h}, nil 412 } 413 414 type errString string 415 416 func (s errString) Error() string { return string(s) }