Golang NewLazyDLL示例

说明

golang newlazydll示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: syscall

示例#1
文件: memtotal_windows.go 项目: hooklift/terraform

// PhysicalMemoryBytes returns the total amount of host memory.
func PhysicalMemoryBytes() (uint64, error) {
	// https://msdn.microsoft.com/en-us/library/windows/desktop/cc300158(v=vs.85).aspx
	// http://stackoverflow.com/questions/30743070/query-total-physical-memory-in-windows-with-golang
	mod := syscall.NewLazyDLL("kernel32.dll")
	proc := mod.NewProc("GetPhysicallyInstalledSystemMemory")
	var memkb uint64

	ret, _, err := proc.Call(uintptr(unsafe.Pointer(&memkb)))
	// return value TRUE(1) succeeds, FAILED(0) fails
	if ret != 1 {
		return 0, err
	}

	return memkb * 1024, nil
}

示例#2
文件: hidden_windows.go 项目: qbit/syncthing

func HideConsole() {
	getConsoleWindow := syscall.NewLazyDLL("kernel32.dll").NewProc("GetConsoleWindow")
	showWindow := syscall.NewLazyDLL("user32.dll").NewProc("ShowWindow")
	if getConsoleWindow.Find() == nil && showWindow.Find() == nil {
		hwnd, _, _ := getConsoleWindow.Call()
		if hwnd != 0 {
			showWindow.Call(hwnd, 0)
		}
	}
}

示例#3
文件: console_windows.go 项目: yazver/throughbox

// ChangeConsoleVisibility Change console visibility
func ChangeConsoleVisibility(visibility bool) {
	var getConsoleWindows = syscall.NewLazyDLL("kernel32.dll").NewProc("GetConsoleWindow")
	var showWindow = syscall.NewLazyDLL("user32.dll").NewProc("ShowWindow")
	if hwnd, _, _ := showWindow.Call(); hwnd != 0 {
		if visibility {
			sw.Call(hwnd, syscall.SW_RESTORE)
		} else {
			sw.Call(hwnd, syscall.SW_HIDE)
		}
	}
}

示例#4
文件: win.go 项目: jingweno/gopass

func getch() byte {
	modkernel32 := syscall.NewLazyDLL("kernel32.dll")
	procReadConsole := modkernel32.NewProc("ReadConsoleW")
	procGetConsoleMode := modkernel32.NewProc("GetConsoleMode")
	procSetConsoleMode := modkernel32.NewProc("SetConsoleMode")

	var mode uint32
	pMode := &mode
	procGetConsoleMode.Call(uintptr(syscall.Stdin), uintptr(unsafe.Pointer(pMode)))

	var echoMode, lineMode uint32
	echoMode = 4
	lineMode = 2
	var newMode uint32
	newMode = mode ^ (echoMode | lineMode)

	procSetConsoleMode.Call(uintptr(syscall.Stdin), uintptr(newMode))

	line := make([]uint16, 1)
	pLine := &line[0]
	var n uint16
	procReadConsole.Call(uintptr(syscall.Stdin), uintptr(unsafe.Pointer(pLine)), uintptr(len(line)), uintptr(unsafe.Pointer(&n)))

	// For some reason n returned seems to big by 2 (Null terminated maybe?)
	if n > 2 {
		n -= 2
	}

	b := []byte(string(utf16.Decode(line[:n])))

	procSetConsoleMode.Call(uintptr(syscall.Stdin), uintptr(mode))

	return b[0]
}

示例#5
文件: sys_tcptable.go 项目: tinycedar/lily

func CloseTCPEntry(row *MIB_TCPROW2) error {
	row.dwState = 12
	if err, _, _ := syscall.NewLazyDLL("Iphlpapi.dll").NewProc("SetTcpEntry").Call(uintptr(unsafe.Pointer(row))); err != 0 {
		return syscall.Errno(err)
	}
	return nil
}

