func GetPrinterPort(printerName string) (string, error) { printerPort := "LPT1" const flags = PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS var needed, returned uint32 buf := make([]byte, 1) err := EnumPrinters(flags, nil, 5, &buf[0], uint32(len(buf)), &needed, &returned) if err != nil { if err != syscall.ERROR_INSUFFICIENT_BUFFER { return "", err } buf = make([]byte, needed) err = EnumPrinters(flags, nil, 5, &buf[0], uint32(len(buf)), &needed, &returned) if err != nil { return "", err } } ps := (*[1024]PRINTER_INFO_5)(unsafe.Pointer(&buf[0]))[:returned] for _, p := range ps { v := (*[1024]uint16)(unsafe.Pointer(p.PrinterName))[:] if strings.Compare(syscall.UTF16ToString(v), printerName) == 0 { v := (*[1024]uint16)(unsafe.Pointer(p.PortName))[:] printerPort = strings.Split(syscall.UTF16ToString(v), ",")[0] } } return printerPort, nil }
func (p *Process) getFromSnapProcess(pid int32) (int32, int32, string, error) { snap := w32.CreateToolhelp32Snapshot(w32.TH32CS_SNAPPROCESS, uint32(pid)) if snap == 0 { return 0, 0, "", syscall.GetLastError() } defer w32.CloseHandle(snap) var pe32 w32.PROCESSENTRY32 pe32.DwSize = uint32(unsafe.Sizeof(pe32)) if w32.Process32First(snap, &pe32) == false { return 0, 0, "", syscall.GetLastError() } if pe32.Th32ProcessID == uint32(pid) { szexe := syscall.UTF16ToString(pe32.SzExeFile[:]) return int32(pe32.Th32ParentProcessID), int32(pe32.CntThreads), szexe, nil } for w32.Process32Next(snap, &pe32) { if pe32.Th32ProcessID == uint32(pid) { szexe := syscall.UTF16ToString(pe32.SzExeFile[:]) return int32(pe32.Th32ParentProcessID), int32(pe32.CntThreads), szexe, nil } } return 0, 0, "", errors.New("Couldn't find pid:" + string(pid)) }
func OpenProcess(pid uint32) (*Process, error) { const da = syscall.STANDARD_RIGHTS_READ | syscall.PROCESS_QUERY_INFORMATION | syscall.SYNCHRONIZE h, err := syscall.OpenProcess(da, false, uint32(pid)) if err != nil { return nil, os.NewSyscallError("OpenProcess", err) } procEntry, err := win32.FindProcessEntry(pid) if err != nil { return nil, err } modEntry, err := win32.FirstModuleEntry(pid) if err != nil { return nil, err } handleCount, err := win32.GetProcessHandleCount(h) if err != nil { return nil, err } return &Process{ Pid: pid, handle: uintptr(h), ParentId: procEntry.ParentProcessID, Name: syscall.UTF16ToString(modEntry.ModuleName[:]), Executable: syscall.UTF16ToString(procEntry.ExeFile[:]), CmdLine: syscall.UTF16ToString(modEntry.ExePath[:]), HandleCount: handleCount, ThreadCount: procEntry.Threads, }, nil }
// Search Path Used by Windows to Locate a DLL - https://msdn.microsoft.com/en-us/library/7d83bc18.aspx func GetDynLibDirs() (dirs []string, err error) { // The directory where the executable module for the current process is located. path, err := osx.Executable() if err != nil { return } dirs = append(dirs, path) // The current directory. path, err = os.Getwd() if err != nil { return } dirs = append(dirs, path) // The Windows system directory. The GetSystemDirectory function retrieves the path of this directory. buf := make([]uint16, syscall.MAX_PATH) _, err = syscallx.GetSystemDirectory(&buf[0], syscall.MAX_PATH) if err != nil { return } path = syscall.UTF16ToString(buf) dirs = append(dirs, path) // The Windows directory. The GetWindowsDirectory function retrieves the path of this directory. _, err = syscallx.GetWindowsDirectory(&buf[0], syscall.MAX_PATH) if err != nil { return } path = syscall.UTF16ToString(buf) dirs = append(dirs, path) // The directories listed in the PATH environment variable. path = os.Getenv("PATH") dirs = append(dirs, strings.Split(path, string(os.PathListSeparator))...) return }
func GetVolumeInfo(rootPathName string) (*VolumeInfo, error) { var volumeSerialNumber uint32 var maximumComponentLength uint32 var fileSystemFlags uint32 volumeNameBuffer := make([]uint16, syscall.MAX_PATH+1) fileSystemNameBuffer := make([]uint16, syscall.MAX_PATH+1) err := wrappers.GetVolumeInformation( syscall.StringToUTF16Ptr(rootPathName), &volumeNameBuffer[0], syscall.MAX_PATH+1, &volumeSerialNumber, &maximumComponentLength, &fileSystemFlags, &fileSystemNameBuffer[0], syscall.MAX_PATH+1) if err != nil { return nil, NewWindowsError("GetVolumeInformation", err) } return &VolumeInfo{ VolumeName: syscall.UTF16ToString(volumeNameBuffer), VolumeSerialNumber: uint(volumeSerialNumber), MaximumComponentLength: uint(maximumComponentLength), FileSystemFlags: FileSystemFlags(fileSystemFlags), FileSystemName: syscall.UTF16ToString(fileSystemNameBuffer), }, nil }
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 }
// GetModuleBase takes a module name as an argument. (e.g. "kernel32.dll") // Returns the modules base address. // // (Mostly taken from genkman's gist: https://gist.github.com/henkman/3083408) // TODO(Andoryuuta): Figure out possible licencing issues with this, or rewrite. func (p *Process) GetModuleBase(moduleName string) (uintptr, error) { snap, ok := w32.CreateToolhelp32Snapshot(w32.TH32CS_SNAPMODULE32|w32.TH32CS_SNAPALL|w32.TH32CS_SNAPMODULE, uint32(p.PID)) if !ok { return 0, errors.New("Error trying on create toolhelp32 snapshot.") } defer w32.CloseHandle(snap) var me32 w32.MODULEENTRY32 me32.DwSize = uint32(unsafe.Sizeof(me32)) // Get first module if !w32.Module32First(snap, &me32) { return 0, errors.New("Error trying to get first module.") } // Check first module if syscall.UTF16ToString(me32.SzModule[:]) == moduleName { return uintptr(unsafe.Pointer(me32.ModBaseAddr)), nil } // Loop all modules remaining for w32.Module32Next(snap, &me32) { // Check this module if syscall.UTF16ToString(me32.SzModule[:]) == moduleName { return uintptr(unsafe.Pointer(me32.ModBaseAddr)), nil } } // If this is reached, then we couldn't find the module return 0, errors.New("Couldn't Find Module.") }
func LoadVariables(etype EnvType) (map[string]string, error) { var hkey HKEY envMap := make(map[string]string) if etype == 0 { RegOpenKeyEx(HKEY_CURRENT_USER, syscall.StringToUTF16Ptr(`Environment`), 0, KEY_READ, &hkey) } else { RegOpenKeyEx(HKEY_LOCAL_MACHINE, syscall.StringToUTF16Ptr(`SYSTEM\CurrentControlSet\Control\Session Manager\Environment`), 0, KEY_READ, &hkey) } for i := 0; ; i++ { var valueLen uint32 = 256 valueBuffer := make([]uint16, 256) var dataLen uint32 = 0 var dataType uint32 = 0 if ERROR_NO_MORE_ITEMS == RegEnumValue(hkey, uint32(i), &valueBuffer[0], &valueLen, nil, &dataType, nil, &dataLen) { break } dataBuffer := make([]uint16, dataLen/2+2) if ERROR_SUCCESS != RegQueryValueEx(hkey, &valueBuffer[0], nil, &dataType, (*byte)(unsafe.Pointer(&dataBuffer[0])), &dataLen) { return nil, errors.New("ERROR2") } envMap[syscall.UTF16ToString(valueBuffer)] = syscall.UTF16ToString(dataBuffer) if syscall.UTF16ToString(valueBuffer) == "Path" { log.Println("Path = ", syscall.UTF16ToString(dataBuffer)) } } return envMap, nil }
func GetProcessModules(pid uint32) ([]ModuleInfo, error) { hSnapshot, err := wrappers.CreateToolhelp32Snapshot(wrappers.TH32CS_SNAPMODULE, pid) if err != nil { return nil, NewWindowsError("CreateToolhelp32Snapshot", err) } defer wrappers.CloseHandle(hSnapshot) me := wrappers.MODULEENTRY32{} me.Size = uint32(unsafe.Sizeof(me)) if err := wrappers.Module32First(hSnapshot, &me); err != nil { return nil, NewWindowsError("Module32First", err) } mi := []ModuleInfo{} for { mi = append(mi, ModuleInfo{ ProcessID: uint(me.ProcessID), ModuleBaseAddress: me.ModBaseAddr, ModuleBaseSize: uint(me.ModBaseSize), ModuleHandle: me.Module, ModuleName: syscall.UTF16ToString((&me.ModuleName)[:]), ExePath: syscall.UTF16ToString((&me.ExePath)[:]), }) err := wrappers.Module32Next(hSnapshot, &me) if err == wrappers.ERROR_NO_MORE_FILES { return mi, nil } else if err != nil { return nil, NewWindowsError("Module32Next", err) } } }
func (self *FindFile) Current() FindFileItem { return FindFileItem{ FileAttributes: FileAttributes(self.current.FileAttributes), FileSize: (uint64(self.current.FileSizeHigh) << 32) | uint64(self.current.FileSizeLow), ReparseTag: ReparseTag(self.current.Reserved0), FileName: syscall.UTF16ToString(self.current.FileName[:]), AlternateFileName: syscall.UTF16ToString(self.current.AlternateFileName[:]), } }
// abbrev returns the abbreviations to use for the given zone z. func abbrev(z *syscall.Timezoneinformation) (std, dst string) { stdName := syscall.UTF16ToString(z.StandardName[:]) a, ok := abbrs[stdName] if !ok { // fallback to using capital letters dstName := syscall.UTF16ToString(z.DaylightName[:]) return extractCAPS(stdName), extractCAPS(dstName) } return a.std, a.dst }
func RegQuery(regname, installer_name, args string) (result string) { var handle, subtestkey syscall.Handle var csubkey uint32 var list [1 << 10]string if syscall.RegOpenKeyEx(syscall.HKEY_LOCAL_MACHINE, syscall.StringToUTF16Ptr(regname), 0, syscall.KEY_READ, &handle) != nil { return } defer syscall.RegCloseKey(handle) csubkey = QueryKey(handle, &list) // fmt.Println("the args is :", args) for j := uint32(0); j < csubkey; j++ { var buffer, uninstall_buf [syscall.MAX_LONG_PATH]uint16 n := uint32(len(buffer)) dwSize := uint32(len(uninstall_buf)) var display_name string reg1 := regname + "\\" + list[j] //fmt.Println("reg1 is ", reg1) if reg1 == "Software\\Wow6432Node\\Xoreax\\IncrediBuild\\Builder" { if syscall.RegOpenKeyEx(syscall.HKEY_LOCAL_MACHINE, syscall.StringToUTF16Ptr(reg1), 0, syscall.KEY_READ, &subtestkey) == nil { e1 := syscall.RegQueryValueEx(subtestkey, syscall.StringToUTF16Ptr(args), nil, nil, (*byte)(unsafe.Pointer(&buffer[0])), &n) if e1 != nil { fmt.Println(e1) } result = syscall.UTF16ToString(buffer[:]) // fmt.Println(result, args) return } } if syscall.RegOpenKeyEx(syscall.HKEY_LOCAL_MACHINE, syscall.StringToUTF16Ptr(reg1), 0, syscall.KEY_READ, &subtestkey) == nil { syscall.RegQueryValueEx(subtestkey, syscall.StringToUTF16Ptr("DisplayName"), nil, nil, (*byte)(unsafe.Pointer(&buffer[0])), &n) display_name = syscall.UTF16ToString(buffer[:]) if strings.Contains(display_name, installer_name) { if syscall.RegQueryValueEx(subtestkey, syscall.StringToUTF16Ptr(args), nil, nil, (*byte)(unsafe.Pointer(&uninstall_buf[0])), &dwSize) == nil { result = syscall.UTF16ToString(uninstall_buf[:]) if result != "" { return } } } } defer syscall.RegCloseKey(subtestkey) } return }
func (c *Client) KeyInfo() (sessionKeySize uint32, sigAlg uint32, sigAlgName string, encAlg uint32, encAlgName string, err error) { var ki _SecPkgContext_KeyInfo ret := sspi.QueryContextAttributes(c.ctx.Handle, _SECPKG_ATTR_KEY_INFO, (*byte)(unsafe.Pointer(&ki))) if ret != sspi.SEC_E_OK { return 0, 0, "", 0, "", ret } defer sspi.FreeContextBuffer((*byte)(unsafe.Pointer(ki.SignatureAlgorithmName))) defer sspi.FreeContextBuffer((*byte)(unsafe.Pointer(ki.EncryptAlgorithmName))) saname := syscall.UTF16ToString((*[2 << 20]uint16)(unsafe.Pointer(ki.SignatureAlgorithmName))[:]) eaname := syscall.UTF16ToString((*[2 << 20]uint16)(unsafe.Pointer(ki.EncryptAlgorithmName))[:]) return ki.KeySize, ki.SignatureAlgorithm, saname, ki.EncryptAlgorithm, eaname, nil }
func init() { var buf [4]uint16 win.GetLocaleInfo(win.LOCALE_USER_DEFAULT, win.LOCALE_SDECIMAL, &buf[0], int32(len(buf))) decimalSepB = byte(buf[0]) decimalSepS = syscall.UTF16ToString(buf[0:1]) decimalSepUint16 = buf[0] win.GetLocaleInfo(win.LOCALE_USER_DEFAULT, win.LOCALE_STHOUSAND, &buf[0], int32(len(buf))) groupSepB = byte(buf[0]) groupSepS = syscall.UTF16ToString(buf[0:1]) groupSepUint16 = buf[0] }
func DirectSoundCaptureEnumerate(dsEnumCallback func(guid *GUID, description string, module string) bool) error { return dllDSResult(procDirectSoundCaptureEnumerate.Call(syscall.NewCallback(func(guid *GUID, description *[maxInt >> 1]uint16, module *[maxInt >> 1]uint16, context uintptr) int { b := dsEnumCallback( guid, syscall.UTF16ToString(description[:]), syscall.UTF16ToString(module[:]), ) if b { return 1 } return 0 }), 0)) }
func (nle *numberLineEdit) setTextFromValue(value float64) error { nle.buf.Reset() nle.buf.WriteString(syscall.UTF16ToString(nle.prefix)) if nle.decimals > 0 { nle.buf.WriteString(FormatFloatGrouped(value, nle.decimals)) } else { nle.buf.WriteString(FormatFloat(value, nle.decimals)) } nle.buf.WriteString(syscall.UTF16ToString(nle.suffix)) return nle.SetText(nle.buf.String()) }
// toEnglishName searches the registry for an English name of a time zone // whose zone names are stdname and dstname and returns the English name. func toEnglishName(stdname, dstname string) (string, error) { var zones syscall.Handle p, _ := syscall.UTF16PtrFromString(`SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones`) if err := syscall.RegOpenKeyEx(syscall.HKEY_LOCAL_MACHINE, p, 0, syscall.KEY_READ, &zones); err != nil { return "", err } defer syscall.RegCloseKey(zones) var count uint32 if err := syscall.RegQueryInfoKey(zones, nil, nil, nil, &count, nil, nil, nil, nil, nil, nil, nil); err != nil { return "", err } var buf [50]uint16 // buf needs to be large enough to fit zone descriptions for i := uint32(0); i < count; i++ { n := uint32(len(buf)) if syscall.RegEnumKeyEx(zones, i, &buf[0], &n, nil, nil, nil, nil) != nil { continue } kname := syscall.UTF16ToString(buf[:]) matched, err := matchZoneKey(zones, kname, stdname, dstname) if err == nil && matched { return kname, nil } } return "", errors.New(`English name for time zone "` + stdname + `" not found in registry`) }
func lookupFullName(domain, username, domainAndUser string) (string, error) { // try domain controller first name, e := syscall.TranslateAccountName(domainAndUser, syscall.NameSamCompatible, syscall.NameDisplay, 50) if e != nil { // domain lookup failed, perhaps this pc is not part of domain d, e := syscall.UTF16PtrFromString(domain) if e != nil { return "", e } u, e := syscall.UTF16PtrFromString(username) if e != nil { return "", e } var p *byte e = syscall.NetUserGetInfo(d, u, 10, &p) if e != nil { // path executed when a domain user is disconnected from the domain // pretend username is fullname return username, nil } defer syscall.NetApiBufferFree(p) i := (*syscall.UserInfo10)(unsafe.Pointer(p)) if i.FullName == nil { return "", nil } name = syscall.UTF16ToString((*[1024]uint16)(unsafe.Pointer(i.FullName))[:]) } return name, nil }
func RegGetString(hKey HKEY, subKey string, value string) string { var bufLen uint32 procRegGetValue.Call( uintptr(hKey), uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(subKey))), uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(value))), uintptr(RRF_RT_REG_SZ), 0, 0, uintptr(unsafe.Pointer(&bufLen))) if bufLen == 0 { return "" } buf := make([]uint16, bufLen) ret, _, _ := procRegGetValue.Call( uintptr(hKey), uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(subKey))), uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(value))), uintptr(RRF_RT_REG_SZ), 0, uintptr(unsafe.Pointer(&buf[0])), uintptr(unsafe.Pointer(&bufLen))) if ret != ERROR_SUCCESS { return "" } return syscall.UTF16ToString(buf) }
func longPathAsString(path string) (string, error) { longp, err := longPath(path) if err != nil { return "", err } return syscall.UTF16ToString(longp), nil }
// wraps SCardStatus func (card *Card) Status() (*CardStatus, error) { var reader [MAX_READERNAME + 1]uint16 var readerLen = uint32(len(reader)) var state, proto uint32 var atr [MAX_ATR_SIZE]byte var atrLen = uint32(len(atr)) r, _, _ := procStatus.Call( card.handle, uintptr(unsafe.Pointer(&reader[0])), uintptr(unsafe.Pointer(&readerLen)), uintptr(unsafe.Pointer(&state)), uintptr(unsafe.Pointer(&proto)), uintptr(unsafe.Pointer(&atr[0])), uintptr(unsafe.Pointer(&atrLen))) if scardError(r) != S_SUCCESS { return nil, scardError(r) } status := &CardStatus{ Reader: syscall.UTF16ToString(reader[0:readerLen]), State: State(state), ActiveProtocol: Protocol(proto), ATR: atr[0:atrLen], } return status, nil }
// LookupSidByName looks up the SID of an account by name func LookupSidByName(name string) (sid string, err error) { if name == "" { return "", &AccountLookupError{name, cERROR_NONE_MAPPED} } var sidSize, sidNameUse, refDomainSize uint32 err = lookupAccountName(nil, name, nil, &sidSize, nil, &refDomainSize, &sidNameUse) if err != nil && err != syscall.ERROR_INSUFFICIENT_BUFFER { return "", &AccountLookupError{name, err} } sidBuffer := make([]byte, sidSize) refDomainBuffer := make([]uint16, refDomainSize) err = lookupAccountName(nil, name, &sidBuffer[0], &sidSize, &refDomainBuffer[0], &refDomainSize, &sidNameUse) if err != nil { return "", &AccountLookupError{name, err} } var strBuffer *uint16 err = convertSidToStringSid(&sidBuffer[0], &strBuffer) if err != nil { return "", &AccountLookupError{name, err} } sid = syscall.UTF16ToString((*[0xffff]uint16)(unsafe.Pointer(strBuffer))[:]) localFree(uintptr(unsafe.Pointer(strBuffer))) return sid, nil }
func listPort() (res []String) { var root win.HKEY res = make([]string, 0) rootpath, _ := syscall.UTF16PtrFromString("HARDWARE\\DEVICEMAP\\SERIALCOMM") fmt.Println(win.RegOpenKeyEx(win.HKEY_LOCAL_MACHINE, rootpath, 0, win.KEY_READ, &root)) var callError int32 var index uint32 = 0 for callError == 0 { var name_length uint32 = 72 var key_type uint32 var lpDataLength uint32 = 72 name := make([]uint16, 72) lpData := make([]byte, 72) callError = win.RegEnumValue(root, index, &name[0], &name_length, nil, &key_type, &lpData[0], &lpDataLength) output := make([]uint16, 72) for i := uint32(0); i < lpDataLength; i = i + 2 { fmt.Println(uint16(lpData[i])<<8, "-", lpData[i+1]) output[i/2] = uint16(lpData[i+1])<<8 + uint16(lpData[i]) } res = append(res, syscall.UTF16ToString(output)) index++ } win.RegCloseKey(root) }
func (*Resolver) lookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error) { // TODO(bradfitz): finish ctx plumbing. Nothing currently depends on this. acquireThread() defer releaseThread() var target string if service == "" && proto == "" { target = name } else { target = "_" + service + "._" + proto + "." + name } var r *syscall.DNSRecord e := syscall.DnsQuery(target, syscall.DNS_TYPE_SRV, 0, nil, &r, nil) if e != nil { return "", nil, &DNSError{Err: winError("dnsquery", e).Error(), Name: target} } defer syscall.DnsRecordListFree(r, 1) srvs := make([]*SRV, 0, 10) for _, p := range validRecs(r, syscall.DNS_TYPE_SRV, target) { v := (*syscall.DNSSRVData)(unsafe.Pointer(&p.Data[0])) srvs = append(srvs, &SRV{absDomainName([]byte(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Target))[:]))), v.Port, v.Priority, v.Weight}) } byPriorityWeight(srvs).sort() return absDomainName([]byte(target)), srvs, nil }
func nativeGetPortsList() ([]string, error) { subKey, err := syscall.UTF16PtrFromString("HARDWARE\\DEVICEMAP\\SERIALCOMM\\") if err != nil { return nil, &PortError{code: ErrorEnumeratingPorts} } var h syscall.Handle if syscall.RegOpenKeyEx(syscall.HKEY_LOCAL_MACHINE, subKey, 0, syscall.KEY_READ, &h) != nil { return nil, &PortError{code: ErrorEnumeratingPorts} } defer syscall.RegCloseKey(h) var valuesCount uint32 if syscall.RegQueryInfoKey(h, nil, nil, nil, nil, nil, nil, &valuesCount, nil, nil, nil, nil) != nil { return nil, &PortError{code: ErrorEnumeratingPorts} } list := make([]string, valuesCount) for i := range list { var data [1024]uint16 dataSize := uint32(len(data)) var name [1024]uint16 nameSize := uint32(len(name)) if regEnumValue(h, uint32(i), &name[0], &nameSize, nil, nil, &data[0], &dataSize) != nil { return nil, &PortError{code: ErrorEnumeratingPorts} } list[i] = syscall.UTF16ToString(data[:]) } return list, nil }
// void * (uintptr)转换为字符串 func UINTptrToString(uintPtr uintptr) string { if uintPtr == 0 { return "" } return syscall.UTF16ToString((*[1 << 16]uint16)(unsafe.Pointer(uintPtr))[0:]) }
func XPane_GetTitleGo(hEle HELE) string { buf_szize := 256 buf := make([]uint16, buf_szize) XPane_GetTitle(hEle, &buf[0], buf_szize) return syscall.UTF16ToString(buf) }
func GetSpecialFolderPath(folder SpecialFolder) (string, error) { buf := [wrappers.MAX_PATH]uint16{} if hr := wrappers.SHGetFolderPath(0, uint32(folder), 0, 0, &buf[0]); wrappers.FAILED(hr) { return "", NewWindowsError("SHGetFolderPath", COMError(hr)) } return syscall.UTF16ToString((&buf)[:]), nil }
// See http://blog.natefinch.com/2012/11/go-win-stuff.html // // This is used by workstationVMwareRoot in order to read some registry data. func readRegString(hive syscall.Handle, subKeyPath, valueName string) (value string, err error) { var h syscall.Handle err = syscall.RegOpenKeyEx(hive, syscall.StringToUTF16Ptr(subKeyPath), 0, syscall.KEY_READ, &h) if err != nil { return } defer syscall.RegCloseKey(h) var typ uint32 var bufSize uint32 err = syscall.RegQueryValueEx( h, syscall.StringToUTF16Ptr(valueName), nil, &typ, nil, &bufSize) if err != nil { return } data := make([]uint16, bufSize/2+1) err = syscall.RegQueryValueEx( h, syscall.StringToUTF16Ptr(valueName), nil, &typ, (*byte)(unsafe.Pointer(&data[0])), &bufSize) if err != nil { return } return syscall.UTF16ToString(data), nil }
func GetOperatingSystem() (string, error) { var h syscall.Handle // Default return value ret := "Unknown Operating System" if err := syscall.RegOpenKeyEx(syscall.HKEY_LOCAL_MACHINE, syscall.StringToUTF16Ptr(`SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\`), 0, syscall.KEY_READ, &h); err != nil { return ret, err } defer syscall.RegCloseKey(h) var buf [1 << 10]uint16 var typ uint32 n := uint32(len(buf) * 2) // api expects array of bytes, not uint16 if err := syscall.RegQueryValueEx(h, syscall.StringToUTF16Ptr("ProductName"), nil, &typ, (*byte)(unsafe.Pointer(&buf[0])), &n); err != nil { return ret, err } ret = syscall.UTF16ToString(buf[:]) return ret, nil }