// Load
//
// If there is an error, it will be of type *Error.
func (mgc *Magic) Load(files ...string) (bool, error) {
mgc.Lock()
defer mgc.Unlock()
runtime.KeepAlive(mgc.magic)
if mgc.cookie == nil {
return false, mgc.error()
}
var cfiles *C.char
runtime.KeepAlive(cfiles)
defer C.free(unsafe.Pointer(cfiles))
// Assemble the list of custom Magic files into a colon-separated
// list that is required by the underlying Magic library, otherwise
// defer to the default list of paths provided by the Magic library.
if len(files) > 0 {
cfiles = C.CString(strings.Join(files, ":"))
} else {
cfiles = C.magic_getpath_wrapper()
}
if rv := C.magic_load_wrapper(mgc.cookie, cfiles, C.int(mgc.flags)); rv < 0 {
return false, mgc.error()
}
mgc.path = strings.Split(C.GoString(cfiles), ":")
return true, nil
}
// File
//
// If there is an error, it will be of type *Error.
func (mgc *Magic) File(filename string) (string, error) {
mgc.Lock()
defer mgc.Unlock()
runtime.KeepAlive(mgc.magic)
if mgc.cookie == nil {
return "", mgc.error()
}
cfilename := C.CString(filename)
runtime.KeepAlive(cfilename)
defer C.free(unsafe.Pointer(cfilename))
cstring := C.magic_file_wrapper(mgc.cookie, cfilename, C.int(mgc.flags))
if cstring == nil {
rv, err := Version()
if err != nil && err.(*Error).Errno != int(syscall.ENOSYS) {
return "", err
}
// Handle the case when the "ERROR" flag is set regardless
// of the current version of the underlying Magic library.
//
// Prior to version 5.15 the correct behaviour that concerns
// the following IEEE 1003.1 standards was broken:
//
// http://pubs.opengroup.org/onlinepubs/007904975/utilities/file.html
// http://pubs.opengroup.org/onlinepubs/9699919799/utilities/file.html
//
// This is an attempt to mitigate the problem and correct
// it to achieve the desired behaviour as per the standards.
if mgc.flags&ERROR != 0 {
return "", mgc.error()
} else if rv < 515 {
C.magic_errno(mgc.cookie)
cstring = C.magic_error(mgc.cookie)
}
}
// XXX(kwilczynski): This case should not happen, ever.
if cstring == nil {
return "", &Error{-1, "unknown result or nil pointer"}
}
// Depending on the version of the underlying
// Magic library the magic_file() function can
// fail and either yield no results or return
// the "(null)" string instead. Often this
// would indicate that an older version of
// the Magic library is in use.
s := C.GoString(cstring)
if s == "" || s == "(null)" {
return "", &Error{-1, "empty or invalid result"}
}
return s, nil
}
func CreateJobObject(sa *syscall.SecurityAttributes, name *uint16) (syscall.Handle, error) {
r1, _, e1 := procCreateJobObjectW.Call(
uintptr(unsafe.Pointer(sa)),
uintptr(unsafe.Pointer(name)))
runtime.KeepAlive(sa)
runtime.KeepAlive(name)
if int(r1) == 0 {
return syscall.InvalidHandle, os.NewSyscallError("CreateJobObject", e1)
}
return syscall.Handle(r1), nil
}
func SetUserObjectSecurity(obj syscall.Handle, sid uint32, desc []byte) error {
r1, _, e1 := procSetUserObjectSecurity.Call(
uintptr(obj),
uintptr(unsafe.Pointer(&sid)),
uintptr(unsafe.Pointer(&desc[0])))
runtime.KeepAlive(&sid)
runtime.KeepAlive(&desc)
if int(r1) == 0 {
return os.NewSyscallError("SetUserObjectSecurity", e1)
}
return nil
}
func AddAccessAllowedAce(acl *Acl, revision, mask uint32, sid *syscall.SID) error {
r1, _, e1 := procAddAccessAllowedAce.Call(
uintptr(unsafe.Pointer(acl)),
uintptr(revision),
uintptr(mask),
uintptr(unsafe.Pointer(sid)))
runtime.KeepAlive(acl)
runtime.KeepAlive(sid)
if int(r1) == 0 {
return os.NewSyscallError("AddAccessAllowedAce", e1)
}
return nil
}
func SetSecurityDescriptorDacl(sd []byte, present bool, acl *Acl, defaulted bool) error {
r1, _, e1 := procSetSecurityDescriptorDacl.Call(
uintptr(unsafe.Pointer(&sd[0])),
uintptr(boolToUint32(present)),
uintptr(unsafe.Pointer(acl)),
uintptr(boolToUint32(defaulted)))
runtime.KeepAlive(sd)
runtime.KeepAlive(acl)
if int(r1) == 0 {
return os.NewSyscallError("SetSecurityDescriptorDacl", e1)
}
return nil
}
func CreateWindowStation(winsta *uint16, flags, desiredAccess uint32, sa *syscall.SecurityAttributes) (Hwinsta, error) {
r1, _, e1 := procCreateWindowStationW.Call(
uintptr(unsafe.Pointer(winsta)),
uintptr(flags),
uintptr(desiredAccess),
uintptr(unsafe.Pointer(sa)))
runtime.KeepAlive(winsta)
runtime.KeepAlive(sa)
if int(r1) == 0 {
return Hwinsta(r1), os.NewSyscallError("CreateWindowStation", e1)
}
return Hwinsta(r1), nil
}
func AddAce(acl *Acl, revision, startIndex uint32, ace *Ace, size uint32) error {
r1, _, e1 := procAddAce.Call(
uintptr(unsafe.Pointer(acl)),
uintptr(revision),
uintptr(startIndex),
uintptr(unsafe.Pointer(ace)),
uintptr(size))
runtime.KeepAlive(acl)
runtime.KeepAlive(ace)
if int(r1) == 0 {
return os.NewSyscallError("AddAce", e1)
}
return nil
}
func f(x *big, start int64) {
if delta := inuse() - start; delta < 9<<20 {
println("after alloc: expected delta at least 9MB, got: ", delta)
}
runtime.KeepAlive(x)
x = nil
if delta := inuse() - start; delta > 1<<20 {
println("after drop: expected delta below 1MB, got: ", delta)
}
x = new(big)
if delta := inuse() - start; delta < 9<<20 {
println("second alloc: expected delta at least 9MB, got: ", delta)
}
runtime.KeepAlive(x)
}
func CreateDesktop(desktop, device *uint16, devmode uintptr, flags, desiredAccess uint32, sa *syscall.SecurityAttributes) (Hdesk, error) {
r1, _, e1 := procCreateDesktopW.Call(
uintptr(unsafe.Pointer(desktop)),
uintptr(unsafe.Pointer(device)),
devmode,
uintptr(flags),
uintptr(desiredAccess),
uintptr(unsafe.Pointer(sa)))
runtime.KeepAlive(desktop)
runtime.KeepAlive(device)
runtime.KeepAlive(sa)
if int(r1) == 0 {
return Hdesk(r1), os.NewSyscallError("CreateDesktop", e1)
}
return Hdesk(r1), nil
}
func (pd *pollDesc) evict() {
pd.closing = true
if pd.fd != nil {
syscall.StopIO(pd.fd.sysfd)
runtime.KeepAlive(pd.fd)
}
}
func LogonUser(username *uint16, domain *uint16, password *uint16, logonType uint32, logonProvider uint32) (token syscall.Handle, err error) {
r1, _, e1 := procLogonUserW.Call(
uintptr(unsafe.Pointer(username)),
uintptr(unsafe.Pointer(domain)),
uintptr(unsafe.Pointer(password)),
uintptr(logonType),
uintptr(logonProvider),
uintptr(unsafe.Pointer(&token)))
runtime.KeepAlive(username)
runtime.KeepAlive(domain)
runtime.KeepAlive(password)
if int(r1) == 0 {
return syscall.InvalidHandle, os.NewSyscallError("LogonUser", e1)
}
return
}
// FlagsSlice returns a slice containing each distinct flag that
// is currently set and included as a part of the current value
// (bitmask) of flags. Results are sorted in an ascending order.
// If there is an error, it will be of type *Error.
func (mgc *Magic) FlagsSlice() ([]int, error) {
mgc.Lock()
defer mgc.Unlock()
runtime.KeepAlive(mgc.magic)
if mgc.cookie == nil {
return []int{}, mgc.error()
}
if mgc.flags == 0 {
return []int{0}, nil
}
var n int
var flags []int
// Split current value (bitmask) into a list
// of distinct flags (bits) currently set.
for i := mgc.flags; i > 0; i = i - n {
n = int(math.Log2(float64(i)))
n = int(math.Pow(2, float64(n)))
flags = append(flags, n)
}
sort.Ints(flags)
return flags, nil
}
func InitializeSecurityDescriptor(sd []byte) error {
r1, _, e1 := procInitializeSecurityDescriptor.Call(
uintptr(unsafe.Pointer(&sd[0])),
SECURITY_DESCRIPTOR_REVISION)
runtime.KeepAlive(sd)
if int(r1) == 0 {
return os.NewSyscallError("InitializeSecurityDescriptor", e1)
}
return nil
}
func (pd *pollDesc) init(fd *netFD) error {
serverInit.Do(runtime_pollServerInit)
ctx, errno := runtime_pollOpen(uintptr(fd.sysfd))
runtime.KeepAlive(fd)
if errno != 0 {
return syscall.Errno(errno)
}
pd.runtimeCtx = ctx
return nil
}
// Flags returns a value (bitmask) representing current flags set.
// If there is an error, it will be of type *Error.
func (mgc *Magic) Flags() (int, error) {
mgc.Lock()
defer mgc.Unlock()
runtime.KeepAlive(mgc.magic)
if mgc.cookie == nil {
return -1, mgc.error()
}
return mgc.flags, nil
}
func GetUserObjectSecurity_Ex(obj syscall.Handle, sid uint32, desc []byte) (uint32, error) {
var nLength uint32
var nptr uintptr
if desc != nil {
nptr = uintptr(unsafe.Pointer(&desc[0]))
}
r1, _, e1 := procGetUserObjectSecurity.Call(
uintptr(obj),
uintptr(unsafe.Pointer(&sid)),
nptr,
uintptr(len(desc)),
uintptr(unsafe.Pointer(&nLength)))
runtime.KeepAlive(&sid)
runtime.KeepAlive(&nLength)
if int(r1) == 0 {
return nLength, os.NewSyscallError("GetUserObjectSecurity", e1)
}
return nLength, nil
}
func LoadUserProfile(token syscall.Handle, pinfo *ProfileInfo) error {
r1, _, e1 := procLoadUserProfileW.Call(
uintptr(token),
uintptr(unsafe.Pointer(pinfo)))
runtime.KeepAlive(pinfo)
if int(r1) == 0 {
return os.NewSyscallError("LoadUserProfile", e1)
}
return nil
}
func InitializeAcl(acl *Acl, length, revision uint32) error {
r1, _, e1 := procInitializeAcl.Call(
uintptr(unsafe.Pointer(acl)),
uintptr(length),
uintptr(revision))
runtime.KeepAlive(acl)
if int(r1) == 0 {
return os.NewSyscallError("InitializeAcl", e1)
}
return nil
}
func GetAce(acl *Acl, index uint32) (*Ace, error) {
var result *Ace
r1, _, e1 := procGetAce.Call(
uintptr(unsafe.Pointer(acl)),
uintptr(index),
uintptr(unsafe.Pointer(&result)))
runtime.KeepAlive(acl)
if int(r1) == 0 {
return nil, os.NewSyscallError("GetAce", e1)
}
return result, nil
}
// New opens and initializes Magic library.
//
// Optionally, a multiple distinct Magic database files can
// be provided to load, otherwise a default database (usually
// available system-wide) will be loaded. Alternatively, the
// "MAGIC" environment variable can be used to name any desired
// Magic database files to be loaded, but it must be set prior
// to calling this function for it to take effect.
//
// Remember to call Close to release initialized resources
// and close currently opened Magic library, or use Open which
// will ensure that Close is called once the closure finishes.
//
// If there is an error originating from the underlying Magic
// library, it will be of type *Error.
func New(files ...string) (*Magic, error) {
mgc, err := open()
if err != nil {
return nil, err
}
runtime.KeepAlive(mgc.magic)
if _, err := mgc.Load(files...); err != nil {
return nil, err
}
return mgc, nil
}
func GetAclInformation(acl *Acl, info unsafe.Pointer, length uint32, class uint32) error {
r1, _, e1 := procGetAclInformation.Call(
uintptr(unsafe.Pointer(acl)),
uintptr(info),
uintptr(length),
uintptr(class))
runtime.KeepAlive(acl)
if int(r1) == 0 {
return os.NewSyscallError("GetAclInformation", e1)
}
return nil
}
// open opens and initializes underlying Magic library and sets the
// finalizer on the object accordingly.
func open() (*Magic, error) {
// Can only fail allocating memory in this particular case.
rv := C.magic_open(C.int(NONE))
if rv == nil {
errno := syscall.ENOMEM
return nil, &Error{int(errno), "failed to initialize Magic library"}
}
mgc := &Magic{&magic{flags: NONE, cookie: rv}}
runtime.SetFinalizer(mgc.magic, (*magic).close)
runtime.KeepAlive(mgc.magic)
return mgc, nil
}
// Check
//
// If there is an error, it will be of type *Error.
func (mgc *Magic) Check(files ...string) (bool, error) {
mgc.Lock()
defer mgc.Unlock()
runtime.KeepAlive(mgc.magic)
if mgc.cookie == nil {
return false, mgc.error()
}
var cfiles *C.char
runtime.KeepAlive(cfiles)
defer C.free(unsafe.Pointer(cfiles))
if len(files) > 0 {
cfiles = C.CString(strings.Join(files, ":"))
}
if rv := C.magic_check_wrapper(mgc.cookie, cfiles, C.int(mgc.flags)); rv < 0 {
return false, mgc.error()
}
return true, nil
}
func GetUserObjectInformation(obj syscall.Handle, index int, info unsafe.Pointer, length uint32) (uint32, error) {
var nLength uint32
r1, _, e1 := procGetUserObjectInformationW.Call(
uintptr(obj),
uintptr(index),
uintptr(info),
uintptr(length),
uintptr(unsafe.Pointer(&nLength)))
runtime.KeepAlive(&nLength)
if int(r1) == 0 {
return nLength, os.NewSyscallError("GetUserObjectInformation", e1)
}
return 0, nil
}
func QueryInformationJobObject(job syscall.Handle, infoclass uint32, info unsafe.Pointer, length uint32) (uint32, error) {
var nLength uint32
r1, _, e1 := procQueryInformationJobObject.Call(
uintptr(job),
uintptr(infoclass),
uintptr(info),
uintptr(length),
uintptr(unsafe.Pointer(&nLength)))
runtime.KeepAlive(&nLength)
if int(r1) == 0 {
return nLength, os.NewSyscallError("QueryInformationJobObject", e1)
}
return nLength, nil
}
// Descriptor
//
// If there is an error, it will be of type *Error.
func (mgc *Magic) Descriptor(fd uintptr) (string, error) {
mgc.Lock()
defer mgc.Unlock()
runtime.KeepAlive(mgc.magic)
if mgc.cookie == nil {
return "", mgc.error()
}
cstring := C.magic_descriptor_wrapper(mgc.cookie, C.int(fd), C.int(mgc.flags))
if cstring == nil {
return "", mgc.error()
}
return C.GoString(cstring), nil
}
// blockUntilWaitable attempts to block until a call to p.Wait will
// succeed immediately, and returns whether it has done so.
// It does not actually call p.Wait.
func (p *Process) blockUntilWaitable() (bool, error) {
// The waitid system call expects a pointer to a siginfo_t,
// which is 128 bytes on all GNU/Linux systems.
// On Darwin, it requires greater than or equal to 64 bytes
// for darwin/{386,arm} and 104 bytes for darwin/amd64.
// We don't care about the values it returns.
var siginfo [128]byte
psig := &siginfo[0]
_, _, e := syscall.Syscall6(syscall.SYS_WAITID, _P_PID, uintptr(p.Pid), uintptr(unsafe.Pointer(psig)), syscall.WEXITED|syscall.WNOWAIT, 0, 0)
runtime.KeepAlive(psig)
if e != 0 {
return false, NewSyscallError("waitid", e)
}
return true, nil
}
func (p *Process) signal(sig Signal) error {
handle := atomic.LoadUintptr(&p.handle)
if handle == uintptr(syscall.InvalidHandle) {
return syscall.EINVAL
}
if p.done() {
return errors.New("os: process already finished")
}
if sig == Kill {
err := terminateProcess(p.Pid, 1)
runtime.KeepAlive(p)
return err
}
// TODO(rsc): Handle Interrupt too?
return syscall.Errno(syscall.EWINDOWS)
}
// Buffer
//
// If there is an error, it will be of type *Error.
func (mgc *Magic) Buffer(buffer []byte) (string, error) {
mgc.Lock()
defer mgc.Unlock()
runtime.KeepAlive(mgc.magic)
if mgc.cookie == nil {
return "", mgc.error()
}
p, length := unsafe.Pointer(&buffer[0]), C.size_t(len(buffer))
cstring := C.magic_buffer_wrapper(mgc.cookie, p, length, C.int(mgc.flags))
if cstring == nil {
return "", mgc.error()
}
return C.GoString(cstring), nil
}