示例#6
文件: main.go 项目: cccqcn/go

func isRunning() bool {

	kernel32 := syscall.NewLazyDLL("kernel32.dll")
	CreateToolhelp32Snapshot := kernel32.NewProc("CreateToolhelp32Snapshot")
	pHandle, _, _ := CreateToolhelp32Snapshot.Call(uintptr(0x2), uintptr(0x0))
	if int(pHandle) == -1 {
		return false
	}
	Process32Next := kernel32.NewProc("Process32Next")
	run := false
	for {
		var proc PROCESSENTRY32
		proc.dwSize = ulong(unsafe.Sizeof(proc))
		if rt, _, _ := Process32Next.Call(uintptr(pHandle), uintptr(unsafe.Pointer(&proc))); int(rt) == 1 {
			pName := string(proc.szExeFile[0:])
			if compareProcess != "" && pName[0:len(compareProcess)] == compareProcess {
				run = true
			}
			//fmt.Println("ProcessName : ",pName+"sssschrome.exe","j");
			//fmt.Println("ProcessID : "+strconv.Itoa(int(proc.th32ProcessID)));
		} else {
			break
		}
	}
	CloseHandle := kernel32.NewProc("CloseHandle")
	_, _, _ = CloseHandle.Call(pHandle)
	return run
}

示例#7
文件: win.go 项目: Machyne/mongo

func getch() (byte, error) {
	modkernel32 := syscall.NewLazyDLL("kernel32.dll")
	procReadConsole := modkernel32.NewProc("ReadConsoleW")
	procGetConsoleMode := modkernel32.NewProc("GetConsoleMode")
	procSetConsoleMode := modkernel32.NewProc("SetConsoleMode")

	var mode uint32
	pMode := &mode
	procGetConsoleMode.Call(uintptr(syscall.Stdin), uintptr(unsafe.Pointer(pMode)))

	var echoMode, lineMode uint32
	echoMode = 4
	lineMode = 2
	var newMode uint32
	newMode = mode &^ (echoMode | lineMode)

	procSetConsoleMode.Call(uintptr(syscall.Stdin), uintptr(newMode))
	defer procSetConsoleMode.Call(uintptr(syscall.Stdin), uintptr(mode))

	line := make([]uint16, 1)
	pLine := &line[0]
	var n uint16
	procReadConsole.Call(uintptr(syscall.Stdin), uintptr(unsafe.Pointer(pLine)), uintptr(len(line)), uintptr(unsafe.Pointer(&n)))

	b := []byte(string(utf16.Decode(line)))

	// Not sure how this could happen, but it did for someone
	if len(b) > 0 {
		return b[0], nil
	} else {
		return 13, errors.New("Read error")
	}
}

示例#8
文件: addtest_basic.go 项目: Xackery/w32

/* Declare imported function so that we can actually use it. */
func main() {
	addbasic := syscall.NewLazyDLL("add_basic.dll")
	procAdd := addbasic.NewProc("Add")
	val, _, _ := procAdd.Call(6, 23)

	fmt.Println(val)
}

示例#9
文件: win.go 项目: jjz/ztodo

func getch() byte {
	modkernel32 := syscall.NewLazyDLL("kernel32.dll")
	procReadConsole := modkernel32.NewProc("ReadConsoleW")
	procGetConsoleMode := modkernel32.NewProc("GetConsoleMode")
	procSetConsoleMode := modkernel32.NewProc("SetConsoleMode")

	var mode uint32
	pMode := &mode
	procGetConsoleMode.Call(uintptr(syscall.Stdin), uintptr(unsafe.Pointer(pMode)))

	var echoMode, lineMode uint32
	echoMode = 4
	lineMode = 2
	var newMode uint32
	newMode = mode ^ (echoMode | lineMode)

	procSetConsoleMode.Call(uintptr(syscall.Stdin), uintptr(newMode))

	line := make([]uint16, 1)
	pLine := &line[0]
	var n uint16
	procReadConsole.Call(uintptr(syscall.Stdin), uintptr(unsafe.Pointer(pLine)), uintptr(len(line)), uintptr(unsafe.Pointer(&n)))

	b := []byte(string(utf16.Decode(line)))

	procSetConsoleMode.Call(uintptr(syscall.Stdin), uintptr(mode))

	if len(b) > 0 {
		return b[0]
	} else {
		return 13
	}
}

