vendor/github.com/fsouza/go-dockerclient/external/github.com/docker/docker/pkg/system/events_windows.go

   1 package system
   2
   3 // This file implements syscalls for Win32 events which are not implemented
   4 // in golang.
   5
   6 import (
   7         "syscall"
   8         "unsafe"
   9 )
  10
  11 var (
  12         procCreateEvent = modkernel32.NewProc("CreateEventW")
  13         procOpenEvent   = modkernel32.NewProc("OpenEventW")
  14         procSetEvent    = modkernel32.NewProc("SetEvent")
  15         procResetEvent  = modkernel32.NewProc("ResetEvent")
  16         procPulseEvent  = modkernel32.NewProc("PulseEvent")
  17 )
  18
  19 // CreateEvent implements win32 CreateEventW func in golang. It will create an event object.
  20 func CreateEvent(eventAttributes *syscall.SecurityAttributes, manualReset bool, initialState bool, name string) (handle syscall.Handle, err error) {
  21         namep, _ := syscall.UTF16PtrFromString(name)
  22         var _p1 uint32
  23         if manualReset {
  24                 _p1 = 1
  25         }
  26         var _p2 uint32
  27         if initialState {
  28                 _p2 = 1
  29         }
  30         r0, _, e1 := procCreateEvent.Call(uintptr(unsafe.Pointer(eventAttributes)), uintptr(_p1), uintptr(_p2), uintptr(unsafe.Pointer(namep)))
  31         use(unsafe.Pointer(namep))
  32         handle = syscall.Handle(r0)
  33         if handle == syscall.InvalidHandle {
  34                 err = e1
  35         }
  36         return
  37 }
  38
  39 // OpenEvent implements win32 OpenEventW func in golang. It opens an event object.
  40 func OpenEvent(desiredAccess uint32, inheritHandle bool, name string) (handle syscall.Handle, err error) {
  41         namep, _ := syscall.UTF16PtrFromString(name)
  42         var _p1 uint32
  43         if inheritHandle {
  44                 _p1 = 1
  45         }
  46         r0, _, e1 := procOpenEvent.Call(uintptr(desiredAccess), uintptr(_p1), uintptr(unsafe.Pointer(namep)))
  47         use(unsafe.Pointer(namep))
  48         handle = syscall.Handle(r0)
  49         if handle == syscall.InvalidHandle {
  50                 err = e1
  51         }
  52         return
  53 }
  54
  55 // SetEvent implements win32 SetEvent func in golang.
  56 func SetEvent(handle syscall.Handle) (err error) {
  57         return setResetPulse(handle, procSetEvent)
  58 }
  59
  60 // ResetEvent implements win32 ResetEvent func in golang.
  61 func ResetEvent(handle syscall.Handle) (err error) {
  62         return setResetPulse(handle, procResetEvent)
  63 }
  64
  65 // PulseEvent implements win32 PulseEvent func in golang.
  66 func PulseEvent(handle syscall.Handle) (err error) {
  67         return setResetPulse(handle, procPulseEvent)
  68 }
  69
  70 func setResetPulse(handle syscall.Handle, proc *syscall.LazyProc) (err error) {
  71         r0, _, _ := proc.Call(uintptr(handle))
  72         if r0 != 0 {
  73                 err = syscall.Errno(r0)
  74         }
  75         return
  76 }
  77
  78 var temp unsafe.Pointer
  79
  80 // use ensures a variable is kept alive without the GC freeing while still needed
  81 func use(p unsafe.Pointer) {
  82         temp = p
  83 }