Esempio n. 1
0
func initCache() {
	if iphlpapi, err := syscall.LoadDLL("Iphlpapi.dll"); err == nil {
		if p, err := iphlpapi.FindProc("NotifyAddrChange"); err == nil {
			notifyAddrChange = p
		}
	}

	if advapi32, err := syscall.LoadDLL("Advapi32.dll"); err == nil {
		if p, err := advapi32.FindProc("RegNotifyChangeKeyValue"); err == nil {
			regNotifyChangeKeyValue = p
		}
	}

	cacheLock.Lock()
	defer cacheLock.Unlock()

	notifyCh = make(chan error)

	if regNotifyChangeKeyValue != nil && notifyAddrChange != nil {
		useLookup = true
		go notifyIpChange(notifyCh)
		go notifyRegChange(registry.CURRENT_USER, PathInternetSettings, notifyCh)
	}

	cache = make(map[string]*url.URL)

	go func() {
		for _ = range notifyCh {
			invalidateCache()
		}
	}()
}
func getAllWindowsLocaleFrom(sysCall string) (string, error) {
	dll, err := syscall.LoadDLL("kernel32")
	if err != nil {
		return "", errors.New("Could not find kernel32 dll")
	}

	proc, err := dll.FindProc(sysCall)
	if err != nil {
		return "", err
	}

	locale, _, dllError := proc.Call()
	if locale == 0 {
		return "", errors.New(COULD_NOT_DETECT_PACKAGE_ERROR_MESSAGE + ":\n" + dllError.Error())
	}
	proc, err = dll.FindProc("GetLocaleInfoW")
	if err != nil {
		return "", err
	}
	langBuf := make([]uint16, LOCALE_SISO_NAME_MAX_LENGTH)
	r, _, dllError := proc.Call(locale, uintptr(LOCALE_SISO639LANGNAME), uintptr(unsafe.Pointer(&langBuf[0])), uintptr(LOCALE_SISO_NAME_MAX_LENGTH))
	if r == 0 {
		err = errors.New(COULD_NOT_DETECT_PACKAGE_ERROR_MESSAGE + ":\n" + dllError.Error())
		return "", err
	}
	countryBuf := make([]uint16, LOCALE_SISO_NAME_MAX_LENGTH)
	r, _, dllError = proc.Call(locale, uintptr(LOCALE_SISO3166CTRYNAME), uintptr(unsafe.Pointer(&countryBuf[0])), uintptr(LOCALE_SISO_NAME_MAX_LENGTH))
	if r == 0 {
		err = errors.New(COULD_NOT_DETECT_PACKAGE_ERROR_MESSAGE + ":\n" + dllError.Error())
		return "", err
	}
	return syscall.UTF16ToString(langBuf) + "-" + syscall.UTF16ToString(countryBuf), nil
}
Esempio n. 3
0
func terminateProc(proc string) error {
	dll, err := syscall.LoadDLL("kernel32.dll")
	if err != nil {
		return err
	}
	defer dll.Release()

	pid := procs[proc].cmd.Process.Pid

	f, err := dll.FindProc("SetConsoleCtrlHandler")
	if err != nil {
		return err
	}
	r1, _, err := f.Call(0, 1)
	if r1 == 0 {
		return err
	}
	f, err = dll.FindProc("GenerateConsoleCtrlEvent")
	if err != nil {
		return err
	}
	r1, _, err = f.Call(syscall.CTRL_BREAK_EVENT, uintptr(pid))
	if r1 == 0 {
		return err
	}
	return nil
}
Esempio n. 4
0
// SaferDLLLoading sets DLL load path to be safer.
func SaferDLLLoading() error {
	kernel32, err := syscall.LoadDLL("kernel32.dll")
	if err != nil {
		return err
	}

	procSetDllDirectoryW, err := kernel32.FindProc("SetDllDirectoryW")
	if err != nil {
		return err
	}
	var zero uint16
	r1, _, e1 := syscall.Syscall(procSetDllDirectoryW.Addr(), 1,
		uintptr(unsafe.Pointer(&zero)), 0, 0)

	procSetDefaultDllDirectories, err := kernel32.FindProc("SetDefaultDllDirectories")
	if err == nil && procSetDefaultDllDirectories.Addr() != 0 {
		r1, _, e1 = syscall.Syscall(procSetDefaultDllDirectories.Addr(), 1,
			loadLibrarySearchSystem32, 0, 0)
		if r1 == 0 {
			return e1
		}
	} else {
		return errors.New("SetDefaultDllDirectories not found - please install KB2533623 for safer DLL loading")
	}

	return nil
}
Esempio n. 5
0
// LoadDLL loads a DLL file into memory. It panics if the file is not found.
func LoadDLL(name string) DLL {
	lib, err := syscall.LoadDLL(name)
	if err != nil {
		panic(err)
	}
	return DLL{lib}
}
Esempio n. 6
0
func GetDLL(t *testing.T, name string) *DLL {
	d, e := syscall.LoadDLL(name)
	if e != nil {
		t.Fatal(e)
	}
	return &DLL{DLL: d, t: t}
}
Esempio n. 7
0
func GetFilesystemRoots() ([]string, error) {
	kernel32, err := syscall.LoadDLL("kernel32.dll")
	if err != nil {
		return nil, err
	}
	getLogicalDriveStringsHandle, err := kernel32.FindProc("GetLogicalDriveStringsA")
	if err != nil {
		return nil, err
	}

	buffer := [1024]byte{}
	bufferSize := uint32(len(buffer))

	hr, _, _ := getLogicalDriveStringsHandle.Call(uintptr(unsafe.Pointer(&bufferSize)), uintptr(unsafe.Pointer(&buffer)))
	if hr == 0 {
		return nil, fmt.Errorf("Syscall failed")
	}

	var drives []string
	parts := bytes.Split(buffer[:], []byte{0})
	for _, part := range parts {
		if len(part) == 0 {
			break
		}
		drives = append(drives, string(part))
	}

	return drives, nil
}
Esempio n. 8
0
func getWindowsLocale() (locale string, err error) {
	dll, err := syscall.LoadDLL("kernel32")
	if err != nil {
		return "", errors.New("Could not find kernel32 dll")
	}

	proc, err := dll.FindProc("GetVersion")
	if err != nil {
		return "", err
	}

	v, _, _ := proc.Call()
	windowsVersion := byte(v)
	isVistaOrGreater := (windowsVersion >= 6)

	if isVistaOrGreater {
		locale, err = getWindowsLocaleFrom("GetUserDefaultLocaleName")
		if err != nil {
			locale, err = getWindowsLocaleFrom("GetSystemDefaultLocaleName")
		}
	} else if !isVistaOrGreater {
		locale, err = getAllWindowsLocaleFrom("GetUserDefaultLCID")
		if err != nil {
			locale, err = getAllWindowsLocaleFrom("GetSystemDefaultLCID")
		}
	} else {
		panic(v)
	}
	return
}
Esempio n. 9
0
func loadDLL(name string) *cutoDLL {
	dll, err := syscall.LoadDLL(name)
	if err != nil {
		panic(err)
	}
	cutoDll := new(cutoDLL)
	cutoDll.dll = dll
	return cutoDll
}
Esempio n. 10
0
/*
   控制台彩色输出,1深蓝,2深绿,3深青,10绿色,11青色,12红色
   The console color output,1 deep blue,2 deep green,3 deep cyan,10 green,11 cyan,12 red
*/
func ColorEdit(i int) {
	kernel32, _ := syscall.LoadDLL("kernel32.dll") //调用dll,call dll
	defer kernel32.Release()                       //延迟释放,delay release
	/*
		找到dll中的方法,并返回此方法
		find the method in the dll and return the method
	*/
	proc, _ := kernel32.FindProc("SetConsoleTextAttribute")
	proc.Call(uintptr(syscall.Stdout), uintptr(i)) //执行此方法,carry out the method
}
Esempio n. 11
0
// LoadDLL loads specified DLL using syscall.LoadDLL (i.e. LoadLibraryW)
// and returns an error if any occurred during the syscall.LoadDLL
// Calling LoadDLL twice or on already loaded DLL has no effect.
func (w *W32s) LoadDLL(name string) error {
	if _, ok := w.dlls[name]; !ok {
		dll, err := syscall.LoadDLL(name)
		if err != nil {
			return err
		}
		w.dlls[name] = newDll(dll, w.encoding)
	}
	return nil
}
Esempio n. 12
0
func load_qtdrv_proc() (uintptr, error) {
	lib, err := syscall.LoadDLL("qtdrv.ui.dll")
	if err != nil {
		return 0, err
	}
	proc, err := lib.FindProc("qtdrv")
	if err != nil {
		return 0, err
	}
	return proc.Addr(), nil
}
Esempio n. 13
0
func init() {
	kernel32 := syscall.NewLazyDLL("kernel32.dll")

	procGetStdHandle = kernel32.NewProc("GetStdHandle")

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

	initScreenInfo = getConsoleScreenBufferInfo(hStdout)

	syscall.LoadDLL("")
}
Esempio n. 14
0
func sendCtrlBreak(pid int) {
	d, e := syscall.LoadDLL("kernel32.dll")
	if e != nil {
		return
	}
	p, e := d.FindProc("GenerateConsoleCtrlEvent")
	if e != nil {
		return
	}
	p.Call(syscall.CTRL_BREAK_EVENT, uintptr(pid))
}
Esempio n. 15
0
func loadProc() *syscall.Proc {
	dll, err := syscall.LoadDLL("kernel32.dll")
	if err != nil {
		panic(err)
	}
	proc, err := dll.FindProc("GetModuleFileNameW")
	if err != nil {
		panic(err)
	}
	return proc
}
Esempio n. 16
0
func init() {
	dll, err := syscall.LoadDLL("vpsc.dll")
	if err != nil {
		log.Println("could not load vpsc.dll")
		return
	}

	removeOverlaps, err = dll.FindProc("remove_overlaps")
	if err != nil {
		log.Println("remove_overlaps missing from vpsc.dll")
	}
}
Esempio n. 17
0
func GetString() (string, error) {
	dll, err := syscall.LoadDLL("kernel32.dll")
	if err != nil {
		return "", errors.New(fmt.Sprintf("Error loading kernel32.dll: %v", err))
	}
	p, err := dll.FindProc("GetVersion")
	if err != nil {
		return "", errors.New(fmt.Sprintf("Error finding GetVersion procedure: %v", err))
	}
	// The error is always non-nil
	v, _, _ := p.Call()
	return fmt.Sprintf("%d.%d.%d", byte(v), byte(v>>8), uint16(v>>16)), nil
}
Esempio n. 18
0
func terminateProc(proc string) error {
	dll, err := syscall.LoadDLL("kernel32.dll")
	if err != nil {
		return err
	}
	f, err := dll.FindProc("GenerateConsoleCtrlEvent")
	if err != nil {
		return err
	}
	pid := procs[proc].cmd.Process.Pid
	f.Call(syscall.CTRL_C_EVENT, uintptr(pid))
	return nil
}
Esempio n. 19
0
func sendCtrlBreak(t *testing.T, pid int) {
	d, e := syscall.LoadDLL("kernel32.dll")
	if e != nil {
		t.Fatalf("LoadDLL: %v\n", e)
	}
	p, e := d.FindProc("GenerateConsoleCtrlEvent")
	if e != nil {
		t.Fatalf("FindProc: %v\n", e)
	}
	r, _, e := p.Call(syscall.CTRL_BREAK_EVENT, uintptr(pid))
	if r == 0 {
		t.Fatalf("GenerateConsoleCtrlEvent: %v\n", e)
	}
}
Esempio n. 20
0
func sendCtrlBreak(t *testing.T) {
	d, e := syscall.LoadDLL("kernel32.dll")
	if e != nil {
		t.Fatalf("LoadDLL: %v\n", e)
	}
	p, e := d.FindProc("GenerateConsoleCtrlEvent")
	if e != nil {
		t.Fatalf("FindProc: %v\n", e)
	}
	r, _, e := p.Call(0, 0)
	if r == 0 {
		t.Fatalf("GenerateConsoleCtrlEvent: %v\n", e)
	}
}
Esempio n. 21
0
// danke windows für die extra wurst
func sendInterruptSignal(p *os.Process) error {
	d, e := syscall.LoadDLL("kernel32.dll")
	if e != nil {
		return e
	}
	proc, e := d.FindProc("GenerateConsoleCtrlEvent")
	if e != nil {
		return e
	}
	r, _, e := proc.Call(syscall.CTRL_BREAK_EVENT, uintptr(p.Pid))
	if r == 0 {
		return e
	}
	return nil
}
Esempio n. 22
0
func loadDLL(name string) (dll *syscall.DLL, err error) {
	if dlls == nil {
		dlls = make(map[string]*syscall.DLL)
	}

	dll, exists := dlls[name]
	if !exists {
		dll, err = syscall.LoadDLL(name)
		if err != nil {
			return
		}
		dlls[name] = dll
	}
	return
}
Esempio n. 23
0
func load_dll() {
	dll, er := syscall.LoadDLL(DllName)
	if er != nil {
		println(er.Error())
		println("WARNING: Consensus verificatrion disabled")
		return
	}
	bitcoinconsensus_verify_script, er = dll.FindProc(ProcName)
	if er != nil {
		println(er.Error())
		println("WARNING: Consensus verificatrion disabled")
		return
	}
	fmt.Println("Using", DllName, "to ensure consensus rules")
	use_consensus_lib = true
}
Esempio n. 24
0
// loadAndFindFromDll finds a procedure in the given DLL. Note we do NOT do lazy loading as
// go is particularly unfriendly in the case of a mismatch. By that - it panics
// if a function can't be found. By explicitly loading, we can control error
// handling gracefully without the daemon terminating.
func loadAndFindFromDll(dllName, procedure string) (dll *syscall.DLL, proc *syscall.Proc, err error) {
	dll, err = syscall.LoadDLL(dllName)
	if err != nil {
		err = fmt.Errorf("Failed to load %s - error %s", dllName, err)
		logrus.Error(err)
		return
	}

	proc, err = dll.FindProc(procedure)
	if err != nil {
		err = fmt.Errorf("Failed to find %s in %s", procedure, dllName)
		logrus.Error(err)
		return
	}

	return
}
// SelfPath returns the path of the executable for the currently running
// process.
func SelfPath() (string, error) {
	kernel32, err := syscall.LoadDLL("kernel32.dll")
	if err != nil {
		return "", err
	}
	sysproc, err := kernel32.FindProc("GetModuleFileNameW")
	if err != nil {
		return "", err
	}
	b := make([]uint16, syscall.MAX_PATH)
	r, _, err := sysproc.Call(0, uintptr(unsafe.Pointer(&b[0])), uintptr(len(b)))
	n := uint32(r)
	if n == 0 {
		return "", err
	}
	return string(utf16.Decode(b[0:n])), nil
}
func interruptProcess(t *testing.T) {
	dll, err := syscall.LoadDLL("kernel32.dll")
	if err != nil {
		t.Fatalf("LoadDLL(\"kernel32.dll\") err: %s", err)
	}
	p, err := dll.FindProc("GenerateConsoleCtrlEvent")
	if err != nil {
		t.Fatalf("FindProc(\"GenerateConsoleCtrlEvent\") err: %s", err)
	}
	// Send the CTRL_BREAK_EVENT to a console process group that shares
	// the console associated with the calling process.
	// https://msdn.microsoft.com/en-us/library/windows/desktop/ms683155(v=vs.85).aspx
	pid := os.Getpid()
	r1, _, err := p.Call(syscall.CTRL_BREAK_EVENT, uintptr(pid))
	if r1 == 0 {
		t.Fatalf("Call(CTRL_BREAK_EVENT, %d) err: %s", pid, err)
	}
}
Esempio n. 27
0
func getAllWindowsLocaleFrom(sysCall string) (string, error) {
	dll, err := syscall.LoadDLL("kernel32")
	if err != nil {
		return "", errors.New("Could not find kernel32 dll")
	}

	proc, err := dll.FindProc(sysCall)
	if err != nil {
		return "", err
	}

	locale, _, dllError := proc.Call()
	if locale == 0 {
		return "", errors.New(COULD_NOT_DETECT_PACKAGE_ERROR_MESSAGE + ":\n" + dllError.Error())
	}

	return SUPPORTED_LOCALES[locale], nil
}
Esempio n. 28
0
func registerETWProvider() error {
	mu.Lock()
	defer mu.Unlock()
	if refCount == 0 {
		var err error
		if win32Lib, err = syscall.LoadDLL("Advapi32.dll"); err != nil {
			return err
		}
		if err = callEventRegister(); err != nil {
			win32Lib.Release()
			win32Lib = nil
			return err
		}
	}

	refCount++
	return nil
}
Esempio n. 29
0
func setSizes() {
	kernel32, err := syscall.LoadDLL("kernel32.dll")
	if nil != err {
		abort("loadLibrary", err)
	}
	defer kernel32.Release()
	set, err := kernel32.FindProc("SetSystemFileCacheSize")
	if nil != err {
		abort("GetProcAddress", err)
	}
	var lpFlags uint32
	lpFlags = FILE_CACHE_MAX_HARD_ENABLE
	max := *MAX * uint64(1000) * uint64(1000)
	min := *MIN * uint64(1000) * uint64(1000)
	res, _, err := set.Call(uintptr(min), uintptr(max), uintptr(lpFlags))
	if res == 0 {
		abort("SetSystemFileCacheSize", err)
	}
}
Esempio n. 30
0
func init() {
	if membind_use_wrapper {
		return
	}
	dll, er := syscall.LoadDLL("kernel32.dll")
	if er != nil {
		return
	}
	funcGlobalAlloc, _ = dll.FindProc("GlobalAlloc")
	funcGlobalFree, _ = dll.FindProc("GlobalFree")
	if funcGlobalAlloc == nil || funcGlobalFree == nil {
		return
	}
	println("Using kernel32.dll for qdb memory bindings")
	_heap_alloc = win_HeapAlloc
	_heap_free = win_HeapFree
	_heap_store = win_AllocPtr
	membind_use_wrapper = true
}