示例#10
文件: race_windows_test.go 项目: 2thetop/go

func TestAtomicMmap(t *testing.T) {
	// Test that atomic operations work on "external" memory. Previously they crashed (#16206).
	// Also do a sanity correctness check: under race detector atomic operations
	// are implemented inside of race runtime.
	kernel32 := syscall.NewLazyDLL("kernel32.dll")
	VirtualAlloc := kernel32.NewProc("VirtualAlloc")
	VirtualFree := kernel32.NewProc("VirtualFree")
	const (
		MEM_COMMIT     = 0x00001000
		MEM_RESERVE    = 0x00002000
		MEM_RELEASE    = 0x8000
		PAGE_READWRITE = 0x04
	)
	mem, _, err := syscall.Syscall6(VirtualAlloc.Addr(), 4, 0, 1<<20, MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE, 0, 0)
	if err != 0 {
		t.Fatalf("VirtualAlloc failed: %v", err)
	}
	defer syscall.Syscall(VirtualFree.Addr(), 3, mem, 1<<20, MEM_RELEASE)
	a := (*uint64)(unsafe.Pointer(mem))
	if *a != 0 {
		t.Fatalf("bad atomic value: %v, want 0", *a)
	}
	atomic.AddUint64(a, 1)
	if *a != 1 {
		t.Fatalf("bad atomic value: %v, want 1", *a)
	}
	atomic.AddUint64(a, 1)
	if *a != 2 {
		t.Fatalf("bad atomic value: %v, want 2", *a)
	}
}

示例#11
文件: platform_windows.go 项目: pkdevboxy/query

// Hide console on windows without removing it unlike -H windowsgui.
func HideConsole(hide bool) {
	var k32 = syscall.NewLazyDLL("kernel32.dll")
	var cw = k32.NewProc("GetConsoleWindow")
	var u32 = syscall.NewLazyDLL("user32.dll")
	var sw = u32.NewProc("ShowWindow")
	hwnd, _, _ := cw.Call()
	if hwnd == 0 {
		return
	}
	if hide {
		var SW_HIDE uintptr = 0
		sw.Call(hwnd, SW_HIDE)
	} else {
		var SW_RESTORE uintptr = 9
		sw.Call(hwnd, SW_RESTORE)
	}
}

示例#12
文件: api.go 项目: WoLfh0UnD/WiFiMon

func init() {
	hapi := syscall.NewLazyDLL("Wlanapi.dll")
	hWlanOpenHandle = hapi.NewProc("WlanOpenHandle")
	hWlanCloseHandle = hapi.NewProc("WlanCloseHandle")
	hWlanEnumInterfaces = hapi.NewProc("WlanEnumInterfaces")
	hWlanGetAvailableNetworkList = hapi.NewProc("WlanGetAvailableNetworkList")
	hWlanGetNetworkBssList = hapi.NewProc("WlanGetNetworkBssList")
	hWlanFreeMemory = hapi.NewProc("WlanFreeMemory")
}

示例#13
文件: ntlm_windows.go 项目: nicollet/bosun

func initialize() {

	secur32dll := syscall.NewLazyDLL("secur32.dll")
	initSecurityInterface := secur32dll.NewProc("InitSecurityInterfaceW")

	ptr, _, _ := initSecurityInterface.Call()
	sec_fn = (*SecurityFunctionTable)(unsafe.Pointer(ptr))

	initialized = true
}

示例#14
文件: sct_windows.go 项目: howeyc/go-sct

// setColorTemp changes the device gamma curve colors to reflect the specified color temperature.
func setColorTemp(gammar, gammag, gammab float64) {
	user32 := syscall.NewLazyDLL("User32.dll")
	gdi32 := syscall.NewLazyDLL("Gdi32.dll")
	procGetDC := user32.NewProc("GetDC")
	procSetDeviceGammaRamp := gdi32.NewProc("SetDeviceGammaRamp")

	var gamma [3][256]uint16

	for i := 0; i < 256; i++ {
		g := 65535.0 * float64(i) / float64(256)
		gamma[0][i] = uint16(g * gammar)
		gamma[1][i] = uint16(g * gammag)
		gamma[2][i] = uint16(g * gammab)
	}

	hdc, _, _ := procGetDC.Call(uintptr(0))

	procSetDeviceGammaRamp.Call(hdc, uintptr(unsafe.Pointer(&gamma)))
}

示例#15
文件: console_windows.go 项目: mabetle/mcore

func (c Console) ColorPrint(s string, i int) {
	kernel32 := syscall.NewLazyDLL("kernel32.dll")
	proc := kernel32.NewProc("SetConsoleTextAttribute")
	handle, _, _ := proc.Call(uintptr(syscall.Stdout), uintptr(i)) //12 Red light

	fmt.Print(s)

	handle, _, _ = proc.Call(uintptr(syscall.Stdout), uintptr(7)) //White dark
	CloseHandle := kernel32.NewProc("CloseHandle")
	CloseHandle.Call(handle)
}

示例#16
文件: ct_win.go 项目: CodeJuan/kubernetes

func init() {
	kernel32 := syscall.NewLazyDLL("kernel32.dll")

	procGetStdHandle = kernel32.NewProc("GetStdHandle")

	hStdout, _, _ = procGetStdHandle.Call(uintptr(std_output_handle))

	initScreenInfo = getConsoleScreenBufferInfo(hStdout)

	syscall.LoadDLL("")
}

示例#17
文件: datapost_upgrade.go 项目: dcmsy/datapost

/**call exe*/
func callEXEByShell(path string) {
	var hand uintptr = uintptr(0)
	var operator uintptr = uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("open")))
	var fpath uintptr = uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(path)))
	var param uintptr = uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("/S")))
	var dirpath uintptr = uintptr(0)
	var ncmd uintptr = uintptr(1)
	shell32 := syscall.NewLazyDLL("shell32.dll")
	ShellExecuteW := shell32.NewProc("ShellExecuteW")
	_, _, _ = ShellExecuteW.Call(hand, operator, fpath, param, dirpath, ncmd)
}

示例#18
文件: hidefile_windows.go 项目: arduino/arduino-create-agent

func MessageBox(title, text string) int {
	var mod = syscall.NewLazyDLL("user32.dll")
	var proc = mod.NewProc("MessageBoxW")
	var MB_YESNO = 0x00000004

	ret, _, _ := proc.Call(0,
		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(text))),
		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(title))),
		uintptr(MB_YESNO))
	return int(ret)
}

示例#19
文件: hide_windows.go 项目: 2722/lantern

func hideFile(path string) error {
	kernel32 := syscall.NewLazyDLL("kernel32.dll")
	setFileAttributes := kernel32.NewProc("SetFileAttributesW")

	r1, _, err := setFileAttributes.Call(uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(path))), 2)

	if r1 == 0 {
		return err
	} else {
		return nil
	}
}

示例#20
文件: windows_api.go 项目: firebitsbr/readline

func NewKernel() *Kernel {
	k := &Kernel{}
	kernel32 := syscall.NewLazyDLL("kernel32.dll")
	v := reflect.ValueOf(k).Elem()
	t := v.Type()
	for i := 0; i < t.NumField(); i++ {
		name := t.Field(i).Name
		f := kernel32.NewProc(name)
		v.Field(i).Set(reflect.ValueOf(k.Wrap(f)))
	}
	return k
}

示例#21
文件: wrapper_windows.go 项目: naoto43/mackerel-agent

func execdir() string {
	var (
		kernel32              = syscall.NewLazyDLL("kernel32")
		procGetModuleFileName = kernel32.NewProc("GetModuleFileNameW")
	)
	var wpath [syscall.MAX_PATH]uint16
	r1, _, err := procGetModuleFileName.Call(0, uintptr(unsafe.Pointer(&wpath[0])), uintptr(len(wpath)))
	if r1 == 0 {
		log.Fatal(err)
	}
	return syscall.UTF16ToString(wpath[:])
}

示例#22
文件: daemon_windows.go 项目: HuKeping/docker

func signalDaemonDump(pid int) {
	modkernel32 := syscall.NewLazyDLL("kernel32.dll")
	procOpenEvent := modkernel32.NewProc("OpenEventW")
	procPulseEvent := modkernel32.NewProc("PulseEvent")

	ev := "Global\\docker-daemon-" + strconv.Itoa(pid)
	h2, _ := openEvent(0x0002, false, ev, procOpenEvent)
	if h2 == 0 {
		return
	}
	pulseEvent(h2, procPulseEvent)
}

示例#23
文件: message.go 项目: gonewbee/myTest

func main() {
	var mod = syscall.NewLazyDLL("user32.dll")
	var proc = mod.NewProc("MessageBoxW")
	var MB_YESNOCANCEL = 0x00000003

	ret, _, _ := proc.Call(0,
		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("Done Title"))),
		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("This test is Done."))),
		uintptr(MB_YESNOCANCEL))
	fmt.Printf("Return: %d\n", ret)

}

示例#24
文件: sys_tcptable.go 项目: tinycedar/lily

// netstat -ano | findstr 202.89.233.104
func getTCPTable() *MIB_TCPTABLE2 {
	getTCPTable2 := syscall.NewLazyDLL("Iphlpapi.dll").NewProc("GetTcpTable2")
	var n uint32
	if err, _, _ := getTCPTable2.Call(uintptr(unsafe.Pointer(&MIB_TCPTABLE2{})), uintptr(unsafe.Pointer(&n)), 1); syscall.Errno(err) != syscall.ERROR_INSUFFICIENT_BUFFER {
		common.Error("Error calling GetTcpTable2: %v", syscall.Errno(err))
	}
	b := make([]byte, n)
	if err, _, _ := getTCPTable2.Call(uintptr(unsafe.Pointer(&b[0])), uintptr(unsafe.Pointer(&n)), 1); err != 0 {
		common.Error("Error calling GetTcpTable2: %v", syscall.Errno(err))
	}
	table := newTCPTable(NewClassReader(b))
	return table
}

示例#25
文件: c_file.go 项目: reinhardtken/golang

func CallCFunc(input_path, output_path string) int {
	dll32 := syscall.NewLazyDLL("dump_analyze_dll.dll")
	println("call dll:", dll32.Name)
	g := dll32.NewProc("test1")
	func2 := dll32.NewProc("analyze")
	//cstr := C.CString("string from golang")
	//defer C.free(unsafe.Pointer(cstr))
	g.Call(uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("string from golang"))))
	//func2.Call(uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("L:\\workspace\\dump_analyze\\Debug\\BAK"))),
	//	uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("L:\\workspace\\result"))))
	re, _, _ := func2.Call(uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(input_path))),
		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(output_path))))
	return int(re)
}

示例#26
文件: main2.go 项目: dave-tucker/wincputest

func main() {
	var mod = syscall.NewLazyDLL("kernel32.dll")
	var proc = mod.NewProc("IsProcessorFeaturePresent")

	r1, r2, _ := proc.Call(uintptr(PF_VIRT_FIRMWARE_ENABLED))
	if r1 != 0 {
		fmt.Printf("Err: %s", syscall.Errno(r1))
	}
	resultPtr := unsafe.Pointer(r2)
	hasVTX := false
	if *resultPtr != 0 {
		hasVTX = true
	}

	fmt.Printf("VTX Enabled: %v", hasVTX)
}

示例#27
文件: memstatus_windows.go 项目: howeyc/scryptutil

func osMemStatus() (Physical, Virtual MemoryStats) {
	modkernel32 := syscall.NewLazyDLL("kernel32.dll")
	GlobalMemoryStatusEx := modkernel32.NewProc("GlobalMemoryStatusEx")

	var stats memoryStatusEx
	stats.dwLength = uint32(unsafe.Sizeof(stats))
	pStats := &stats
	GlobalMemoryStatusEx.Call(uintptr(unsafe.Pointer(pStats)))

	Physical.Free = stats.ullAvailPhys
	Physical.Total = stats.ullTotalPhys
	Physical.Used = Physical.Total - Physical.Free

	Virtual.Free = stats.ullAvailVirtual
	Virtual.Total = stats.ullTotalVirtual
	Virtual.Used = Virtual.Total - Virtual.Free
	return
}

示例#28
文件: windows.go 项目: Mic92/docker

// getFileSystemType obtains the type of a file system through GetVolumeInformation
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364993(v=vs.85).aspx
func getFileSystemType(drive string) (fsType string, hr error) {
	var (
		modkernel32              = syscall.NewLazyDLL("kernel32.dll")
		procGetVolumeInformation = modkernel32.NewProc("GetVolumeInformationW")
		buf                      = make([]uint16, 255)
		size                     = syscall.MAX_PATH + 1
	)
	if len(drive) != 1 {
		hr = errors.New("getFileSystemType must be called with a drive letter")
		return
	}
	drive += `:\`
	n := uintptr(unsafe.Pointer(nil))
	r0, _, _ := syscall.Syscall9(procGetVolumeInformation.Addr(), 8, uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(drive))), n, n, n, n, n, uintptr(unsafe.Pointer(&buf[0])), uintptr(size), 0)
	if int32(r0) < 0 {
		hr = syscall.Errno(win32FromHresult(r0))
	}
	fsType = syscall.UTF16ToString(buf)
	return
}

示例#29
文件: comctl_windows.go 项目: UIKit0/ui

func initCommonControls() (err error) {
	var icc struct {
		dwSize uint32
		dwICC  uint32
	}

	err = forceCommonControls6()
	if err != nil {
		return fmt.Errorf("error forcing Common Controls version 6 (or newer): %v", err)
	}

	icc.dwSize = uint32(unsafe.Sizeof(icc))
	icc.dwICC = _ICC_PROGRESS_CLASS

	comctl32 = syscall.NewLazyDLL("comctl32.dll")
	r1, _, err := comctl32.NewProc("InitCommonControlsEx").Call(uintptr(unsafe.Pointer(&icc)))
	if r1 == _FALSE { // failure
		return fmt.Errorf("error initializing Common Controls (comctl32.dll); Windows last error: %v", err)
	}
	return nil
}

示例#30
文件: main.go 项目: john049/allbeforeversion

func main() {

	var hand uintptr = uintptr(0)

	var operator uintptr = uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("open")))

	var fpath uintptr = uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("D:\\Program Files (x86)\\KoGou\\KGMusic\\KuGou.exe")))

	var param uintptr = uintptr(0)

	var dirpath uintptr = uintptr(0)

	var ncmd uintptr = uintptr(1)

	shell32 := syscall.NewLazyDLL("shell32.dll")

	ShellExecuteW := shell32.NewProc("ShellExecuteW")

	_, _, _ = ShellExecuteW.Call(hand, operator, fpath, param, dirpath, ncmd)

}

展开阅读全文