diff --git a/.gitignore b/.gitignore index 6f72f89..117752e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,9 @@ # If you prefer the allow list template instead of the deny list, see community template: # https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore -# + +# Work dir and files +.idea + # Binaries for programs and plugins *.exe *.exe~ diff --git a/client.go b/client.go new file mode 100644 index 0000000..2b288b9 --- /dev/null +++ b/client.go @@ -0,0 +1,184 @@ +package main + +import ( + "context" + "log" + "net" + "os" + "strings" + "sync" + "time" + + "ShotRDP/common" + "ShotRDP/grdp/core" + "ShotRDP/grdp/glog" + "ShotRDP/grdp/plugin" + "ShotRDP/grdp/protocol/nla" + "ShotRDP/grdp/protocol/pdu" + "ShotRDP/grdp/protocol/sec" + "ShotRDP/grdp/protocol/t125" + "ShotRDP/grdp/protocol/tpkt" + "ShotRDP/grdp/protocol/x224" +) + +type Client struct { + Host string // 服务地址(ip:port) + tpkt *tpkt.TPKT // TPKT协议层 + x224 *x224.X224 // X224协议层 + mcs *t125.MCSClient // MCS协议层 + sec *sec.Client // 安全层 + pdu *pdu.Client // PDU协议层 + + channels *plugin.Channels +} + +type Position struct { + Top int + Left int + Right int + Bottom int +} + +var ( + modifyMux = sync.Mutex{} + positionMap = make(map[Position]*common.Bitmap) +) + +func NewClient(host string, logLevel glog.LEVEL) *Client { + _logger := log.New(os.Stdout, "", 0) + + glog.SetLogger(_logger) + glog.SetLevel(logLevel) + + return &Client{Host: host} +} + +func (client *Client) Login(domain, username, password string) error { + conn, err := net.Dial("tcp", client.Host) + if err != nil { + glog.Errorf("TCP连接失败：%v", err) + return err + } + + // 初始化协议栈 + client.initProtocolStack(conn, domain, username, password) + + // 建立X224连接 + err = client.x224.Connect() + if err != nil { + glog.Errorf("建立X224连接失败：%v", err) + return err + } + + wg := &sync.WaitGroup{} + wg.Add(1) + + // 设置事件处理 + client.setEventHandler(wg) + + wg.Wait() + return nil +} + +// initProtocolStack 初始化RDP协议栈 +func (client *Client) initProtocolStack(conn net.Conn, domain, username, password string) { + // 创建协议层实例 + client.tpkt = tpkt.New(core.NewSocketLayer(conn), nla.NewNTLMv2(domain, username, password)) + client.x224 = x224.New(client.tpkt) + client.mcs = t125.NewMCSClient(client.x224) + client.sec = sec.NewClient(client.mcs) + client.pdu = pdu.NewClient(client.sec) + + // 配置桌面信息 + client.channels = plugin.NewChannels(client.sec) + client.mcs.SetClientDesktop(uint16(1920), uint16(1080)) + + // 设置认证信息 + client.sec.SetDomain(domain) + client.sec.SetUsername(username) + client.sec.SetPassword(password) + + // 配置协议层关联 + client.tpkt.SetFastPathListener(client.sec) + client.sec.SetFastPathListener(client.pdu) + + client.sec.SetChannelSender(client.mcs) +} + +// setEventHandler 设置PDU事件处理器 +func (client *Client) setEventHandler(wg *sync.WaitGroup) { + client.pdu.On("ready", func() { + glog.Info("PDU连接就绪") + + // Test + //glog.Infof("服务端核心信息: %+v", *client.sec.ServerCoreData()) + //glog.Infof("服务端安全信息: %+v", *client.sec.ServerSecurityData()) + }) + + client.pdu.On("success", func() { + glog.Info("PDU连接成功") + }) + + client.pdu.On("close", func() { + glog.Info("PDU连接关闭") + }) + + client.pdu.On("done", func() { + glog.Info("PDU处理完成") + }) + + client.pdu.On("error", func(err error) { + glog.Errorf("PDU错误事件：%v", err) + client.pdu.Emit("done") + }) + + client.pdu.On("bitmap", func(rectangles []pdu.BitmapData) { + modifyMux.Lock() + for _, rectangle := range rectangles { + pos := Position{Left: int(rectangle.DestLeft / rectangle.Width), Top: int(rectangle.DestTop / rectangle.Height), Right: int(rectangle.DestRight / rectangle.Width), Bottom: int(rectangle.DestBottom / rectangle.Height)} + isCompress := rectangle.IsCompress() + data := rectangle.BitmapDataStream + if isCompress { + data = common.BitmapDecompress(&rectangle) + isCompress = false + } + + bitmap := &common.Bitmap{ + DestLeft: int(rectangle.DestLeft), + DestTop: int(rectangle.DestTop), + DestRight: int(rectangle.DestRight), + DestBottom: int(rectangle.DestBottom), + Width: int(rectangle.Width), + Height: int(rectangle.Height), + BitsPerPixel: common.Bpp(rectangle.BitsPerPixel), + IsCompress: isCompress, + Data: data, + } + positionMap[pos] = bitmap + } + modifyMux.Unlock() + }) + + // 合并登录界面位图 + surfaceflingerCtx, _ := context.WithCancel(context.Background()) + go func(ctx context.Context, c *Client) { + outputName := strings.ReplaceAll(client.Host, ":", "_") + + for common.Opened(ctx) { + // TODO: 寻找合适的截图时机 + time.Sleep(5 * time.Second) + modifyMux.Lock() + + var bitmapList = make([]*common.Bitmap, 0) + for _, bitmap := range positionMap { + //common.DrawOneBitmap(bitmap, fmt.Sprintf("%d-%d-%d-%d.png", pos.Left, pos.Top, pos.Right, pos.Bottom)) + bitmapList = append(bitmapList, bitmap) + } + + common.DrawFullImage(outputName, bitmapList) + modifyMux.Unlock() + + wg.Done() + } + }(surfaceflingerCtx, client) +} diff --git a/common/bitmap.go b/common/bitmap.go new file mode 100644 index 0000000..abb0613 --- /dev/null +++ b/common/bitmap.go @@ -0,0 +1,172 @@ +package common + +import ( + "fmt" + "image" + "image/color" + "image/draw" + "image/png" + "os" + "sort" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/glog" + "ShotRDP/grdp/protocol/pdu" +) + +type Bitmap struct { + // 位图坐标信息 + DestTop int + DestLeft int + DestRight int + DestBottom int + + // 位图尺寸信息 + Width int + Height int + + Data []byte + IsCompress bool + BitsPerPixel int +} + +func BitmapDecompress(bitmap *pdu.BitmapData) []byte { + return core.Decompress(bitmap.BitmapDataStream, int(bitmap.Width), int(bitmap.Height), Bpp(bitmap.BitsPerPixel)) +} + +// Bpp 计算每像素所需的字节数 +func Bpp(BitsPerPixel uint16) (pixel int) { + switch BitsPerPixel { + case 15: + pixel = 1 + + case 16: + pixel = 2 + + case 24: + pixel = 3 + + case 32: + pixel = 4 + + default: + glog.Error("非法位图数据") + + } + return +} + +func ToRGBA(pixel int, i int, data []byte) (r, g, b, a uint8) { + a = 255 + switch pixel { + case 1: + rgb555 := core.Uint16BE(data[i], data[i+1]) + r, g, b = core.RGB555ToRGB(rgb555) + case 2: + rgb565 := core.Uint16BE(data[i], data[i+1]) + r, g, b = core.RGB565ToRGB(rgb565) + case 3, 4: + fallthrough + default: + r, g, b = data[i+2], data[i+1], data[i] + } + + return +} + +func DrawOneBitmap(bitmap *Bitmap, name string) { + finalImg := image.NewRGBA(image.Rect(0, 0, bitmap.Width, bitmap.Height)) + + var ( + i, p int + r, g, b, a uint8 + ) + + i = 0 + p = bitmap.BitsPerPixel + m := image.NewRGBA(image.Rect(0, 0, bitmap.Width, bitmap.Height)) + for y := 0; y < bitmap.Height; y++ { + for x := 0; x < bitmap.Width; x++ { + r, g, b, a = ToRGBA(p, i, bitmap.Data) + c := color.RGBA{R: r, G: g, B: b, A: a} + m.Set(x, y, c) + + i += p + } + } + + draw.Draw(finalImg, finalImg.Bounds(), m, m.Bounds().Min, draw.Src) + //_, _ = os.ReadFile(fmt.Sprintf("%s.png", name)) + + outFile, err := os.Create(fmt.Sprintf("%s.png", name)) + if err != nil { + glog.Errorf("创建文件失败: %v", err) + } + defer outFile.Close() + + // 保存图像为PNG文件 + err = png.Encode(outFile, finalImg) + if err != nil { + glog.Errorf("保存文件失败: %v", err) + } +} + +func DrawFullImage(outputName string, bitmapList []*Bitmap) { + // 对位图按 DestTop 和 DestLeft 排序 + sort.Slice(bitmapList, func(i, j int) bool { + if bitmapList[i].DestTop == bitmapList[j].DestTop { + return bitmapList[i].DestLeft < bitmapList[j].DestLeft + } + return bitmapList[i].DestTop < bitmapList[j].DestTop + }) + + // 计算合并后的总尺寸 + var totalWidth, totalHeight int + for _, bmp := range bitmapList { + if bmp.DestLeft+bmp.Width > totalWidth { + totalWidth = bmp.DestLeft + bmp.Width + } + if bmp.DestTop+bmp.Height > totalHeight { + totalHeight = bmp.DestTop + bmp.Height + } + } + + // 创建一个空白的画布，大小为合并后的总尺寸 + finalImg := image.NewRGBA(image.Rect(0, 0, totalWidth, totalHeight)) + + var ( + i, p int + r, g, b, a uint8 + ) + + for _, bmp := range bitmapList { + i = 0 + p = bmp.BitsPerPixel + m := image.NewRGBA(image.Rect(0, 0, bmp.Width, bmp.Height)) + for y := 0; y < bmp.Height; y++ { + for x := 0; x < bmp.Width; x++ { + r, g, b, a = ToRGBA(p, i, bmp.Data) + c := color.RGBA{R: r, G: g, B: b, A: a} + m.Set(x, y, c) + + i += p + } + } + + draw.Draw(finalImg, finalImg.Bounds().Add(image.Pt(bmp.DestLeft, bmp.DestTop)), m, m.Bounds().Min, draw.Src) + } + + // 创建保存PNG文件 + outFile, err := os.Create(fmt.Sprintf("%s.png", outputName)) + if err != nil { + glog.Errorf("创建文件失败: %v", err) + } + defer outFile.Close() + + err = png.Encode(outFile, finalImg) + if err != nil { + glog.Errorf("保存文件失败: %v", err) + } + + glog.Info("合并图像完成") +} diff --git a/common/context.go b/common/context.go new file mode 100644 index 0000000..4794cc8 --- /dev/null +++ b/common/context.go @@ -0,0 +1,12 @@ +package common + +import "context" + +func Opened(_ctx context.Context) bool { + select { + case <-_ctx.Done(): + return false + default: + return true + } +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..080eeff --- /dev/null +++ b/go.mod @@ -0,0 +1,11 @@ +module ShotRDP + +go 1.23 + +require ( + github.com/huin/asn1ber v0.0.0-20120622192748-af09f62e6358 + github.com/icodeface/tls v0.0.0-20230910023335-34df9250cd12 + github.com/lunixbochs/struc v0.0.0-20241101090106-8d528fa2c543 + github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4 + golang.org/x/crypto v0.31.0 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..811b1e7 --- /dev/null +++ b/go.sum @@ -0,0 +1,10 @@ +github.com/huin/asn1ber v0.0.0-20120622192748-af09f62e6358 h1:hVXNJ57IHkOA8FBq80UG263MEBwNUMfS9c82J2QE5UQ= +github.com/huin/asn1ber v0.0.0-20120622192748-af09f62e6358/go.mod h1:qBE210J2T9uLXRB3GNc73SvZACDEFAmDCOlDkV47zbY= +github.com/icodeface/tls v0.0.0-20230910023335-34df9250cd12 h1:uSJXMFVNfN2hyXDLM19op2fNiCN/nL8xgdmNXgs5738= +github.com/icodeface/tls v0.0.0-20230910023335-34df9250cd12/go.mod h1:VJNHW2GxCtQP/IQtXykBIPBV8maPJ/dHWirVTwm9GwY= +github.com/lunixbochs/struc v0.0.0-20241101090106-8d528fa2c543 h1:GxMuVb9tJajC1QpbQwYNY1ZAo1EIE8I+UclBjOfjz/M= +github.com/lunixbochs/struc v0.0.0-20241101090106-8d528fa2c543/go.mod h1:vy1vK6wD6j7xX6O6hXe621WabdtNkou2h7uRtTfRMyg= +github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4 h1:udFKJ0aHUL60LboW/A+DfgoHVedieIzIXE8uylPue0U= +github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4/go.mod h1:qsXQc7+bwAM3Q1u/4XEfrquwF8Lw7D7y5cD8CuHnfIc= +golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U= +golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= diff --git a/grdp/core/io.go b/grdp/core/io.go new file mode 100644 index 0000000..fa6334e --- /dev/null +++ b/grdp/core/io.go @@ -0,0 +1,138 @@ +package core + +import ( + "encoding/binary" + "io" +) + +type ReadBytesComplete func(result []byte, err error) + +func StartReadBytes(len int, r io.Reader, cb ReadBytesComplete) { + b := make([]byte, len) + go func() { + _, err := io.ReadFull(r, b) + //glog.Debug("StartReadBytes Get", n, "Bytes:", hex.EncodeToString(b)) + cb(b, err) + }() +} + +func ReadBytes(len int, r io.Reader) ([]byte, error) { + b := make([]byte, len) + length, err := io.ReadFull(r, b) + return b[:length], err +} + +func ReadByte(r io.Reader) (byte, error) { + b, err := ReadBytes(1, r) + return b[0], err +} + +func ReadUInt8(r io.Reader) (uint8, error) { + b, err := ReadBytes(1, r) + return uint8(b[0]), err +} + +func ReadUint16LE(r io.Reader) (uint16, error) { + b := make([]byte, 2) + _, err := io.ReadFull(r, b) + if err != nil { + return 0, nil + } + return binary.LittleEndian.Uint16(b), nil +} + +func ReadUint16BE(r io.Reader) (uint16, error) { + b := make([]byte, 2) + _, err := io.ReadFull(r, b) + if err != nil { + return 0, nil + } + return binary.BigEndian.Uint16(b), nil +} + +func ReadUInt32LE(r io.Reader) (uint32, error) { + b := make([]byte, 4) + _, err := io.ReadFull(r, b) + if err != nil { + return 0, nil + } + return binary.LittleEndian.Uint32(b), nil +} + +func ReadUInt32BE(r io.Reader) (uint32, error) { + b := make([]byte, 4) + _, err := io.ReadFull(r, b) + if err != nil { + return 0, nil + } + return binary.BigEndian.Uint32(b), nil +} + +func WriteByte(data byte, w io.Writer) (int, error) { + b := make([]byte, 1) + b[0] = byte(data) + return w.Write(b) +} + +func WriteBytes(data []byte, w io.Writer) (int, error) { + return w.Write(data) +} + +func WriteUInt8(data uint8, w io.Writer) (int, error) { + b := make([]byte, 1) + b[0] = byte(data) + return w.Write(b) +} + +func WriteUInt16BE(data uint16, w io.Writer) (int, error) { + b := make([]byte, 2) + binary.BigEndian.PutUint16(b, data) + return w.Write(b) +} + +func WriteUInt16LE(data uint16, w io.Writer) (int, error) { + b := make([]byte, 2) + binary.LittleEndian.PutUint16(b, data) + return w.Write(b) +} + +func WriteUInt32LE(data uint32, w io.Writer) (int, error) { + b := make([]byte, 4) + binary.LittleEndian.PutUint32(b, data) + return w.Write(b) +} + +func WriteUInt32BE(data uint32, w io.Writer) (int, error) { + b := make([]byte, 4) + binary.BigEndian.PutUint32(b, data) + return w.Write(b) +} + +func PutUint16BE(data uint16) (uint8, uint8) { + b := make([]byte, 2) + binary.BigEndian.PutUint16(b, data) + return uint8(b[0]), uint8(b[1]) +} + +func Uint16BE(d0, d1 uint8) uint16 { + b := make([]byte, 2) + b[0] = d0 + b[1] = d1 + + return binary.BigEndian.Uint16(b) +} + +func RGB565ToRGB(data uint16) (r, g, b uint8) { + r = uint8(data & 0xF800 >> 8) + g = uint8(data & 0x07E0 >> 3) + b = uint8(data & 0x001F << 3) + + return +} +func RGB555ToRGB(data uint16) (r, g, b uint8) { + r = uint8(data & 0x7C00 >> 7) + g = uint8(data & 0x03E0 >> 2) + b = uint8(data & 0x001F << 3) + + return +} diff --git a/grdp/core/io_test.go b/grdp/core/io_test.go new file mode 100644 index 0000000..fc2731b --- /dev/null +++ b/grdp/core/io_test.go @@ -0,0 +1,17 @@ +package core + +import ( + "bytes" + "encoding/hex" + "testing" +) + +func TestWriteUInt16LE(t *testing.T) { + buff := &bytes.Buffer{} + WriteUInt32LE(66538, buff) + result := hex.EncodeToString(buff.Bytes()) + expected := "ea030100" + if result != expected { + t.Error(result, "not equals to", expected) + } +} diff --git a/grdp/core/rle.go b/grdp/core/rle.go new file mode 100644 index 0000000..67ffcc9 --- /dev/null +++ b/grdp/core/rle.go @@ -0,0 +1,865 @@ +package core + +import ( + "fmt" + "unsafe" +) + +func CVAL(p *[]uint8) int { + a := int((*p)[0]) + *p = (*p)[1:] + return a +} + +func CVAL2(p *[]uint8, v *uint16) { + *v = *((*uint16)(unsafe.Pointer(&(*p)[0]))) + *p = (*p)[2:] +} + +func CVAL3(p *[]uint8, v *[3]uint8) { + (*v)[0] = (*p)[0] + (*v)[1] = (*p)[1] + (*v)[2] = (*p)[2] + *p = (*p)[3:] +} + +func REPEAT(f func(), count *int, x *int, width int) { + for (*count & ^0x7) != 0 && ((*x + 8) < width) { + for i := 0; i < 8; i++ { + f() + *count = *count - 1 + *x = *x + 1 + } + } + + for (*count > 0) && (*x < width) { + f() + *count = *count - 1 + *x = *x + 1 + } +} + +/* 1 byte bitmap decompress */ +func decompress1(output *[]uint8, width, height int, input []uint8, size int) bool { + var ( + prevline, line, count int + offset, code int + x int = width + opcode int + lastopcode int8 = -1 + insertmix, bicolour, isfillormix bool + mixmask, mask uint8 + colour1, colour2 uint8 + mix uint8 = 0xff + fom_mask uint8 + ) + out := *output + for len(input) != 0 { + fom_mask = 0 + code = CVAL(&input) + opcode = code >> 4 + /* Handle different opcode forms */ + switch opcode { + case 0xc, 0xd, 0xe: + opcode -= 6 + count = int(code & 0xf) + offset = 16 + break + case 0xf: + opcode = code & 0xf + if opcode < 9 { + count = int(CVAL(&input)) + count |= int(CVAL(&input) << 8) + } else { + count = 1 + if opcode < 0xb { + count = 8 + } + } + offset = 0 + break + default: + opcode >>= 1 + count = int(code & 0x1f) + offset = 32 + break + } + /* Handle strange cases for counts */ + if offset != 0 { + isfillormix = ((opcode == 2) || (opcode == 7)) + if count == 0 { + if isfillormix { + count = int(CVAL(&input)) + 1 + } else { + count = int(CVAL(&input) + offset) + } + } else if isfillormix { + count <<= 3 + } + } + /* Read preliminary data */ + switch opcode { + case 0: /* Fill */ + if (lastopcode == int8(opcode)) && !((x == width) && (prevline == 0)) { + insertmix = true + } + break + case 8: /* Bicolour */ + colour1 = uint8(CVAL(&input)) + colour2 = uint8(CVAL(&input)) + break + case 3: /* Colour */ + colour2 = uint8(CVAL(&input)) + break + case 6: /* SetMix/Mix */ + fallthrough + case 7: /* SetMix/FillOrMix */ + mix = uint8(CVAL(&input)) + opcode -= 5 + break + case 9: /* FillOrMix_1 */ + mask = 0x03 + opcode = 0x02 + fom_mask = 3 + break + case 0x0a: /* FillOrMix_2 */ + mask = 0x05 + opcode = 0x02 + fom_mask = 5 + break + } + lastopcode = int8(opcode) + mixmask = 0 + /* Output body */ + for count > 0 { + if x >= width { + if height <= 0 { + return false + } + + x = 0 + height-- + prevline = line + line = height * width + } + switch opcode { + case 0: /* Fill */ + if insertmix { + if prevline == 0 { + out[x+line] = mix + } else { + out[x+line] = out[prevline+x] ^ mix + } + insertmix = false + count-- + x++ + } + if prevline == 0 { + REPEAT(func() { + out[x+line] = 0 + }, &count, &x, width) + } else { + REPEAT(func() { + out[x+line] = out[prevline+x] + }, &count, &x, width) + } + break + case 1: /* Mix */ + if prevline == 0 { + REPEAT(func() { + out[x+line] = mix + }, &count, &x, width) + } else { + REPEAT(func() { + out[x+line] = out[prevline+x] ^ mix + }, &count, &x, width) + } + break + case 2: /* Fill or Mix */ + if prevline == 0 { + REPEAT(func() { + mixmask <<= 1 + if mixmask == 0 { + mask = fom_mask + if fom_mask == 0 { + mask = uint8(CVAL(&input)) + mixmask = 1 + } + } + if mask&mixmask != 0 { + out[x+line] = mix + } else { + out[x+line] = 0 + } + }, &count, &x, width) + } else { + REPEAT(func() { + mixmask = mixmask << 1 + if mixmask == 0 { + mask = fom_mask + if fom_mask == 0 { + mask = uint8(CVAL(&input)) + mixmask = 1 + } + } + if mask&mixmask != 0 { + out[x+line] = out[prevline+x] ^ mix + } else { + out[x+line] = out[prevline+x] + } + }, &count, &x, width) + } + break + case 3: /* Colour */ + REPEAT(func() { + out[x+line] = colour2 + }, &count, &x, width) + break + case 4: /* Copy */ + REPEAT(func() { + out[x+line] = uint8(CVAL(&input)) + }, &count, &x, width) + break + case 8: /* Bicolour */ + REPEAT(func() { + if bicolour { + out[x+line] = colour2 + bicolour = false + } else { + out[x+line] = colour1 + bicolour = true + count++ + } + }, &count, &x, width) + + break + + case 0xd: /* White */ + REPEAT(func() { + out[x+line] = 0xff + }, &count, &x, width) + break + case 0xe: /* Black */ + REPEAT(func() { + out[x+line] = 0 + }, &count, &x, width) + break + default: + fmt.Printf("bitmap opcode 0x%x\n", opcode) + return false + } + } + } + return true +} + +/* 2 byte bitmap decompress */ +func decompress2(output *[]uint8, width, height int, input []uint8, size int) bool { + var ( + prevline, line, count int + offset, code int + x int = width + opcode int + lastopcode int = -1 + insertmix, bicolour, isfillormix bool + mixmask, mask uint8 + colour1, colour2 uint16 + mix uint16 = 0xffff + fom_mask uint8 + ) + + out := make([]uint16, width*height) + for len(input) != 0 { + fom_mask = 0 + code = CVAL(&input) + opcode = code >> 4 + /* Handle different opcode forms */ + switch opcode { + case 0xc, 0xd, 0xe: + opcode -= 6 + count = code & 0xf + offset = 16 + break + case 0xf: + opcode = code & 0xf + if opcode < 9 { + count = CVAL(&input) + count |= CVAL(&input) << 8 + } else { + count = 1 + if opcode < 0xb { + count = 8 + } + } + offset = 0 + break + default: + opcode >>= 1 + count = code & 0x1f + offset = 32 + break + } + + /* Handle strange cases for counts */ + if offset != 0 { + isfillormix = ((opcode == 2) || (opcode == 7)) + if count == 0 { + if isfillormix { + count = CVAL(&input) + 1 + } else { + count = CVAL(&input) + offset + } + } else if isfillormix { + count <<= 3 + } + } + /* Read preliminary data */ + switch opcode { + case 0: /* Fill */ + if (lastopcode == opcode) && !((x == width) && (prevline == 0)) { + insertmix = true + } + break + case 8: /* Bicolour */ + CVAL2(&input, &colour1) + CVAL2(&input, &colour2) + break + case 3: /* Colour */ + CVAL2(&input, &colour2) + break + case 6: /* SetMix/Mix */ + fallthrough + case 7: /* SetMix/FillOrMix */ + CVAL2(&input, &mix) + opcode -= 5 + break + case 9: /* FillOrMix_1 */ + mask = 0x03 + opcode = 0x02 + fom_mask = 3 + break + case 0x0a: /* FillOrMix_2 */ + mask = 0x05 + opcode = 0x02 + fom_mask = 5 + break + } + lastopcode = opcode + mixmask = 0 + /* Output body */ + for count > 0 { + if x >= width { + if height <= 0 { + return false + } + + x = 0 + height-- + prevline = line + line = height * width + } + switch opcode { + case 0: /* Fill */ + if insertmix { + if prevline == 0 { + out[x+line] = mix + } else { + out[x+line] = out[prevline+x] ^ mix + } + insertmix = false + count-- + x++ + } + if prevline == 0 { + REPEAT(func() { + out[x+line] = 0 + }, &count, &x, width) + } else { + REPEAT(func() { + out[x+line] = out[prevline+x] + }, &count, &x, width) + } + break + case 1: /* Mix */ + if prevline == 0 { + REPEAT(func() { + out[x+line] = mix + }, &count, &x, width) + } else { + REPEAT(func() { + out[x+line] = out[prevline+x] ^ mix + }, &count, &x, width) + } + break + case 2: /* Fill or Mix */ + if prevline == 0 { + REPEAT(func() { + mixmask <<= 1 + if mixmask == 0 { + mask = fom_mask + if fom_mask == 0 { + mask = uint8(CVAL(&input)) + mixmask = 1 + } + } + if mask&mixmask != 0 { + out[x+line] = mix + } else { + out[x+line] = 0 + } + }, &count, &x, width) + } else { + REPEAT(func() { + mixmask = mixmask << 1 + if mixmask == 0 { + mask = fom_mask + if fom_mask == 0 { + mask = uint8(CVAL(&input)) + mixmask = 1 + } + } + if mask&mixmask != 0 { + out[x+line] = out[prevline+x] ^ mix + } else { + out[x+line] = out[prevline+x] + } + }, &count, &x, width) + } + break + case 3: /* Colour */ + REPEAT(func() { + out[x+line] = colour2 + }, &count, &x, width) + break + case 4: /* Copy */ + REPEAT(func() { + var a uint16 + CVAL2(&input, &a) + out[x+line] = a + }, &count, &x, width) + + break + case 8: /* Bicolour */ + REPEAT(func() { + if bicolour { + out[x+line] = colour2 + bicolour = false + } else { + out[x+line] = colour1 + bicolour = true + count++ + } + }, &count, &x, width) + + break + case 0xd: /* White */ + REPEAT(func() { + out[x+line] = 0xffff + }, &count, &x, width) + break + case 0xe: /* Black */ + REPEAT(func() { + out[x+line] = 0 + }, &count, &x, width) + break + default: + fmt.Printf("bitmap opcode 0x%x\n", opcode) + return false + } + } + } + j := 0 + for _, v := range out { + (*output)[j], (*output)[j+1] = PutUint16BE(v) + j += 2 + } + return true +} + +// /* 3 byte bitmap decompress */ +func decompress3(output *[]uint8, width, height int, input []uint8, size int) bool { + var ( + prevline, line, count int + opcode, offset, code int + x int = width + lastopcode int = -1 + insertmix, bicolour, isfillormix bool + mixmask, mask uint8 + colour1 = [3]uint8{0, 0, 0} + colour2 = [3]uint8{0, 0, 0} + mix = [3]uint8{0xff, 0xff, 0xff} + fom_mask uint8 + ) + out := *output + for len(input) != 0 { + fom_mask = 0 + code = CVAL(&input) + opcode = code >> 4 + /* Handle different opcode forms */ + switch opcode { + case 0xc, 0xd, 0xe: + opcode -= 6 + count = code & 0xf + offset = 16 + break + case 0xf: + opcode = code & 0xf + if opcode < 9 { + count = CVAL(&input) + count |= CVAL(&input) << 8 + } else { + count = 1 + if opcode < 0xb { + count = 8 + } + } + offset = 0 + break + default: + opcode >>= 1 + count = code & 0x1f + offset = 32 + break + } + + /* Handle strange cases for counts */ + if offset != 0 { + isfillormix = ((opcode == 2) || (opcode == 7)) + if count == 0 { + if isfillormix { + count = CVAL(&input) + 1 + } else { + count = CVAL(&input) + offset + } + } else if isfillormix { + count <<= 3 + } + } + /* Read preliminary data */ + switch opcode { + case 0: /* Fill */ + if (lastopcode == opcode) && !((x == width) && (prevline == 0)) { + insertmix = true + } + break + case 8: /* Bicolour */ + CVAL3(&input, &colour1) + CVAL3(&input, &colour2) + break + case 3: /* Colour */ + CVAL3(&input, &colour2) + break + case 6: /* SetMix/Mix */ + fallthrough + case 7: /* SetMix/FillOrMix */ + CVAL3(&input, &mix) + opcode -= 5 + break + case 9: /* FillOrMix_1 */ + mask = 0x03 + opcode = 0x02 + fom_mask = 3 + break + case 0x0a: /* FillOrMix_2 */ + mask = 0x05 + opcode = 0x02 + fom_mask = 5 + break + } + + lastopcode = opcode + mixmask = 0 + /* Output body */ + for count > 0 { + if x >= width { + if height <= 0 { + return false + } + + x = 0 + height-- + prevline = line + line = height * width * 3 + } + switch opcode { + case 0: /* Fill */ + if insertmix { + if prevline == 0 { + out[3*x+line] = mix[0] + out[3*x+line+1] = mix[1] + out[3*x+line+2] = mix[2] + } else { + out[3*x+line] = out[prevline+3*x] ^ mix[0] + out[3*x+line+1] = out[prevline+3*x+1] ^ mix[1] + out[3*x+line+2] = out[prevline+3*x+2] ^ mix[2] + } + insertmix = false + count-- + x++ + } + if prevline == 0 { + REPEAT(func() { + out[3*x+line] = 0 + out[3*x+line+1] = 0 + out[3*x+line+2] = 0 + }, &count, &x, width) + } else { + REPEAT(func() { + out[3*x+line] = out[prevline+3*x] + out[3*x+line+1] = out[prevline+3*x+1] + out[3*x+line+2] = out[prevline+3*x+2] + }, &count, &x, width) + } + break + case 1: /* Mix */ + if prevline == 0 { + REPEAT(func() { + out[3*x+line] = mix[0] + out[3*x+line+1] = mix[1] + out[3*x+line+2] = mix[2] + }, &count, &x, width) + } else { + REPEAT(func() { + out[3*x+line] = out[prevline+3*x] ^ mix[0] + out[3*x+line+1] = out[prevline+3*x+1] ^ mix[1] + out[3*x+line+2] = out[prevline+3*x+2] ^ mix[2] + }, &count, &x, width) + } + break + case 2: /* Fill or Mix */ + if prevline == 0 { + REPEAT(func() { + mixmask = mixmask << 1 + if mixmask == 0 { + mask = fom_mask + if fom_mask == 0 { + mask = uint8(CVAL(&input)) + mixmask = 1 + } + } + if mask&mixmask != 0 { + out[3*x+line] = mix[0] + out[3*x+line+1] = mix[1] + out[3*x+line+2] = mix[2] + } else { + out[3*x+line] = 0 + out[3*x+line+1] = 0 + out[3*x+line+2] = 0 + } + }, &count, &x, width) + } else { + REPEAT(func() { + mixmask = mixmask << 1 + if mixmask == 0 { + mask = fom_mask + if fom_mask == 0 { + mask = uint8(CVAL(&input)) + mixmask = 1 + } + } + if mask&mixmask != 0 { + out[3*x+line] = out[prevline+3*x] ^ mix[0] + out[3*x+line+1] = out[prevline+3*x+1] ^ mix[1] + out[3*x+line+2] = out[prevline+3*x+2] ^ mix[2] + } else { + out[3*x+line] = out[prevline+3*x] + out[3*x+line+1] = out[prevline+3*x+1] + out[3*x+line+2] = out[prevline+3*x+2] + } + }, &count, &x, width) + } + break + case 3: /* Colour */ + REPEAT(func() { + out[3*x+line] = colour2[0] + out[3*x+line+1] = colour2[1] + out[3*x+line+2] = colour2[2] + + }, &count, &x, width) + break + case 4: /* Copy */ + REPEAT(func() { + out[3*x+line] = uint8(CVAL(&input)) + out[3*x+line+1] = uint8(CVAL(&input)) + out[3*x+line+2] = uint8(CVAL(&input)) + }, &count, &x, width) + break + case 8: /* Bicolour */ + REPEAT(func() { + if bicolour { + out[3*x+line] = colour2[0] + out[3*x+line+1] = colour2[1] + out[3*x+line+2] = colour2[2] + bicolour = false + } else { + out[3*x+line] = colour1[0] + out[3*x+line+1] = colour1[1] + out[3*x+line+2] = colour1[2] + bicolour = true + count++ + } + }, &count, &x, width) + break + case 0xd: /* White */ + REPEAT(func() { + out[3*x+line] = 0xff + out[3*x+line+1] = 0xff + out[3*x+line+2] = 0xff + + }, &count, &x, width) + break + case 0xe: /* Black */ + REPEAT(func() { + out[3*x+line] = 0 + out[3*x+line+1] = 0 + out[3*x+line+2] = 0 + }, &count, &x, width) + break + default: + fmt.Printf("bitmap opcode 0x%x\n", opcode) + return false + } + } + } + + return true +} + +/* decompress a colour plane */ +func processPlane(in *[]uint8, width, height int, output *[]uint8, j int) int { + var ( + indexw int + indexh int + code int + collen int + replen int + color uint8 + x uint8 + revcode int + lastline int + thisline int + ) + ln := len(*in) + + lastline = 0 + indexh = 0 + i := 0 + for indexh < height { + thisline = j + (width * height * 4) - ((indexh + 1) * width * 4) + color = 0 + indexw = 0 + i = thisline + + if lastline == 0 { + for indexw < width { + code = CVAL(in) + replen = int(code & 0xf) + collen = int((code >> 4) & 0xf) + revcode = (replen << 4) | collen + if (revcode <= 47) && (revcode >= 16) { + replen = revcode + collen = 0 + } + for collen > 0 { + color = uint8(CVAL(in)) + (*output)[i] = uint8(color) + i += 4 + + indexw++ + collen-- + } + for replen > 0 { + (*output)[i] = uint8(color) + i += 4 + indexw++ + replen-- + } + } + } else { + for indexw < width { + code = CVAL(in) + replen = int(code & 0xf) + collen = int((code >> 4) & 0xf) + revcode = (replen << 4) | collen + if (revcode <= 47) && (revcode >= 16) { + replen = revcode + collen = 0 + } + for collen > 0 { + x = uint8(CVAL(in)) + if x&1 != 0 { + x = x >> 1 + x = x + 1 + color = -x + } else { + x = x >> 1 + color = x + } + x = (*output)[indexw*4+lastline] + color + (*output)[i] = uint8(x) + i += 4 + indexw++ + collen-- + } + for replen > 0 { + x = (*output)[indexw*4+lastline] + color + (*output)[i] = uint8(x) + i += 4 + indexw++ + replen-- + } + } + } + indexh++ + lastline = thisline + } + return ln - len(*in) +} + +/* 4 byte bitmap decompress */ +func decompress4(output *[]uint8, width, height int, input []uint8, size int) bool { + var ( + code int + onceBytes, total int + ) + + code = CVAL(&input) + if code != 0x10 { + return false + } + + total = 1 + onceBytes = processPlane(&input, width, height, output, 3) + total += onceBytes + + onceBytes = processPlane(&input, width, height, output, 2) + total += onceBytes + + onceBytes = processPlane(&input, width, height, output, 1) + total += onceBytes + + onceBytes = processPlane(&input, width, height, output, 0) + total += onceBytes + + return size == total +} + +/* main decompress function */ +func Decompress(input []uint8, width, height int, Bpp int) []uint8 { + size := width * height * Bpp + output := make([]uint8, size) + switch Bpp { + case 1: + decompress1(&output, width, height, input, size) + case 2: + decompress2(&output, width, height, input, size) + case 3: + decompress3(&output, width, height, input, size) + case 4: + decompress4(&output, width, height, input, size) + default: + fmt.Printf("Bpp %d\n", Bpp) + } + + return output +} diff --git a/grdp/core/rle_test.go b/grdp/core/rle_test.go new file mode 100644 index 0000000..329d817 --- /dev/null +++ b/grdp/core/rle_test.go @@ -0,0 +1,15 @@ +// rle_test.go +package core + +import ( + "fmt" + "testing" +) + +func TestSum(t *testing.T) { + input := []byte{ + 192, 44, 200, 8, 132, 200, 8, 200, 8, 200, 8, 200, 8, 0, 19, 132, 232, 8, 12, 50, 142, 66, 77, 58, 208, 59, 225, 25, 1, 0, 0, 0, 0, 0, 0, 0, 132, 139, 33, 142, 66, 142, 66, 142, 66, 208, 59, 4, 43, 1, 0, 0, 0, 0, 0, 0, 0, 132, 203, 41, 142, 66, 142, 66, 142, 66, 208, 59, 96, 0, 1, 0, 0, 0, 0, 0, 0, 0, 132, 9, 17, 142, 66, 142, 66, 142, 66, 208, 59, 230, 27, 1, 0, 0, 0, 0, 0, 0, 0, 132, 200, 8, 9, 17, 139, 33, 74, 25, 243, 133, 14, 200, 8, 132, 200, 8, 200, 8, 200, 8, 200, 8, + } + out := Decompress(input, 64, 64, 3) + fmt.Println(out) +} diff --git a/grdp/core/socket.go b/grdp/core/socket.go new file mode 100644 index 0000000..875a5ec --- /dev/null +++ b/grdp/core/socket.go @@ -0,0 +1,74 @@ +package core + +import ( + "crypto/rsa" + "math/big" + + "github.com/huin/asn1ber" + + //"crypto/tls" + "errors" + "net" + "github.com/icodeface/tls" +) + +type SocketLayer struct { + conn net.Conn + tlsConn *tls.Conn +} + +func NewSocketLayer(conn net.Conn) *SocketLayer { + l := &SocketLayer{ + conn: conn, + tlsConn: nil, + } + return l +} + +func (s *SocketLayer) Read(b []byte) (n int, err error) { + if s.tlsConn != nil { + return s.tlsConn.Read(b) + } + return s.conn.Read(b) +} + +func (s *SocketLayer) Write(b []byte) (n int, err error) { + if s.tlsConn != nil { + return s.tlsConn.Write(b) + } + return s.conn.Write(b) +} + +func (s *SocketLayer) Close() error { + if s.tlsConn != nil { + err := s.tlsConn.Close() + if err != nil { + return err + } + } + return s.conn.Close() +} + +func (s *SocketLayer) StartTLS() error { + config := &tls.Config{ + InsecureSkipVerify: true, + MinVersion: tls.VersionTLS10, + MaxVersion: tls.VersionTLS13, + PreferServerCipherSuites: true, + } + s.tlsConn = tls.Client(s.conn, config) + return s.tlsConn.Handshake() +} + +type PublicKey struct { + N *big.Int `asn1:"explicit,tag:0"` // modulus + E int `asn1:"explicit,tag:1"` // public exponent +} + +func (s *SocketLayer) TlsPubKey() ([]byte, error) { + if s.tlsConn == nil { + return nil, errors.New("TLS conn does not exist") + } + pub := s.tlsConn.ConnectionState().PeerCertificates[0].PublicKey.(*rsa.PublicKey) + return asn1ber.Marshal(*pub) +} diff --git a/grdp/core/types.go b/grdp/core/types.go new file mode 100644 index 0000000..7369c03 --- /dev/null +++ b/grdp/core/types.go @@ -0,0 +1,25 @@ +package core + +import "ShotRDP/grdp/emission" + +type Transport interface { + Read(b []byte) (n int, err error) + Write(b []byte) (n int, err error) + Close() error + + On(event, listener interface{}) *emission.Emitter + Once(event, listener interface{}) *emission.Emitter + Emit(event interface{}, arguments ...interface{}) *emission.Emitter +} + +type FastPathListener interface { + RecvFastPath(secFlag byte, s []byte) +} + +type FastPathSender interface { + SendFastPath(secFlag byte, s []byte) (int, error) +} + +type ChannelSender interface { + SendToChannel(channel string, s []byte) (int, error) +} diff --git a/grdp/core/util.go b/grdp/core/util.go new file mode 100644 index 0000000..a74cb4f --- /dev/null +++ b/grdp/core/util.go @@ -0,0 +1,67 @@ +package core + +import ( + "bytes" + "crypto/rand" + "encoding/binary" + "unicode/utf16" +) + +func Reverse(s []byte) []byte { + for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 { + s[i], s[j] = s[j], s[i] + } + return s +} + +func Random(n int) []byte { + const alpha = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + var bytes = make([]byte, n) + rand.Read(bytes) + for i, b := range bytes { + bytes[i] = alpha[b%byte(len(alpha))] + } + return bytes +} + +func UTF16ToLittleEndianBytes(u []uint16) []byte { + b := make([]byte, 2*len(u)) + for index, value := range u { + binary.LittleEndian.PutUint16(b[index*2:], value) + } + return b +} + +func LittleEndianBytesToUTF16(u []byte) []uint16 { + b := make([]uint16, 0, len(u)/2) + n := make([]byte, 2) + for i, v := range u { + if i%2 == 0 { + n[0] = v + } else { + n[1] = v + b = append(b, binary.LittleEndian.Uint16(n)) + } + } + return b +} + +// s.encode('utf-16le') +func UnicodeEncode(p string) []byte { + return UTF16ToLittleEndianBytes(utf16.Encode([]rune(p))) +} + +func UnicodeDecode(p []byte) string { + r := bytes.NewReader(p) + n := make([]uint16, 0, 100) + for r.Len() > 0 { + a, _ := ReadUint16LE(r) + n = append(n, a) + } + //n := LittleEndianBytesToUTF16(p) + return string(utf16.Decode(n)) +} + +func BytesToUint64(b []byte) uint64 { + return binary.LittleEndian.Uint64(b) +} diff --git a/grdp/emission/emitter.go b/grdp/emission/emitter.go new file mode 100644 index 0000000..0434fde --- /dev/null +++ b/grdp/emission/emitter.go @@ -0,0 +1,273 @@ +// Package emission provides an event emitter. +// copy form https://raw.githubusercontent.com/chuckpreslar/emission/master/emitter.go +// fix issue with nest once + +package emission + +import ( + "errors" + "fmt" + "os" + "reflect" + "sync" +) + +// Default number of maximum listeners for an event. +const DefaultMaxListeners = 10 + +// Error presented when an invalid argument is provided as a listener function +var ErrNoneFunction = errors.New("Kind of Value for listener is not Func.") + +// RecoveryListener ... +type RecoveryListener func(interface{}, interface{}, error) + +// Emitter ... +type Emitter struct { + // Mutex to prevent race conditions within the Emitter. + *sync.Mutex + // Map of event to a slice of listener function's reflect Values. + events map[interface{}][]reflect.Value + // Optional RecoveryListener to call when a panic occurs. + recoverer RecoveryListener + // Maximum listeners for debugging potential memory leaks. + maxListeners int + + // Map of event to a slice of listener function's reflect Values. + onces map[interface{}][]reflect.Value +} + +// AddListener appends the listener argument to the event arguments slice +// in the Emitter's events map. If the number of listeners for an event +// is greater than the Emitter's maximum listeners then a warning is printed. +// If the relect Value of the listener does not have a Kind of Func then +// AddListener panics. If a RecoveryListener has been set then it is called +// recovering from the panic. +func (emitter *Emitter) AddListener(event, listener interface{}) *Emitter { + emitter.Lock() + defer emitter.Unlock() + + fn := reflect.ValueOf(listener) + + if reflect.Func != fn.Kind() { + if nil == emitter.recoverer { + panic(ErrNoneFunction) + } else { + emitter.recoverer(event, listener, ErrNoneFunction) + } + } + + if emitter.maxListeners != -1 && emitter.maxListeners < len(emitter.events[event])+1 { + fmt.Fprintf(os.Stdout, "Warning: event `%v` has exceeded the maximum "+ + "number of listeners of %d.\n", event, emitter.maxListeners) + } + + emitter.events[event] = append(emitter.events[event], fn) + + return emitter +} + +// On is an alias for AddListener. +func (emitter *Emitter) On(event, listener interface{}) *Emitter { + return emitter.AddListener(event, listener) +} + +// RemoveListener removes the listener argument from the event arguments slice +// in the Emitter's events map. If the reflect Value of the listener does not +// have a Kind of Func then RemoveListener panics. If a RecoveryListener has +// been set then it is called after recovering from the panic. +func (emitter *Emitter) RemoveListener(event, listener interface{}) *Emitter { + emitter.Lock() + defer emitter.Unlock() + + fn := reflect.ValueOf(listener) + + if reflect.Func != fn.Kind() { + if nil == emitter.recoverer { + panic(ErrNoneFunction) + } else { + emitter.recoverer(event, listener, ErrNoneFunction) + } + } + + if events, ok := emitter.events[event]; ok { + newEvents := []reflect.Value{} + + for _, listener := range events { + if fn.Pointer() != listener.Pointer() { + newEvents = append(newEvents, listener) + } + } + + emitter.events[event] = newEvents + } + + if events, ok := emitter.onces[event]; ok { + newEvents := []reflect.Value{} + + for _, listener := range events { + if fn.Pointer() != listener.Pointer() { + newEvents = append(newEvents, listener) + } + } + + emitter.onces[event] = newEvents + } + + return emitter +} + +// Off is an alias for RemoveListener. +func (emitter *Emitter) Off(event, listener interface{}) *Emitter { + return emitter.RemoveListener(event, listener) +} + +// Once generates a new function which invokes the supplied listener +// only once before removing itself from the event's listener slice +// in the Emitter's events map. If the reflect Value of the listener +// does not have a Kind of Func then Once panics. If a RecoveryListener +// has been set then it is called after recovering from the panic. +func (emitter *Emitter) Once(event, listener interface{}) *Emitter { + emitter.Lock() + defer emitter.Unlock() + + fn := reflect.ValueOf(listener) + + if reflect.Func != fn.Kind() { + if nil == emitter.recoverer { + panic(ErrNoneFunction) + } else { + emitter.recoverer(event, listener, ErrNoneFunction) + } + } + + if emitter.maxListeners != -1 && emitter.maxListeners < len(emitter.onces[event])+1 { + fmt.Fprintf(os.Stdout, "Warning: event `%v` has exceeded the maximum "+ + "number of listeners of %d.\n", event, emitter.maxListeners) + } + + emitter.onces[event] = append(emitter.onces[event], fn) + return emitter +} + +// Emit attempts to use the reflect package to Call each listener stored +// in the Emitter's events map with the supplied arguments. Each listener +// is called within its own go routine. The reflect package will panic if +// the agruments supplied do not align the parameters of a listener function. +// If a RecoveryListener has been set then it is called after recovering from +// the panic. +func (emitter *Emitter) Emit(event interface{}, arguments ...interface{}) *Emitter { + var ( + listeners []reflect.Value + ok bool + ) + + // Lock the mutex when reading from the Emitter's + // events map. + emitter.Lock() + + if listeners, ok = emitter.events[event]; !ok { + // If the Emitter does not include the event in its + // event map, it has no listeners to Call yet. + emitter.Unlock() + goto ONCES + } + + // Unlock the mutex immediately following the read + // instead of deferring so that listeners registered + // with Once can aquire the mutex for removal. + emitter.Unlock() + emitter.callListeners(listeners, event, arguments...) + +ONCES: + // execute onces + emitter.Lock() + if listeners, ok = emitter.onces[event]; !ok { + emitter.Unlock() + return emitter + } + emitter.Unlock() + emitter.callListeners(listeners, event, arguments...) + // clear executed listeners + emitter.onces[event] = emitter.onces[event][len(listeners):] + return emitter +} + +func (emitter *Emitter) callListeners(listeners []reflect.Value, event interface{}, arguments ...interface{}) { + var wg sync.WaitGroup + + wg.Add(len(listeners)) + + for _, fn := range listeners { + go func(fn reflect.Value) { + defer wg.Done() + + // Recover from potential panics, supplying them to a + // RecoveryListener if one has been set, else allowing + // the panic to occur. + if nil != emitter.recoverer { + defer func() { + if r := recover(); nil != r { + err := fmt.Errorf("%v", r) + emitter.recoverer(event, fn.Interface(), err) + } + }() + } + + var values []reflect.Value + + for i := 0; i < len(arguments); i++ { + if arguments[i] == nil { + values = append(values, reflect.New(fn.Type().In(i)).Elem()) + } else { + values = append(values, reflect.ValueOf(arguments[i])) + } + } + + fn.Call(values) + }(fn) + } + + wg.Wait() +} + +// RecoverWith sets the listener to call when a panic occurs, recovering from +// panics and attempting to keep the application from crashing. +func (emitter *Emitter) RecoverWith(listener RecoveryListener) *Emitter { + emitter.recoverer = listener + return emitter +} + +// SetMaxListeners sets the maximum number of listeners per +// event for the Emitter. If -1 is passed as the maximum, +// all events may have unlimited listeners. By default, each +// event can have a maximum number of 10 listeners which is +// useful for finding memory leaks. +func (emitter *Emitter) SetMaxListeners(max int) *Emitter { + emitter.Lock() + defer emitter.Unlock() + + emitter.maxListeners = max + return emitter +} + +// GetListenerCount gets count of listeners for a given event. +func (emitter *Emitter) GetListenerCount(event interface{}) (count int) { + emitter.Lock() + if listeners, ok := emitter.events[event]; ok { + count = len(listeners) + } + emitter.Unlock() + return +} + +// NewEmitter returns a new Emitter object, defaulting the +// number of maximum listeners per event to the DefaultMaxListeners +// constant and initializing its events map. +func NewEmitter() (emitter *Emitter) { + emitter = new(Emitter) + emitter.Mutex = new(sync.Mutex) + emitter.events = make(map[interface{}][]reflect.Value) + emitter.maxListeners = DefaultMaxListeners + emitter.onces = make(map[interface{}][]reflect.Value) + return +} diff --git a/grdp/glog/log.go b/grdp/glog/log.go new file mode 100644 index 0000000..82021e8 --- /dev/null +++ b/grdp/glog/log.go @@ -0,0 +1,129 @@ +package glog + +import ( + "fmt" + "log" + "sync" +) + +var ( + logger *log.Logger + level LEVEL + mu sync.Mutex +) + +type LEVEL int + +const ( + TRACE LEVEL = iota + DEBUG + INFO + WARN + ERROR + NONE +) + +func SetLogger(l *log.Logger) { + l.SetFlags(log.Ldate | log.Ltime | log.Lshortfile) + logger = l +} + +func SetLevel(l LEVEL) { + level = l +} + +func checkLogger() { + if logger == nil && level != NONE { + panic("logger not inited") + } +} +func Trace(v ...interface{}) { + checkLogger() + if level <= TRACE { + mu.Lock() + defer mu.Unlock() + logger.SetPrefix("[TRACE]") + logger.Output(2, fmt.Sprintln(v...)) + } +} +func Tracef(f string, v ...interface{}) { + checkLogger() + if level <= TRACE { + mu.Lock() + defer mu.Unlock() + logger.SetPrefix("[TRACE]") + logger.Output(2, fmt.Sprintln(fmt.Sprintf(f, v...))) + } +} +func Debug(v ...interface{}) { + checkLogger() + if level <= DEBUG { + mu.Lock() + defer mu.Unlock() + logger.SetPrefix("[DEBUG]") + logger.Output(2, fmt.Sprintln(v...)) + } +} +func Debugf(f string, v ...interface{}) { + checkLogger() + if level <= DEBUG { + mu.Lock() + defer mu.Unlock() + logger.SetPrefix("[DEBUG]") + logger.Output(2, fmt.Sprintln(fmt.Sprintf(f, v...))) + } +} +func Info(v ...interface{}) { + checkLogger() + if level <= INFO { + mu.Lock() + defer mu.Unlock() + logger.SetPrefix("[INFO]") + logger.Output(2, fmt.Sprintln(v...)) + } +} +func Infof(f string, v ...interface{}) { + checkLogger() + if level <= INFO { + mu.Lock() + defer mu.Unlock() + logger.SetPrefix("[INFO]") + logger.Output(2, fmt.Sprintln(fmt.Sprintf(f, v...))) + } +} +func Warn(v ...interface{}) { + checkLogger() + if level <= WARN { + mu.Lock() + defer mu.Unlock() + logger.SetPrefix("[WARN]") + logger.Output(2, fmt.Sprintln(v...)) + } +} +func Warnf(f string, v ...interface{}) { + checkLogger() + if level <= WARN { + mu.Lock() + defer mu.Unlock() + logger.SetPrefix("[WARN]") + logger.Output(2, fmt.Sprintln(fmt.Sprintf(f, v...))) + } +} +func Error(v ...interface{}) { + checkLogger() + if level <= ERROR { + mu.Lock() + defer mu.Unlock() + logger.SetPrefix("[ERROR]") + logger.Output(2, fmt.Sprintln(v...)) + } +} +func Errorf(f string, v ...interface{}) { + checkLogger() + if level <= ERROR { + mu.Lock() + defer mu.Unlock() + logger.SetPrefix("[ERROR]") + logger.Output(2, fmt.Sprintln(fmt.Sprintf(f, v...))) + } +} diff --git a/grdp/plugin/addins.go b/grdp/plugin/addins.go new file mode 100644 index 0000000..21538eb --- /dev/null +++ b/grdp/plugin/addins.go @@ -0,0 +1,328 @@ +// +build ignore + +// addins.go +package plugin + +import ( + "strings" + "sync/atomic" + "syscall" + "unsafe" +) + +var ( + openHandleSeq uint32 + freerdpClient2 = syscall.NewLazyDLL("freerdp-client2.dll") + winpr2 = syscall.NewLazyDLL("winpr2.dll") + freerdp2 = syscall.NewLazyDLL("freerdp2.dll") +) + +var ( + virtualChannelEntry = freerdpClient2.NewProc("VirtualChannelEntry") + virtualChannelEntryEx = freerdpClient2.NewProc("VirtualChannelEntryEx") +) + +func VirtualChannelEntryEx(ex *ChannelEntryPointsEx, pInitHandle interface{}) (err error) { + r0, _, ec := virtualChannelEntryEx.Call(uintptr(unsafe.Pointer(ex)), + uintptr(unsafe.Pointer(&pInitHandle))) + if r0 == 0 { + err = error(ec) + } + return +} + +func ChannelsClientLoadEx(cs *rdpChannels) { + var client ChannelClientData + client.entryEx = VIRTUALCHANNELENTRYEX(VirtualChannelEntryEx) + cs.clientDataList = append(cs.clientDataList, client) + cs.clientDataCount++ + + var init ChannelInitData + init.channels = cs + init.openDataMap = make(map[uint32]*ChannelOpenData) + cs.initDataList = append(cs.initDataList, init) + cs.initDataCount++ + + ex := NewChannelEntryPointsEx() + ex.PVirtualChannelInitEx = VIRTUALCHANNELINITEX(RdpVirtualChannelInitEx) + ex.PVirtualChannelOpenEx = VIRTUALCHANNELOPENEX(RdpVirtualChannelOpenEx) + ex.PVirtualChannelCloseEx = VIRTUALCHANNELCLOSEEX(RdpVirtualChannelCloseEx) + ex.PVirtualChannelWriteEx = VIRTUALCHANNELWRITEEX(RdpVirtualChannelWriteEx) + client.entryEx(ex, uintptr(unsafe.Pointer(&init))) +} + +type ChannelClientData struct { + //PVIRTUALCHANNELENTRY entry; + entryEx VIRTUALCHANNELENTRYEX + // pChannelInitEventProc *CHANNEL_INIT_EVENT_FN + pChannelInitEventProcEx CHANNEL_INIT_EVENT_EX_FN + pInitHandle interface{} + lpUserParam interface{} +} +type ChannelOpenData struct { + name string + OpenHandle uint32 + options uint32 + flags int + pInterface interface{} + channels *rdpChannels + lpUserParam interface{} + //pChannelOpenEventProc *CHANNEL_OPEN_EVENT_FN + pChannelOpenEventProcEx *CHANNEL_OPEN_EVENT_EX_FN +} +type ChannelInitData struct { + channels *rdpChannels + pInterface interface{} + openDataMap map[uint32]*ChannelOpenData +} +type rdpChannels struct { + clientDataCount int + clientDataList []ChannelClientData + + openDataCount int + openDataList []ChannelOpenData + + initDataCount int + initDataList []ChannelInitData + + /* control for entry into MyVirtualChannelInit */ + can_call_init bool + + /* true once freerdp_channels_post_connect is called */ + connected bool + + /* used for locating the channels for a given instance */ + //freerdp* instance; + + //wMessageQueue* queue; + + //DrdynvcClientContext* drdynvc; + //CRITICAL_SECTION channelsLock; +} +type ChannelOpenEvent struct { + Data interface{} + DataLength uint32 + UserData interface{} + pChannelOpenData *ChannelOpenData +} + +func RdpVirtualChannelInitEx(lpUserParam interface{}, clientContext interface{}, + pInitHandle interface{}, pChannel []ChannelDef, + channelCount int, versionRequested uint32, + pChannelInitEventProcEx CHANNEL_INIT_EVENT_EX_FN) uint { + var ( + //rdpSettings* settings; + pChannelInitData *ChannelInitData + pChannelClientData *ChannelClientData + channels *rdpChannels + ) + + if pInitHandle == nil { + return CHANNEL_RC_BAD_INIT_HANDLE + } + + if pChannel == nil { + return CHANNEL_RC_BAD_CHANNEL + } + + if (channelCount <= 0) || pChannelInitEventProcEx == nil { + return CHANNEL_RC_INITIALIZATION_ERROR + } + + pChannelInitData = pInitHandle.(*ChannelInitData) + //WINPR_ASSERT(pChannelInitData); + + channels = pChannelInitData.channels + //WINPR_ASSERT(channels); + + if !channels.can_call_init { + return CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY + } + + if (channels.openDataCount + channelCount) > 30 { + return CHANNEL_RC_TOO_MANY_CHANNELS + } + + if channels.connected { + return CHANNEL_RC_ALREADY_CONNECTED + } + + if versionRequested != VIRTUAL_CHANNEL_VERSION_WIN2000 { + } + + for i := range pChannel { + pChannelDef := &pChannel[i] + if getChannelOpenDataByName(channels, pChannelDef.Name) == nil { + return CHANNEL_RC_BAD_CHANNEL + } + } + + pChannelClientData = &channels.clientDataList[channels.clientDataCount] + pChannelClientData.pChannelInitEventProcEx = pChannelInitEventProcEx + pChannelClientData.pInitHandle = pInitHandle + pChannelClientData.lpUserParam = lpUserParam + channels.clientDataCount++ + + //WINPR_ASSERT(channels->instance); + //WINPR_ASSERT(channels->instance->context); + //settings = channels.instance.context.settings + //WINPR_ASSERT(settings); + + for i := range pChannel { + pChannelDef := &pChannel[i] + var pChannelOpenData ChannelOpenData + + //WINPR_ASSERT(pChannelOpenData) + + pChannelOpenData.OpenHandle = atomic.AddUint32(&openHandleSeq, 1) + pChannelOpenData.channels = channels + pChannelOpenData.lpUserParam = lpUserParam + if _, ok := pChannelInitData.openDataMap[pChannelOpenData.OpenHandle]; ok { + return CHANNEL_RC_INITIALIZATION_ERROR + } + + pChannelInitData.pInterface = clientContext + + pChannelOpenData.flags = 1 + pChannelOpenData.name = pChannelDef.Name + pChannelOpenData.options = pChannelDef.Options + pChannelInitData.openDataMap[pChannelOpenData.OpenHandle] = &pChannelOpenData + channels.openDataList = append(channels.openDataList, pChannelOpenData) + channels.openDataCount++ + /* + if settings.ChannelCount < 30 { + channel := freerdp_settings_get_pointer_array_writable( + settings, FreeRDP_ChannelDefArray, settings.ChannelCount) + channel.name = pChannelDef.Name + channel.options = pChannelDef.Options + settings.ChannelCount++ + }*/ + + channels.openDataCount++ + } + + return CHANNEL_RC_OK +} +func getChannelOpenDataByName(channel *rdpChannels, name string) *ChannelOpenData { + for _, v := range channel.openDataList { + if strings.EqualFold(name, v.name) { + return &v + } + } + return nil +} +func RdpVirtualChannelOpenEx(pInitHandle interface{}, pOpenHandle *uint32, pChannelName string, + pChannelOpenEventProcEx *CHANNEL_OPEN_EVENT_EX_FN) uint { + pChannelInitData := pInitHandle.(*ChannelInitData) + channels := pChannelInitData.channels + pInterface := pChannelInitData.pInterface + + if pOpenHandle == nil { + return CHANNEL_RC_BAD_CHANNEL_HANDLE + } + if pChannelOpenEventProcEx == nil { + return CHANNEL_RC_BAD_PROC + } + + if !channels.connected { + return CHANNEL_RC_NOT_CONNECTED + } + + pChannelOpenData := getChannelOpenDataByName(channels, pChannelName) + + if pChannelOpenData == nil { + return CHANNEL_RC_UNKNOWN_CHANNEL_NAME + } + + if pChannelOpenData.flags == 2 { + return CHANNEL_RC_ALREADY_OPEN + } + + pChannelOpenData.flags = 2 /* open */ + pChannelOpenData.pInterface = pInterface + pChannelOpenData.pChannelOpenEventProcEx = pChannelOpenEventProcEx + *pOpenHandle = pChannelOpenData.OpenHandle + return CHANNEL_RC_OK +} +func RdpVirtualChannelCloseEx(pInitHandle interface{}, openHandle uint32) uint { + if pInitHandle == nil { + return CHANNEL_RC_BAD_INIT_HANDLE + } + pChannelInitData := pInitHandle.(*ChannelInitData) + pChannelOpenData := pChannelInitData.openDataMap[openHandle] + + if pChannelOpenData == nil { + return CHANNEL_RC_BAD_CHANNEL_HANDLE + } + + if pChannelOpenData.flags != 2 { + return CHANNEL_RC_NOT_OPEN + } + + pChannelOpenData.flags = 0 + + return CHANNEL_RC_OK +} +func RdpVirtualChannelWriteEx(pInitHandle interface{}, openHandle uint32, + pData interface{}, dataLength uint32, + pUserData interface{}) uint { + + //wMessage message; + + if pInitHandle == nil { + return CHANNEL_RC_BAD_INIT_HANDLE + } + + pChannelInitData := pInitHandle.(*ChannelInitData) + channels := pChannelInitData.channels + + if channels == nil { + return CHANNEL_RC_BAD_CHANNEL_HANDLE + } + + pChannelOpenData := pChannelInitData.openDataMap[openHandle] + if pChannelOpenData == nil { + return CHANNEL_RC_BAD_CHANNEL_HANDLE + } + + if !channels.connected { + return CHANNEL_RC_NOT_CONNECTED + } + + if pData == nil { + return CHANNEL_RC_NULL_DATA + } + + if dataLength == 0 { + return CHANNEL_RC_ZERO_LENGTH + } + + if pChannelOpenData.flags != 2 { + return CHANNEL_RC_NOT_OPEN + } + + pChannelOpenEvent := new(ChannelOpenEvent) + + if pChannelOpenEvent == nil { + return CHANNEL_RC_NO_MEMORY + + } + + pChannelOpenEvent.Data = pData + pChannelOpenEvent.DataLength = dataLength + pChannelOpenEvent.UserData = pUserData + pChannelOpenEvent.pChannelOpenData = pChannelOpenData + /*message.context = channels; + message.id = 0; + message.wParam = pChannelOpenEvent; + message.lParam = NULL; + message.Free = channel_queue_message_free; + + if (!MessageQueue_Dispatch(channels->queue, &message)) + { + free(pChannelOpenEvent); + return CHANNEL_RC_NO_MEMORY; + }*/ + + return CHANNEL_RC_OK +} diff --git a/grdp/plugin/channel.go b/grdp/plugin/channel.go new file mode 100644 index 0000000..8577f55 --- /dev/null +++ b/grdp/plugin/channel.go @@ -0,0 +1,304 @@ +package plugin + +import "C" +import ( + "bytes" + "fmt" + "unsafe" + + "ShotRDP/grdp/glog" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/emission" +) + +const ( + CHANNEL_RC_OK = 0 + CHANNEL_RC_ALREADY_INITIALIZED = 1 + CHANNEL_RC_NOT_INITIALIZED = 2 + CHANNEL_RC_ALREADY_CONNECTED = 3 + CHANNEL_RC_NOT_CONNECTED = 4 + CHANNEL_RC_TOO_MANY_CHANNELS = 5 + CHANNEL_RC_BAD_CHANNEL = 6 + CHANNEL_RC_BAD_CHANNEL_HANDLE = 7 + CHANNEL_RC_NO_BUFFER = 8 + CHANNEL_RC_BAD_INIT_HANDLE = 9 + CHANNEL_RC_NOT_OPEN = 10 + CHANNEL_RC_BAD_PROC = 11 + CHANNEL_RC_NO_MEMORY = 12 + CHANNEL_RC_UNKNOWN_CHANNEL_NAME = 13 + CHANNEL_RC_ALREADY_OPEN = 14 + CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY = 15 + CHANNEL_RC_NULL_DATA = 16 + CHANNEL_RC_ZERO_LENGTH = 17 + CHANNEL_RC_INVALID_INSTANCE = 18 + CHANNEL_RC_UNSUPPORTED_VERSION = 19 + CHANNEL_RC_INITIALIZATION_ERROR = 20 +) +const ( + VIRTUAL_CHANNEL_VERSION_WIN2000 = 1 +) + +const ( + CHANNEL_EVENT_INITIALIZED = 0 + CHANNEL_EVENT_CONNECTED = 1 + CHANNEL_EVENT_V1_CONNECTED = 2 + CHANNEL_EVENT_DISCONNECTED = 3 + CHANNEL_EVENT_TERMINATED = 4 + CHANNEL_EVENT_REMOTE_CONTROL_START = 5 + CHANNEL_EVENT_REMOTE_CONTROL_STOP = 6 + CHANNEL_EVENT_ATTACHED = 7 + CHANNEL_EVENT_DETACHED = 8 + CHANNEL_EVENT_DATA_RECEIVED = 10 + CHANNEL_EVENT_WRITE_COMPLETE = 11 + CHANNEL_EVENT_WRITE_CANCELLED = 12 +) + +const ( + CHANNEL_OPTION_INITIALIZED = 0x80000000 + CHANNEL_OPTION_ENCRYPT_RDP = 0x40000000 + CHANNEL_OPTION_ENCRYPT_SC = 0x20000000 + CHANNEL_OPTION_ENCRYPT_CS = 0x10000000 + CHANNEL_OPTION_PRI_HIGH = 0x08000000 + CHANNEL_OPTION_PRI_MED = 0x04000000 + CHANNEL_OPTION_PRI_LOW = 0x02000000 + CHANNEL_OPTION_COMPRESS_RDP = 0x00800000 + CHANNEL_OPTION_COMPRESS = 0x00400000 + CHANNEL_OPTION_SHOW_PROTOCOL = 0x00200000 + CHANNEL_OPTION_REMOTE_CONTROL_PERSISTENT = 0x00100000 +) + +type ChannelDef struct { + Name string + Options uint32 +} +type CHANNEL_INIT_EVENT_EX_FN func(lpUserParam interface{}, + pInitHandle interface{}, event uint, pData uintptr, dataLength uint) +type VIRTUALCHANNELINITEX func(lpUserParam interface{}, clientContext interface{}, + pInitHandle interface{}, pChannel []ChannelDef, + channelCount int, versionRequested uint32, + pChannelInitEventProcEx CHANNEL_INIT_EVENT_EX_FN) uint + +type CHANNEL_OPEN_EVENT_EX_FN func(lpUserParam uintptr, + openHandle uint32, event uint, + pData uintptr, dataLength uint32, totalLength uint32, dataFlags uint32) +type VIRTUALCHANNELOPENEX func(pInitHandle interface{}, pOpenHandle *uint32, + pChannelName string, + pChannelOpenEventProcEx *CHANNEL_OPEN_EVENT_EX_FN) uint + +type VIRTUALCHANNELCLOSEEX func(pInitHandle interface{}, openHandle uint32) uint + +type VIRTUALCHANNELWRITEEX func(pInitHandle interface{}, openHandle uint32, pData interface{}, + dataLength uint32, pUserData interface{}) uint + +type ChannelEntryPointsEx struct { + CbSize uint32 + ProtocolVersion uint32 + PVirtualChannelInitEx VIRTUALCHANNELINITEX + PVirtualChannelOpenEx VIRTUALCHANNELOPENEX + PVirtualChannelCloseEx VIRTUALCHANNELCLOSEEX + PVirtualChannelWriteEx VIRTUALCHANNELWRITEEX +} + +func NewChannelEntryPointsEx() *ChannelEntryPointsEx { + e := &ChannelEntryPointsEx{} + e.CbSize = uint32(unsafe.Sizeof(e)) + e.ProtocolVersion = VIRTUAL_CHANNEL_VERSION_WIN2000 + return e +} + +type VIRTUALCHANNELENTRYEX func(pEntryPointsEx *ChannelEntryPointsEx, + pInitHandle interface{}) error + +/* +type ChannelEntryPoints struct { + CbSize uint32 + ProtocolVersion uint32 + PVirtualChannelInit PVIRTUALCHANNELINIT + PVirtualChannelOpen PVIRTUALCHANNELOPEN + PVirtualChannelClose PVIRTUALCHANNELCLOSE + PVirtualChannelWrite PVIRTUALCHANNELWRITE +} +typedef VOID VCAPITYPE CHANNEL_INIT_EVENT_FN(LPVOID pInitHandle, + UINT event, LPVOID pData, UINT dataLength); + +typedef CHANNEL_INIT_EVENT_FN* PCHANNEL_INIT_EVENT_FN; +typedef VOID VCAPITYPE CHANNEL_OPEN_EVENT_FN(DWORD openHandle, UINT event, + LPVOID pData, UINT32 dataLength, UINT32 totalLength, UINT32 dataFlags); + +typedef CHANNEL_OPEN_EVENT_FN* PCHANNEL_OPEN_EVENT_FN; +typedef UINT VCAPITYPE VIRTUALCHANNELINIT(LPVOID* ppInitHandle, PCHANNEL_DEF pChannel, + INT channelCount, ULONG versionRequested, + PCHANNEL_INIT_EVENT_FN pChannelInitEventProc); +typedef VIRTUALCHANNELINIT* PVIRTUALCHANNELINIT; + +typedef UINT VCAPITYPE VIRTUALCHANNELOPEN(LPVOID pInitHandle, LPDWORD pOpenHandle, + PCHAR pChannelName, + PCHANNEL_OPEN_EVENT_FN pChannelOpenEventProc); + +typedef VIRTUALCHANNELOPEN* PVIRTUALCHANNELOPEN; + +typedef UINT VCAPITYPE VIRTUALCHANNELCLOSE(DWORD openHandle); +typedef VIRTUALCHANNELCLOSE* PVIRTUALCHANNELCLOSE; + +typedef UINT VCAPITYPE VIRTUALCHANNELWRITE(DWORD openHandle, LPVOID pData, ULONG dataLength, + LPVOID pUserData); +typedef VIRTUALCHANNELWRITE* PVIRTUALCHANNELWRITE; + +typedef UINT VCAPITYPE VIRTUALCHANNELINITEX(LPVOID lpUserParam, LPVOID clientContext, + LPVOID pInitHandle, PCHANNEL_DEF pChannel, + INT channelCount, ULONG versionRequested, + PCHANNEL_INIT_EVENT_EX_FN pChannelInitEventProcEx); +typedef VIRTUALCHANNELINITEX* PVIRTUALCHANNELINITEX; + +typedef UINT VCAPITYPE VIRTUALCHANNELOPENEX(LPVOID pInitHandle, LPDWORD pOpenHandle, + PCHAR pChannelName, + PCHANNEL_OPEN_EVENT_EX_FN pChannelOpenEventProcEx); +typedef VIRTUALCHANNELOPENEX* PVIRTUALCHANNELOPENEX; + + +typedef UINT VCAPITYPE VIRTUALCHANNELCLOSEEX(LPVOID pInitHandle, DWORD openHandle); +typedef VIRTUALCHANNELCLOSEEX* PVIRTUALCHANNELCLOSEEX; + +typedef UINT VCAPITYPE VIRTUALCHANNELWRITEEX(LPVOID pInitHandle, DWORD openHandle, LPVOID pData, + ULONG dataLength, LPVOID pUserData); +typedef VIRTUALCHANNELWRITEEX* PVIRTUALCHANNELWRITEEX; +*/ + +// static channel name +const ( + CLIPRDR_SVC_CHANNEL_NAME = "cliprdr" //剪切板 + RDPDR_SVC_CHANNEL_NAME = "rdpdr" //设备重定向(打印机，磁盘，端口，智能卡等) + RDPSND_SVC_CHANNEL_NAME = "rdpsnd" //音频输出 + RAIL_SVC_CHANNEL_NAME = "rail" //远程应用 + DRDYNVC_SVC_CHANNEL_NAME = "drdynvc" //动态虚拟通道 + REMDESK_SVC_CHANNEL_NAME = "remdesk" //远程协助 +) + +const ( + RDPGFX_DVC_CHANNEL_NAME = "Microsoft::Windows::RDS::Graphics" //图形扩展 +) + +var StaticVirtualChannels = map[string]int{ + CLIPRDR_SVC_CHANNEL_NAME: CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | + CHANNEL_OPTION_COMPRESS_RDP | CHANNEL_OPTION_SHOW_PROTOCOL, + RDPDR_SVC_CHANNEL_NAME: CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | CHANNEL_OPTION_COMPRESS_RDP, + RDPSND_SVC_CHANNEL_NAME: CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | + CHANNEL_OPTION_COMPRESS_RDP | CHANNEL_OPTION_SHOW_PROTOCOL, + RAIL_SVC_CHANNEL_NAME: CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | + CHANNEL_OPTION_COMPRESS_RDP | CHANNEL_OPTION_SHOW_PROTOCOL, +} + +const ( + CHANNEL_CHUNK_LENGTH = 1600 + CHANNEL_FLAG_FIRST = 0x01 + CHANNEL_FLAG_LAST = 0x02 + CHANNEL_FLAG_SHOW_PROTOCOL = 0x10 +) + +type ChannelTransport interface { + GetType() (string, uint32) + Sender(core.ChannelSender) + Process(s []byte) +} +type ChannelClient struct { + ChannelDef + t ChannelTransport +} + +type Channels struct { + emission.Emitter + channels map[string]ChannelClient + transport core.Transport + buff *bytes.Buffer + channelSender core.ChannelSender +} + +func NewChannels(t core.Transport) *Channels { + c := &Channels{ + Emitter: *emission.NewEmitter(), + channels: make(map[string]ChannelClient, 20), + transport: t, + buff: &bytes.Buffer{}, + } + t.On("channel", c.process) + return c +} + +func (c *Channels) SetChannelSender(f core.ChannelSender) { + c.channelSender = f +} +func (c *Channels) Register(t ChannelTransport) { + name, option := t.GetType() + _, ok := c.channels[name] + if ok { + glog.Warn("Already register channel:", name) + return + } + t.Sender(c) + c.channels[name] = ChannelClient{ChannelDef{name, option}, t} +} + +func (c *Channels) SendToChannel(channel string, s []byte) (int, error) { + cli, ok := c.channels[channel] + if !ok { + glog.Warn("No register channel:", channel) + return 0, fmt.Errorf("No register channel: %s", channel) + } + idx := 0 + ln := len(s) + b := &bytes.Buffer{} + for ln > 0 { + var flag uint32 = 0 + if cli.Options&CHANNEL_OPTION_SHOW_PROTOCOL != 0 { + flag |= CHANNEL_FLAG_SHOW_PROTOCOL + } + if idx == 0 { + flag |= CHANNEL_FLAG_FIRST + } + + var ss []byte + if ln > CHANNEL_CHUNK_LENGTH { + ss = s[idx : idx+CHANNEL_CHUNK_LENGTH] + idx += CHANNEL_CHUNK_LENGTH + } else { + flag |= CHANNEL_FLAG_LAST + ss = s[idx : idx+ln] + } + glog.Debug("len:", len(ss), "flag:", flag) + ln -= len(ss) + b.Reset() + core.WriteUInt32LE(uint32(len(s)), b) + core.WriteUInt32LE(flag, b) + b.Write(ss) + c.channelSender.SendToChannel(channel, b.Bytes()) + } + return ln, nil +} + +func (c *Channels) process(channel string, s []byte) { + cli, ok := c.channels[channel] + if !ok { + glog.Warn("No found channel:", channel) + return + } + r := bytes.NewReader(s) + ln, _ := core.ReadUInt32LE(r) + flags, _ := core.ReadUInt32LE(r) + glog.Debugf("channel:%s length: %d, flags: %d", channel, ln, flags) + if flags&CHANNEL_FLAG_FIRST == 0 || flags&CHANNEL_FLAG_LAST == 0 { + if flags&CHANNEL_FLAG_FIRST != 0 { + c.buff.Reset() + } + b, _ := core.ReadBytes(r.Len(), r) + c.buff.Write(b) + if flags&CHANNEL_FLAG_LAST == 0 { + return + } + s = c.buff.Bytes() + } else { + s, _ = core.ReadBytes(r.Len(), r) + } + + cli.t.Process(s) +} diff --git a/grdp/plugin/cliprdr/cliprdr.go b/grdp/plugin/cliprdr/cliprdr.go new file mode 100644 index 0000000..0abfa89 --- /dev/null +++ b/grdp/plugin/cliprdr/cliprdr.go @@ -0,0 +1,771 @@ +package cliprdr + +import ( + "bytes" + "encoding/hex" + "os" + "strings" + "unicode/utf16" + + "github.com/lunixbochs/struc" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/glog" + "ShotRDP/grdp/plugin" +) + +/** + * Initialization Sequence\n + * Client Server\n + * | |\n + * |<----------------------Server Clipboard Capabilities PDU-----------------|\n + * |<-----------------------------Monitor Ready PDU--------------------------|\n + * |-----------------------Client Clipboard Capabilities PDU---------------->|\n + * |---------------------------Temporary Directory PDU---------------------->|\n + * |-------------------------------Format List PDU-------------------------->|\n + * |<--------------------------Format List Response PDU----------------------|\n + * + */ + +/** + * Data Transfer Sequences\n + * Shared Local\n + * Clipboard Owner Clipboard Owner\n + * | |\n + * |-------------------------------------------------------------------------|\n _ + * |-------------------------------Format List PDU-------------------------->|\n | + * |<--------------------------Format List Response PDU----------------------|\n _| Copy + * Sequence + * |<---------------------Lock Clipboard Data PDU (Optional)-----------------|\n + * |-------------------------------------------------------------------------|\n + * |-------------------------------------------------------------------------|\n _ + * |<--------------------------Format Data Request PDU-----------------------|\n | Paste + * Sequence Palette, + * |---------------------------Format Data Response PDU--------------------->|\n _| Metafile, + * File List Data + * |-------------------------------------------------------------------------|\n + * |-------------------------------------------------------------------------|\n _ + * |<------------------------Format Contents Request PDU---------------------|\n | Paste + * Sequence + * |-------------------------Format Contents Response PDU------------------->|\n _| File + * Stream Data + * |<---------------------Lock Clipboard Data PDU (Optional)-----------------|\n + * |-------------------------------------------------------------------------|\n + * + */ + +const ( + ChannelName = plugin.CLIPRDR_SVC_CHANNEL_NAME + ChannelOption = plugin.CHANNEL_OPTION_INITIALIZED | plugin.CHANNEL_OPTION_ENCRYPT_RDP | + plugin.CHANNEL_OPTION_COMPRESS_RDP | plugin.CHANNEL_OPTION_SHOW_PROTOCOL +) + +type MsgType uint16 + +const ( + CB_MONITOR_READY = 0x0001 + CB_FORMAT_LIST = 0x0002 + CB_FORMAT_LIST_RESPONSE = 0x0003 + CB_FORMAT_DATA_REQUEST = 0x0004 + CB_FORMAT_DATA_RESPONSE = 0x0005 + CB_TEMP_DIRECTORY = 0x0006 + CB_CLIP_CAPS = 0x0007 + CB_FILECONTENTS_REQUEST = 0x0008 + CB_FILECONTENTS_RESPONSE = 0x0009 + CB_LOCK_CLIPDATA = 0x000A + CB_UNLOCK_CLIPDATA = 0x000B +) + +type MsgFlags uint16 + +const ( + CB_RESPONSE_OK = 0x0001 + CB_RESPONSE_FAIL = 0x0002 + CB_ASCII_NAMES = 0x0004 +) + +type DwFlags uint32 + +const ( + FILECONTENTS_SIZE = 0x00000001 + FILECONTENTS_RANGE = 0x00000002 +) + +type CliprdrPDUHeader struct { + MsgType uint16 `struc:"little"` + MsgFlags uint16 `struc:"little"` + DataLen uint32 `struc:"little"` +} + +func NewCliprdrPDUHeader(mType, flags uint16, ln uint32) *CliprdrPDUHeader { + return &CliprdrPDUHeader{ + MsgType: mType, + MsgFlags: flags, + DataLen: ln, + } +} +func (h *CliprdrPDUHeader) serialize() []byte { + b := &bytes.Buffer{} + core.WriteUInt16LE(h.MsgType, b) + core.WriteUInt16LE(h.MsgFlags, b) + core.WriteUInt32LE(h.DataLen, b) + return b.Bytes() +} + +type CliprdrGeneralCapabilitySet struct { + CapabilitySetType uint16 `struc:"little"` + CapabilitySetLength uint16 `struc:"little"` + Version uint32 `struc:"little"` + GeneralFlags uint32 `struc:"little"` +} + +const ( + CB_CAPSTYPE_GENERAL = 0x0001 +) + +type CliprdrCapabilitySets struct { + CapabilitySetType uint16 `struc:"little"` + LengthCapability uint16 `struc:"little"` + Version uint32 `struc:"little"` + GeneralFlags uint32 `struc:"little"` + //CapabilityData []byte `struc:"little"` +} +type CliprdrCapabilitiesPDU struct { + CCapabilitiesSets uint16 `struc:"little,sizeof=CapabilitySets"` + Pad1 uint16 `struc:"little"` + CapabilitySets []CliprdrGeneralCapabilitySet `struc:"little"` +} + +type CliprdrMonitorReady struct { +} + +type GeneralFlags uint32 + +const ( + /* CLIPRDR_GENERAL_CAPABILITY.generalFlags */ + CB_USE_LONG_FORMAT_NAMES = 0x00000002 + CB_STREAM_FILECLIP_ENABLED = 0x00000004 + CB_FILECLIP_NO_FILE_PATHS = 0x00000008 + CB_CAN_LOCK_CLIPDATA = 0x00000010 + CB_HUGE_FILE_SUPPORT_ENABLED = 0x00000020 +) + +const ( + /* CLIPRDR_GENERAL_CAPABILITY.version */ + CB_CAPS_VERSION_1 = 0x00000001 + CB_CAPS_VERSION_2 = 0x00000002 +) +const ( + CB_CAPSTYPE_GENERAL_LEN = 12 +) + +const ( + FD_CLSID = 0x00000001 + FD_SIZEPOINT = 0x00000002 + FD_ATTRIBUTES = 0x00000004 + FD_CREATETIME = 0x00000008 + FD_ACCESSTIME = 0x00000010 + FD_WRITESTIME = 0x00000020 + FD_FILESIZE = 0x00000040 + FD_PROGRESSUI = 0x00004000 + FD_LINKUI = 0x00008000 +) + +type FileGroupDescriptor struct { + CItems uint32 `struc:"little"` + Fgd []FileDescriptor `struc:"sizefrom=CItems"` +} +type FileDescriptor struct { + Flags uint32 `struc:"little"` + Clsid [16]byte `struc:"little"` + Sizel [8]byte `struc:"little"` + Pointl [8]byte `struc:"little"` + FileAttributes uint32 `struc:"little"` + CreationTime [8]byte `struc:"little"` + LastAccessTime [8]byte `struc:"little"` + LastWriteTime []byte `struc:"[8]byte"` //8 + FileSizeHigh uint32 `struc:"little"` + FileSizeLow uint32 `struc:"little"` + FileName []byte `struc:"[512]byte"` +} + +func (f *FileGroupDescriptor) Unpack(b []byte) error { + r := bytes.NewReader(b) + err := struc.Unpack(r, f) + if err != nil { + glog.Error(err) + } + + return err +} + +func (f *FileDescriptor) serialize() []byte { + b := &bytes.Buffer{} + core.WriteUInt32LE(f.Flags, b) + for i := 0; i < 32; i++ { + core.WriteByte(0, b) + } + core.WriteUInt32LE(f.FileAttributes, b) + for i := 0; i < 16; i++ { + core.WriteByte(0, b) + } + core.WriteBytes(f.LastWriteTime[:], b) + core.WriteUInt32LE(f.FileSizeHigh, b) + core.WriteUInt32LE(f.FileSizeLow, b) + name := make([]byte, 512) + copy(name, f.FileName) + core.WriteBytes(name, b) + return b.Bytes() +} + +func (f *FileDescriptor) isDir() bool { + if f.Flags&FD_ATTRIBUTES != 0 { + return f.FileAttributes&FILE_ATTRIBUTE_DIRECTORY != 0 + } + + return false +} + +func (f *FileDescriptor) hasFileSize() bool { + return f.Flags&FD_FILESIZE != 0 +} + +// temp dir +type CliprdrTempDirectory struct { + SzTempDir []byte `struc:"[260]byte"` +} + +// format list +type CliprdrFormat struct { + FormatId uint32 + FormatName string +} +type CliprdrFormatList struct { + NumFormats uint32 + Formats []CliprdrFormat +} +type ClipboardFormats uint16 + +const ( + CB_FORMAT_HTML = 0xD010 + CB_FORMAT_PNG = 0xD011 + CB_FORMAT_JPEG = 0xD012 + CB_FORMAT_GIF = 0xD013 + CB_FORMAT_TEXTURILIST = 0xD014 + CB_FORMAT_GNOMECOPIEDFILES = 0xD015 + CB_FORMAT_MATECOPIEDFILES = 0xD016 +) + +// lock or unlock +type CliprdrCtrlClipboardData struct { + ClipDataId uint32 +} + +// format data +type CliprdrFormatDataRequest struct { + RequestedFormatId uint32 +} +type CliprdrFormatDataResponse struct { + RequestedFormatData []byte +} + +// file contents +type CliprdrFileContentsRequest struct { + StreamId uint32 `struc:"little"` + Lindex uint32 `struc:"little"` + DwFlags uint32 `struc:"little"` + NPositionLow uint32 `struc:"little"` + NPositionHigh uint32 `struc:"little"` + CbRequested uint32 `struc:"little"` + ClipDataId uint32 `struc:"little"` +} + +func FileContentsSizeRequest(i uint32) *CliprdrFileContentsRequest { + return &CliprdrFileContentsRequest{ + StreamId: 1, + Lindex: i, + DwFlags: FILECONTENTS_SIZE, + NPositionLow: 0, + NPositionHigh: 0, + CbRequested: 65535, + ClipDataId: 0, + } +} + +type CliprdrFileContentsResponse struct { + StreamId uint32 + CbRequested uint32 + RequestedData []byte +} + +func (resp *CliprdrFileContentsResponse) Unpack(b []byte) { + r := bytes.NewReader(b) + resp.StreamId, _ = core.ReadUInt32LE(r) + resp.CbRequested = uint32(r.Len()) + resp.RequestedData, _ = core.ReadBytes(int(resp.CbRequested), r) +} + +type CliprdrClient struct { + w core.ChannelSender + useLongFormatNames bool + streamFileClipEnabled bool + fileClipNoFilePaths bool + canLockClipData bool + hasHugeFileSupport bool + formatIdMap map[uint32]uint32 + Files []FileDescriptor + reply chan []byte + Control +} + +func NewCliprdrClient() *CliprdrClient { + c := &CliprdrClient{ + formatIdMap: make(map[uint32]uint32, 20), + Files: make([]FileDescriptor, 0, 20), + reply: make(chan []byte, 100), + } + + go ClipWatcher(c) + + return c +} + +func (c *CliprdrClient) Send(s []byte) (int, error) { + glog.Debug("len:", len(s), "data:", hex.EncodeToString(s)) + name, _ := c.GetType() + return c.w.SendToChannel(name, s) +} +func (c *CliprdrClient) Sender(f core.ChannelSender) { + c.w = f +} +func (c *CliprdrClient) GetType() (string, uint32) { + return ChannelName, ChannelOption +} + +func (c *CliprdrClient) Process(s []byte) { + glog.Debug("recv:", hex.EncodeToString(s)) + r := bytes.NewReader(s) + + msgType, _ := core.ReadUint16LE(r) + flag, _ := core.ReadUint16LE(r) + length, _ := core.ReadUInt32LE(r) + glog.Debugf("cliprdr: type=0x%x flag=%d length=%d, all=%d", msgType, flag, length, r.Len()) + + b, _ := core.ReadBytes(int(length), r) + + switch msgType { + case CB_CLIP_CAPS: + glog.Info("CB_CLIP_CAPS") + c.processClipCaps(b) + + case CB_MONITOR_READY: + glog.Info("CB_MONITOR_READY") + c.processMonitorReady(b) + + case CB_FORMAT_LIST: + glog.Info("CB_FORMAT_LIST") + c.processFormatList(b) + + case CB_FORMAT_LIST_RESPONSE: + glog.Info("CB_FORMAT_LIST_RESPONSE") + c.processFormatListResponse(flag, b) + + case CB_FORMAT_DATA_REQUEST: + glog.Info("CB_FORMAT_DATA_REQUEST") + c.processFormatDataRequest(b) + + case CB_FORMAT_DATA_RESPONSE: + glog.Info("CB_FORMAT_DATA_RESPONSE") + c.processFormatDataResponse(flag, b) + + case CB_FILECONTENTS_REQUEST: + glog.Info("CB_FILECONTENTS_REQUEST") + c.processFileContentsRequest(b) + + case CB_FILECONTENTS_RESPONSE: + glog.Info("CB_FILECONTENTS_RESPONSE") + c.processFileContentsResponse(flag, b) + + case CB_LOCK_CLIPDATA: + glog.Info("CB_LOCK_CLIPDATA") + c.processLockClipData(b) + + case CB_UNLOCK_CLIPDATA: + glog.Info("CB_UNLOCK_CLIPDATA") + c.processUnlockClipData(b) + + default: + glog.Errorf("type 0x%x not supported", msgType) + } +} +func (c *CliprdrClient) processClipCaps(b []byte) { + r := bytes.NewReader(b) + var cp CliprdrCapabilitiesPDU + err := struc.Unpack(r, &cp) + if err != nil { + glog.Error(err) + return + } + glog.Debugf("Capabilities:%+v", cp) + c.useLongFormatNames = cp.CapabilitySets[0].GeneralFlags&CB_USE_LONG_FORMAT_NAMES != 0 + c.streamFileClipEnabled = cp.CapabilitySets[0].GeneralFlags&CB_STREAM_FILECLIP_ENABLED != 0 + c.fileClipNoFilePaths = cp.CapabilitySets[0].GeneralFlags&CB_FILECLIP_NO_FILE_PATHS != 0 + c.canLockClipData = cp.CapabilitySets[0].GeneralFlags&CB_CAN_LOCK_CLIPDATA != 0 + c.hasHugeFileSupport = cp.CapabilitySets[0].GeneralFlags&CB_HUGE_FILE_SUPPORT_ENABLED != 0 + glog.Info("UseLongFormatNames:", c.useLongFormatNames) + glog.Info("StreamFileClipEnabled:", c.streamFileClipEnabled) + glog.Info("FileClipNoFilePaths:", c.fileClipNoFilePaths) + glog.Info("CanLockClipData:", c.canLockClipData) + glog.Info("HasHugeFileSupport:", c.hasHugeFileSupport) +} + +func (c *CliprdrClient) processMonitorReady(b []byte) { + //Client Clipboard Capabilities PDU + c.sendClientCapabilitiesPDU() + + //Temporary Directory PDU + //c.sendTemporaryDirectoryPDU() + + //Format List PDU + c.sendFormatListPDU() + +} +func (c *CliprdrClient) processFormatList(b []byte) { + c.withOpenClipboard(func() { + if !EmptyClipboard() { + glog.Error("EmptyClipboard failed") + } + }) + fl, hasFile := c.readForamtList(b) + glog.Info("numFormats:", fl.NumFormats) + + if hasFile { + c.SendCliprdrMessage() + } else { + c.withOpenClipboard(func() { + if !EmptyClipboard() { + glog.Error("EmptyClipboard failed") + } + for i := range c.formatIdMap { + glog.Debug("i:", i) + SetClipboardData(i, 0) + } + }) + + } + + c.sendFormatListResponse(CB_RESPONSE_OK) +} +func (c *CliprdrClient) processFormatListResponse(flag uint16, b []byte) { + if flag != CB_RESPONSE_OK { + glog.Error("Format List Response Failed") + return + } + glog.Error("Format List Response OK") +} +func getFilesDescriptor(name string) (FileDescriptor, error) { + var fd FileDescriptor + fd.Flags = FD_ATTRIBUTES | FD_FILESIZE | FD_WRITESTIME | FD_PROGRESSUI + f, e := os.Stat(name) + if e != nil { + glog.Error(e.Error()) + return fd, e + } + fd.FileAttributes, fd.LastWriteTime, + fd.FileSizeHigh, fd.FileSizeLow = GetFileInfo(f.Sys()) + fd.FileName = core.UnicodeEncode(name) + + return fd, nil +} +func (c *CliprdrClient) processFormatDataRequest(b []byte) { + r := bytes.NewReader(b) + requestId, _ := core.ReadUInt32LE(r) + + buff := &bytes.Buffer{} + if requestId == RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW) { + fs := GetFileNames() + core.WriteUInt32LE(uint32(len(fs)), buff) + c.Files = c.Files[:0] + for _, v := range fs { + glog.Info("Name:", v) + f, _ := getFilesDescriptor(v) + buff.Write(f.serialize()) + for i := 0; i < 8; i++ { + buff.WriteByte(0) + } + c.Files = append(c.Files, f) + + } + } else { + c.withOpenClipboard(func() { + data := GetClipboardData(requestId) + glog.Debug("data:", data) + buff.Write(core.UnicodeEncode(data)) + buff.Write([]byte{0, 0}) + }) + } + + c.sendFormatDataResponse(buff.Bytes()) +} +func (c *CliprdrClient) processFormatDataResponse(flag uint16, b []byte) { + if flag != CB_RESPONSE_OK { + glog.Error("Format Data Response Failed") + } + c.reply <- b +} + +func (c *CliprdrClient) processFileContentsRequest(b []byte) { + r := bytes.NewReader(b) + var req CliprdrFileContentsRequest + struc.Unpack(r, &req) + if len(c.Files) <= int(req.Lindex) { + glog.Error("No found file:", req.Lindex) + c.sendFormatContentsResponse(req.StreamId, []byte{}) + return + } + buff := &bytes.Buffer{} + /*o := OleGetClipboard() + var format_etc FORMATETC + var stg_medium STGMEDIUM + format_etc.CFormat = RegisterClipboardFormat(CFSTR_FILECONTENTS) + format_etc.Tymed = TYMED_ISTREAM + format_etc.Aspect = 1 + format_etc.Index = req.Lindex + o.GetData(&format_etc, &stg_medium) + s, _ := stg_medium.Stream()*/ + f := c.Files[req.Lindex] + if req.DwFlags == FILECONTENTS_SIZE { + core.WriteUInt32LE(f.FileSizeLow, buff) + core.WriteUInt32LE(f.FileSizeHigh, buff) + c.sendFormatContentsResponse(req.StreamId, buff.Bytes()) + } else if req.DwFlags == FILECONTENTS_RANGE { + name := core.UnicodeDecode(f.FileName) + fi, err := os.Open(name) + if err != nil { + glog.Error(err.Error()) + return + } + defer fi.Close() + data := make([]byte, req.CbRequested) + n, _ := fi.ReadAt(data, int64(f.FileSizeHigh)) + c.sendFormatContentsResponse(req.StreamId, data[:n]) + } +} +func (c *CliprdrClient) processFileContentsResponse(flag uint16, b []byte) { + if flag != CB_RESPONSE_OK { + glog.Error("File Contents Response Failed") + } + var resp CliprdrFileContentsResponse + resp.Unpack(b) + glog.Debug("Get File Contents Response:", resp.StreamId, resp.CbRequested) + c.reply <- resp.RequestedData +} +func (c *CliprdrClient) processLockClipData(b []byte) { + r := bytes.NewReader(b) + var l CliprdrCtrlClipboardData + l.ClipDataId, _ = core.ReadUInt32LE(r) +} +func (c *CliprdrClient) processUnlockClipData(b []byte) { + r := bytes.NewReader(b) + var l CliprdrCtrlClipboardData + l.ClipDataId, _ = core.ReadUInt32LE(r) + +} + +func (c *CliprdrClient) sendClientCapabilitiesPDU() { + glog.Info("Send Client Clipboard Capabilities PDU") + var cs CliprdrGeneralCapabilitySet + cs.CapabilitySetLength = 12 + cs.CapabilitySetType = CB_CAPSTYPE_GENERAL + cs.Version = CB_CAPS_VERSION_2 + cs.GeneralFlags = CB_USE_LONG_FORMAT_NAMES | + CB_STREAM_FILECLIP_ENABLED | + CB_FILECLIP_NO_FILE_PATHS + var cc CliprdrCapabilitiesPDU + cc.CCapabilitiesSets = 1 + cc.Pad1 = 0 + cc.CapabilitySets = make([]CliprdrGeneralCapabilitySet, 0, 1) + cc.CapabilitySets = append(cc.CapabilitySets, cs) + header := NewCliprdrPDUHeader(CB_CLIP_CAPS, 0, 16) + + buff := &bytes.Buffer{} + buff.Write(header.serialize()) + core.WriteUInt16LE(cc.CCapabilitiesSets, buff) + core.WriteUInt16LE(cc.Pad1, buff) + for _, v := range cc.CapabilitySets { + struc.Pack(buff, v) + } + + c.Send(buff.Bytes()) +} + +func (c *CliprdrClient) sendTemporaryDirectoryPDU() { + glog.Info("Send Temporary Directory PDU") + var t CliprdrTempDirectory + header := &CliprdrPDUHeader{CB_TEMP_DIRECTORY, 0, 260} + t.SzTempDir = core.UnicodeEncode(os.TempDir()) + + buff := &bytes.Buffer{} + core.WriteBytes(header.serialize(), buff) + core.WriteBytes(t.SzTempDir, buff) + c.Send(buff.Bytes()) +} +func (c *CliprdrClient) sendFormatListPDU() { + glog.Info("Send Format List PDU") + var f CliprdrFormatList + + f.Formats = GetFormatList(c.hwnd) + f.NumFormats = uint32(len(f.Formats)) + + glog.Info("NumFormats:", f.NumFormats) + glog.Debug("Formats:", f.Formats) + + b := &bytes.Buffer{} + for _, v := range f.Formats { + core.WriteUInt32LE(v.FormatId, b) + if v.FormatName == "" { + core.WriteUInt16LE(0, b) + } else { + n := core.UnicodeEncode(v.FormatName) + core.WriteBytes(n, b) + b.Write([]byte{0, 0}) + } + } + + header := NewCliprdrPDUHeader(CB_FORMAT_LIST, 0, uint32(b.Len())) + + buff := &bytes.Buffer{} + buff.Write(header.serialize()) + core.WriteBytes(b.Bytes(), buff) + + c.Send(buff.Bytes()) +} +func (c *CliprdrClient) readForamtList(b []byte) (*CliprdrFormatList, bool) { + r := bytes.NewReader(b) + fs := make([]CliprdrFormat, 0, 20) + var numFormats uint32 = 0 + hasFile := false + c.formatIdMap = make(map[uint32]uint32, 0) + for r.Len() > 0 { + foramtId, _ := core.ReadUInt32LE(r) + bs := make([]uint16, 0, 20) + ln := r.Len() + for j := 0; j < ln; j++ { + b, _ := core.ReadUint16LE(r) + if b == 0 { + break + } + bs = append(bs, b) + } + name := string(utf16.Decode(bs)) + if strings.EqualFold(name, CFSTR_FILEDESCRIPTORW) { + hasFile = true + } + glog.Infof("Foramt:%d Name:<%s>", foramtId, name) + if name != "" { + localId := RegisterClipboardFormat(name) + glog.Info("local:", localId, "remote:", foramtId) + c.formatIdMap[localId] = foramtId + } else { + c.formatIdMap[foramtId] = foramtId + } + + numFormats++ + fs = append(fs, CliprdrFormat{foramtId, name}) + } + + return &CliprdrFormatList{numFormats, fs}, hasFile +} + +func (c *CliprdrClient) sendFormatListResponse(flags uint16) { + glog.Info("Send Format List Response") + header := NewCliprdrPDUHeader(CB_FORMAT_LIST_RESPONSE, flags, 0) + buff := &bytes.Buffer{} + buff.Write(header.serialize()) + c.Send(buff.Bytes()) +} + +func (c *CliprdrClient) sendFormatDataRequest(id uint32) { + glog.Info("Send Format Data Request") + var r CliprdrFormatDataRequest + r.RequestedFormatId = id + header := NewCliprdrPDUHeader(CB_FORMAT_DATA_REQUEST, 0, 4) + + buff := &bytes.Buffer{} + buff.Write(header.serialize()) + core.WriteUInt32LE(r.RequestedFormatId, buff) + + c.Send(buff.Bytes()) +} +func (c *CliprdrClient) sendFormatDataResponse(b []byte) { + glog.Info("Send Format Data Response") + var resp CliprdrFormatDataResponse + resp.RequestedFormatData = b + + header := NewCliprdrPDUHeader(CB_FORMAT_DATA_RESPONSE, CB_RESPONSE_OK, uint32(len(resp.RequestedFormatData))) + + buff := &bytes.Buffer{} + buff.Write(header.serialize()) + buff.Write(resp.RequestedFormatData) + + c.Send(buff.Bytes()) +} + +func (c *CliprdrClient) sendFormatContentsRequest(r CliprdrFileContentsRequest) uint32 { + glog.Info("Send Format Contents Request") + glog.Debugf("Format Contents Request:%+v", r) + header := NewCliprdrPDUHeader(CB_FILECONTENTS_REQUEST, 0, 28) + + buff := &bytes.Buffer{} + buff.Write(header.serialize()) + core.WriteUInt32LE(r.StreamId, buff) + core.WriteUInt32LE(uint32(r.Lindex), buff) + core.WriteUInt32LE(r.DwFlags, buff) + core.WriteUInt32LE(r.NPositionLow, buff) + core.WriteUInt32LE(r.NPositionHigh, buff) + core.WriteUInt32LE(r.CbRequested, buff) + core.WriteUInt32LE(r.ClipDataId, buff) + + c.Send(buff.Bytes()) + + return uint32(buff.Len()) +} +func (c *CliprdrClient) sendFormatContentsResponse(streamId uint32, b []byte) { + glog.Info("Send Format Contents Response") + var r CliprdrFileContentsResponse + r.StreamId = streamId + r.RequestedData = b + r.CbRequested = uint32(len(b)) + header := NewCliprdrPDUHeader(CB_FILECONTENTS_RESPONSE, CB_RESPONSE_OK, uint32(4+r.CbRequested)) + + buff := &bytes.Buffer{} + buff.Write(header.serialize()) + core.WriteUInt32LE(r.StreamId, buff) + core.WriteBytes(r.RequestedData, buff) + + c.Send(buff.Bytes()) +} + +func (c *CliprdrClient) sendLockClipData() { + glog.Info("Send Lock Clip Data") + var r CliprdrCtrlClipboardData + header := NewCliprdrPDUHeader(CB_LOCK_CLIPDATA, 0, 4) + + buff := &bytes.Buffer{} + buff.Write(header.serialize()) + core.WriteUInt32LE(r.ClipDataId, buff) + + c.Send(buff.Bytes()) +} + +func (c *CliprdrClient) sendUnlockClipData() { + glog.Info("Send Unlock Clip Data") + var r CliprdrCtrlClipboardData + header := NewCliprdrPDUHeader(CB_UNLOCK_CLIPDATA, 0, 4) + + buff := &bytes.Buffer{} + buff.Write(header.serialize()) + core.WriteUInt32LE(r.ClipDataId, buff) + + c.Send(buff.Bytes()) +} diff --git a/grdp/plugin/cliprdr/cliprdr_test.go b/grdp/plugin/cliprdr/cliprdr_test.go new file mode 100644 index 0000000..21e260d --- /dev/null +++ b/grdp/plugin/cliprdr/cliprdr_test.go @@ -0,0 +1,22 @@ +// cliprdr_test.go +package cliprdr_test + +import ( + "fmt" + "testing" + + "ShotRDP/grdp/plugin/cliprdr" +) + +func TestClip(t *testing.T) { + //t1, _ := cliprdr.ReadAll() + //fmt.Printf("%s\n", t1) + ok := cliprdr.OpenClipboard(0) + fmt.Println(ok) + if ok { + name := cliprdr.GetClipboardData(13) + fmt.Printf("name=%s\n", name) + + cliprdr.CloseClipboard() + } +} diff --git a/grdp/plugin/cliprdr/cliprdr_windows.go b/grdp/plugin/cliprdr/cliprdr_windows.go new file mode 100644 index 0000000..84acd76 --- /dev/null +++ b/grdp/plugin/cliprdr/cliprdr_windows.go @@ -0,0 +1,354 @@ +// cliprdr_windows.go +package cliprdr + +import ( + "bytes" + "syscall" + "unicode/utf16" + "unsafe" + + "ShotRDP/grdp/glog" + "github.com/shirou/w32" + + "ShotRDP/grdp/core" + + "ShotRDP/grdp/win" +) + +const ( + CFSTR_SHELLIDLIST = "Shell IDList Array" + CFSTR_SHELLIDLISTOFFSET = "Shell Object Offsets" + CFSTR_NETRESOURCES = "Net Resource" + CFSTR_FILECONTENTS = "FileContents" + CFSTR_FILENAMEA = "FileName" + CFSTR_FILENAMEMAPA = "FileNameMap" + CFSTR_FILEDESCRIPTORA = "FileGroupDescriptor" + CFSTR_INETURLA = "UniformResourceLocator" + CFSTR_SHELLURL = CFSTR_INETURLA + CFSTR_FILENAMEW = "FileNameW" + CFSTR_FILENAMEMAPW = "FileNameMapW" + CFSTR_FILEDESCRIPTORW = "FileGroupDescriptorW" + CFSTR_INETURLW = "UniformResourceLocatorW" + CFSTR_PRINTERGROUP = "PrinterFriendlyName" + CFSTR_INDRAGLOOP = "InShellDragLoop" + CFSTR_PASTESUCCEEDED = "Paste Succeeded" + CFSTR_PERFORMEDDROPEFFECT = "Performed DropEffect" + CFSTR_PREFERREDDROPEFFECT = "Preferred DropEffect" +) +const DVASPECT_CONTENT = 0x1 + +const ( + CF_TEXT = 1 + CF_BITMAP = 2 + CF_METAFILEPICT = 3 + CF_SYLK = 4 + CF_DIF = 5 + CF_TIFF = 6 + CF_OEMTEXT = 7 + CF_DIB = 8 + CF_PALETTE = 9 + CF_PENDATA = 10 + CF_RIFF = 11 + CF_WAVE = 12 + CF_UNICODETEXT = 13 + CF_ENHMETAFILE = 14 + CF_HDROP = 15 + CF_LOCALE = 16 + CF_DIBV5 = 17 + CF_MAX = 18 +) +const ( + WM_CLIPRDR_MESSAGE = (w32.WM_USER + 156) + OLE_SETCLIPBOARD = 1 +) + +type Control struct { + hwnd uintptr + dataObject *IDataObject +} + +func (c *Control) withOpenClipboard(f func()) { + if OpenClipboard(c.hwnd) { + f() + CloseClipboard() + } +} +func ClipWatcher(c *CliprdrClient) { + win.OleInitialize(0) + defer win.OleUninitialize() + className := syscall.StringToUTF16Ptr("ClipboardHiddenMessageProcessor") + windowName := syscall.StringToUTF16Ptr("rdpclip") + wndClassEx := w32.WNDCLASSEX{ + ClassName: className, + WndProc: syscall.NewCallback(func(hwnd w32.HWND, msg uint32, wParam, lParam uintptr) uintptr { + switch msg { + case w32.WM_CLIPBOARDUPDATE: + glog.Info("info: WM_CLIPBOARDUPDATE wParam:", wParam) + glog.Debug("IsClipboardOwner:", IsClipboardOwner(win.HWND(c.hwnd))) + glog.Debug("OleIsCurrentClipboard:", OleIsCurrentClipboard(c.dataObject)) + if !IsClipboardOwner(win.HWND(c.hwnd)) && int(wParam) != 0 && + !OleIsCurrentClipboard(c.dataObject) { + c.sendFormatListPDU() + } + + case w32.WM_RENDERALLFORMATS: + glog.Info("info: WM_RENDERALLFORMATS") + c.withOpenClipboard(func() { + EmptyClipboard() + }) + + case w32.WM_RENDERFORMAT: + glog.Info("info: WM_RENDERFORMAT wParam:", wParam) + formatId := uint32(wParam) + c.sendFormatDataRequest(formatId) + b := <-c.reply + hmem := HmemAlloc(b) + SetClipboardData(formatId, hmem) + + case WM_CLIPRDR_MESSAGE: + glog.Info("info: WM_CLIPRDR_MESSAGE wParam:", wParam) + if wParam == OLE_SETCLIPBOARD { + if !OleIsCurrentClipboard(c.dataObject) { + o := CreateDataObject(c) + OleSetClipboard(o) + c.dataObject = o + } + } + default: + return w32.DefWindowProc(hwnd, msg, wParam, lParam) + } + return 0 + }), + Style: w32.CS_OWNDC, + } + wndClassEx.Size = uint32(unsafe.Sizeof(wndClassEx)) + w32.RegisterClassEx(&wndClassEx) + + hwnd := w32.CreateWindowEx(w32.WS_EX_LEFT, className, windowName, 0, 0, 0, 0, 0, w32.HWND_MESSAGE, 0, 0, nil) + c.hwnd = uintptr(hwnd) + w32.AddClipboardFormatListener(hwnd) + defer w32.RemoveClipboardFormatListener(hwnd) + + msg := w32.MSG{} + for w32.GetMessage(&msg, 0, 0, 0) > 0 { + w32.DispatchMessage(&msg) + } + +} +func OpenClipboard(hwnd uintptr) bool { + return win.OpenClipboard(win.HWND(hwnd)) +} +func CloseClipboard() bool { + return win.CloseClipboard() +} +func CountClipboardFormats() int32 { + return win.CountClipboardFormats() +} +func IsClipboardFormatAvailable(id uint32) bool { + return win.IsClipboardFormatAvailable(win.UINT(id)) +} +func EnumClipboardFormats(formatId uint32) uint32 { + id := win.EnumClipboardFormats(win.UINT(formatId)) + return uint32(id) +} +func GetClipboardFormatName(id uint32) string { + buf := make([]uint16, 250) + n := win.GetClipboardFormatName(win.UINT(id), win.LPWSTR(unsafe.Pointer(&buf[0])), int32(len(buf))) + return string(utf16.Decode(buf[:n])) +} +func EmptyClipboard() bool { + return win.EmptyClipboard() +} +func RegisterClipboardFormat(format string) uint32 { + id := win.RegisterClipboardFormat(format) + return uint32(id) +} +func IsClipboardOwner(h win.HWND) bool { + hwnd := win.GetClipboardOwner() + return h == hwnd +} + +func HmemAlloc(data []byte) uintptr { + ln := (len(data)) + h := win.GlobalAlloc(0x0002, win.SIZE_T(ln)) + if h == 0 { + return uintptr(h) + } + if ln == 0 { + return uintptr(h) + } + l := win.GlobalLock(h) + defer win.GlobalUnlock(h) + + win.RtlCopyMemory(uintptr(unsafe.Pointer(l)), uintptr(unsafe.Pointer(&data[0])), win.SIZE_T(ln)) + + return uintptr(h) + +} +func SetClipboardData(formatId uint32, hmem uintptr) bool { + r := win.SetClipboardData(win.UINT(formatId), win.HANDLE(hmem)) + if r == 0 { + //glog.Error("SetClipboardData failed:", formatId, hmem) + return false + } + return true +} +func GetClipboardData(formatId uint32) string { + r := win.GetClipboardData(win.UINT(formatId)) + if r == 0 { + return "" + } + + h := win.GlobalHandle(uintptr(r)) + size := win.GlobalSize(h) + l := win.GlobalLock(h) + defer win.GlobalUnlock(h) + + result := make([]byte, size) + win.RtlCopyMemory(uintptr(unsafe.Pointer(&result[0])), uintptr(unsafe.Pointer(l)), size) + + return core.UnicodeDecode(result) +} + +func GetFormatList(hwnd uintptr) []CliprdrFormat { + list := make([]CliprdrFormat, 0, 10) + if OpenClipboard(hwnd) { + n := CountClipboardFormats() + if IsClipboardFormatAvailable(CF_HDROP) { + formatId := RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW) + var f CliprdrFormat + f.FormatId = formatId + f.FormatName = CFSTR_FILEDESCRIPTORW + list = append(list, f) + formatId = RegisterClipboardFormat(CFSTR_FILECONTENTS) + var f1 CliprdrFormat + f1.FormatId = formatId + f1.FormatName = CFSTR_FILECONTENTS + list = append(list, f1) + } else { + var id uint32 + for i := 0; i < int(n); i++ { + id = EnumClipboardFormats(id) + name := GetClipboardFormatName(id) + var f CliprdrFormat + f.FormatId = id + f.FormatName = name + list = append(list, f) + } + } + CloseClipboard() + } + return list +} + +func OleGetClipboard() *IDataObject { + var dataObject *IDataObject + win.OleGetClipboard((**win.IDataObject)(unsafe.Pointer(&dataObject))) + return dataObject +} + +func OleSetClipboard(dataObject *IDataObject) bool { + r := win.OleSetClipboard((*win.IDataObject)(unsafe.Pointer(dataObject))) + if r != 0 { + glog.Error("OleSetClipboard failed") + return false + } + return true +} + +func OleIsCurrentClipboard(dataObject *IDataObject) bool { + r := win.OleIsCurrentClipboard((*win.IDataObject)(unsafe.Pointer(dataObject))) + if r != 0 { + return false + } + return true +} +func GlobalSize(hMem uintptr) win.SIZE_T { + return win.GlobalSize(win.HGLOBAL(hMem)) +} +func GlobalLock(hMem uintptr) uintptr { + r := win.GlobalLock(win.HGLOBAL(hMem)) + + return uintptr(r) +} +func GlobalUnlock(hMem uintptr) { + win.GlobalUnlock(win.HGLOBAL(hMem)) +} + +func (c *Control) SendCliprdrMessage() { + win.PostMessage(win.HWND(c.hwnd), WM_CLIPRDR_MESSAGE, OLE_SETCLIPBOARD, 0) +} +func GetFileInfo(sys interface{}) (uint32, []byte, uint32, uint32) { + f := sys.(*syscall.Win32FileAttributeData) + b := &bytes.Buffer{} + core.WriteUInt32LE(f.LastWriteTime.LowDateTime, b) + core.WriteUInt32LE(f.LastWriteTime.HighDateTime, b) + return f.FileAttributes, b.Bytes(), f.FileSizeHigh, f.FileSizeLow +} + +func GetFileNames() []string { + o := OleGetClipboard() + var formatEtc FORMATETC + var stgMedium STGMEDIUM + formatEtc.CFormat = CF_HDROP + formatEtc.Tymed = TYMED_HGLOBAL + formatEtc.Aspect = DVASPECT_CONTENT + formatEtc.Index = -1 + o.GetData(&formatEtc, &stgMedium) + b, _ := stgMedium.Bytes() + //DROPFILES + r := bytes.NewReader(b[20:]) + fs := make([]string, 0, 20) + for r.Len() > 0 { + bs := make([]uint16, 0, 20) + ln := r.Len() + for j := 0; j < ln; j++ { + b, _ := core.ReadUint16LE(r) + if b == 0 { + break + } + bs = append(bs, b) + } + name := string(utf16.Decode(bs)) + + if name == "" { + continue + } + fs = append(fs, name) + } + + return fs +} + +const ( + /* File attribute flags */ + FILE_SHARE_READ = 0x00000001 + FILE_SHARE_WRITE = 0x00000002 + FILE_SHARE_DELETE = 0x00000004 + + FILE_ATTRIBUTE_READONLY = 0x00000001 + FILE_ATTRIBUTE_HIDDEN = 0x00000002 + FILE_ATTRIBUTE_SYSTEM = 0x00000004 + FILE_ATTRIBUTE_DIRECTORY = 0x00000010 + FILE_ATTRIBUTE_ARCHIVE = 0x00000020 + FILE_ATTRIBUTE_DEVICE = 0x00000040 + FILE_ATTRIBUTE_NORMAL = 0x00000080 + FILE_ATTRIBUTE_TEMPORARY = 0x00000100 + FILE_ATTRIBUTE_SPARSE_FILE = 0x00000200 + FILE_ATTRIBUTE_REPARSE_POINT = 0x00000400 + FILE_ATTRIBUTE_COMPRESSED = 0x00000800 + FILE_ATTRIBUTE_OFFLINE = 0x00001000 + FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 0x00002000 + FILE_ATTRIBUTE_ENCRYPTED = 0x00004000 + FILE_ATTRIBUTE_INTEGRITY_STREAM = 0x00008000 + FILE_ATTRIBUTE_VIRTUAL = 0x00010000 + FILE_ATTRIBUTE_NO_SCRUB_DATA = 0x00020000 + FILE_ATTRIBUTE_EA = 0x00040000 +) + +type DROPFILES struct { + pFiles uintptr + pt uintptr + fNC bool + fWide bool +} diff --git a/grdp/plugin/cliprdr/data_object.go b/grdp/plugin/cliprdr/data_object.go new file mode 100644 index 0000000..b3c7bdc --- /dev/null +++ b/grdp/plugin/cliprdr/data_object.go @@ -0,0 +1,864 @@ +//go:build windows +// +build windows + +// dataobject.go +package cliprdr + +import ( + "bytes" + "fmt" + "io" + "reflect" + "sync/atomic" + "syscall" + "unsafe" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/glog" + "ShotRDP/grdp/win" +) + +const ( + S_OK = 0x00000000 + E_UNEXPECTED = 0x8000FFFF + E_NOTIMPL = 0x80004001 + E_OUTOFMEMORY = 0x8007000E + E_INVALIDARG = 0x80070057 + E_NOINTERFACE = 0x80004002 + E_POINTER = 0x80004003 + E_HANDLE = 0x80070006 + E_ABORT = 0x80004004 + E_FAIL = 0x80004005 + E_ACCESSDENIED = 0x80070005 + E_PENDING = 0x8000000A + E_ADVISENOTSUPPORTED = 0x80040003 + E_FORMATETC = 0x80040064 + CO_E_CLASSSTRING = 0x800401F3 +) + +type HRESULT uintptr + +func (hr HRESULT) Error() string { + switch uint32(hr) { + case 0x80040064: + return "DV_E_FORMATETC (0x80040064)" + case 0x800401D3: + return "CLIPBRD_E_BAD_DATA (0x800401D3)" + case 0x80004005: + return "E_FAIL (0x80004005)" + case 0x00000001: + return "S_FALSE (0x00000001)" + } + return fmt.Sprintf("%d", hr) +} + +const ( + TYMED_NULL = 0x0 + TYMED_HGLOBAL = 0x1 + TYMED_FILE = 0x2 + TYMED_ISTREAM = 0x4 + TYMED_ISTORAGE = 0x8 + TYMED_GDI = 0x10 + TYMED_MFPICT = 0x20 + TYMED_ENHMF = 0x40 +) + +type iUnknownVtbl struct { + QueryInterface uintptr + AddRef uintptr + Release uintptr +} +type iDataObjectVtbl struct { + iUnknownVtbl + GetData uintptr + GetDataHere uintptr + QueryGetData uintptr + GetCanonicalFormatEtc uintptr + SetData uintptr + EnumFormatEtc uintptr + DAdvise uintptr + DUnadvise uintptr + EnumDAdvise uintptr +} + +type FORMATETC struct { + CFormat uint32 + DvTargetDevice uintptr + Aspect uint32 + Index int32 + Tymed uint32 +} +type STGMEDIUM struct { + Tymed uint32 + UnionMember uintptr + PUnkForRelease *IUnknown +} +type ISequentialStreamVtbl struct { + iUnknownVtbl + Read uintptr + Write uintptr +} + +type IUnknown struct { + vtbl iUnknownVtbl +} + +func (obj *IUnknown) Release() error { + ret, _, _ := syscall.Syscall( + obj.vtbl.Release, + 1, + uintptr(unsafe.Pointer(obj)), + 0, + 0, + ) + if ret != 0 { + return HRESULT(ret) + } + return nil +} + +func (m STGMEDIUM) Release() { + if m.PUnkForRelease == nil { + win.ReleaseStgMedium((*win.STGMEDIUM)(unsafe.Pointer(&m))) + } +} + +func (m STGMEDIUM) Stream() (*IStream, error) { + if m.Tymed != TYMED_ISTREAM { + return nil, fmt.Errorf("invalid Tymed") + } + return (*IStream)(unsafe.Pointer(m.UnionMember)), nil +} + +func (m STGMEDIUM) Bytes() ([]byte, error) { + if m.Tymed != TYMED_HGLOBAL { + return nil, fmt.Errorf("invalid Tymed") + } + size := GlobalSize(m.UnionMember) + l := GlobalLock(m.UnionMember) + defer GlobalUnlock(m.UnionMember) + + result := make([]byte, size) + win.RtlCopyMemory(uintptr(unsafe.Pointer(&result[0])), uintptr(unsafe.Pointer(l)), size) + + return result, nil +} + +type IDataObject struct { + vtbl *iDataObjectVtbl +} + +func (obj *IDataObject) Release() error { + ret, _, _ := syscall.Syscall( + obj.vtbl.Release, + 1, + uintptr(unsafe.Pointer(obj)), + 0, + 0, + ) + if ret != 0 { + return HRESULT(ret) + } + return nil +} + +func (obj *IDataObject) GetData(formatEtc *FORMATETC, medium *STGMEDIUM) error { + s2 := unsafe.Sizeof(*medium) + _ = s2 + ret, _, _ := syscall.Syscall( + obj.vtbl.GetData, + 3, + uintptr(unsafe.Pointer(obj)), + uintptr(unsafe.Pointer(formatEtc)), + uintptr(unsafe.Pointer(medium)), + ) + + if ret != 0 { + return HRESULT(ret) + } + return nil +} + +func (obj *IDataObject) GetDataHere(formatEtc *FORMATETC, medium *STGMEDIUM) error { + ret, _, _ := syscall.Syscall( + obj.vtbl.GetDataHere, + 3, + uintptr(unsafe.Pointer(obj)), + uintptr(unsafe.Pointer(formatEtc)), + uintptr(unsafe.Pointer(medium)), + ) + + if ret != 0 { + return HRESULT(ret) + } + return nil +} +func (obj *IDataObject) QueryGetData(formatEtc *FORMATETC) error { + ret, _, _ := syscall.Syscall( + obj.vtbl.QueryGetData, + 2, + uintptr(unsafe.Pointer(obj)), + uintptr(unsafe.Pointer(formatEtc)), + 0, + ) + + if ret != 0 { + return HRESULT(ret) + } + return nil +} +func (obj *IDataObject) EnumFormatEtc(direction uint32, pIEnumFORMATETC **IEnumFORMATETC) error { + ret, _, _ := syscall.Syscall( + obj.vtbl.EnumFormatEtc, + 3, + uintptr(unsafe.Pointer(obj)), + uintptr(direction), + uintptr(unsafe.Pointer(pIEnumFORMATETC)), + ) + + if ret != 0 { + return HRESULT(ret) + } + return nil +} + +type iEnumFORMATETCVtbl struct { + iUnknownVtbl + Next uintptr + Skip uintptr + Reset uintptr + Clone uintptr +} + +type IEnumFORMATETC struct { + vtbl *iEnumFORMATETCVtbl +} + +func (obj *IEnumFORMATETC) Release() error { + ret, _, _ := syscall.Syscall( + obj.vtbl.Release, + 1, + uintptr(unsafe.Pointer(obj)), + 0, + 0, + ) + if ret != 0 { + return HRESULT(ret) + } + return nil +} + +func (obj *IEnumFORMATETC) Next(formatEtc []FORMATETC, celtFetched *uint32) error { + ret, _, _ := syscall.Syscall6( + obj.vtbl.Next, + 4, + uintptr(unsafe.Pointer(obj)), + uintptr(len(formatEtc)), + uintptr(unsafe.Pointer(&formatEtc[0])), + uintptr(unsafe.Pointer(celtFetched)), + 0, + 0, + ) + if ret != 1 { + return HRESULT(ret) + } + return nil +} + +type EnumInstance struct { + iEnumFORMATETC IEnumFORMATETC + refCount int32 + index int + formatEtc []FORMATETC +} + +var ( + IID_IDataObject = win.GUID{0x10e, 0, 0, [8]byte{0xc0, 0, 0, 0, 0, 0, 0, 0x46}} + IID_IUnknown = win.GUID{0x000, 0, 0, [8]byte{0xc0, 0, 0, 0, 0, 0, 0, 0x46}} + IID_IEnumFORMATETC = win.GUID{0x103, 0, 0, [8]byte{0xc0, 0, 0, 0, 0, 0, 0, 0x46}} + IID_IStream = win.GUID{0x00c, 0, 0, [8]byte{0xc0, 0, 0, 0, 0, 0, 0, 0x46}} +) + +func newEnumInstance(fs []FORMATETC) *EnumInstance { + var instance EnumInstance + ie := &instance.iEnumFORMATETC + ie.vtbl = new(iEnumFORMATETCVtbl) + ie.vtbl.QueryInterface = syscall.NewCallback((*EnumInstance).QueryInterface) + ie.vtbl.AddRef = syscall.NewCallback((*EnumInstance).AddRef) + ie.vtbl.Release = syscall.NewCallback((*EnumInstance).Release) + ie.vtbl.Next = syscall.NewCallback((*EnumInstance).Next) + ie.vtbl.Skip = syscall.NewCallback((*EnumInstance).Skip) + ie.vtbl.Reset = syscall.NewCallback((*EnumInstance).Reset) + ie.vtbl.Clone = syscall.NewCallback((*EnumInstance).Clone) + + instance.refCount = 1 + if len(fs) > 0 { + instance.formatEtc = make([]FORMATETC, len(fs)) + copy(instance.formatEtc, fs) + } + + return &instance +} + +func (i *EnumInstance) QueryInterface(riid win.REFGUID, ppvObject *uintptr) uintptr { + if win.IsEqualGUID(riid, &IID_IEnumFORMATETC) || + win.IsEqualGUID(riid, &IID_IUnknown) { + *ppvObject = uintptr(unsafe.Pointer(i)) + i.AddRef() + return 0 + } + *ppvObject = 0 + return E_NOINTERFACE +} + +func (i *EnumInstance) AddRef() uintptr { + n := atomic.AddInt32(&i.refCount, 1) + return uintptr(n) +} + +func (i *EnumInstance) Release() uintptr { + n := atomic.AddInt32(&i.refCount, -1) + if n == 0 { + i = nil + return 0 + } + return uintptr(n) +} + +func (i *EnumInstance) Next(celt uint32, rgelt *FORMATETC, pceltFetched *uint32) uintptr { + r := make([]FORMATETC, celt) + var idx uint32 + for i.index < len(i.formatEtc) && idx < celt { + r[idx] = i.formatEtc[i.index] + i.index++ + idx++ + } + + *rgelt = r[0] + if pceltFetched != nil { + *pceltFetched = idx + } + + if idx != celt { + return E_FAIL + } + return 0 +} +func (i *EnumInstance) Skip(celt uint32) uintptr { + if i.index+int(celt) > len(i.formatEtc) { + return E_FAIL + } + i.index += int(celt) + return 0 +} +func (i *EnumInstance) Reset() uintptr { + i.index = 0 + return 0 +} +func (i *EnumInstance) Clone(ppEnum **IEnumFORMATETC) uintptr { + ins := newEnumInstance(i.formatEtc) + ins.index = i.index + (*ppEnum) = (*IEnumFORMATETC)(unsafe.Pointer(ins)) + + return 0 +} +func CreateDataObject(c *CliprdrClient) *IDataObject { + fmtetc := make([]FORMATETC, 2) + stgmeds := make([]STGMEDIUM, 2) + + fmtetc[0].CFormat = RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW) + fmtetc[0].Aspect = DVASPECT_CONTENT + fmtetc[0].Index = 0 + //fmtetc[0].DvTargetDevice = nil + fmtetc[0].Tymed = TYMED_HGLOBAL + stgmeds[0].Tymed = TYMED_HGLOBAL + //stgmeds[0].UnionMember = nil + stgmeds[0].PUnkForRelease = nil + fmtetc[1].CFormat = RegisterClipboardFormat(CFSTR_FILECONTENTS) + fmtetc[1].Aspect = DVASPECT_CONTENT + fmtetc[1].Index = 0 + //fmtetc[1].DvTargetDevice = nil + fmtetc[1].Tymed = TYMED_ISTREAM + stgmeds[1].Tymed = TYMED_ISTREAM + //stgmeds[1].UnionMember = nil + stgmeds[1].PUnkForRelease = nil + + instance := newDataInstance() + instance.refCount = 1 + instance.formatEtc = fmtetc + instance.stgMedium = stgmeds + instance.data = c + + return (*IDataObject)(unsafe.Pointer(instance)) +} + +type DataInstance struct { + iDataObject IDataObject + refCount int32 + idx int32 + formatEtc []FORMATETC + stgMedium []STGMEDIUM + streams []*StreamInstance + data interface{} +} + +func newDataInstance() *DataInstance { + var instance DataInstance + obj := &instance.iDataObject + obj.vtbl = new(iDataObjectVtbl) + obj.vtbl.QueryInterface = syscall.NewCallback((*DataInstance).QueryInterface) + obj.vtbl.AddRef = syscall.NewCallback((*DataInstance).AddRef) + obj.vtbl.Release = syscall.NewCallback((*DataInstance).Release) + obj.vtbl.GetData = syscall.NewCallback((*DataInstance).GetData) + obj.vtbl.GetDataHere = syscall.NewCallback((*DataInstance).GetDataHere) + obj.vtbl.QueryGetData = syscall.NewCallback((*DataInstance).QueryGetData) + obj.vtbl.GetCanonicalFormatEtc = syscall.NewCallback((*DataInstance).GetCanonicalFormatEtc) + obj.vtbl.SetData = syscall.NewCallback((*DataInstance).SetData) + obj.vtbl.EnumFormatEtc = syscall.NewCallback((*DataInstance).EnumFormatEtc) + obj.vtbl.DAdvise = syscall.NewCallback((*DataInstance).DAdvise) + obj.vtbl.DUnadvise = syscall.NewCallback((*DataInstance).DUnadvise) + obj.vtbl.EnumDAdvise = syscall.NewCallback((*DataInstance).EnumDAdvise) + + return &instance +} + +func (i *DataInstance) QueryInterface(riid win.REFGUID, ppvObject *uintptr) uintptr { + if win.IsEqualGUID(riid, &IID_IDataObject) || + win.IsEqualGUID(riid, &IID_IUnknown) { + *ppvObject = uintptr(unsafe.Pointer(i)) + i.AddRef() + return 0 + } + + *ppvObject = 0 + return E_NOINTERFACE +} + +func (i *DataInstance) AddRef() uintptr { + n := atomic.AddInt32(&i.refCount, 1) + return uintptr(n) +} + +func (i *DataInstance) Release() uintptr { + n := atomic.AddInt32(&i.refCount, -1) + if n == 0 { + i = nil + return 0 + } + return uintptr(n) +} + +func (i *DataInstance) GetData(formatEtc *FORMATETC, medium *STGMEDIUM) uintptr { + idx := -1 + for j, f := range i.formatEtc { + if formatEtc.Tymed&f.Tymed != 0 && + formatEtc.CFormat == f.CFormat && + formatEtc.Aspect&f.Aspect != 0 { + idx = j + } + } + if idx == -1 { + return E_FORMATETC + } + glog.Debugf("GetData:%+v, %s", formatEtc.CFormat, GetClipboardFormatName(formatEtc.CFormat)) + + medium.Tymed = i.formatEtc[idx].Tymed + + if i.formatEtc[idx].CFormat == RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW) { + c := i.data.(*CliprdrClient) + if remoteid, ok := c.formatIdMap[i.formatEtc[idx].CFormat]; ok { + c.sendFormatDataRequest(remoteid) + b := <-c.reply + if len(b) == 0 { + return E_FAIL + } + medium.UnionMember = HmemAlloc(b) + var dsc FileGroupDescriptor + dsc.Unpack(b) + if dsc.CItems > 0 { + glog.Debug("Items:", dsc.CItems) + i.streams = make([]*StreamInstance, dsc.CItems) + var j uint32 + for j = 0; j < dsc.CItems; j++ { + glog.Debug("FileName:", core.UnicodeDecode(dsc.Fgd[j].FileName)) + s := newStream(j, i.data, &dsc.Fgd[j]) + i.streams[j] = s + } + } + } + + } else if i.formatEtc[idx].CFormat == RegisterClipboardFormat(CFSTR_FILECONTENTS) { + if formatEtc.Index >= 0 && formatEtc.Index < int32(len(i.streams)) { + medium.UnionMember = uintptr(unsafe.Pointer(i.streams[formatEtc.Index])) + i.AddRef() + } else { + return E_INVALIDARG + } + } else { + return E_UNEXPECTED + } + + return 0 +} + +func (i *DataInstance) GetDataHere(formatEtc *FORMATETC, medium *STGMEDIUM) uintptr { + return E_NOTIMPL +} + +func (i *DataInstance) QueryGetData(formatEtc *FORMATETC) uintptr { + for _, f := range i.formatEtc { + if formatEtc.Tymed&f.Tymed != 0 && + formatEtc.CFormat == f.CFormat && + formatEtc.Aspect&f.Aspect != 0 { + return 0 + } + } + return E_FORMATETC +} + +func (i *DataInstance) GetCanonicalFormatEtc(informatEtc, outformatEtc *FORMATETC) uintptr { + return E_NOTIMPL +} + +func (i *DataInstance) SetData(formatEtc *FORMATETC, medium *STGMEDIUM, r bool) uintptr { + return E_NOTIMPL +} + +func (i *DataInstance) EnumFormatEtc(dwDirection uint32, ppenumFormatEtc **IEnumFORMATETC) uintptr { + if dwDirection == 1 { + ins := newEnumInstance(i.formatEtc) + (*ppenumFormatEtc) = (*IEnumFORMATETC)(unsafe.Pointer(ins)) + return 0 + } + + return E_NOTIMPL +} + +func (i *DataInstance) DAdvise(formatEtc *FORMATETC, advf uint32, pAdvSink uintptr, pdwConnection *uint32) uintptr { + return E_ADVISENOTSUPPORTED +} +func (i *DataInstance) DUnadvise(dwDirection uint32) uintptr { + return E_ADVISENOTSUPPORTED +} +func (i *DataInstance) EnumDAdvise(ppenumAdvise uintptr) uintptr { + return E_ADVISENOTSUPPORTED +} + +const ( + STREAM_SEEK_SET = 0 + STREAM_SEEK_CUR = 1 + STREAM_SEEK_END = 2 +) + +const ( + STATFLAG_DEFAULT = 0 + STATFLAG_NONAME = 1 + STATFLAG_NOOPEN = 2 +) + +const ( + STG_E_INSUFFICIENTMEMORY = 0x80030008 + STG_E_INVALIDFLAG = 0x800300FF +) + +const ( + STGTY_STORAGE = 1 + STGTY_STREAM = 2 + STGTY_LOCKBYTES = 3 + STGTY_PROPERTY = 4 +) + +const ( + LOCK_WRITE = 1 + LOCK_EXCLUSIVE = 2 + LOCK_ONLYONCE = 4 +) + +const ( + GENERIC_READ = 0x80000000 + GENERIC_WRITE = 0x40000000 + GENERIC_EXECUTE = 0x20000000 +) + +type IStreamVtbl struct { + ISequentialStreamVtbl + Seek uintptr + SetSize uintptr + CopyTo uintptr + Commit uintptr + Revert uintptr + LockRegion uintptr + UnlockRegion uintptr + Stat uintptr + Clone uintptr +} + +type IStream struct { + vtbl *IStreamVtbl +} +type ULARGE_INTEGER struct { + QuadPart uint64 +} +type LARGE_INTEGER struct { + QuadPart int64 +} + +func (l *ULARGE_INTEGER) LowPart() *uint32 { + return (*uint32)(unsafe.Pointer(&l.QuadPart)) +} +func (l *ULARGE_INTEGER) HighPart() *uint32 { + return (*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&l.QuadPart)) + uintptr(4))) +} +func (l *LARGE_INTEGER) LowPart() *uint32 { + return (*uint32)(unsafe.Pointer(&l.QuadPart)) +} +func (l *LARGE_INTEGER) HighPart() *int32 { + return (*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&l.QuadPart)) + uintptr(4))) +} + +type StreamInstance struct { + iStream IStream + streamId uint32 + refCount int32 + index uint32 + lSize ULARGE_INTEGER + lOffset ULARGE_INTEGER + dsc FileDescriptor + data interface{} +} +type STATSTG struct { + pwcsName []uint16 + sType uint32 + cbSize ULARGE_INTEGER + mtime win.FILETIME + ctime win.FILETIME + atime win.FILETIME + grfMode uint32 + grfLocksSupported uint32 + clsid win.CLSID + grfStateBits uint32 + reserved uint32 +} + +func (obj *IStream) Read(buffer []byte) (int, error) { + bufPtr := &buffer[0] + var read uint32 + ret, _, _ := syscall.Syscall6( + obj.vtbl.Read, + 4, + uintptr(unsafe.Pointer(obj)), + uintptr(unsafe.Pointer(bufPtr)), + uintptr(len(buffer)), + uintptr(unsafe.Pointer(&read)), + 0, + 0, + ) + if ret == 1 { + return int(read), io.EOF + } + if ret != 0 { + return int(read), HRESULT(ret) + } + return int(read), nil +} +func (obj *IStream) Close() error { + return obj.Release() +} +func (obj *IStream) Release() error { + ret, _, _ := syscall.Syscall( + obj.vtbl.Release, + 1, + uintptr(unsafe.Pointer(obj)), + 0, + 0, + ) + if ret != 0 { + return HRESULT(ret) + } + return nil +} +func newStream(index uint32, data interface{}, dsc *FileDescriptor) *StreamInstance { + var instance StreamInstance + is := &instance.iStream + is.vtbl = new(IStreamVtbl) + is.vtbl.QueryInterface = syscall.NewCallback((*StreamInstance).QueryInterface) + is.vtbl.AddRef = syscall.NewCallback((*StreamInstance).AddRef) + is.vtbl.Release = syscall.NewCallback((*StreamInstance).Release) + is.vtbl.Read = syscall.NewCallback((*StreamInstance).Read) + is.vtbl.Write = syscall.NewCallback((*StreamInstance).Write) + is.vtbl.Seek = syscall.NewCallback((*StreamInstance).Seek) + is.vtbl.SetSize = syscall.NewCallback((*StreamInstance).SetSize) + is.vtbl.CopyTo = syscall.NewCallback((*StreamInstance).CopyTo) + is.vtbl.Commit = syscall.NewCallback((*StreamInstance).Commit) + is.vtbl.Revert = syscall.NewCallback((*StreamInstance).Revert) + is.vtbl.LockRegion = syscall.NewCallback((*StreamInstance).LockRegion) + is.vtbl.UnlockRegion = syscall.NewCallback((*StreamInstance).UnlockRegion) + is.vtbl.Stat = syscall.NewCallback((*StreamInstance).Stat) + is.vtbl.Clone = syscall.NewCallback((*StreamInstance).Clone) + + instance.streamId = (uint32)(reflect.ValueOf(&instance).Pointer()) + instance.refCount = 1 + instance.dsc = *dsc + instance.data = data + instance.index = index + if !instance.dsc.hasFileSize() && !instance.dsc.isDir() { + c := data.(*CliprdrClient) + var r CliprdrFileContentsRequest + r.StreamId = instance.streamId + r.Lindex = instance.index + r.DwFlags = FILECONTENTS_SIZE + r.CbRequested = 8 + c.sendFormatContentsRequest(r) + b := <-c.reply + instance.lSize.QuadPart = core.BytesToUint64(b) + } else { + b := &bytes.Buffer{} + core.WriteUInt32LE(dsc.FileSizeLow, b) + core.WriteUInt32LE(dsc.FileSizeHigh, b) + instance.lSize.QuadPart = core.BytesToUint64(b.Bytes()) + } + + return &instance +} + +func (i *StreamInstance) QueryInterface(riid win.REFGUID, ppvObject *uintptr) uintptr { + if win.IsEqualGUID(riid, &IID_IStream) || + win.IsEqualGUID(riid, &IID_IUnknown) { + *ppvObject = uintptr(unsafe.Pointer(i)) + i.AddRef() + return 0 + } + *ppvObject = 0 + return E_NOINTERFACE +} + +func (i *StreamInstance) AddRef() uintptr { + n := atomic.AddInt32(&i.refCount, 1) + return uintptr(n) +} + +func (i *StreamInstance) Release() uintptr { + n := atomic.AddInt32(&i.refCount, -1) + if n == 0 { + i = nil + return 0 + } + return uintptr(n) +} + +func (i *StreamInstance) Read(pv uintptr, cb uint32, cbRead *uint32) uintptr { + glog.Debug("StreamInstance Read:", i.lOffset.QuadPart, i.lSize.QuadPart) + if i.lOffset.QuadPart >= i.lSize.QuadPart { + return 1 + } + + c := i.data.(*CliprdrClient) + *cbRead = 0 + var r CliprdrFileContentsRequest + r.StreamId = i.streamId + r.Lindex = i.index + r.DwFlags = FILECONTENTS_RANGE + r.NPositionHigh = *(i.lOffset.HighPart()) + r.NPositionLow = *(i.lOffset.LowPart()) + r.CbRequested = cb + c.sendFormatContentsRequest(r) + b := <-c.reply + if len(b) == 0 { + return E_FAIL + } + win.RtlCopyMemory(pv, uintptr(unsafe.Pointer(&b[0])), win.SIZE_T(len(b))) + *cbRead = uint32(len(b)) + i.lOffset.QuadPart += uint64(len(b)) + glog.Debug("StreamInstance Read:", *cbRead, cb) + if *cbRead < cb { + return 1 + } + return 0 +} + +func (i *StreamInstance) Write(pv uintptr, cb uint32, cbWritten *uint32) uintptr { + return E_ACCESSDENIED +} + +func (i *StreamInstance) Seek(dlibMove LARGE_INTEGER, dwOrigin uint32, plibNewPosition *ULARGE_INTEGER) uintptr { + glog.Debug("StreamInstance Seek:", dwOrigin, dlibMove, plibNewPosition) + var newoffset uint64 = i.lOffset.QuadPart + switch dwOrigin { + case STREAM_SEEK_SET: + newoffset = uint64(dlibMove.QuadPart) + break + + case STREAM_SEEK_CUR: + newoffset += uint64(dlibMove.QuadPart) + break + + case STREAM_SEEK_END: + newoffset = i.lSize.QuadPart + uint64(dlibMove.QuadPart) + break + + default: + return E_INVALIDARG + } + glog.Debug("StreamInstance Seek:", newoffset, i.lSize.QuadPart) + if newoffset < 0 || newoffset >= i.lSize.QuadPart { + return 1 + } + i.lOffset.QuadPart = newoffset + + if plibNewPosition != nil { + (*plibNewPosition).QuadPart = i.lOffset.QuadPart + } + + return 0 +} + +func (i *StreamInstance) SetSize(libNewSize ULARGE_INTEGER) uintptr { + return E_NOTIMPL +} + +func (i *StreamInstance) CopyTo(pstm *IStream, cb ULARGE_INTEGER, cbRead, cbWritten *ULARGE_INTEGER) uintptr { + return E_NOTIMPL +} + +func (i *StreamInstance) Commit(grfCommitFlags uint32) uintptr { + return E_NOTIMPL +} + +func (i *StreamInstance) Revert() uintptr { + return E_NOTIMPL +} + +func (i *StreamInstance) LockRegion(libOffset, cb ULARGE_INTEGER, dwLockType uint32) uintptr { + return E_NOTIMPL +} + +func (i *StreamInstance) UnlockRegion(libOffset, cb ULARGE_INTEGER, dwLockType uint32) uintptr { + return E_NOTIMPL +} + +func (i *StreamInstance) Stat(pstatstg *STATSTG, grfStatFlag uint32) uintptr { + switch grfStatFlag { + case STATFLAG_DEFAULT: + return STG_E_INSUFFICIENTMEMORY + + case STATFLAG_NONAME: + pstatstg.cbSize.QuadPart = i.lSize.QuadPart + pstatstg.grfLocksSupported = LOCK_EXCLUSIVE + pstatstg.grfMode = GENERIC_READ + pstatstg.grfStateBits = 0 + pstatstg.sType = STGTY_STREAM + break + + case STATFLAG_NOOPEN: + return STG_E_INVALIDFLAG + + default: + return STG_E_INVALIDFLAG + } + + return 0 +} + +func (i *StreamInstance) Clone(ppstm **IStream) uintptr { + return E_NOTIMPL +} diff --git a/grdp/plugin/drdynvc/dvc.go b/grdp/plugin/drdynvc/dvc.go new file mode 100644 index 0000000..22f418e --- /dev/null +++ b/grdp/plugin/drdynvc/dvc.go @@ -0,0 +1,162 @@ +package drdynvc + +import ( + "bytes" + "encoding/hex" + "io" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/glog" + "ShotRDP/grdp/plugin" +) + +const ( + ChannelName = plugin.DRDYNVC_SVC_CHANNEL_NAME + ChannelOption = plugin.CHANNEL_OPTION_INITIALIZED | + plugin.CHANNEL_OPTION_ENCRYPT_RDP +) + +const ( + MAX_DVC_CHANNELS = 20 +) + +const ( + DYNVC_CREATE_REQ = 0x01 + DYNVC_DATA_FIRST = 0x02 + DYNVC_DATA = 0x03 + DYNVC_CLOSE = 0x04 + DYNVC_CAPABILITIES = 0x05 + DYNVC_DATA_FIRST_COMPRESSED = 0x06 + DYNVC_DATA_COMPRESSED = 0x07 + DYNVC_SOFT_SYNC_REQUEST = 0x08 + DYNVC_SOFT_SYNC_RESPONSE = 0x09 +) + +type ChannelClient struct { + name string + id uint32 + channelSender core.ChannelSender +} + +type DvcClient struct { + w core.ChannelSender + channels map[string]ChannelClient +} + +func NewDvcClient() *DvcClient { + return &DvcClient{ + channels: make(map[string]ChannelClient, 100), + } +} + +func (c *DvcClient) LoadAddin(f core.ChannelSender) { + +} + +type DvcHeader struct { + cmd uint8 + sp uint8 + cbChId uint8 +} + +func readHeader(r io.Reader) *DvcHeader { + value, _ := core.ReadUInt8(r) + cmd := (value & 0xf0) >> 4 + sp := (value & 0x0c) >> 2 + cbChId := (value & 0x03) >> 0 + return &DvcHeader{cmd, sp, cbChId} +} + +func (h *DvcHeader) serialize(channelId uint32) []byte { + b := &bytes.Buffer{} + core.WriteUInt8((h.cmd<<4)|(h.sp<<2)|h.cbChId, b) + if h.cbChId == 0 { + core.WriteUInt8(uint8(channelId), b) + } else if h.cbChId == 1 { + core.WriteUInt16LE(uint16(channelId), b) + } else { + core.WriteUInt32LE(channelId, b) + } + + return b.Bytes() +} + +func (c *DvcClient) Send(s []byte) (int, error) { + glog.Debug("len:", len(s), "data:", hex.EncodeToString(s)) + name, _ := c.GetType() + return c.w.SendToChannel(name, s) +} +func (c *DvcClient) Sender(f core.ChannelSender) { + c.w = f +} +func (c *DvcClient) GetType() (string, uint32) { + return ChannelName, ChannelOption +} + +func (c *DvcClient) Process(s []byte) { + glog.Debug("recv:", hex.EncodeToString(s)) + r := bytes.NewReader(s) + hdr := readHeader(r) + glog.Infof("dvc: Cmd=0x%x, Sp=%d CbChId=%d all=%d", hdr.cmd, hdr.sp, hdr.cbChId, r.Len()) + + b, _ := core.ReadBytes(r.Len(), r) + + switch hdr.cmd { + case DYNVC_CAPABILITIES: + glog.Info("DYNVC_CAPABILITIES") + c.processCapsPdu(hdr, b) + case DYNVC_CREATE_REQ: + glog.Info("DYNVC_CREATE_REQ") + c.processCreateReq(hdr, b) + case DYNVC_DATA_FIRST: + glog.Info("DYNVC_DATA_FIRST") + case DYNVC_DATA: + glog.Info("DYNVC_DATA") + case DYNVC_CLOSE: + glog.Info("DYNVC_CLOSE") + default: + glog.Errorf("type 0x%x not supported", hdr.cmd) + } +} +func (c *DvcClient) processCreateReq(hdr *DvcHeader, s []byte) { + r := bytes.NewReader(s) + channelId := readDvcId(r, hdr.cbChId) + name, _ := core.ReadBytes(r.Len(), r) + channelName := string(name) + glog.Infof("Server requests channelId=%d, name=%s", channelId, channelName) + + //response + b := &bytes.Buffer{} + b.Write(hdr.serialize(channelId)) + core.WriteUInt32LE(0, b) + c.Send(b.Bytes()) +} + +func readDvcId(r io.Reader, cbLen uint8) (id uint32) { + switch cbLen { + case 0: + i, _ := core.ReadUInt8(r) + id = uint32(i) + case 1: + i, _ := core.ReadUint16LE(r) + id = uint32(i) + default: + id, _ = core.ReadUInt32LE(r) + } + return +} +func (c *DvcClient) processCapsPdu(hdr *DvcHeader, s []byte) { + r := bytes.NewReader(s) + core.ReadUInt8(r) + ver, _ := core.ReadUint16LE(r) + glog.Infof("Server supports dvc=%d", ver) + + hdr.cmd = DYNVC_CAPABILITIES + hdr.cbChId = 0 + hdr.sp = 0 + + b := &bytes.Buffer{} + core.WriteUInt16LE(0x0050, b) + core.WriteUInt16LE(ver, b) + c.Send(b.Bytes()) +} diff --git a/grdp/plugin/rail/rail.go b/grdp/plugin/rail/rail.go new file mode 100644 index 0000000..121aa89 --- /dev/null +++ b/grdp/plugin/rail/rail.go @@ -0,0 +1,451 @@ +// rail.go +package rail + +import ( + "bytes" + "encoding/hex" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/glog" + "ShotRDP/grdp/plugin" +) + +const ( + ChannelName = plugin.RAIL_SVC_CHANNEL_NAME + ChannelOption = plugin.CHANNEL_OPTION_INITIALIZED | plugin.CHANNEL_OPTION_ENCRYPT_RDP | + plugin.CHANNEL_OPTION_COMPRESS_RDP | plugin.CHANNEL_OPTION_SHOW_PROTOCOL +) + +const ( + TS_RAIL_ORDER_EXEC = 0x0001 + TS_RAIL_ORDER_ACTIVATE = 0x0002 + TS_RAIL_ORDER_SYSPARAM = 0x0003 + TS_RAIL_ORDER_SYSCOMMAND = 0x0004 + TS_RAIL_ORDER_HANDSHAKE = 0x0005 + TS_RAIL_ORDER_NOTIFY_EVENT = 0x0006 + TS_RAIL_ORDER_WINDOWMOVE = 0x0008 + TS_RAIL_ORDER_LOCALMOVESIZE = 0x0009 + TS_RAIL_ORDER_MINMAXINFO = 0x000A + TS_RAIL_ORDER_CLIENTSTATUS = 0x000B + TS_RAIL_ORDER_SYSMENU = 0x000C + TS_RAIL_ORDER_LANGBARINFO = 0x000D + TS_RAIL_ORDER_GET_APPID_REQ = 0x000E + TS_RAIL_ORDER_GET_APPID_RESP = 0x000F + TS_RAIL_ORDER_TASKBARINFO = 0x0010 + TS_RAIL_ORDER_LANGUAGEIMEINFO = 0x0011 + TS_RAIL_ORDER_COMPARTMENTINFO = 0x0012 + TS_RAIL_ORDER_HANDSHAKE_EX = 0x0013 + TS_RAIL_ORDER_ZORDER_SYNC = 0x0014 + TS_RAIL_ORDER_CLOAK = 0x0015 + TS_RAIL_ORDER_POWER_DISPLAY_REQUEST = 0x0016 + TS_RAIL_ORDER_SNAP_ARRANGE = 0x0017 + TS_RAIL_ORDER_GET_APPID_RESP_EX = 0x0018 + TS_RAIL_ORDER_EXEC_RESULT = 0x0080 +) + +type RailClient struct { + w core.ChannelSender + DesktopWidth uint16 + DesktopHeight uint16 + RemoteApplicationProgram string + ShellWorkingDirectory string + RemoteApplicationCmdLine string +} + +func NewClient() *RailClient { + return &RailClient{ + DesktopWidth: 800, + DesktopHeight: 600, + RemoteApplicationProgram: "calc", + ShellWorkingDirectory: "/tmp", + } +} + +type RailPDUHeader struct { + OrderType uint16 `struc:"little"` + OrderLength uint16 `struc:"little"` +} + +func NewRailPDUHeader(mType, ln uint16) *RailPDUHeader { + return &RailPDUHeader{ + OrderType: mType, + OrderLength: ln, + } +} + +func (h *RailPDUHeader) serialize() []byte { + b := &bytes.Buffer{} + core.WriteUInt16LE(h.OrderType, b) + core.WriteUInt16LE(h.OrderLength, b) + return b.Bytes() +} + +func (c *RailClient) sendData(mType uint16, ln int, s []byte) { + glog.Debug(ln, ":ln:", len(s), "data:", hex.EncodeToString(s)) + header := NewRailPDUHeader(mType, uint16(ln)) + + b := &bytes.Buffer{} + core.WriteBytes(header.serialize(), b) + core.WriteBytes(s, b) + + c.Send(b.Bytes()) +} + +func (c *RailClient) Send(s []byte) (int, error) { + glog.Debug("len:", len(s), "data:", hex.EncodeToString(s)) + name, _ := c.GetType() + return c.w.SendToChannel(name, s) +} +func (c *RailClient) Sender(f core.ChannelSender) { + c.w = f +} +func (c *RailClient) GetType() (string, uint32) { + return ChannelName, ChannelOption +} + +func (c *RailClient) Process(s []byte) { + glog.Debug("recv:", hex.EncodeToString(s)) + r := bytes.NewReader(s) + msgType, _ := core.ReadUint16LE(r) + length, _ := core.ReadUint16LE(r) + + glog.Infof("rail: type=0x%x length=%d, all=%d", msgType, length, r.Len()) + + b, _ := core.ReadBytes(int(length), r) + glog.Info("b:", hex.EncodeToString(b)) + + switch msgType { + case TS_RAIL_ORDER_HANDSHAKE: + glog.Info("TS_RAIL_ORDER_HANDSHAKE") + c.processOrderHandshake(b) + case TS_RAIL_ORDER_SYSPARAM: + glog.Info("TS_RAIL_ORDER_SYSPARAM") + c.processOrderSysparam(b) + case TS_RAIL_ORDER_EXEC_RESULT: + glog.Info("TS_RAIL_ORDER_EXEC_RESULT") + c.processExecResult(b) + + default: + glog.Errorf("type 0x%x not supported", msgType) + } +} + +func (c *RailClient) processOrderHandshake(b []byte) { + r := bytes.NewReader(b) + buildNumber, _ := core.ReadUInt32LE(r) + glog.Info("buildNumber:", buildNumber) + + //send client info + c.sendClientStatus() + + //send client systemparam + c.sendClientSystemparam() + + //send client execute + c.sendClientExecute() +} + +const ( + TS_RAIL_CLIENTSTATUS_ALLOWLOCALMOVESIZE = 0x00000001 + TS_RAIL_CLIENTSTATUS_AUTORECONNECT = 0x00000002 + TS_RAIL_CLIENTSTATUS_ZORDER_SYNC = 0x00000004 + TS_RAIL_CLIENTSTATUS_WINDOW_RESIZE_MARGIN_SUPPORTED = 0x00000010 + TS_RAIL_CLIENTSTATUS_HIGH_DPI_ICONS_SUPPORTED = 0x00000020 + TS_RAIL_CLIENTSTATUS_APPBAR_REMOTING_SUPPORTED = 0x00000040 + TS_RAIL_CLIENTSTATUS_POWER_DISPLAY_REQUEST_SUPPORTED = 0x00000080 + TS_RAIL_CLIENTSTATUS_GET_APPID_RESPONSE_EX_SUPPORTED = 0x00000100 + TS_RAIL_CLIENTSTATUS_BIDIRECTIONAL_CLOAK_SUPPORTED = 0x00000200 +) + +func (c *RailClient) sendClientStatus() { + glog.Info("Send client Status") + var flags uint32 = TS_RAIL_CLIENTSTATUS_ALLOWLOCALMOVESIZE + + //if (settings->AutoReconnectionEnabled) + //clientStatus.flags |= TS_RAIL_CLIENTSTATUS_AUTORECONNECT; + + flags |= TS_RAIL_CLIENTSTATUS_ZORDER_SYNC + flags |= TS_RAIL_CLIENTSTATUS_WINDOW_RESIZE_MARGIN_SUPPORTED + flags |= TS_RAIL_CLIENTSTATUS_APPBAR_REMOTING_SUPPORTED + flags |= TS_RAIL_CLIENTSTATUS_POWER_DISPLAY_REQUEST_SUPPORTED + flags |= TS_RAIL_CLIENTSTATUS_BIDIRECTIONAL_CLOAK_SUPPORTED + + b := &bytes.Buffer{} + core.WriteUInt32LE(flags, b) + + c.sendData(TS_RAIL_ORDER_CLIENTSTATUS, 4, b.Bytes()) +} + +const ( + SPI_SET_SCREEN_SAVE_ACTIVE = 0x00000011 + SPI_SET_SCREEN_SAVE_SECURE = 0x00000077 +) +const ( + /*Bit mask values for SPI_ parameters*/ + SPI_MASK_SET_DRAG_FULL_WINDOWS = 0x00000001 + SPI_MASK_SET_KEYBOARD_CUES = 0x00000002 + SPI_MASK_SET_KEYBOARD_PREF = 0x00000004 + SPI_MASK_SET_MOUSE_BUTTON_SWAP = 0x00000008 + SPI_MASK_SET_WORK_AREA = 0x00000010 + SPI_MASK_DISPLAY_CHANGE = 0x00000020 + SPI_MASK_TASKBAR_POS = 0x00000040 + SPI_MASK_SET_HIGH_CONTRAST = 0x00000080 + SPI_MASK_SET_SCREEN_SAVE_ACTIVE = 0x00000100 + SPI_MASK_SET_SET_SCREEN_SAVE_SECURE = 0x00000200 + SPI_MASK_SET_CARET_WIDTH = 0x00000400 + SPI_MASK_SET_STICKY_KEYS = 0x00000800 + SPI_MASK_SET_TOGGLE_KEYS = 0x00001000 + SPI_MASK_SET_FILTER_KEYS = 0x00002000 +) +const ( + SPI_SET_DRAG_FULL_WINDOWS = 0x00000025 + SPI_SET_KEYBOARD_CUES = 0x0000100B + SPI_SET_KEYBOARD_PREF = 0x00000045 + SPI_SET_MOUSE_BUTTON_SWAP = 0x00000021 + SPI_SET_WORK_AREA = 0x0000002F + SPI_DISPLAY_CHANGE = 0x0000F001 + SPI_TASKBAR_POS = 0x0000F000 + SPI_SET_HIGH_CONTRAST = 0x00000043 + SPI_SETCARETWIDTH = 0x00002007 + SPI_SETSTICKYKEYS = 0x0000003B + SPI_SETTOGGLEKEYS = 0x00000035 + SPI_SETFILTERKEYS = 0x00000033 +) + +type TsFilterKeys struct { + Flags uint32 + WaitTime uint32 + DelayTime uint32 + RepeatTime uint32 + BounceTime uint32 +} +type RailHighContrast struct { + flags uint32 + colorSchemeLength uint32 + colorScheme string +} +type Rectangle16 struct { + left uint16 + top uint16 + right uint16 + bottom uint16 +} +type RailSysparamOrder struct { + param uint32 + params uint32 + dragFullWindows uint8 + keyboardCues uint8 + keyboardPref uint8 + mouseButtonSwap uint8 + workArea Rectangle16 + displayChange Rectangle16 + taskbarPos Rectangle16 + highContrast RailHighContrast + caretWidth uint32 + stickyKeys uint32 + toggleKeys uint32 + filterKeys TsFilterKeys + setScreenSaveActive uint8 + setScreenSaveSecure uint8 +} + +func (c *RailClient) sendClientSystemparam() { + glog.Info("Send client Systemparam") + + var sp RailSysparamOrder + sp.params = 0 + sp.params |= SPI_MASK_SET_HIGH_CONTRAST + sp.highContrast.colorScheme = "" + sp.highContrast.colorSchemeLength = 0 + sp.highContrast.flags = 0x7E + sp.params |= SPI_MASK_SET_MOUSE_BUTTON_SWAP + sp.mouseButtonSwap = 0 + sp.params |= SPI_MASK_SET_KEYBOARD_PREF + sp.keyboardPref = 0 + sp.params |= SPI_MASK_SET_DRAG_FULL_WINDOWS + sp.dragFullWindows = 0 + sp.params |= SPI_MASK_SET_KEYBOARD_CUES + sp.keyboardCues = 0 + sp.params |= SPI_MASK_SET_WORK_AREA + sp.workArea.left = 0 + sp.workArea.top = 0 + sp.workArea.right = c.DesktopWidth + sp.workArea.bottom = c.DesktopHeight + + if sp.params&SPI_MASK_SET_HIGH_CONTRAST != 0 { + sp.param = SPI_SET_HIGH_CONTRAST + c.sendOneClientSysparam(&sp) + } + + if sp.params&SPI_MASK_TASKBAR_POS != 0 { + sp.param = SPI_TASKBAR_POS + c.sendOneClientSysparam(&sp) + } + + if sp.params&SPI_MASK_SET_MOUSE_BUTTON_SWAP != 0 { + sp.param = SPI_SET_MOUSE_BUTTON_SWAP + c.sendOneClientSysparam(&sp) + } + + if sp.params&SPI_MASK_SET_KEYBOARD_PREF != 0 { + sp.param = SPI_SET_KEYBOARD_PREF + c.sendOneClientSysparam(&sp) + } + + if sp.params&SPI_MASK_SET_DRAG_FULL_WINDOWS != 0 { + sp.param = SPI_SET_DRAG_FULL_WINDOWS + c.sendOneClientSysparam(&sp) + } + + if sp.params&SPI_MASK_SET_KEYBOARD_CUES != 0 { + sp.param = SPI_SET_KEYBOARD_CUES + c.sendOneClientSysparam(&sp) + } + + if sp.params&SPI_MASK_SET_WORK_AREA != 0 { + sp.param = SPI_SET_WORK_AREA + glog.Debug("SPI_SET_WORK_AREA") + c.sendOneClientSysparam(&sp) + } +} + +func (c *RailClient) sendOneClientSysparam(sp *RailSysparamOrder) { + length := 0 + b := &bytes.Buffer{} + core.WriteUInt32LE(sp.param, b) + switch sp.param { + case SPI_SET_DRAG_FULL_WINDOWS: + core.WriteUInt8(sp.dragFullWindows, b) + + case SPI_SET_KEYBOARD_CUES: + core.WriteUInt8(sp.keyboardCues, b) + + case SPI_SET_KEYBOARD_PREF: + core.WriteUInt8(sp.keyboardPref, b) + + case SPI_SET_MOUSE_BUTTON_SWAP: + core.WriteUInt8(sp.mouseButtonSwap, b) + + case SPI_SET_WORK_AREA: + core.WriteUInt16LE(sp.workArea.left, b) + core.WriteUInt16LE(sp.workArea.top, b) + core.WriteUInt16LE(sp.workArea.right, b) + core.WriteUInt16LE(sp.workArea.bottom, b) + + case SPI_DISPLAY_CHANGE: + core.WriteUInt16LE(sp.displayChange.left, b) + core.WriteUInt16LE(sp.displayChange.top, b) + core.WriteUInt16LE(sp.displayChange.right, b) + core.WriteUInt16LE(sp.displayChange.bottom, b) + + case SPI_TASKBAR_POS: + core.WriteUInt16LE(sp.taskbarPos.left, b) + core.WriteUInt16LE(sp.taskbarPos.top, b) + core.WriteUInt16LE(sp.taskbarPos.right, b) + core.WriteUInt16LE(sp.taskbarPos.bottom, b) + + case SPI_SET_HIGH_CONTRAST: + core.WriteUInt32LE(sp.highContrast.flags, b) + core.WriteUInt32LE(sp.highContrast.colorSchemeLength, b) + data := core.UnicodeEncode(sp.highContrast.colorScheme) + core.WriteBytes(data, b) + + case SPI_SETFILTERKEYS: + core.WriteUInt32LE(sp.filterKeys.Flags, b) + core.WriteUInt32LE(sp.filterKeys.WaitTime, b) + core.WriteUInt32LE(sp.filterKeys.DelayTime, b) + core.WriteUInt32LE(sp.filterKeys.RepeatTime, b) + core.WriteUInt32LE(sp.filterKeys.BounceTime, b) + + case SPI_SETSTICKYKEYS: + core.WriteUInt32LE(sp.stickyKeys, b) + + case SPI_SETCARETWIDTH: + core.WriteUInt32LE(sp.caretWidth, b) + + case SPI_SETTOGGLEKEYS: + core.WriteUInt32LE(sp.toggleKeys, b) + + case SPI_MASK_SET_SET_SCREEN_SAVE_SECURE: + core.WriteUInt8(sp.setScreenSaveSecure, b) + + case SPI_MASK_SET_SCREEN_SAVE_ACTIVE: + core.WriteUInt8(sp.setScreenSaveActive, b) + + default: + glog.Error("ERROR_BAD_ARGUMENTS") + return + } + + c.sendData(TS_RAIL_ORDER_SYSPARAM, length+b.Len(), b.Bytes()) +} + +type RailExecOrder struct { + flags uint16 + RemoteApplicationProgram string + RemoteApplicationWorkingDir string + RemoteApplicationArguments string +} + +func (c *RailClient) sendClientExecute() { + glog.Info("Send Client Execute") + var exec RailExecOrder + //exec.flags = TS_RAIL_EXEC_FLAG_EXPAND_ARGUMENTS + exec.RemoteApplicationProgram = c.RemoteApplicationProgram + exec.RemoteApplicationWorkingDir = c.ShellWorkingDirectory + exec.RemoteApplicationArguments = c.RemoteApplicationCmdLine + + program := core.UnicodeEncode(exec.RemoteApplicationProgram) + workdir := core.UnicodeEncode(exec.RemoteApplicationWorkingDir) + arguments := core.UnicodeEncode(exec.RemoteApplicationArguments) + + length := 4 + b := &bytes.Buffer{} + core.WriteUInt16LE(exec.flags, b) + core.WriteUInt16LE(uint16(len(program)), b) + core.WriteUInt16LE(uint16(len(workdir)), b) + core.WriteUInt16LE(uint16(len(arguments)), b) + core.WriteBytes(program, b) + core.WriteBytes(workdir, b) + core.WriteBytes(arguments, b) + length += b.Len() + + c.sendData(TS_RAIL_ORDER_EXEC, length, b.Bytes()) + +} + +func (c *RailClient) processOrderSysparam(b []byte) { + r := bytes.NewReader(b) + systemParam, _ := core.ReadUInt32LE(r) + body, _ := core.ReadUInt8(r) + glog.Infof("systemParam:0x%x, body:%d", systemParam, body) +} + +const ( + //The Client Execute request was successful and the requested application or file has been launched. + RAIL_EXEC_S_OK = 0x0000 + //The Client Execute request could not be satisfied because the server is not monitoring the current input desktop. + RAIL_EXEC_E_HOOK_NOT_LOADED = 0x0001 + //The Execute request could not be satisfied because the request PDU was malformed. + RAIL_EXEC_E_DECODE_FAILED = 0x0002 + //The Client Execute request could not be satisfied because the requested application was blocked by policy from being launched on the server. + RAIL_EXEC_E_NOT_IN_ALLOWLIST = 0x0003 + //The Client Execute request could not be satisfied because the application or file path could not be found. + RAIL_EXEC_E_FILE_NOT_FOUND = 0x0005 + //The Client Execute request could not be satisfied because an unspecified error occurred on the server. + RAIL_EXEC_E_FAIL = 0x0006 + //The Client Execute request could not be satisfied because the remote session is locked. + RAIL_EXEC_E_SESSION_LOCKED = 0x0007 +) + +func (c *RailClient) processExecResult(b []byte) { + r := bytes.NewReader(b) + flags, _ := core.ReadUint16LE(r) + execResult, _ := core.ReadUint16LE(r) + rawResult, _ := core.ReadUInt32LE(r) + core.ReadUint16LE(r) + exeOrFileLength, _ := core.ReadUint16LE(r) + exeOrFile, _ := core.ReadBytes(r.Len(), r) + glog.Info("flags:", flags, "execResult:", execResult, "rawResult:", rawResult) + glog.Info("length:", exeOrFileLength, "file:", core.UnicodeDecode(exeOrFile)) +} diff --git a/grdp/plugin/rdpgfx/rdpgfx.go b/grdp/plugin/rdpgfx/rdpgfx.go new file mode 100644 index 0000000..34e82c2 --- /dev/null +++ b/grdp/plugin/rdpgfx/rdpgfx.go @@ -0,0 +1,28 @@ +package rdpgfx + +import ( + "encoding/hex" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/glog" + "ShotRDP/grdp/plugin" +) + +const ( + ChannelName = plugin.RDPGFX_DVC_CHANNEL_NAME +) + +type gfxClient struct { +} + +func (c *gfxClient) Send(s []byte) (int, error) { + glog.Debug("len:", len(s), "data:", hex.EncodeToString(s)) + name, _ := c.GetType() + return c.w.SendToChannel(name, s) +} +func (c *gfxClient) Sender(f core.ChannelSender) { + c.w = f +} +func (c *gfxClient) GetType() (string, uint32) { + return ChannelName, 0 +} diff --git a/grdp/protocol/lic/lic.go b/grdp/protocol/lic/lic.go new file mode 100644 index 0000000..f594d1a --- /dev/null +++ b/grdp/protocol/lic/lic.go @@ -0,0 +1,183 @@ +package lic + +import ( + "io" + + "ShotRDP/grdp/core" +) + +const ( + LICENSE_REQUEST = 0x01 + PLATFORM_CHALLENGE = 0x02 + NEW_LICENSE = 0x03 + UPGRADE_LICENSE = 0x04 + LICENSE_INFO = 0x12 + NEW_LICENSE_REQUEST = 0x13 + PLATFORM_CHALLENGE_RESPONSE = 0x15 + ERROR_ALERT = 0xFF +) + +// error code +const ( + ERR_INVALID_SERVER_CERTIFICATE = 0x00000001 + ERR_NO_LICENSE = 0x00000002 + ERR_INVALID_SCOPE = 0x00000004 + ERR_NO_LICENSE_SERVER = 0x00000006 + STATUS_VALID_CLIENT = 0x00000007 + ERR_INVALID_CLIENT = 0x00000008 + ERR_INVALID_PRODUCTID = 0x0000000B + ERR_INVALID_MESSAGE_LEN = 0x0000000C + ERR_INVALID_MAC = 0x00000003 +) + +// state transition +const ( + ST_TOTAL_ABORT = 0x00000001 + ST_NO_TRANSITION = 0x00000002 + ST_RESET_PHASE_TO_START = 0x00000003 + ST_RESEND_LAST_MESSAGE = 0x00000004 +) + +/* +""" +@summary: Binary blob data type +@see: http://msdn.microsoft.com/en-us/library/cc240481.aspx +""" +*/ +type BinaryBlobType uint16 + +const ( + BB_ANY_BLOB = 0x0000 + BB_DATA_BLOB = 0x0001 + BB_RANDOM_BLOB = 0x0002 + BB_CERTIFICATE_BLOB = 0x0003 + BB_ERROR_BLOB = 0x0004 + BB_ENCRYPTED_DATA_BLOB = 0x0009 + BB_KEY_EXCHG_ALG_BLOB = 0x000D + BB_SCOPE_BLOB = 0x000E + BB_CLIENT_USER_NAME_BLOB = 0x000F + BB_CLIENT_MACHINE_NAME_BLOB = 0x0010 +) + +type ErrorMessage struct { + DwErrorCode uint32 + DwStateTransaction uint32 + Blob []byte +} + +func readErrorMessage(r io.Reader) *ErrorMessage { + m := &ErrorMessage{} + m.DwErrorCode, _ = core.ReadUInt32LE(r) + m.DwStateTransaction, _ = core.ReadUInt32LE(r) + return m +} + +type LicensePacket struct { + BMsgtype uint8 + Flag uint8 + WMsgSize uint16 + LicensingMessage interface{} +} + +func ReadLicensePacket(r io.Reader) *LicensePacket { + l := &LicensePacket{} + l.BMsgtype, _ = core.ReadUInt8(r) + l.Flag, _ = core.ReadUInt8(r) + l.WMsgSize, _ = core.ReadUint16LE(r) + + switch l.BMsgtype { + case ERROR_ALERT: + l.LicensingMessage = readErrorMessage(r) + default: + l.LicensingMessage, _ = core.ReadBytes(int(l.WMsgSize-4), r) + } + + return l +} + +/* +""" +@summary: Blob use by license manager to exchange security data +@see: http://msdn.microsoft.com/en-us/library/cc240481.aspx +""" +*/ +type LicenseBinaryBlob struct { + WBlobType uint16 `struc:"little"` + WBlobLen uint16 `struc:"little"` + BlobData []byte `struc:"sizefrom=WBlobLen"` +} + +func NewLicenseBinaryBlob(WBlobType uint16) *LicenseBinaryBlob { + return &LicenseBinaryBlob{} +} + +/* +""" +@summary: License server product information +@see: http://msdn.microsoft.com/en-us/library/cc241915.aspx +""" +*/ +type ProductInformation struct { + DwVersion uint32 `struc:"little"` + CbCompanyName uint32 `struc:"little"` + //may contain "Microsoft Corporation" from server microsoft + PbCompanyName []byte `struc:"sizefrom=CbCompanyName"` + CbProductId uint32 `struc:"little"` + //may contain "A02" from microsoft license server + PbProductId []byte `struc:"sizefrom=CbProductId"` +} + +/* +@summary: Send by server to signal license request + + server -> client + +@see: http://msdn.microsoft.com/en-us/library/cc241914.aspx +*/ +type ServerLicenseRequest struct { + ServerRandom []byte `struc:"[32]byte"` + ProductInfo ProductInformation `struc:"little"` + KeyExchangeList LicenseBinaryBlob `struc:"little"` + ServerCertificate LicenseBinaryBlob `struc:"little"` + //ScopeList ScopeList +} + +/* +@summary: Send by client to ask new license for client. + RDPY doesn'support license reuse, need it in futur version +@see: http://msdn.microsoft.com/en-us/library/cc241918.aspx + #RSA and must be only RSA + #pure microsoft client ;-) + #http://msdn.microsoft.com/en-us/library/1040af38-c733-4fb3-acd1-8db8cc979eda#id10 +*/ + +type ClientNewLicenseRequest struct { + PreferredKeyExchangeAlg uint32 `struc:"little"` + PlatformId uint32 `struc:"little"` + ClientRandom []byte `struc:"[32]byte"` + EncryptedPreMasterSecret LicenseBinaryBlob `struc:"little"` + ClientUserName LicenseBinaryBlob `struc:"little"` + ClientMachineName LicenseBinaryBlob `struc:"little"` +} + +/* +@summary: challenge send from server to client +@see: http://msdn.microsoft.com/en-us/library/cc241921.aspx +*/ +type ServerPlatformChallenge struct { + ConnectFlags uint32 + EncryptedPlatformChallenge LicenseBinaryBlob + MACData [16]byte +} + +/* +""" +@summary: client challenge response +@see: http://msdn.microsoft.com/en-us/library/cc241922.aspx +""" +*/ +type ClientPLatformChallengeResponse struct { + EncryptedPlatformChallengeResponse LicenseBinaryBlob + EncryptedHWID LicenseBinaryBlob + MACData []byte //[16]byte +} diff --git a/grdp/protocol/nla/cssp.go b/grdp/protocol/nla/cssp.go new file mode 100644 index 0000000..32ad297 --- /dev/null +++ b/grdp/protocol/nla/cssp.go @@ -0,0 +1,99 @@ +package nla + +import ( + "encoding/asn1" + + "ShotRDP/grdp/glog" +) + +type NegoToken struct { + Data []byte `asn1:"explicit,tag:0"` +} + +type TSRequest struct { + Version int `asn1:"explicit,tag:0"` + NegoTokens []NegoToken `asn1:"optional,explicit,tag:1"` + AuthInfo []byte `asn1:"optional,explicit,tag:2"` + PubKeyAuth []byte `asn1:"optional,explicit,tag:3"` + //ErrorCode int `asn1:"optional,explicit,tag:4"` +} + +type TSCredentials struct { + CredType int `asn1:"explicit,tag:0"` + Credentials []byte `asn1:"explicit,tag:1"` +} + +type TSPasswordCreds struct { + DomainName []byte `asn1:"explicit,tag:0"` + UserName []byte `asn1:"explicit,tag:1"` + Password []byte `asn1:"explicit,tag:2"` +} + +type TSCspDataDetail struct { + KeySpec int `asn1:"explicit,tag:0"` + CardName string `asn1:"explicit,tag:1"` + ReaderName string `asn1:"explicit,tag:2"` + ContainerName string `asn1:"explicit,tag:3"` + CspName string `asn1:"explicit,tag:4"` +} + +type TSSmartCardCreds struct { + Pin string `asn1:"explicit,tag:0"` + CspData []TSCspDataDetail `asn1:"explicit,tag:1"` + UserHint string `asn1:"explicit,tag:2"` + DomainHint string `asn1:"explicit,tag:3"` +} + +func EncodeDERTRequest(msgs []Message, authInfo []byte, pubKeyAuth []byte) []byte { + req := TSRequest{ + Version: 2, + } + + if len(msgs) > 0 { + req.NegoTokens = make([]NegoToken, 0, len(msgs)) + } + + for _, msg := range msgs { + token := NegoToken{msg.Serialize()} + req.NegoTokens = append(req.NegoTokens, token) + } + + if len(authInfo) > 0 { + req.AuthInfo = authInfo + } + + if len(pubKeyAuth) > 0 { + req.PubKeyAuth = pubKeyAuth + } + + result, err := asn1.Marshal(req) + if err != nil { + glog.Error(err) + } + return result +} + +func DecodeDERTRequest(s []byte) (*TSRequest, error) { + treq := &TSRequest{} + _, err := asn1.Unmarshal(s, treq) + return treq, err +} +func EncodeDERTCredentials(domain, username, password []byte) []byte { + tpas := TSPasswordCreds{domain, username, password} + result, err := asn1.Marshal(tpas) + if err != nil { + glog.Error(err) + } + tcre := TSCredentials{1, result} + result, err = asn1.Marshal(tcre) + if err != nil { + glog.Error(err) + } + return result +} + +func DecodeDERTCredentials(s []byte) (*TSCredentials, error) { + tcre := &TSCredentials{} + _, err := asn1.Unmarshal(s, tcre) + return tcre, err +} diff --git a/grdp/protocol/nla/cssp_test.go b/grdp/protocol/nla/cssp_test.go new file mode 100644 index 0000000..6219d1e --- /dev/null +++ b/grdp/protocol/nla/cssp_test.go @@ -0,0 +1,16 @@ +package nla_test + +import ( + "encoding/hex" + "testing" + + "ShotRDP/grdp/protocol/nla" +) + +func TestEncodeDERTRequest(t *testing.T) { + ntlm := nla.NewNTLMv2("", "", "") + result := nla.EncodeDERTRequest([]nla.Message{ntlm.GetNegotiateMessage()}, "", "") + if hex.EncodeToString(result) != "302fa003020102a12830263024a02204204e544c4d53535000010000003582086000000000000000000000000000000000" { + t.Error("not equal") + } +} diff --git a/grdp/protocol/nla/encode.go b/grdp/protocol/nla/encode.go new file mode 100644 index 0000000..ba3c437 --- /dev/null +++ b/grdp/protocol/nla/encode.go @@ -0,0 +1,46 @@ +package nla + +import ( + "crypto/hmac" + "crypto/md5" + "crypto/rc4" + "strings" + + "ShotRDP/grdp/core" + "golang.org/x/crypto/md4" +) + +func MD4(data []byte) []byte { + h := md4.New() + h.Write(data) + return h.Sum(nil) +} + +func MD5(data []byte) []byte { + h := md5.New() + h.Write(data) + return h.Sum(nil) +} + +func HMAC_MD5(key, data []byte) []byte { + h := hmac.New(md5.New, key) + h.Write(data) + return h.Sum(nil) +} + +// Version 2 of NTLM hash function +func NTOWFv2(password, user, domain string) []byte { + return HMAC_MD5(MD4(core.UnicodeEncode(password)), core.UnicodeEncode(strings.ToUpper(user)+domain)) +} + +// Same as NTOWFv2 +func LMOWFv2(password, user, domain string) []byte { + return NTOWFv2(password, user, domain) +} + +func RC4K(key, src []byte) []byte { + result := make([]byte, len(src)) + rc4obj, _ := rc4.NewCipher(key) + rc4obj.XORKeyStream(result, src) + return result +} diff --git a/grdp/protocol/nla/encode_test.go b/grdp/protocol/nla/encode_test.go new file mode 100644 index 0000000..d9a4cc8 --- /dev/null +++ b/grdp/protocol/nla/encode_test.go @@ -0,0 +1,32 @@ +package nla_test + +import ( + "encoding/hex" + "testing" + + "ShotRDP/grdp/protocol/nla" +) + +func TestNTOWFv2(t *testing.T) { + res := hex.EncodeToString(nla.NTOWFv2("", "", "")) + expected := "f4c1a15dd59d4da9bd595599220d971a" + if res != expected { + t.Error(res, "not equal to", expected) + } + + res = hex.EncodeToString(nla.NTOWFv2("user", "pwd", "dom")) + expected = "652feb8208b3a8a6264c9c5d5b820979" + if res != expected { + t.Error(res, "not equal to", expected) + } +} + +func TestRC4K(t *testing.T) { + key, _ := hex.DecodeString("55638e834ce774c100637f197bc0683f") + src, _ := hex.DecodeString("177d16086dd3f06fa8d594e3bad005b7") + res := hex.EncodeToString(nla.RC4K(key, src)) + expected := "f5ab375222707a492bd5a90705d96d1d" + if res != expected { + t.Error(res, "not equal to", expected) + } +} diff --git a/grdp/protocol/nla/ntlm.go b/grdp/protocol/nla/ntlm.go new file mode 100644 index 0000000..8eae679 --- /dev/null +++ b/grdp/protocol/nla/ntlm.go @@ -0,0 +1,515 @@ +package nla + +import ( + "bytes" + "crypto/md5" + "crypto/rc4" + "encoding/binary" + "encoding/hex" + "time" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/glog" + "github.com/lunixbochs/struc" +) + +const ( + WINDOWS_MINOR_VERSION_0 = 0x00 + WINDOWS_MINOR_VERSION_1 = 0x01 + WINDOWS_MINOR_VERSION_2 = 0x02 + WINDOWS_MINOR_VERSION_3 = 0x03 + + WINDOWS_MAJOR_VERSION_5 = 0x05 + WINDOWS_MAJOR_VERSION_6 = 0x06 + NTLMSSP_REVISION_W2K3 = 0x0F +) + +const ( + MsvAvEOL = 0x0000 + MsvAvNbComputerName = 0x0001 + MsvAvNbDomainName = 0x0002 + MsvAvDnsComputerName = 0x0003 + MsvAvDnsDomainName = 0x0004 + MsvAvDnsTreeName = 0x0005 + MsvAvFlags = 0x0006 + MsvAvTimestamp = 0x0007 + MsvAvSingleHost = 0x0008 + MsvAvTargetName = 0x0009 + MsvChannelBindings = 0x000A +) + +type AVPair struct { + Id uint16 `struc:"little"` + Len uint16 `struc:"little,sizeof=Value"` + Value []byte `struc:"little"` +} + +const ( + NTLMSSP_NEGOTIATE_56 = 0x80000000 + NTLMSSP_NEGOTIATE_KEY_EXCH = 0x40000000 + NTLMSSP_NEGOTIATE_128 = 0x20000000 + NTLMSSP_NEGOTIATE_VERSION = 0x02000000 + NTLMSSP_NEGOTIATE_TARGET_INFO = 0x00800000 + NTLMSSP_REQUEST_NON_NT_SESSION_KEY = 0x00400000 + NTLMSSP_NEGOTIATE_IDENTIFY = 0x00100000 + NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY = 0x00080000 + NTLMSSP_TARGET_TYPE_SERVER = 0x00020000 + NTLMSSP_TARGET_TYPE_DOMAIN = 0x00010000 + NTLMSSP_NEGOTIATE_ALWAYS_SIGN = 0x00008000 + NTLMSSP_NEGOTIATE_OEM_WORKSTATION_SUPPLIED = 0x00002000 + NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED = 0x00001000 + NTLMSSP_NEGOTIATE_NTLM = 0x00000200 + NTLMSSP_NEGOTIATE_LM_KEY = 0x00000080 + NTLMSSP_NEGOTIATE_DATAGRAM = 0x00000040 + NTLMSSP_NEGOTIATE_SEAL = 0x00000020 + NTLMSSP_NEGOTIATE_SIGN = 0x00000010 + NTLMSSP_REQUEST_TARGET = 0x00000004 + NTLM_NEGOTIATE_OEM = 0x00000002 + NTLMSSP_NEGOTIATE_UNICODE = 0x00000001 +) + +type NVersion struct { + ProductMajorVersion uint8 `struc:"little"` + ProductMinorVersion uint8 `struc:"little"` + ProductBuild uint16 `struc:"little"` + Reserved [3]byte `struc:"little"` + NTLMRevisionCurrent uint8 `struc:"little"` +} + +func NewNVersion() NVersion { + return NVersion{ + ProductMajorVersion: WINDOWS_MAJOR_VERSION_6, + ProductMinorVersion: WINDOWS_MINOR_VERSION_0, + ProductBuild: 6002, + NTLMRevisionCurrent: NTLMSSP_REVISION_W2K3, + } +} + +type Message interface { + Serialize() []byte +} + +type NegotiateMessage struct { + Signature [8]byte `struc:"little"` + MessageType uint32 `struc:"little"` + NegotiateFlags uint32 `struc:"little"` + DomainNameLen uint16 `struc:"little"` + DomainNameMaxLen uint16 `struc:"little"` + DomainNameBufferOffset uint32 `struc:"little"` + WorkstationLen uint16 `struc:"little"` + WorkstationMaxLen uint16 `struc:"little"` + WorkstationBufferOffset uint32 `struc:"little"` + Version NVersion `struc:"little"` + Payload [32]byte `struc:"skip"` +} + +func NewNegotiateMessage() *NegotiateMessage { + return &NegotiateMessage{ + Signature: [8]byte{'N', 'T', 'L', 'M', 'S', 'S', 'P', 0x00}, + MessageType: 0x00000001, + } +} + +func (m *NegotiateMessage) Serialize() []byte { + if (m.NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION) != 0 { + m.Version = NewNVersion() + } + buff := &bytes.Buffer{} + struc.Pack(buff, m) + + return buff.Bytes() +} + +type ChallengeMessage struct { + Signature []byte `struc:"[8]byte"` + MessageType uint32 `struc:"little"` + TargetNameLen uint16 `struc:"little"` + TargetNameMaxLen uint16 `struc:"little"` + TargetNameBufferOffset uint32 `struc:"little"` + NegotiateFlags uint32 `struc:"little"` + ServerChallenge [8]byte `struc:"little"` + Reserved [8]byte `struc:"little"` + TargetInfoLen uint16 `struc:"little"` + TargetInfoMaxLen uint16 `struc:"little"` + TargetInfoBufferOffset uint32 `struc:"little"` + Version NVersion `struc:"skip"` + Payload []byte `struc:"skip"` +} + +func (m *ChallengeMessage) Serialize() []byte { + buff := &bytes.Buffer{} + struc.Pack(buff, m) + if (m.NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION) != 0 { + struc.Pack(buff, m.Version) + } + buff.Write(m.Payload) + return buff.Bytes() +} + +func NewChallengeMessage() *ChallengeMessage { + return &ChallengeMessage{ + Signature: []byte{'N', 'T', 'L', 'M', 'S', 'S', 'P', 0x00}, + MessageType: 0x00000002, + } +} + +// total len - payload len +func (m *ChallengeMessage) BaseLen() uint32 { + return 56 +} + +func (m *ChallengeMessage) getTargetInfo() []byte { + if m.TargetInfoLen == 0 { + return make([]byte, 0) + } + offset := m.BaseLen() + start := m.TargetInfoBufferOffset - offset + return m.Payload[start : start+uint32(m.TargetInfoLen)] +} +func (m *ChallengeMessage) getTargetName() []byte { + if m.TargetNameLen == 0 { + return make([]byte, 0) + } + offset := m.BaseLen() + start := m.TargetNameBufferOffset - offset + return m.Payload[start : start+uint32(m.TargetNameLen)] +} +func (m *ChallengeMessage) getTargetInfoTimestamp(data []byte) []byte { + r := bytes.NewReader(data) + for r.Len() > 0 { + avPair := &AVPair{} + struc.Unpack(r, avPair) + if avPair.Id == MsvAvTimestamp { + return avPair.Value + } + + if avPair.Id == MsvAvEOL { + break + } + } + return nil +} + +type AuthenticateMessage struct { + Signature [8]byte + MessageType uint32 `struc:"little"` + LmChallengeResponseLen uint16 `struc:"little"` + LmChallengeResponseMaxLen uint16 `struc:"little"` + LmChallengeResponseBufferOffset uint32 `struc:"little"` + NtChallengeResponseLen uint16 `struc:"little"` + NtChallengeResponseMaxLen uint16 `struc:"little"` + NtChallengeResponseBufferOffset uint32 `struc:"little"` + DomainNameLen uint16 `struc:"little"` + DomainNameMaxLen uint16 `struc:"little"` + DomainNameBufferOffset uint32 `struc:"little"` + UserNameLen uint16 `struc:"little"` + UserNameMaxLen uint16 `struc:"little"` + UserNameBufferOffset uint32 `struc:"little"` + WorkstationLen uint16 `struc:"little"` + WorkstationMaxLen uint16 `struc:"little"` + WorkstationBufferOffset uint32 `struc:"little"` + EncryptedRandomSessionLen uint16 `struc:"little"` + EncryptedRandomSessionMaxLen uint16 `struc:"little"` + EncryptedRandomSessionBufferOffset uint32 `struc:"little"` + NegotiateFlags uint32 `struc:"little"` + Version NVersion `struc:"little"` + MIC [16]byte `struc:"little"` + Payload []byte `struc:"skip"` +} + +func (m *AuthenticateMessage) BaseLen() uint32 { + return 88 +} + +func NewAuthenticateMessage(negFlag uint32, domain, user, workstation []byte, + lmchallResp, ntchallResp, enRandomSessKey []byte) *AuthenticateMessage { + msg := &AuthenticateMessage{ + Signature: [8]byte{'N', 'T', 'L', 'M', 'S', 'S', 'P', 0x00}, + MessageType: 0x00000003, + NegotiateFlags: negFlag, + } + payloadBuff := &bytes.Buffer{} + + msg.LmChallengeResponseLen = uint16(len(lmchallResp)) + msg.LmChallengeResponseMaxLen = msg.LmChallengeResponseLen + msg.LmChallengeResponseBufferOffset = msg.BaseLen() + payloadBuff.Write(lmchallResp) + + msg.NtChallengeResponseLen = uint16(len(ntchallResp)) + msg.NtChallengeResponseMaxLen = msg.NtChallengeResponseLen + msg.NtChallengeResponseBufferOffset = msg.LmChallengeResponseBufferOffset + uint32(msg.LmChallengeResponseLen) + payloadBuff.Write(ntchallResp) + + msg.DomainNameLen = uint16(len(domain)) + msg.DomainNameMaxLen = msg.DomainNameLen + msg.DomainNameBufferOffset = msg.NtChallengeResponseBufferOffset + uint32(msg.NtChallengeResponseLen) + payloadBuff.Write(domain) + + msg.UserNameLen = uint16(len(user)) + msg.UserNameMaxLen = msg.UserNameLen + msg.UserNameBufferOffset = msg.DomainNameBufferOffset + uint32(msg.DomainNameLen) + payloadBuff.Write(user) + + msg.WorkstationLen = uint16(len(workstation)) + msg.WorkstationMaxLen = msg.WorkstationLen + msg.WorkstationBufferOffset = msg.UserNameBufferOffset + uint32(msg.UserNameLen) + payloadBuff.Write(workstation) + + msg.EncryptedRandomSessionLen = uint16(len(enRandomSessKey)) + msg.EncryptedRandomSessionMaxLen = msg.EncryptedRandomSessionLen + msg.EncryptedRandomSessionBufferOffset = msg.WorkstationBufferOffset + uint32(msg.WorkstationLen) + payloadBuff.Write(enRandomSessKey) + + if (msg.NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION) != 0 { + msg.Version = NewNVersion() + } + msg.Payload = payloadBuff.Bytes() + + return msg +} + +func (m *AuthenticateMessage) Serialize() []byte { + buff := &bytes.Buffer{} + struc.Pack(buff, m) + buff.Write(m.Payload) + return buff.Bytes() +} + +type NTLMv2 struct { + domain string + user string + password string + respKeyNT []byte + respKeyLM []byte + negotiateMessage *NegotiateMessage + challengeMessage *ChallengeMessage + authenticateMessage *AuthenticateMessage + enableUnicode bool +} + +func NewNTLMv2(domain, user, password string) *NTLMv2 { + return &NTLMv2{ + domain: domain, + user: user, + password: password, + respKeyNT: NTOWFv2(password, user, domain), + respKeyLM: LMOWFv2(password, user, domain), + } +} + +// generate first handshake messgae +func (n *NTLMv2) GetNegotiateMessage() *NegotiateMessage { + negoMsg := NewNegotiateMessage() + negoMsg.NegotiateFlags = NTLMSSP_NEGOTIATE_KEY_EXCH | + NTLMSSP_NEGOTIATE_128 | + NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY | + NTLMSSP_NEGOTIATE_ALWAYS_SIGN | + NTLMSSP_NEGOTIATE_NTLM | + NTLMSSP_NEGOTIATE_SEAL | + NTLMSSP_NEGOTIATE_SIGN | + NTLMSSP_REQUEST_TARGET | + NTLMSSP_NEGOTIATE_UNICODE + n.negotiateMessage = negoMsg + return n.negotiateMessage +} + +// process NTLMv2 Authenticate hash +func (n *NTLMv2) ComputeResponseV2(respKeyNT, respKeyLM, serverChallenge, clientChallenge, + timestamp, serverInfo []byte) (ntChallResp, lmChallResp, SessBaseKey []byte) { + + tempBuff := &bytes.Buffer{} + tempBuff.Write([]byte{0x01, 0x01}) // Responser version, HiResponser version + tempBuff.Write([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}) + tempBuff.Write(timestamp) + tempBuff.Write(clientChallenge) + tempBuff.Write([]byte{0x00, 0x00, 0x00, 0x00}) + tempBuff.Write(serverInfo) + tempBuff.Write([]byte{0x00, 0x00, 0x00, 0x00}) + + ntBuf := bytes.NewBuffer(serverChallenge) + ntBuf.Write(tempBuff.Bytes()) + ntProof := HMAC_MD5(respKeyNT, ntBuf.Bytes()) + + ntChallResp = make([]byte, 0, len(ntProof)+tempBuff.Len()) + ntChallResp = append(ntChallResp, ntProof...) + ntChallResp = append(ntChallResp, tempBuff.Bytes()...) + + lmBuf := bytes.NewBuffer(serverChallenge) + lmBuf.Write(clientChallenge) + lmChallResp = HMAC_MD5(respKeyLM, lmBuf.Bytes()) + lmChallResp = append(lmChallResp, clientChallenge...) + + SessBaseKey = HMAC_MD5(respKeyNT, ntProof) + return +} + +func MIC(exportedSessionKey []byte, negotiateMessage, challengeMessage, authenticateMessage Message) []byte { + buff := bytes.Buffer{} + buff.Write(negotiateMessage.Serialize()) + buff.Write(challengeMessage.Serialize()) + buff.Write(authenticateMessage.Serialize()) + return HMAC_MD5(exportedSessionKey, buff.Bytes()) +} + +func concat(bs ...[]byte) []byte { + return bytes.Join(bs, nil) +} + +var ( + clientSigning = concat([]byte("session key to client-to-server signing key magic constant"), []byte{0x00}) + serverSigning = concat([]byte("session key to server-to-client signing key magic constant"), []byte{0x00}) + clientSealing = concat([]byte("session key to client-to-server sealing key magic constant"), []byte{0x00}) + serverSealing = concat([]byte("session key to server-to-client sealing key magic constant"), []byte{0x00}) +) + +func (n *NTLMv2) GetAuthenticateMessage(s []byte) (*AuthenticateMessage, *NTLMv2Security) { + challengeMsg := &ChallengeMessage{} + r := bytes.NewReader(s) + err := struc.Unpack(r, challengeMsg) + if err != nil { + glog.Error("read challengeMsg", err) + return nil, nil + } + if challengeMsg.NegotiateFlags&NTLMSSP_NEGOTIATE_VERSION != 0 { + version := NVersion{} + err := struc.Unpack(r, &version) + if err != nil { + glog.Error("read version", err) + return nil, nil + } + challengeMsg.Version = version + } + challengeMsg.Payload, _ = core.ReadBytes(r.Len(), r) + n.challengeMessage = challengeMsg + glog.Debugf("challengeMsg:%+v", challengeMsg) + + serverName := challengeMsg.getTargetName() + serverInfo := challengeMsg.getTargetInfo() + timestamp := challengeMsg.getTargetInfoTimestamp(serverInfo) + computeMIC := false + if timestamp == nil { + ft := uint64(time.Now().UnixNano()) / 100 + ft += 116444736000000000 // add time between unix & windows offset + timestamp = make([]byte, 8) + binary.LittleEndian.PutUint64(timestamp, ft) + } else { + computeMIC = true + } + glog.Infof("serverName=%+v", core.UnicodeDecode(serverName)) + serverChallenge := challengeMsg.ServerChallenge[:] + clientChallenge := core.Random(8) + ntChallengeResponse, lmChallengeResponse, SessionBaseKey := n.ComputeResponseV2( + n.respKeyNT, n.respKeyLM, serverChallenge, clientChallenge, timestamp, serverInfo) + + exchangeKey := SessionBaseKey + exportedSessionKey := core.Random(16) + EncryptedRandomSessionKey := make([]byte, len(exportedSessionKey)) + rc, _ := rc4.NewCipher(exchangeKey) + rc.XORKeyStream(EncryptedRandomSessionKey, exportedSessionKey) + + if challengeMsg.NegotiateFlags&NTLMSSP_NEGOTIATE_UNICODE != 0 { + n.enableUnicode = true + } + glog.Infof("user: %s, passwd:%s", n.user, n.password) + domain, user, _ := n.GetEncodedCredentials() + + n.authenticateMessage = NewAuthenticateMessage(challengeMsg.NegotiateFlags, + domain, user, []byte(""), lmChallengeResponse, ntChallengeResponse, EncryptedRandomSessionKey) + + if computeMIC { + copy(n.authenticateMessage.MIC[:], MIC(exportedSessionKey, n.negotiateMessage, n.challengeMessage, n.authenticateMessage)[:16]) + } + + md := md5.New() + //ClientSigningKey + a := concat(exportedSessionKey, clientSigning) + md.Write(a) + ClientSigningKey := md.Sum(nil) + //ServerSigningKey + md.Reset() + a = concat(exportedSessionKey, serverSigning) + md.Write(a) + ServerSigningKey := md.Sum(nil) + //ClientSealingKey + md.Reset() + a = concat(exportedSessionKey, clientSealing) + md.Write(a) + ClientSealingKey := md.Sum(nil) + //ServerSealingKey + md.Reset() + a = concat(exportedSessionKey, serverSealing) + md.Write(a) + ServerSealingKey := md.Sum(nil) + + glog.Debugf("ClientSigningKey:%s", hex.EncodeToString(ClientSigningKey)) + glog.Debugf("ServerSigningKey:%s", hex.EncodeToString(ServerSigningKey)) + glog.Debugf("ClientSealingKey:%s", hex.EncodeToString(ClientSealingKey)) + glog.Debugf("ServerSealingKey:%s", hex.EncodeToString(ServerSealingKey)) + + encryptRC4, _ := rc4.NewCipher(ClientSealingKey) + decryptRC4, _ := rc4.NewCipher(ServerSealingKey) + + ntlmSec := &NTLMv2Security{encryptRC4, decryptRC4, ClientSigningKey, ServerSigningKey, 0} + + return n.authenticateMessage, ntlmSec +} + +func (n *NTLMv2) GetEncodedCredentials() ([]byte, []byte, []byte) { + if n.enableUnicode { + return core.UnicodeEncode(n.domain), core.UnicodeEncode(n.user), core.UnicodeEncode(n.password) + } + return []byte(n.domain), []byte(n.user), []byte(n.password) +} + +type NTLMv2Security struct { + EncryptRC4 *rc4.Cipher + DecryptRC4 *rc4.Cipher + SigningKey []byte + VerifyKey []byte + SeqNum uint32 +} + +func (n *NTLMv2Security) GssEncrypt(s []byte) []byte { + p := make([]byte, len(s)) + n.EncryptRC4.XORKeyStream(p, s) + b := &bytes.Buffer{} + + //signature + core.WriteUInt32LE(n.SeqNum, b) + core.WriteBytes(s, b) + s1 := HMAC_MD5(n.SigningKey, b.Bytes())[:8] + checksum := make([]byte, 8) + n.EncryptRC4.XORKeyStream(checksum, s1) + b.Reset() + core.WriteUInt32LE(0x00000001, b) + core.WriteBytes(checksum, b) + core.WriteUInt32LE(n.SeqNum, b) + + core.WriteBytes(p, b) + + n.SeqNum++ + + return b.Bytes() +} +func (n *NTLMv2Security) GssDecrypt(s []byte) []byte { + r := bytes.NewReader(s) + core.ReadUInt32LE(r) //version + checksum, _ := core.ReadBytes(8, r) + seqNum, _ := core.ReadUInt32LE(r) + data, _ := core.ReadBytes(r.Len(), r) + + p := make([]byte, len(data)) + n.DecryptRC4.XORKeyStream(p, data) + + check := make([]byte, len(checksum)) + n.DecryptRC4.XORKeyStream(check, checksum) + + b := &bytes.Buffer{} + core.WriteUInt32LE(seqNum, b) + core.WriteBytes(p, b) + verify := HMAC_MD5(n.VerifyKey, b.Bytes()) + if string(verify) != string(check) { + return nil + } + return p +} diff --git a/grdp/protocol/nla/ntlm_test.go b/grdp/protocol/nla/ntlm_test.go new file mode 100644 index 0000000..54dcc67 --- /dev/null +++ b/grdp/protocol/nla/ntlm_test.go @@ -0,0 +1,62 @@ +package nla_test + +import ( + "bytes" + "encoding/hex" + "testing" + + "ShotRDP/grdp/protocol/nla" + "github.com/lunixbochs/struc" +) + +func TestNewNegotiateMessage(t *testing.T) { + ntlm := nla.NewNTLMv2("", "", "") + negoMsg := ntlm.GetNegotiateMessage() + buff := &bytes.Buffer{} + struc.Pack(buff, negoMsg) + + result := hex.EncodeToString(buff.Bytes()) + expected := "4e544c4d535350000100000035820860000000000000000000000000000000000000000000000000" + + if result != expected { + t.Error(result, " not equals to", expected) + } +} + +func TestNTLMv2_ComputeResponse(t *testing.T) { + ntlm := nla.NewNTLMv2("", "", "") + + ResponseKeyNT, _ := hex.DecodeString("39e32c766260586a9036f1ceb04c3007") + ResponseKeyLM, _ := hex.DecodeString("39e32c766260586a9036f1ceb04c3007") + ServerChallenge, _ := hex.DecodeString("adcb9d1c8d4a5ed8") + ClienChallenge, _ := hex.DecodeString("1a78bed8e5d5efa7") + Timestamp, _ := hex.DecodeString("a02f44f01267d501") + ServerName, _ := hex.DecodeString("02001e00570049004e002d00460037005200410041004d004100500034004a00430001001e00570049004e002d00460037005200410041004d004100500034004a00430004001e00570049004e002d00460037005200410041004d004100500034004a00430003001e00570049004e002d00460037005200410041004d004100500034004a00430007000800a02f44f01267d50100000000") + + NtChallengeResponse, LmChallengeResponse, SessionBaseKey := ntlm.ComputeResponse(ResponseKeyNT, ResponseKeyLM, ServerChallenge, ClienChallenge, Timestamp, ServerName) + + ntChallRespExpected := "4e7316531937d2fc91e7230853844b890101000000000000a02f44f01267d5011a78bed8e5d5efa70000000002001e00570049004e002d00460037005200410041004d004100500034004a00430001001e00570049004e002d00460037005200410041004d004100500034004a00430004001e00570049004e002d00460037005200410041004d004100500034004a00430003001e00570049004e002d00460037005200410041004d004100500034004a00430007000800a02f44f01267d50100000000" + lmChallRespExpected := "d4dc6edc0c37dd70f69b5c4f05a615661a78bed8e5d5efa7" + sessBaseKeyExpected := "034009be89a0507b2bd6d28e966e1dab" + + if hex.EncodeToString(NtChallengeResponse) != ntChallRespExpected { + t.Error("NtChallengeResponse incorrect") + } + + if hex.EncodeToString(LmChallengeResponse) != lmChallRespExpected { + t.Error("LmChallengeResponse incorrect") + } + + if hex.EncodeToString(SessionBaseKey) != sessBaseKeyExpected { + t.Error("SessionBaseKey incorrect") + } +} + +func TestSIGNKEY(t *testing.T) { + exportedSessionKey, _ := hex.DecodeString("be32c3c56ea6683200a35329d67880c3") + result := hex.EncodeToString(nla.SIGNKEY(exportedSessionKey, true)) + expected := "79b4f9a4113230f378a0af99f784adae" + if result != expected { + t.Error(result, "not equal to", expected) + } +} diff --git a/grdp/protocol/pdu/caps.go b/grdp/protocol/pdu/caps.go new file mode 100644 index 0000000..2069b41 --- /dev/null +++ b/grdp/protocol/pdu/caps.go @@ -0,0 +1,760 @@ +package pdu + +import ( + "bytes" + "encoding/hex" + "errors" + "fmt" + "io" + + "ShotRDP/grdp/glog" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/protocol/t125/gcc" + "github.com/lunixbochs/struc" +) + +type CapsType uint16 + +const ( + CAPSTYPE_GENERAL CapsType = 0x0001 + CAPSTYPE_BITMAP = 0x0002 + CAPSTYPE_ORDER = 0x0003 + CAPSTYPE_BITMAPCACHE = 0x0004 + CAPSTYPE_CONTROL = 0x0005 + CAPSTYPE_ACTIVATION = 0x0007 + CAPSTYPE_POINTER = 0x0008 + CAPSTYPE_SHARE = 0x0009 + CAPSTYPE_COLORCACHE = 0x000A + CAPSTYPE_SOUND = 0x000C + CAPSTYPE_INPUT = 0x000D + CAPSTYPE_FONT = 0x000E + CAPSTYPE_BRUSH = 0x000F + CAPSTYPE_GLYPHCACHE = 0x0010 + CAPSTYPE_OFFSCREENCACHE = 0x0011 + CAPSTYPE_BITMAPCACHE_HOSTSUPPORT = 0x0012 + CAPSTYPE_BITMAPCACHE_REV2 = 0x0013 + CAPSTYPE_VIRTUALCHANNEL = 0x0014 + CAPSTYPE_DRAWNINEGRIDCACHE = 0x0015 + CAPSTYPE_DRAWGDIPLUS = 0x0016 + CAPSTYPE_RAIL = 0x0017 + CAPSTYPE_WINDOW = 0x0018 + CAPSETTYPE_COMPDESK = 0x0019 + CAPSETTYPE_MULTIFRAGMENTUPDATE = 0x001A + CAPSETTYPE_LARGE_POINTER = 0x001B + CAPSETTYPE_SURFACE_COMMANDS = 0x001C + CAPSETTYPE_BITMAP_CODECS = 0x001D + CAPSSETTYPE_FRAME_ACKNOWLEDGE = 0x001E +) + +func (c CapsType) String() string { + switch c { + case CAPSTYPE_GENERAL: + return "CAPSTYPE_GENERAL" + case CAPSTYPE_BITMAP: + return "CAPSTYPE_BITMAP" + case CAPSTYPE_ORDER: + return "CAPSTYPE_ORDER" + case CAPSTYPE_BITMAPCACHE: + return "CAPSTYPE_BITMAPCACHE" + case CAPSTYPE_CONTROL: + return "CAPSTYPE_CONTROL" + case CAPSTYPE_ACTIVATION: + return "CAPSTYPE_ACTIVATION" + case CAPSTYPE_POINTER: + return "CAPSTYPE_POINTER" + case CAPSTYPE_SHARE: + return "CAPSTYPE_SHARE" + case CAPSTYPE_COLORCACHE: + return "CAPSTYPE_COLORCACHE" + case CAPSTYPE_SOUND: + return "CAPSTYPE_SOUND" + case CAPSTYPE_INPUT: + return "CAPSTYPE_INPUT" + case CAPSTYPE_FONT: + return "CAPSTYPE_FONT" + case CAPSTYPE_BRUSH: + return "CAPSTYPE_BRUSH" + case CAPSTYPE_GLYPHCACHE: + return "CAPSTYPE_GLYPHCACHE" + case CAPSTYPE_OFFSCREENCACHE: + return "CAPSTYPE_OFFSCREENCACHE" + case CAPSTYPE_BITMAPCACHE_HOSTSUPPORT: + return "CAPSTYPE_BITMAPCACHE_HOSTSUPPORT" + case CAPSTYPE_BITMAPCACHE_REV2: + return "CAPSTYPE_BITMAPCACHE_REV2" + case CAPSTYPE_VIRTUALCHANNEL: + return "CAPSTYPE_VIRTUALCHANNEL" + case CAPSTYPE_DRAWNINEGRIDCACHE: + return "CAPSTYPE_DRAWNINEGRIDCACHE" + case CAPSTYPE_DRAWGDIPLUS: + return "CAPSTYPE_DRAWGDIPLUS" + case CAPSTYPE_RAIL: + return "CAPSTYPE_RAIL" + case CAPSTYPE_WINDOW: + return "CAPSTYPE_WINDOW" + case CAPSETTYPE_COMPDESK: + return "CAPSETTYPE_COMPDESK" + case CAPSETTYPE_MULTIFRAGMENTUPDATE: + return "CAPSETTYPE_MULTIFRAGMENTUPDATE" + case CAPSETTYPE_LARGE_POINTER: + return "CAPSETTYPE_LARGE_POINTER" + case CAPSETTYPE_SURFACE_COMMANDS: + return "CAPSETTYPE_SURFACE_COMMANDS" + case CAPSETTYPE_BITMAP_CODECS: + return "CAPSETTYPE_BITMAP_CODECS" + case CAPSSETTYPE_FRAME_ACKNOWLEDGE: + return "CAPSSETTYPE_FRAME_ACKNOWLEDGE" + } + + return "Unknown" +} + +type MajorType uint16 + +const ( + OSMAJORTYPE_UNSPECIFIED MajorType = 0x0000 + OSMAJORTYPE_WINDOWS = 0x0001 + OSMAJORTYPE_OS2 = 0x0002 + OSMAJORTYPE_MACINTOSH = 0x0003 + OSMAJORTYPE_UNIX = 0x0004 + OSMAJORTYPE_IOS = 0x0005 + OSMAJORTYPE_OSX = 0x0006 + OSMAJORTYPE_ANDROID = 0x0007 +) + +type MinorType uint16 + +const ( + OSMINORTYPE_UNSPECIFIED MinorType = 0x0000 + OSMINORTYPE_WINDOWS_31X = 0x0001 + OSMINORTYPE_WINDOWS_95 = 0x0002 + OSMINORTYPE_WINDOWS_NT = 0x0003 + OSMINORTYPE_OS2_V21 = 0x0004 + OSMINORTYPE_POWER_PC = 0x0005 + OSMINORTYPE_MACINTOSH = 0x0006 + OSMINORTYPE_NATIVE_XSERVER = 0x0007 + OSMINORTYPE_PSEUDO_XSERVER = 0x0008 + OSMINORTYPE_WINDOWS_RT = 0x0009 +) + +const ( + FASTPATH_OUTPUT_SUPPORTED uint16 = 0x0001 + NO_BITMAP_COMPRESSION_HDR = 0x0400 + LONG_CREDENTIALS_SUPPORTED = 0x0004 + AUTORECONNECT_SUPPORTED = 0x0008 + ENC_SALTED_CHECKSUM = 0x0010 +) + +type OrderFlag uint16 + +const ( + NEGOTIATEORDERSUPPORT OrderFlag = 0x0002 + ZEROBOUNDSDELTASSUPPORT = 0x0008 + COLORINDEXSUPPORT = 0x0020 + SOLIDPATTERNBRUSHONLY = 0x0040 + ORDERFLAGS_EXTRA_FLAGS = 0x0080 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240556.aspx + */ +type Order uint8 + +const ( + TS_NEG_DSTBLT_INDEX Order = 0x00 + TS_NEG_PATBLT_INDEX = 0x01 + TS_NEG_SCRBLT_INDEX = 0x02 + TS_NEG_MEMBLT_INDEX = 0x03 + TS_NEG_MEM3BLT_INDEX = 0x04 + TS_NEG_DRAWNINEGRID_INDEX = 0x07 + TS_NEG_LINETO_INDEX = 0x08 + TS_NEG_MULTI_DRAWNINEGRID_INDEX = 0x09 + TS_NEG_SAVEBITMAP_INDEX = 0x0B + TS_NEG_MULTIDSTBLT_INDEX = 0x0F + TS_NEG_MULTIPATBLT_INDEX = 0x10 + TS_NEG_MULTISCRBLT_INDEX = 0x11 + TS_NEG_MULTIOPAQUERECT_INDEX = 0x12 + TS_NEG_FAST_INDEX_INDEX = 0x13 + TS_NEG_POLYGON_SC_INDEX = 0x14 + TS_NEG_POLYGON_CB_INDEX = 0x15 + TS_NEG_POLYLINE_INDEX = 0x16 + TS_NEG_FAST_GLYPH_INDEX = 0x18 + TS_NEG_ELLIPSE_SC_INDEX = 0x19 + TS_NEG_ELLIPSE_CB_INDEX = 0x1A + TS_NEG_GLYPH_INDEX_INDEX = 0x1B +) + +type OrderEx uint16 + +const ( + ORDERFLAGS_EX_CACHE_BITMAP_REV3_SUPPORT OrderEx = 0x0002 + ORDERFLAGS_EX_ALTSEC_FRAME_MARKER_SUPPORT = 0x0004 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240563.aspx + */ + +const ( + INPUT_FLAG_SCANCODES uint16 = 0x0001 + INPUT_FLAG_MOUSEX = 0x0004 + INPUT_FLAG_FASTPATH_INPUT = 0x0008 + INPUT_FLAG_UNICODE = 0x0010 + INPUT_FLAG_FASTPATH_INPUT2 = 0x0020 + INPUT_FLAG_UNUSED1 = 0x0040 + INPUT_FLAG_UNUSED2 = 0x0080 + INPUT_FLAG_MOUSE_HWHEEL = 0x0100 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240564.aspx + */ +type BrushSupport uint32 + +const ( + BRUSH_DEFAULT BrushSupport = 0x00000000 + BRUSH_COLOR_8x8 = 0x00000001 + BRUSH_COLOR_FULL = 0x00000002 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240565.aspx + */ +type GlyphSupport uint16 + +const ( + GLYPH_SUPPORT_NONE GlyphSupport = 0x0000 + GLYPH_SUPPORT_PARTIAL = 0x0001 + GLYPH_SUPPORT_FULL = 0x0002 + GLYPH_SUPPORT_ENCODE = 0x0003 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240550.aspx + */ +type OffscreenSupportLevel uint32 + +const ( + OSL_FALSE OffscreenSupportLevel = 0x00000000 + OSL_TRUE = 0x00000001 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240551.aspx + */ +type VirtualChannelCompressionFlag uint32 + +const ( + VCCAPS_NO_COMPR VirtualChannelCompressionFlag = 0x00000000 + VCCAPS_COMPR_SC = 0x00000001 + VCCAPS_COMPR_CS_8K = 0x00000002 +) + +type SoundFlag uint16 + +const ( + SOUND_NONE SoundFlag = 0x0000 + SOUND_BEEPS_FLAG = 0x0001 +) + +type RailsupportLevel uint32 + +const ( + RAIL_LEVEL_SUPPORTED = 0x00000001 + RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED = 0x00000002 + RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED = 0x00000004 + RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED = 0x00000008 + RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED = 0x00000010 + RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED = 0x00000020 + RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED = 0x00000040 + RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED = 0x00000080 +) + +const ( + INPUT_EVENT_SYNC = 0x0000 + INPUT_EVENT_UNUSED = 0x0002 + INPUT_EVENT_SCANCODE = 0x0004 + INPUT_EVENT_UNICODE = 0x0005 + INPUT_EVENT_MOUSE = 0x8001 + INPUT_EVENT_MOUSEX = 0x8002 +) + +const ( + PTRFLAGS_HWHEEL = 0x0400 + PTRFLAGS_WHEEL = 0x0200 + PTRFLAGS_WHEEL_NEGATIVE = 0x0100 + WheelRotationMask = 0x01FF + PTRFLAGS_MOVE = 0x0800 + PTRFLAGS_DOWN = 0x8000 + PTRFLAGS_BUTTON1 = 0x1000 + PTRFLAGS_BUTTON2 = 0x2000 + PTRFLAGS_BUTTON3 = 0x4000 +) + +const ( + KBDFLAGS_EXTENDED = 0x0100 + KBDFLAGS_DOWN = 0x4000 + KBDFLAGS_RELEASE = 0x8000 +) + +type SurfaceCmdFlags uint32 + +const ( + SURFCMDS_SET_SURFACE_BITS = 0x00000002 + SURFCMDS_FRAME_MARKER = 0x00000010 + SURFCMDS_STREAM_SURFACE_BITS = 0x00000040 +) + +type Capability interface { + Type() CapsType +} + +type GeneralCapability struct { + // 010018000100030000020000000015040000000000000000 + OSMajorType MajorType `struc:"little"` + OSMinorType MinorType `struc:"little"` + ProtocolVersion uint16 `struc:"little"` + Pad2octetsA uint16 `struc:"little"` + GeneralCompressionTypes uint16 `struc:"little"` + ExtraFlags uint16 `struc:"little"` + UpdateCapabilityFlag uint16 `struc:"little"` + RemoteUnshareFlag uint16 `struc:"little"` + GeneralCompressionLevel uint16 `struc:"little"` + RefreshRectSupport uint8 `struc:"little"` + SuppressOutputSupport uint8 `struc:"little"` +} + +func (*GeneralCapability) Type() CapsType { + return CAPSTYPE_GENERAL +} + +type BitmapCapability struct { + // 02001c00180001000100010000052003000000000100000001000000 + PreferredBitsPerPixel gcc.HighColor `struc:"little"` + Receive1BitPerPixel uint16 `struc:"little"` + Receive4BitsPerPixel uint16 `struc:"little"` + Receive8BitsPerPixel uint16 `struc:"little"` + DesktopWidth uint16 `struc:"little"` + DesktopHeight uint16 `struc:"little"` + Pad2octets uint16 `struc:"little"` + DesktopResizeFlag uint16 `struc:"little"` + BitmapCompressionFlag uint16 `struc:"little"` + HighColorFlags uint8 `struc:"little"` + DrawingFlags uint8 `struc:"little"` + MultipleRectangleSupport uint16 `struc:"little"` + Pad2octetsB uint16 `struc:"little"` +} + +func (*BitmapCapability) Type() CapsType { + return CAPSTYPE_BITMAP +} + +type BitmapCacheCapability struct { + // 04002800000000000000000000000000000000000000000000000000000000000000000000000000 + Pad1 uint32 `struc:"little"` + Pad2 uint32 `struc:"little"` + Pad3 uint32 `struc:"little"` + Pad4 uint32 `struc:"little"` + Pad5 uint32 `struc:"little"` + Pad6 uint32 `struc:"little"` + Cache0Entries uint16 `struc:"little"` + Cache0MaximumCellSize uint16 `struc:"little"` + Cache1Entries uint16 `struc:"little"` + Cache1MaximumCellSize uint16 `struc:"little"` + Cache2Entries uint16 `struc:"little"` + Cache2MaximumCellSize uint16 `struc:"little"` +} + +func (*BitmapCacheCapability) Type() CapsType { + return CAPSTYPE_BITMAPCACHE +} + +type OrderCapability struct { + // 030058000000000000000000000000000000000000000000010014000000010000000a0000000000000000000000000000000000000000000000000000000000000000000000000000000000008403000000000000000000 + TerminalDescriptor [16]byte + Pad4octetsA uint32 `struc:"little"` + DesktopSaveXGranularity uint16 `struc:"little"` + DesktopSaveYGranularity uint16 `struc:"little"` + Pad2octetsA uint16 `struc:"little"` + MaximumOrderLevel uint16 `struc:"little"` + NumberFonts uint16 `struc:"little"` + OrderFlags OrderFlag `struc:"little"` + OrderSupport [32]byte + TextFlags uint16 `struc:"little"` + OrderSupportExFlags uint16 `struc:"little"` + Pad4octetsB uint32 `struc:"little"` + DesktopSaveSize uint32 `struc:"little"` + Pad2octetsC uint16 `struc:"little"` + Pad2octetsD uint16 `struc:"little"` + TextANSICodePage uint16 `struc:"little"` + Pad2octetsE uint16 `struc:"little"` +} + +func (*OrderCapability) Type() CapsType { + return CAPSTYPE_ORDER +} + +type PointerCapability struct { + ColorPointerFlag uint16 `struc:"little"` + ColorPointerCacheSize uint16 `struc:"little"` + // old version of rdp doesn't support ... + PointerCacheSize uint16 `struc:"little"` // only server need +} + +func (*PointerCapability) Type() CapsType { + return CAPSTYPE_POINTER +} + +type InputCapability struct { + // 0d005c001500000009040000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c000000 + Flags uint16 `struc:"little"` + Pad2octetsA uint16 `struc:"little"` + // same value as gcc.ClientCoreSettings.kbdLayout + KeyboardLayout gcc.KeyboardLayout `struc:"little"` + // same value as gcc.ClientCoreSettings.keyboardType + KeyboardType uint32 `struc:"little"` + // same value as gcc.ClientCoreSettings.keyboardSubType + KeyboardSubType uint32 `struc:"little"` + // same value as gcc.ClientCoreSettings.keyboardFnKeys + KeyboardFunctionKey uint32 `struc:"little"` + // same value as gcc.ClientCoreSettingrrs.imeFileName + ImeFileName [64]byte + //need add 0c000000 in the end +} + +func (*InputCapability) Type() CapsType { + return CAPSTYPE_INPUT +} + +type BrushCapability struct { + // 0f00080000000000 + SupportLevel BrushSupport `struc:"little"` +} + +func (*BrushCapability) Type() CapsType { + return CAPSTYPE_BRUSH +} + +type cacheEntry struct { + Entries uint16 `struc:"little"` + MaximumCellSize uint16 `struc:"little"` +} + +type GlyphCapability struct { + // 10003400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + GlyphCache [10]cacheEntry `struc:"little"` + FragCache uint32 `struc:"little"` + SupportLevel GlyphSupport `struc:"little"` + Pad2octets uint16 `struc:"little"` +} + +func (*GlyphCapability) Type() CapsType { + return CAPSTYPE_GLYPHCACHE +} + +type OffscreenBitmapCacheCapability struct { + // 11000c000000000000000000 + SupportLevel OffscreenSupportLevel `struc:"little"` + CacheSize uint16 `struc:"little"` + CacheEntries uint16 `struc:"little"` +} + +func (*OffscreenBitmapCacheCapability) Type() CapsType { + return CAPSTYPE_OFFSCREENCACHE +} + +type BitmapCache2Capability struct { + BitmapCachePersist uint16 `struc:"little"` + Pad2octets uint8 `struc:"little"` + CachesNum uint8 `struc:"little"` + BmpC0Cells uint32 `struc:"little"` + BmpC1Cells uint32 `struc:"little"` + BmpC2Cells uint32 `struc:"little"` + BmpC3Cells uint32 `struc:"little"` + BmpC4Cells uint32 `struc:"little"` + Pad2octets1 [12]byte `struc:"little"` +} + +func (*BitmapCache2Capability) Type() CapsType { + return CAPSTYPE_BITMAPCACHE_REV2 +} + +type VirtualChannelCapability struct { + // 14000c000000000000000000 + Flags VirtualChannelCompressionFlag `struc:"little"` + VCChunkSize uint32 `struc:"little"` // optional +} + +func (*VirtualChannelCapability) Type() CapsType { + return CAPSTYPE_VIRTUALCHANNEL +} + +type SoundCapability struct { + // 0c00080000000000 + Flags SoundFlag `struc:"little"` + Pad2octets uint16 `struc:"little"` +} + +func (*SoundCapability) Type() CapsType { + return CAPSTYPE_SOUND +} + +type ControlCapability struct { + ControlFlags uint16 `struc:"little"` + RemoteDetachFlag uint16 `struc:"little"` + ControlInterest uint16 `struc:"little"` + DetachInterest uint16 `struc:"little"` +} + +func (*ControlCapability) Type() CapsType { + return CAPSTYPE_CONTROL +} + +type WindowActivationCapability struct { + HelpKeyFlag uint16 `struc:"little"` + HelpKeyIndexFlag uint16 `struc:"little"` + HelpExtendedKeyFlag uint16 `struc:"little"` + WindowManagerKeyFlag uint16 `struc:"little"` +} + +func (*WindowActivationCapability) Type() CapsType { + return CAPSTYPE_ACTIVATION +} + +type FontCapability struct { + SupportFlags uint16 `struc:"little"` + Pad2octets uint16 `struc:"little"` +} + +func (*FontCapability) Type() CapsType { + return CAPSTYPE_FONT +} + +type ColorCacheCapability struct { + CacheSize uint16 `struc:"little"` + Pad2octets uint16 `struc:"little"` +} + +func (*ColorCacheCapability) Type() CapsType { + return CAPSTYPE_COLORCACHE +} + +type ShareCapability struct { + NodeId uint16 `struc:"little"` + Pad2octets uint16 `struc:"little"` +} + +func (*ShareCapability) Type() CapsType { + return CAPSTYPE_SHARE +} + +type MultiFragmentUpdate struct { + // 1a00080000000000 + MaxRequestSize uint32 `struc:"little"` +} + +func (*MultiFragmentUpdate) Type() CapsType { + return CAPSETTYPE_MULTIFRAGMENTUPDATE +} + +// see https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpegdi/52635737-d144-4f47-9c88-b48ceaf3efb4 + +type DrawGDIPlusCapability struct { + SupportLevel uint32 + GdipVersion uint32 + CacheLevel uint32 + GdipCacheEntries [10]byte + GdipCacheChunkSize [8]byte + GdipImageCacheProperties [6]byte +} + +func (*DrawGDIPlusCapability) Type() CapsType { + return CAPSTYPE_DRAWGDIPLUS +} + +// see https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/86507fed-a0ee-4242-b802-237534a8f65e +type BitmapCodec struct { + GUID [16]byte + ID uint8 + PropertiesLength uint16 `struc:"little,sizeof=Properties"` + Properties []byte +} + +// see https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/408b1878-9f6e-4106-8329-1af42219ba6a +type BitmapCodecS struct { + Count uint8 `struc:"sizeof=Array"` + Array []BitmapCodec +} + +// see https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/17e80f50-d163-49de-a23b-fd6456aa472f +type BitmapCodecsCapability struct { + SupportedBitmapCodecs BitmapCodecS // A variable-length field containing a TS_BITMAPCODECS structure (section 2.2.7.2.10.1). +} + +func (*BitmapCodecsCapability) Type() CapsType { + return CAPSETTYPE_BITMAP_CODECS +} + +// see https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/fc05c385-46c3-42cb-9ed2-c475a3990e0b +type BitmapCacheHostSupportCapability struct { + CacheVersion uint8 + Pad1 uint8 + Pad2 uint16 +} + +func (*BitmapCacheHostSupportCapability) Type() CapsType { + return CAPSTYPE_BITMAPCACHE_HOSTSUPPORT +} + +// see https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/41323437-c753-460e-8108-495a6fdd68a8 +type LargePointerCapability struct { + SupportFlags uint16 `struc:"little"` +} + +func (*LargePointerCapability) Type() CapsType { + return CAPSETTYPE_LARGE_POINTER +} + +// see https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdperp/36a25e21-25e1-4954-aae8-09aaf6715c79 +type RemoteProgramsCapability struct { + RailSupportLevel uint32 `struc:"little"` +} + +func (*RemoteProgramsCapability) Type() CapsType { + return CAPSTYPE_RAIL +} + +// see https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdperp/82ec7a69-f7e3-4294-830d-666178b35d15 +type WindowListCapability struct { + WndSupportLevel uint32 `struc:"little"` + NumIconCaches uint8 + NumIconCacheEntries uint16 `struc:"little"` +} + +func (*WindowListCapability) Type() CapsType { + return CAPSTYPE_WINDOW +} + +// see https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/9132002f-f133-4a0f-ba2f-2dc48f1e7f93 +type DesktopCompositionCapability struct { + CompDeskSupportLevel uint16 `struc:"little"` +} + +func (*DesktopCompositionCapability) Type() CapsType { + return CAPSETTYPE_COMPDESK +} + +// see https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/aa953018-c0a8-4761-bb12-86586c2cd56a +type SurfaceCommandsCapability struct { + CmdFlags uint32 `struc:"little"` + Reserved uint32 `struc:"little"` +} + +func (*SurfaceCommandsCapability) Type() CapsType { + return CAPSETTYPE_SURFACE_COMMANDS +} + +type FrameAcknowledgeCapability struct { + FrameCount uint32 `struc:"little"` +} + +func (*FrameAcknowledgeCapability) Type() CapsType { + return CAPSSETTYPE_FRAME_ACKNOWLEDGE +} + +type DrawNineGridCapability struct { + SupportLevel uint32 `struc:"little"` + CacheSize uint16 `struc:"little"` + CacheEntries uint16 `struc:"little"` +} + +func (*DrawNineGridCapability) Type() CapsType { + return CAPSTYPE_DRAWNINEGRIDCACHE +} + +func readCapability(r io.Reader) (Capability, error) { + capType, err := core.ReadUint16LE(r) + if err != nil { + return nil, err + } + capLen, err := core.ReadUint16LE(r) + if err != nil { + return nil, err + } + if int(capLen)-4 <= 0 { + return nil, errors.New(fmt.Sprintf("Capability length expected %d", capLen)) + } + + capBytes, err := core.ReadBytes(int(capLen)-4, r) + if err != nil { + return nil, err + } + capReader := bytes.NewReader(capBytes) + var c Capability + glog.Debugf("Capability type 0x%04x", capType) + switch CapsType(capType) { + case CAPSTYPE_GENERAL: + c = &GeneralCapability{} + case CAPSTYPE_BITMAP: + c = &BitmapCapability{} + case CAPSTYPE_ORDER: + c = &OrderCapability{} + case CAPSTYPE_BITMAPCACHE: + c = &BitmapCacheCapability{} + case CAPSTYPE_POINTER: + c = &PointerCapability{} + case CAPSTYPE_INPUT: + c = &InputCapability{} + case CAPSTYPE_BRUSH: + c = &BrushCapability{} + case CAPSTYPE_GLYPHCACHE: + c = &GlyphCapability{} + case CAPSTYPE_OFFSCREENCACHE: + c = &OffscreenBitmapCacheCapability{} + case CAPSTYPE_VIRTUALCHANNEL: + c = &VirtualChannelCapability{} + case CAPSTYPE_SOUND: + c = &SoundCapability{} + case CAPSTYPE_CONTROL: + c = &ControlCapability{} + case CAPSTYPE_ACTIVATION: + c = &WindowActivationCapability{} + case CAPSTYPE_FONT: + c = &FontCapability{} + case CAPSTYPE_COLORCACHE: + c = &ColorCacheCapability{} + case CAPSTYPE_SHARE: + c = &ShareCapability{} + case CAPSETTYPE_MULTIFRAGMENTUPDATE: + c = &MultiFragmentUpdate{} + case CAPSTYPE_DRAWGDIPLUS: + c = &DrawGDIPlusCapability{} + case CAPSETTYPE_BITMAP_CODECS: + c = &BitmapCodecsCapability{} + case CAPSTYPE_BITMAPCACHE_HOSTSUPPORT: + c = &BitmapCacheHostSupportCapability{} + case CAPSETTYPE_LARGE_POINTER: + c = &LargePointerCapability{} + case CAPSTYPE_RAIL: + c = &RemoteProgramsCapability{} + case CAPSTYPE_WINDOW: + c = &WindowListCapability{} + case CAPSETTYPE_COMPDESK: + c = &DesktopCompositionCapability{} + case CAPSETTYPE_SURFACE_COMMANDS: + c = &SurfaceCommandsCapability{} + case CAPSSETTYPE_FRAME_ACKNOWLEDGE: + c = &FrameAcknowledgeCapability{} + default: + err := errors.New(fmt.Sprintf("unsupported Capability type 0x%04x", capType)) + glog.Error(err) + return nil, err + } + if err := struc.Unpack(capReader, c); err != nil { + glog.Error("Capability unpack error", err, fmt.Sprintf("0x%04x", capType), hex.EncodeToString(capBytes)) + return nil, err + } + glog.Debugf("Capability<%s>: %+v", c.Type(), c) + return c, nil +} diff --git a/grdp/protocol/pdu/data.go b/grdp/protocol/pdu/data.go new file mode 100644 index 0000000..25d8df8 --- /dev/null +++ b/grdp/protocol/pdu/data.go @@ -0,0 +1,1053 @@ +package pdu + +import ( + "bytes" + "errors" + "fmt" + "io" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/glog" + "github.com/lunixbochs/struc" +) + +const ( + PDUTYPE_DEMANDACTIVEPDU = 0x11 + PDUTYPE_CONFIRMACTIVEPDU = 0x13 + PDUTYPE_DEACTIVATEALLPDU = 0x16 + PDUTYPE_DATAPDU = 0x17 + PDUTYPE_SERVER_REDIR_PKT = 0x1A +) + +type PduType2 uint8 + +const ( + PDUTYPE2_UPDATE = 0x02 + PDUTYPE2_CONTROL = 0x14 + PDUTYPE2_POINTER = 0x1B + PDUTYPE2_INPUT = 0x1C + PDUTYPE2_SYNCHRONIZE = 0x1F + PDUTYPE2_REFRESH_RECT = 0x21 + PDUTYPE2_PLAY_SOUND = 0x22 + PDUTYPE2_SUPPRESS_OUTPUT = 0x23 + PDUTYPE2_SHUTDOWN_REQUEST = 0x24 + PDUTYPE2_SHUTDOWN_DENIED = 0x25 + PDUTYPE2_SAVE_SESSION_INFO = 0x26 + PDUTYPE2_FONTLIST = 0x27 + PDUTYPE2_FONTMAP = 0x28 + PDUTYPE2_SET_KEYBOARD_INDICATORS = 0x29 + PDUTYPE2_BITMAPCACHE_PERSISTENT_LIST = 0x2B + PDUTYPE2_BITMAPCACHE_ERROR_PDU = 0x2C + PDUTYPE2_SET_KEYBOARD_IME_STATUS = 0x2D + PDUTYPE2_OFFSCRCACHE_ERROR_PDU = 0x2E + PDUTYPE2_SET_ERROR_INFO_PDU = 0x2F + PDUTYPE2_DRAWNINEGRID_ERROR_PDU = 0x30 + PDUTYPE2_DRAWGDIPLUS_ERROR_PDU = 0x31 + PDUTYPE2_ARC_STATUS_PDU = 0x32 + PDUTYPE2_STATUS_INFO_PDU = 0x36 + PDUTYPE2_MONITOR_LAYOUT_PDU = 0x37 +) + +func (p PduType2) String() string { + switch p { + case PDUTYPE2_UPDATE: + return "PDUTYPE2_UPDATE" + case PDUTYPE2_CONTROL: + return "PDUTYPE2_CONTROL" + case PDUTYPE2_POINTER: + return "PDUTYPE2_POINTER" + case PDUTYPE2_INPUT: + return "PDUTYPE2_INPUT" + case PDUTYPE2_SYNCHRONIZE: + return "PDUTYPE2_SYNCHRONIZE" + case PDUTYPE2_REFRESH_RECT: + return "PDUTYPE2_REFRESH_RECT" + case PDUTYPE2_PLAY_SOUND: + return "PDUTYPE2_PLAY_SOUND" + case PDUTYPE2_SUPPRESS_OUTPUT: + return "PDUTYPE2_SUPPRESS_OUTPUT" + case PDUTYPE2_SHUTDOWN_REQUEST: + return "PDUTYPE2_SHUTDOWN_REQUEST" + case PDUTYPE2_SHUTDOWN_DENIED: + return "PDUTYPE2_SHUTDOWN_DENIED" + case PDUTYPE2_SAVE_SESSION_INFO: + return "PDUTYPE2_SAVE_SESSION_INFO" + case PDUTYPE2_FONTLIST: + return "PDUTYPE2_FONTLIST" + case PDUTYPE2_FONTMAP: + return "PDUTYPE2_FONTMAP" + case PDUTYPE2_SET_KEYBOARD_INDICATORS: + return "PDUTYPE2_SET_KEYBOARD_INDICATORS" + case PDUTYPE2_BITMAPCACHE_PERSISTENT_LIST: + return "PDUTYPE2_BITMAPCACHE_PERSISTENT_LIST" + case PDUTYPE2_BITMAPCACHE_ERROR_PDU: + return "PDUTYPE2_BITMAPCACHE_ERROR_PDU" + case PDUTYPE2_SET_KEYBOARD_IME_STATUS: + return "PDUTYPE2_SET_KEYBOARD_IME_STATUS" + case PDUTYPE2_OFFSCRCACHE_ERROR_PDU: + return "PDUTYPE2_OFFSCRCACHE_ERROR_PDU" + case PDUTYPE2_SET_ERROR_INFO_PDU: + return "PDUTYPE2_SET_ERROR_INFO_PDU" + case PDUTYPE2_DRAWNINEGRID_ERROR_PDU: + return "PDUTYPE2_DRAWNINEGRID_ERROR_PDU" + case PDUTYPE2_DRAWGDIPLUS_ERROR_PDU: + return "PDUTYPE2_DRAWGDIPLUS_ERROR_PDU" + case PDUTYPE2_ARC_STATUS_PDU: + return "PDUTYPE2_ARC_STATUS_PDU" + case PDUTYPE2_STATUS_INFO_PDU: + return "PDUTYPE2_STATUS_INFO_PDU" + case PDUTYPE2_MONITOR_LAYOUT_PDU: + return "PDUTYPE2_MONITOR_LAYOUT_PDU" + } + + return "Unknown" +} + +const ( + CTRLACTION_REQUEST_CONTROL = 0x0001 + CTRLACTION_GRANTED_CONTROL = 0x0002 + CTRLACTION_DETACH = 0x0003 + CTRLACTION_COOPERATE = 0x0004 +) + +const ( + STREAM_UNDEFINED = 0x00 + STREAM_LOW = 0x01 + STREAM_MED = 0x02 + STREAM_HI = 0x04 +) + +type FastPathUpdateType uint8 + +const ( + FASTPATH_UPDATETYPE_ORDERS = 0x0 + FASTPATH_UPDATETYPE_BITMAP = 0x1 + FASTPATH_UPDATETYPE_PALETTE = 0x2 + FASTPATH_UPDATETYPE_SYNCHRONIZE = 0x3 + FASTPATH_UPDATETYPE_SURFCMDS = 0x4 + FASTPATH_UPDATETYPE_PTR_NULL = 0x5 + FASTPATH_UPDATETYPE_PTR_DEFAULT = 0x6 + FASTPATH_UPDATETYPE_PTR_POSITION = 0x8 + FASTPATH_UPDATETYPE_COLOR = 0x9 + FASTPATH_UPDATETYPE_CACHED = 0xA + FASTPATH_UPDATETYPE_POINTER = 0xB + FASTPATH_UPDATETYPE_LARGE_POINTER = 0xC +) + +func (t FastPathUpdateType) String() string { + switch t { + case FASTPATH_UPDATETYPE_ORDERS: + return "FASTPATH_UPDATETYPE_ORDERS" + case FASTPATH_UPDATETYPE_BITMAP: + return "FASTPATH_UPDATETYPE_BITMAP" + case FASTPATH_UPDATETYPE_PALETTE: + return "FASTPATH_UPDATETYPE_PALETTE" + case FASTPATH_UPDATETYPE_SYNCHRONIZE: + return "FASTPATH_UPDATETYPE_SYNCHRONIZE" + case FASTPATH_UPDATETYPE_SURFCMDS: + return "FASTPATH_UPDATETYPE_SURFCMDS" + case FASTPATH_UPDATETYPE_PTR_NULL: + return "FASTPATH_UPDATETYPE_PTR_NULL" + case FASTPATH_UPDATETYPE_PTR_DEFAULT: + return "FASTPATH_UPDATETYPE_PTR_DEFAULT" + case FASTPATH_UPDATETYPE_PTR_POSITION: + return "FASTPATH_UPDATETYPE_PTR_POSITION" + case FASTPATH_UPDATETYPE_COLOR: + return "FASTPATH_UPDATETYPE_COLOR" + case FASTPATH_UPDATETYPE_CACHED: + return "FASTPATH_UPDATETYPE_CACHED" + case FASTPATH_UPDATETYPE_POINTER: + return "FASTPATH_UPDATETYPE_POINTER" + case FASTPATH_UPDATETYPE_LARGE_POINTER: + return "FASTPATH_UPDATETYPE_LARGE_POINTER" + } + + return "Unknown" +} + +const ( + BITMAP_COMPRESSION = 0x0001 + //NO_BITMAP_COMPRESSION_HDR = 0x0400 +) + +/* compression types */ +const ( + RDP_MPPC_BIG = 0x01 + RDP_MPPC_COMPRESSED = 0x20 + RDP_MPPC_RESET = 0x40 + RDP_MPPC_FLUSH = 0x80 + RDP_MPPC_DICT_SIZE = 65536 +) + +type ShareDataHeader struct { + SharedId uint32 `struc:"little"` + Padding1 uint8 `struc:"little"` + StreamId uint8 `struc:"little"` + UncompressedLength uint16 `struc:"little"` + PDUType2 uint8 `struc:"little"` + CompressedType uint8 `struc:"little"` + CompressedLength uint16 `struc:"little"` +} + +func NewShareDataHeader(size int, type2 uint8, shareId uint32) *ShareDataHeader { + return &ShareDataHeader{ + SharedId: shareId, + PDUType2: type2, + StreamId: STREAM_LOW, + UncompressedLength: uint16(size + 4), + } +} + +type PDUMessage interface { + Type() uint16 + Serialize() []byte +} + +type DemandActivePDU struct { + SharedId uint32 `struc:"little"` + LengthSourceDescriptor uint16 `struc:"little,sizeof=SourceDescriptor"` + LengthCombinedCapabilities uint16 `struc:"little"` + SourceDescriptor []byte `struc:"sizefrom=LengthSourceDescriptor"` + NumberCapabilities uint16 `struc:"little,sizeof=CapabilitySets"` + Pad2Octets uint16 `struc:"little"` + CapabilitySets []Capability `struc:"sizefrom=NumberCapabilities"` + SessionId uint32 `struc:"little"` +} + +func (d *DemandActivePDU) Type() uint16 { + return PDUTYPE_DEMANDACTIVEPDU +} + +func (d *DemandActivePDU) Serialize() []byte { + buff := &bytes.Buffer{} + core.WriteUInt32LE(d.SharedId, buff) + core.WriteUInt16LE(d.LengthSourceDescriptor, buff) + core.WriteUInt16LE(d.LengthCombinedCapabilities, buff) + core.WriteBytes([]byte(d.SourceDescriptor), buff) + core.WriteUInt16LE(uint16(len(d.CapabilitySets)), buff) + core.WriteUInt16LE(d.Pad2Octets, buff) + for _, cap := range d.CapabilitySets { + core.WriteUInt16LE(uint16(cap.Type()), buff) + capBuff := &bytes.Buffer{} + struc.Pack(capBuff, cap) + capBytes := capBuff.Bytes() + core.WriteUInt16LE(uint16(len(capBytes)+4), buff) + core.WriteBytes(capBytes, buff) + } + core.WriteUInt32LE(d.SessionId, buff) + return buff.Bytes() +} + +func readDemandActivePDU(r io.Reader) (*DemandActivePDU, error) { + d := &DemandActivePDU{} + var err error + d.SharedId, err = core.ReadUInt32LE(r) + if err != nil { + return nil, err + } + d.LengthSourceDescriptor, err = core.ReadUint16LE(r) + d.LengthCombinedCapabilities, err = core.ReadUint16LE(r) + sourceDescriptorBytes, err := core.ReadBytes(int(d.LengthSourceDescriptor), r) + if err != nil { + return nil, err + } + d.SourceDescriptor = sourceDescriptorBytes + d.NumberCapabilities, err = core.ReadUint16LE(r) + d.Pad2Octets, err = core.ReadUint16LE(r) + d.CapabilitySets = make([]Capability, 0, d.NumberCapabilities) + glog.Debug("NumberCapabilities is", d.NumberCapabilities) + for i := 0; i < int(d.NumberCapabilities); i++ { + c, err := readCapability(r) + if err != nil { + //return nil, err + continue + } + d.CapabilitySets = append(d.CapabilitySets, c) + } + d.NumberCapabilities = uint16(len(d.CapabilitySets)) + d.SessionId, err = core.ReadUInt32LE(r) + if err != nil { + return nil, err + } + return d, nil +} + +type ConfirmActivePDU struct { + SharedId uint32 `struc:"little"` + OriginatorId uint16 `struc:"little"` + LengthSourceDescriptor uint16 `struc:"little,sizeof=SourceDescriptor"` + LengthCombinedCapabilities uint16 `struc:"little"` + SourceDescriptor []byte `struc:"sizefrom=LengthSourceDescriptor"` + NumberCapabilities uint16 `struc:"little,sizeof=CapabilitySets"` + Pad2Octets uint16 `struc:"little"` + CapabilitySets []Capability `struc:"sizefrom=NumberCapabilities"` +} + +func (*ConfirmActivePDU) Type() uint16 { + return PDUTYPE_CONFIRMACTIVEPDU +} + +func (c *ConfirmActivePDU) Serialize() []byte { + buff := &bytes.Buffer{} + core.WriteUInt32LE(c.SharedId, buff) + core.WriteUInt16LE(c.OriginatorId, buff) + core.WriteUInt16LE(uint16(len(c.SourceDescriptor)), buff) + + capsBuff := &bytes.Buffer{} + for _, capa := range c.CapabilitySets { + core.WriteUInt16LE(uint16(capa.Type()), capsBuff) + capBuff := &bytes.Buffer{} + struc.Pack(capBuff, capa) + capBytes := capBuff.Bytes() + core.WriteUInt16LE(uint16(len(capBytes)+4), capsBuff) + core.WriteBytes(capBytes, capsBuff) + } + capsBytes := capsBuff.Bytes() + + core.WriteUInt16LE(uint16(2+2+len(capsBytes)), buff) + core.WriteBytes(c.SourceDescriptor, buff) + core.WriteUInt16LE(c.NumberCapabilities, buff) + core.WriteUInt16LE(c.Pad2Octets, buff) + core.WriteBytes(capsBytes, buff) + return buff.Bytes() +} + +// 9401 => share control header +// 1300 => share control header +// ec03 => share control header +// ea030100 => shareId 66538 +// ea03 => OriginatorId +// 0400 +// 8001 => LengthCombinedCapabilities +// 72647079 +// 0c00 => NumberCapabilities 12 +// 0000 +// caps below +// 010018000100030000020000000015040000000000000000 +// 02001c00180001000100010000052003000000000100000001000000 +// 030058000000000000000000000000000000000000000000010014000000010000000a0000000000000000000000000000000000000000000000000000000000000000000000000000000000008403000000000000000000 +// 04002800000000000000000000000000000000000000000000000000000000000000000000000000 +// 0800080000001400 +// 0c00080000000000 +// 0d005c001500000009040000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c000000 +// 0f00080000000000 +// 10003400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +// 11000c000000000000000000 +// 14000c000000000000000000 +// 1a00080000000000 + +func NewConfirmActivePDU() *ConfirmActivePDU { + return &ConfirmActivePDU{ + OriginatorId: 0x03EA, + CapabilitySets: make([]Capability, 0), + SourceDescriptor: []byte("rdpy"), + } +} + +func readConfirmActivePDU(r io.Reader) (*ConfirmActivePDU, error) { + p := &ConfirmActivePDU{} + var err error + p.SharedId, err = core.ReadUInt32LE(r) + if err != nil { + return nil, err + } + p.OriginatorId, err = core.ReadUint16LE(r) + p.LengthSourceDescriptor, err = core.ReadUint16LE(r) + p.LengthCombinedCapabilities, err = core.ReadUint16LE(r) + + sourceDescriptorBytes, err := core.ReadBytes(int(p.LengthSourceDescriptor), r) + if err != nil { + return nil, err + } + p.SourceDescriptor = sourceDescriptorBytes + p.NumberCapabilities, err = core.ReadUint16LE(r) + p.Pad2Octets, err = core.ReadUint16LE(r) + + p.CapabilitySets = make([]Capability, 0) + for i := 0; i < int(p.NumberCapabilities); i++ { + c, err := readCapability(r) + if err != nil { + return nil, err + } + p.CapabilitySets = append(p.CapabilitySets, c) + } + s, _ := core.ReadUInt32LE(r) + glog.Info("sessionid:", s) + return p, nil +} + +type DeactiveAllPDU struct { + ShareId uint32 `struc:"little"` + LengthSourceDescriptor uint16 `struc:"little,sizeof=SourceDescriptor"` + SourceDescriptor []byte +} + +func (*DeactiveAllPDU) Type() uint16 { + return PDUTYPE_DEACTIVATEALLPDU +} + +func (d *DeactiveAllPDU) Serialize() []byte { + buff := &bytes.Buffer{} + struc.Pack(buff, d) + return buff.Bytes() +} + +func readDeactiveAllPDU(r io.Reader) (*DeactiveAllPDU, error) { + p := &DeactiveAllPDU{} + err := struc.Unpack(r, p) + return p, err +} + +type DataPDU struct { + Header *ShareDataHeader + Data DataPDUData +} + +func (*DataPDU) Type() uint16 { + return PDUTYPE_DATAPDU +} + +func (d *DataPDU) Serialize() []byte { + buff := &bytes.Buffer{} + struc.Pack(buff, d.Header) + struc.Pack(buff, d.Data) + return buff.Bytes() +} + +func NewDataPDU(data DataPDUData, shareId uint32) *DataPDU { + dataBuff := &bytes.Buffer{} + struc.Pack(dataBuff, data) + return &DataPDU{ + Header: NewShareDataHeader(len(dataBuff.Bytes()), data.Type2(), shareId), + Data: data, + } +} + +func readDataPDU(r io.Reader) (*DataPDU, error) { + header := &ShareDataHeader{} + err := struc.Unpack(r, header) + if err != nil { + glog.Error("read data pdu header error", err) + return nil, err + } + var d DataPDUData + glog.Debugf("PDUType2 0x%02x", header.PDUType2) + switch header.PDUType2 { + case PDUTYPE2_UPDATE: + d = &UpdateDataPDU{} + + case PDUTYPE2_SYNCHRONIZE: + d = &SynchronizeDataPDU{} + + case PDUTYPE2_CONTROL: + d = &ControlDataPDU{} + + case PDUTYPE2_FONTLIST: + d = &FontListDataPDU{} + + case PDUTYPE2_SET_ERROR_INFO_PDU: + d = &ErrorInfoDataPDU{} + + case PDUTYPE2_FONTMAP: + d = &FontMapDataPDU{} + + case PDUTYPE2_SAVE_SESSION_INFO: + d = &SaveSessionInfo{} + + default: + err = errors.New(fmt.Sprintf("Unknown data pdu type2 0x%02x", header.PDUType2)) + glog.Error(err) + return nil, err + } + + err = d.Unpack(r) + if err != nil { + glog.Error("Read data pdu:", err) + return nil, err + } + + p := &DataPDU{ + Header: header, + Data: d, + } + return p, nil +} + +type DataPDUData interface { + Type2() uint8 + Unpack(io.Reader) error +} + +type UpdateDataPDU struct { + UpdateType uint16 + Udata UpdateData +} + +func (*UpdateDataPDU) Type2() uint8 { + return PDUTYPE2_UPDATE +} +func (d *UpdateDataPDU) Unpack(r io.Reader) (err error) { + //slow path update + d.UpdateType, err = core.ReadUint16LE(r) + glog.Debugf("UpdateType 0x%02x", d.UpdateType) + var p UpdateData + switch d.UpdateType { + case FASTPATH_UPDATETYPE_ORDERS: + case FASTPATH_UPDATETYPE_BITMAP: + p = &BitmapUpdateDataPDU{} + case FASTPATH_UPDATETYPE_PALETTE: + case FASTPATH_UPDATETYPE_SYNCHRONIZE: + } + if p != nil { + err = p.Unpack(r) + if err != nil { + //glog.Error("Unpack:", err) + return err + } + } else { + return errors.New(fmt.Sprintf("Unsupport slow update type 0x%x", d.UpdateType)) + } + + d.Udata = p + + return nil +} + +type BitmapUpdateDataPDU struct { + NumberRectangles uint16 `struc:"little,sizeof=Rectangles"` + Rectangles []BitmapData +} + +func (*BitmapUpdateDataPDU) FastPathUpdateType() uint8 { + return FASTPATH_UPDATETYPE_BITMAP +} +func (f *BitmapUpdateDataPDU) Unpack(r io.Reader) error { + var err error + f.NumberRectangles, err = core.ReadUint16LE(r) + f.Rectangles = make([]BitmapData, 0, f.NumberRectangles) + for i := 0; i < int(f.NumberRectangles); i++ { + rect := BitmapData{} + rect.DestLeft, err = core.ReadUint16LE(r) + rect.DestTop, err = core.ReadUint16LE(r) + rect.DestRight, err = core.ReadUint16LE(r) + rect.DestBottom, err = core.ReadUint16LE(r) + rect.Width, err = core.ReadUint16LE(r) + rect.Height, err = core.ReadUint16LE(r) + rect.BitsPerPixel, err = core.ReadUint16LE(r) + rect.Flags, err = core.ReadUint16LE(r) + rect.BitmapLength, err = core.ReadUint16LE(r) + ln := rect.BitmapLength + if rect.Flags&BITMAP_COMPRESSION != 0 && (rect.Flags&NO_BITMAP_COMPRESSION_HDR == 0) { + rect.BitmapComprHdr = new(BitmapCompressedDataHeader) + rect.BitmapComprHdr.CbCompFirstRowSize, err = core.ReadUint16LE(r) + rect.BitmapComprHdr.CbCompMainBodySize, err = core.ReadUint16LE(r) + rect.BitmapComprHdr.CbScanWidth, err = core.ReadUint16LE(r) + rect.BitmapComprHdr.CbUncompressedSize, err = core.ReadUint16LE(r) + ln = rect.BitmapComprHdr.CbCompMainBodySize + } + + rect.BitmapDataStream, err = core.ReadBytes(int(ln), r) + f.Rectangles = append(f.Rectangles, rect) + } + return err +} + +type SynchronizeDataPDU struct { + MessageType uint16 `struc:"little"` + TargetUser uint16 `struc:"little"` +} + +func (*SynchronizeDataPDU) Type2() uint8 { + return PDUTYPE2_SYNCHRONIZE +} + +func NewSynchronizeDataPDU(targetUser uint16) *SynchronizeDataPDU { + return &SynchronizeDataPDU{ + MessageType: 1, + TargetUser: targetUser, + } +} +func (d *SynchronizeDataPDU) Unpack(r io.Reader) error { + return struc.Unpack(r, d) +} + +type ControlDataPDU struct { + Action uint16 `struc:"little"` + GrantId uint16 `struc:"little"` + ControlId uint32 `struc:"little"` +} + +func (*ControlDataPDU) Type2() uint8 { + return PDUTYPE2_CONTROL +} +func (d *ControlDataPDU) Unpack(r io.Reader) error { + return struc.Unpack(r, d) +} + +type FontListDataPDU struct { + NumberFonts uint16 `struc:"little"` + TotalNumFonts uint16 `struc:"little"` + ListFlags uint16 `struc:"little"` + EntrySize uint16 `struc:"little"` +} + +func (*FontListDataPDU) Type2() uint8 { + return PDUTYPE2_FONTLIST +} +func (d *FontListDataPDU) Unpack(r io.Reader) error { + return struc.Unpack(r, d) +} + +type ErrorInfoDataPDU struct { + ErrorInfo uint32 `struc:"little"` +} + +func (*ErrorInfoDataPDU) Type2() uint8 { + return PDUTYPE2_SET_ERROR_INFO_PDU +} +func (d *ErrorInfoDataPDU) Unpack(r io.Reader) error { + return struc.Unpack(r, d) +} + +type FontMapDataPDU struct { + NumberEntries uint16 `struc:"little"` + TotalNumEntries uint16 `struc:"little"` + MapFlags uint16 `struc:"little"` + EntrySize uint16 `struc:"little"` +} + +func (*FontMapDataPDU) Type2() uint8 { + return PDUTYPE2_FONTMAP +} +func (d *FontMapDataPDU) Unpack(r io.Reader) error { + return struc.Unpack(r, d) +} + +type InfoType uint32 + +const ( + INFOTYPE_LOGON = 0x00000000 + INFOTYPE_LOGON_LONG = 0x00000001 + INFOTYPE_LOGON_PLAINNOTIFY = 0x00000002 + INFOTYPE_LOGON_EXTENDED_INFO = 0x00000003 +) +const ( + LOGON_EX_AUTORECONNECTCOOKIE = 0x00000001 + LOGON_EX_LOGONERRORS = 0x00000002 +) + +type LogonFields struct { + CbFileData uint32 `struc:"little"` + Len uint32 //28 `struc:"little"` + Version uint32 // 1 `struc:"little"` + LogonId uint32 `struc:"little"` + random [16]byte //16 `struc:"little"` +} +type SaveSessionInfo struct { + InfoType uint32 + Length uint16 + FieldsPresent uint32 + LogonId uint32 + Random []byte +} + +func (s *SaveSessionInfo) logonInfoV1(r io.Reader) (err error) { + core.ReadUInt32LE(r) // cbDomain + b, _ := core.ReadBytes(52, r) + domain := core.UnicodeDecode(b) + + core.ReadUInt32LE(r) // cbUserName + b, _ = core.ReadBytes(512, r) + userName := core.UnicodeDecode(b) + + sessionId, _ := core.ReadUInt32LE(r) + s.LogonId = sessionId + glog.Infof("SessionId:[%d] UserName:[%s] Domain:[%s]", s.LogonId, userName, domain) + return err +} +func (s *SaveSessionInfo) logonInfoV2(r io.Reader) (err error) { + core.ReadUint16LE(r) + core.ReadUInt32LE(r) + sessionId, _ := core.ReadUInt32LE(r) + s.LogonId = sessionId + cbDomain, _ := core.ReadUInt32LE(r) + cbUserName, _ := core.ReadUInt32LE(r) + core.ReadBytes(558, r) + + b, _ := core.ReadBytes(int(cbDomain), r) + domain := core.UnicodeDecode(b) + b, _ = core.ReadBytes(int(cbUserName), r) + userName := core.UnicodeDecode(b) + glog.Infof("SessionId:[%d] UserName:[ %s] Domain:[ %s]", s.LogonId, userName, domain) + + return err +} +func (s *SaveSessionInfo) logonPlainNotify(r io.Reader) (err error) { + core.ReadBytes(576, r) /* pad (576 bytes) */ + return err +} +func (s *SaveSessionInfo) logonInfoExtended(r io.Reader) (err error) { + s.Length, err = core.ReadUint16LE(r) + s.FieldsPresent, err = core.ReadUInt32LE(r) + //glog.Info("FieldsPresent:", s.FieldsPresent) + // auto reconnect cookie + if s.FieldsPresent&LOGON_EX_AUTORECONNECTCOOKIE != 0 { + core.ReadUInt32LE(r) + b, _ := core.ReadUInt32LE(r) + if b != 28 { + return errors.New(fmt.Sprintf("invalid length in Auto-Reconnect packet")) + } + b, _ = core.ReadUInt32LE(r) + if b != 1 { + return errors.New(fmt.Sprintf("unsupported version of Auto-Reconnect packet")) + } + b, _ = core.ReadUInt32LE(r) + s.LogonId = b + s.Random, _ = core.ReadBytes(16, r) + } else { // logon error info + core.ReadUInt32LE(r) + b, _ := core.ReadUInt32LE(r) + b, _ = core.ReadUInt32LE(r) + s.LogonId = b + } + core.ReadBytes(570, r) + return err +} +func (s *SaveSessionInfo) Unpack(r io.Reader) (err error) { + s.InfoType, err = core.ReadUInt32LE(r) + switch s.InfoType { + case INFOTYPE_LOGON: + err = s.logonInfoV1(r) + case INFOTYPE_LOGON_LONG: + err = s.logonInfoV2(r) + case INFOTYPE_LOGON_PLAINNOTIFY: + err = s.logonPlainNotify(r) + case INFOTYPE_LOGON_EXTENDED_INFO: + err = s.logonInfoExtended(r) + default: + glog.Errorf("Unhandled saveSessionInfo type 0x%x", s.InfoType) + return fmt.Errorf("Unhandled saveSessionInfo type 0x%x", s.InfoType) + } + + return err +} + +func (*SaveSessionInfo) Type2() uint8 { + return PDUTYPE2_SAVE_SESSION_INFO +} + +type PersistKeyPDU struct { + NumEntriesCache0 uint16 `struc:"little"` + NumEntriesCache1 uint16 `struc:"little"` + NumEntriesCache2 uint16 `struc:"little"` + NumEntriesCache3 uint16 `struc:"little"` + NumEntriesCache4 uint16 `struc:"little"` + TotalEntriesCache0 uint16 `struc:"little"` + TotalEntriesCache1 uint16 `struc:"little"` + TotalEntriesCache2 uint16 `struc:"little"` + TotalEntriesCache3 uint16 `struc:"little"` + TotalEntriesCache4 uint16 `struc:"little"` + BBitMask uint8 `struc:"little"` + Pad1 uint8 `struc:"little"` + Ppad3 uint16 `struc:"little"` +} + +func (*PersistKeyPDU) Type2() uint8 { + return PDUTYPE2_BITMAPCACHE_PERSISTENT_LIST +} + +type UpdateData interface { + FastPathUpdateType() uint8 + Unpack(io.Reader) error +} + +type BitmapCompressedDataHeader struct { + CbCompFirstRowSize uint16 `struc:"little"` + CbCompMainBodySize uint16 `struc:"little"` + CbScanWidth uint16 `struc:"little"` + CbUncompressedSize uint16 `struc:"little"` +} + +type BitmapData struct { + DestLeft uint16 `struc:"little"` + DestTop uint16 `struc:"little"` + DestRight uint16 `struc:"little"` + DestBottom uint16 `struc:"little"` + Width uint16 `struc:"little"` + Height uint16 `struc:"little"` + BitsPerPixel uint16 `struc:"little"` + Flags uint16 `struc:"little"` + BitmapLength uint16 `struc:"little,sizeof=BitmapDataStream"` + BitmapComprHdr *BitmapCompressedDataHeader + BitmapDataStream []byte +} + +func (b *BitmapData) IsCompress() bool { + return b.Flags&BITMAP_COMPRESSION != 0 +} + +type FastPathBitmapUpdateDataPDU struct { + Header uint16 `struc:"little"` + NumberRectangles uint16 `struc:"little,sizeof=Rectangles"` + Rectangles []BitmapData +} + +func (f *FastPathBitmapUpdateDataPDU) Unpack(r io.Reader) error { + var err error + f.Header, err = core.ReadUint16LE(r) + f.NumberRectangles, err = core.ReadUint16LE(r) + f.Rectangles = make([]BitmapData, 0, f.NumberRectangles) + for i := 0; i < int(f.NumberRectangles); i++ { + rect := BitmapData{} + rect.DestLeft, err = core.ReadUint16LE(r) + rect.DestTop, err = core.ReadUint16LE(r) + rect.DestRight, err = core.ReadUint16LE(r) + rect.DestBottom, err = core.ReadUint16LE(r) + rect.Width, err = core.ReadUint16LE(r) + rect.Height, err = core.ReadUint16LE(r) + rect.BitsPerPixel, err = core.ReadUint16LE(r) + rect.Flags, err = core.ReadUint16LE(r) + rect.BitmapLength, err = core.ReadUint16LE(r) + ln := rect.BitmapLength + if rect.Flags&BITMAP_COMPRESSION != 0 && (rect.Flags&NO_BITMAP_COMPRESSION_HDR == 0) { + rect.BitmapComprHdr = new(BitmapCompressedDataHeader) + rect.BitmapComprHdr.CbCompFirstRowSize, err = core.ReadUint16LE(r) + rect.BitmapComprHdr.CbCompMainBodySize, err = core.ReadUint16LE(r) + rect.BitmapComprHdr.CbScanWidth, err = core.ReadUint16LE(r) + rect.BitmapComprHdr.CbUncompressedSize, err = core.ReadUint16LE(r) + ln = rect.BitmapComprHdr.CbCompMainBodySize + } + + rect.BitmapDataStream, err = core.ReadBytes(int(ln), r) + f.Rectangles = append(f.Rectangles, rect) + } + return err +} + +func (*FastPathBitmapUpdateDataPDU) FastPathUpdateType() uint8 { + return FASTPATH_UPDATETYPE_BITMAP +} + +type FastPathColorPdu struct { + CacheIdx uint16 + X uint16 + Y uint16 + Width uint16 + Height uint16 + MaskLen uint16 `struc:"little,sizeof=Mask"` + DataLen uint16 `struc:"little,sizeof=Data"` + Mask []byte + Data []byte +} + +func (*FastPathColorPdu) FastPathUpdateType() uint8 { + return FASTPATH_UPDATETYPE_COLOR +} +func (f *FastPathColorPdu) Unpack(r io.Reader) error { + return struc.Unpack(r, f) +} + +type FastPathSurfaceCmds struct { +} + +func (*FastPathSurfaceCmds) FastPathUpdateType() uint8 { + return FASTPATH_UPDATETYPE_SURFCMDS +} +func (f *FastPathSurfaceCmds) Unpack(r io.Reader) error { + cmdType, _ := core.ReadUint16LE(r) + switch cmdType { + + } + + return nil +} + +type FastPathUpdatePDU struct { + UpdateHeader uint8 + Fragmentation uint8 + CompressionFlags uint8 + Size uint16 + Data UpdateData +} + +const ( + FASTPATH_OUTPUT_COMPRESSION_USED = 0x2 +) + +const ( + FASTPATH_FRAGMENT_SINGLE = (0x0 << 4) + FASTPATH_FRAGMENT_LAST = (0x1 << 4) + FASTPATH_FRAGMENT_FIRST = (0x2 << 4) + FASTPATH_FRAGMENT_NEXT = (0x3 << 4) +) + +func readFastPathUpdatePDU(r io.Reader, code uint8) (*FastPathUpdatePDU, error) { + f := &FastPathUpdatePDU{} + var err error + var d UpdateData + //glog.Debugf("FastPathPDU type %s(0x%x)", FastPathUpdateType(code), code) + switch code { + case FASTPATH_UPDATETYPE_ORDERS: + d = &FastPathOrdersPDU{} + case FASTPATH_UPDATETYPE_BITMAP: + d = &FastPathBitmapUpdateDataPDU{} + case FASTPATH_UPDATETYPE_PALETTE: + case FASTPATH_UPDATETYPE_SYNCHRONIZE: + case FASTPATH_UPDATETYPE_SURFCMDS: + //d = &FastPathSurfaceCmds{} + case FASTPATH_UPDATETYPE_PTR_NULL: + case FASTPATH_UPDATETYPE_PTR_DEFAULT: + case FASTPATH_UPDATETYPE_PTR_POSITION: + case FASTPATH_UPDATETYPE_COLOR: + //d = &FastPathColorPdu{} + case FASTPATH_UPDATETYPE_CACHED: + case FASTPATH_UPDATETYPE_POINTER: + case FASTPATH_UPDATETYPE_LARGE_POINTER: + default: + glog.Debugf("Unknown FastPathPDU type 0x%x", code) + return f, errors.New(fmt.Sprintf("Unknown FastPathPDU type 0x%x", code)) + } + if d != nil { + err = d.Unpack(r) + if err != nil { + //glog.Error("Unpack:", err) + return nil, err + } + } else { + return nil, errors.New(fmt.Sprintf("Unsupport FastPathPDU type 0x%x", code)) + } + + f.Data = d + return f, nil +} + +type ShareControlHeader struct { + TotalLength uint16 `struc:"little"` + PDUType uint16 `struc:"little"` + PDUSource uint16 `struc:"little"` +} + +type PDU struct { + ShareCtrlHeader *ShareControlHeader + Message PDUMessage +} + +func NewPDU(userId uint16, message PDUMessage) *PDU { + pdu := &PDU{} + pdu.ShareCtrlHeader = &ShareControlHeader{ + TotalLength: uint16(len(message.Serialize()) + 6), + PDUType: message.Type(), + PDUSource: userId, + } + pdu.Message = message + return pdu +} + +func readPDU(r io.Reader) (*PDU, error) { + pdu := &PDU{} + var err error + header := &ShareControlHeader{} + err = struc.Unpack(r, header) + if err != nil { + return nil, err + } + + pdu.ShareCtrlHeader = header + + var d PDUMessage + switch pdu.ShareCtrlHeader.PDUType { + case PDUTYPE_DEMANDACTIVEPDU: + glog.Debug("PDUTYPE_DEMANDACTIVEPDU") + d, err = readDemandActivePDU(r) + case PDUTYPE_DATAPDU: + glog.Debug("PDUTYPE_DATAPDU") + d, err = readDataPDU(r) + case PDUTYPE_CONFIRMACTIVEPDU: + glog.Debug("PDUTYPE_CONFIRMACTIVEPDU") + d, err = readConfirmActivePDU(r) + case PDUTYPE_DEACTIVATEALLPDU: + glog.Debug("PDUTYPE_DEACTIVATEALLPDU") + d, err = readDeactiveAllPDU(r) + default: + glog.Errorf("PDU invalid pdu type: 0x%02x", pdu.ShareCtrlHeader.PDUType) + } + if err != nil { + return nil, err + } + pdu.Message = d + return pdu, err +} + +func (p *PDU) serialize() []byte { + buff := &bytes.Buffer{} + struc.Pack(buff, p.ShareCtrlHeader) + core.WriteBytes(p.Message.Serialize(), buff) + return buff.Bytes() +} + +type SlowPathInputEvent struct { + EventTime uint32 `struc:"little"` + MessageType uint16 `struc:"little"` + Size int `struc:"skip"` + SlowPathInputData []byte `struc:"sizefrom=Size"` +} + +type PointerEvent struct { + PointerFlags uint16 `struc:"little"` + XPos uint16 `struc:"little"` + YPos uint16 `struc:"little"` +} + +func (p *PointerEvent) Serialize() []byte { + buff := &bytes.Buffer{} + struc.Pack(buff, p) + return buff.Bytes() +} + +type SynchronizeEvent struct { + Pad2Octets uint16 `struc:"little"` + ToggleFlags uint32 `struc:"little"` +} + +func (p *SynchronizeEvent) Serialize() []byte { + buff := &bytes.Buffer{} + struc.Pack(buff, p) + return buff.Bytes() +} + +type ScancodeKeyEvent struct { + KeyboardFlags uint16 `struc:"little"` + KeyCode uint16 `struc:"little"` + Pad2Octets uint16 `struc:"little"` +} + +func (p *ScancodeKeyEvent) Serialize() []byte { + buff := &bytes.Buffer{} + struc.Pack(buff, p) + return buff.Bytes() +} + +type UnicodeKeyEvent struct { + KeyboardFlags uint16 `struc:"little"` + Unicode uint16 `struc:"little"` + Pad2Octets uint16 `struc:"little"` +} + +func (p *UnicodeKeyEvent) Serialize() []byte { + buff := &bytes.Buffer{} + struc.Pack(buff, p) + return buff.Bytes() +} + +type ClientInputEventPDU struct { + NumEvents uint16 `struc:"little,sizeof=SlowPathInputEvents"` + Pad2Octets uint16 `struc:"little"` + SlowPathInputEvents []SlowPathInputEvent `struc:"little"` +} + +func (*ClientInputEventPDU) Type2() uint8 { + return PDUTYPE2_INPUT +} +func (*ClientInputEventPDU) Unpack(io.Reader) error { + return nil +} diff --git a/grdp/protocol/pdu/gdi.go b/grdp/protocol/pdu/gdi.go new file mode 100644 index 0000000..0952c67 --- /dev/null +++ b/grdp/protocol/pdu/gdi.go @@ -0,0 +1,560 @@ +package pdu + +/* Binary Raster Operations (ROP2) */ +const ( + GDI_R2_BLACK = 0x01 + GDI_R2_NOTMERGEPEN = 0x02 + GDI_R2_MASKNOTPEN = 0x03 + GDI_R2_NOTCOPYPEN = 0x04 + GDI_R2_MASKPENNOT = 0x05 + GDI_R2_NOT = 0x06 + GDI_R2_XORPEN = 0x07 + GDI_R2_NOTMASKPEN = 0x08 + GDI_R2_MASKPEN = 0x09 + GDI_R2_NOTXORPEN = 0x0A + GDI_R2_NOP = 0x0B + GDI_R2_MERGENOTPEN = 0x0C + GDI_R2_COPYPEN = 0x0D + GDI_R2_MERGEPENNOT = 0x0E + GDI_R2_MERGEPEN = 0x0F + GDI_R2_WHITE = 0x10 +) + +/* Ternary Raster Operations (ROP3) */ +const ( + GDI_BLACKNESS = 0x00000042 + GDI_DPSoon = 0x00010289 + GDI_DPSona = 0x00020C89 + GDI_PSon = 0x000300AA + GDI_SDPona = 0x00040C88 + GDI_DPon = 0x000500A9 + GDI_PDSxnon = 0x00060865 + GDI_PDSaon = 0x000702C5 + GDI_SDPnaa = 0x00080F08 + GDI_PDSxon = 0x00090245 + GDI_DPna = 0x000A0329 + GDI_PSDnaon = 0x000B0B2A + GDI_SPna = 0x000C0324 + GDI_PDSnaon = 0x000D0B25 + GDI_PDSonon = 0x000E08A5 + GDI_Pn = 0x000F0001 + GDI_PDSona = 0x00100C85 + GDI_NOTSRCERASE = 0x001100A6 + GDI_SDPxnon = 0x00120868 + GDI_SDPaon = 0x001302C8 + GDI_DPSxnon = 0x00140869 + GDI_DPSaon = 0x001502C9 + GDI_PSDPSanaxx = 0x00165CCA + GDI_SSPxDSxaxn = 0x00171D54 + GDI_SPxPDxa = 0x00180D59 + GDI_SDPSanaxn = 0x00191CC8 + GDI_PDSPaox = 0x001A06C5 + GDI_SDPSxaxn = 0x001B0768 + GDI_PSDPaox = 0x001C06CA + GDI_DSPDxaxn = 0x001D0766 + GDI_PDSox = 0x001E01A5 + GDI_PDSoan = 0x001F0385 + GDI_DPSnaa = 0x00200F09 + GDI_SDPxon = 0x00210248 + GDI_DSna = 0x00220326 + GDI_SPDnaon = 0x00230B24 + GDI_SPxDSxa = 0x00240D55 + GDI_PDSPanaxn = 0x00251CC5 + GDI_SDPSaox = 0x002606C8 + GDI_SDPSxnox = 0x00271868 + GDI_DPSxa = 0x00280369 + GDI_PSDPSaoxxn = 0x002916CA + GDI_DPSana = 0x002A0CC9 + GDI_SSPxPDxaxn = 0x002B1D58 + GDI_SPDSoax = 0x002C0784 + GDI_PSDnox = 0x002D060A + GDI_PSDPxox = 0x002E064A + GDI_PSDnoan = 0x002F0E2A + GDI_PSna = 0x0030032A + GDI_SDPnaon = 0x00310B28 + GDI_SDPSoox = 0x00320688 + GDI_NOTSRCCOPY = 0x00330008 + GDI_SPDSaox = 0x003406C4 + GDI_SPDSxnox = 0x00351864 + GDI_SDPox = 0x003601A8 + GDI_SDPoan = 0x00370388 + GDI_PSDPoax = 0x0038078A + GDI_SPDnox = 0x00390604 + GDI_SPDSxox = 0x003A0644 + GDI_SPDnoan = 0x003B0E24 + GDI_PSx = 0x003C004A + GDI_SPDSonox = 0x003D18A4 + GDI_SPDSnaox = 0x003E1B24 + GDI_PSan = 0x003F00EA + GDI_PSDnaa = 0x00400F0A + GDI_DPSxon = 0x00410249 + GDI_SDxPDxa = 0x00420D5D + GDI_SPDSanaxn = 0x00431CC4 + GDI_SRCERASE = 0x00440328 + GDI_DPSnaon = 0x00450B29 + GDI_DSPDaox = 0x004606C6 + GDI_PSDPxaxn = 0x0047076A + GDI_SDPxa = 0x00480368 + GDI_PDSPDaoxxn = 0x004916C5 + GDI_DPSDoax = 0x004A0789 + GDI_PDSnox = 0x004B0605 + GDI_SDPana = 0x004C0CC8 + GDI_SSPxDSxoxn = 0x004D1954 + GDI_PDSPxox = 0x004E0645 + GDI_PDSnoan = 0x004F0E25 + GDI_PDna = 0x00500325 + GDI_DSPnaon = 0x00510B26 + GDI_DPSDaox = 0x005206C9 + GDI_SPDSxaxn = 0x00530764 + GDI_DPSonon = 0x005408A9 + GDI_DSTINVERT = 0x00550009 + GDI_DPSox = 0x005601A9 + GDI_DPSoan = 0x00570389 + GDI_PDSPoax = 0x00580785 + GDI_DPSnox = 0x00590609 + GDI_PATINVERT = 0x005A0049 + GDI_DPSDonox = 0x005B18A9 + GDI_DPSDxox = 0x005C0649 + GDI_DPSnoan = 0x005D0E29 + GDI_DPSDnaox = 0x005E1B29 + GDI_DPan = 0x005F00E9 + GDI_PDSxa = 0x00600365 + GDI_DSPDSaoxxn = 0x006116C6 + GDI_DSPDoax = 0x00620786 + GDI_SDPnox = 0x00630608 + GDI_SDPSoax = 0x00640788 + GDI_DSPnox = 0x00650606 + GDI_SRCINVERT = 0x00660046 + GDI_SDPSonox = 0x006718A8 + GDI_DSPDSonoxxn = 0x006858A6 + GDI_PDSxxn = 0x00690145 + GDI_DPSax = 0x006A01E9 + GDI_PSDPSoaxxn = 0x006B178A + GDI_SDPax = 0x006C01E8 + GDI_PDSPDoaxxn = 0x006D1785 + GDI_SDPSnoax = 0x006E1E28 + GDI_PDSxnan = 0x006F0C65 + GDI_PDSana = 0x00700CC5 + GDI_SSDxPDxaxn = 0x00711D5C + GDI_SDPSxox = 0x00720648 + GDI_SDPnoan = 0x00730E28 + GDI_DSPDxox = 0x00740646 + GDI_DSPnoan = 0x00750E26 + GDI_SDPSnaox = 0x00761B28 + GDI_DSan = 0x007700E6 + GDI_PDSax = 0x007801E5 + GDI_DSPDSoaxxn = 0x00791786 + GDI_DPSDnoax = 0x007A1E29 + GDI_SDPxnan = 0x007B0C68 + GDI_SPDSnoax = 0x007C1E24 + GDI_DPSxnan = 0x007D0C69 + GDI_SPxDSxo = 0x007E0955 + GDI_DPSaan = 0x007F03C9 + GDI_DPSaa = 0x008003E9 + GDI_SPxDSxon = 0x00810975 + GDI_DPSxna = 0x00820C49 + GDI_SPDSnoaxn = 0x00831E04 + GDI_SDPxna = 0x00840C48 + GDI_PDSPnoaxn = 0x00851E05 + GDI_DSPDSoaxx = 0x008617A6 + GDI_PDSaxn = 0x008701C5 + GDI_SRCAND = 0x008800C6 + GDI_SDPSnaoxn = 0x00891B08 + GDI_DSPnoa = 0x008A0E06 + GDI_DSPDxoxn = 0x008B0666 + GDI_SDPnoa = 0x008C0E08 + GDI_SDPSxoxn = 0x008D0668 + GDI_SSDxPDxax = 0x008E1D7C + GDI_PDSanan = 0x008F0CE5 + GDI_PDSxna = 0x00900C45 + GDI_SDPSnoaxn = 0x00911E08 + GDI_DPSDPoaxx = 0x009217A9 + GDI_SPDaxn = 0x009301C4 + GDI_PSDPSoaxx = 0x009417AA + GDI_DPSaxn = 0x009501C9 + GDI_DPSxx = 0x00960169 + GDI_PSDPSonoxx = 0x0097588A + GDI_SDPSonoxn = 0x00981888 + GDI_DSxn = 0x00990066 + GDI_DPSnax = 0x009A0709 + GDI_SDPSoaxn = 0x009B07A8 + GDI_SPDnax = 0x009C0704 + GDI_DSPDoaxn = 0x009D07A6 + GDI_DSPDSaoxx = 0x009E16E6 + GDI_PDSxan = 0x009F0345 + GDI_DPa = 0x00A000C9 + GDI_PDSPnaoxn = 0x00A11B05 + GDI_DPSnoa = 0x00A20E09 + GDI_DPSDxoxn = 0x00A30669 + GDI_PDSPonoxn = 0x00A41885 + GDI_PDxn = 0x00A50065 + GDI_DSPnax = 0x00A60706 + GDI_PDSPoaxn = 0x00A707A5 + GDI_DPSoa = 0x00A803A9 + GDI_DPSoxn = 0x00A90189 + GDI_DSTCOPY = 0x00AA0029 + GDI_DPSono = 0x00AB0889 + GDI_SPDSxax = 0x00AC0744 + GDI_DPSDaoxn = 0x00AD06E9 + GDI_DSPnao = 0x00AE0B06 + GDI_DPno = 0x00AF0229 + GDI_PDSnoa = 0x00B00E05 + GDI_PDSPxoxn = 0x00B10665 + GDI_SSPxDSxox = 0x00B21974 + GDI_SDPanan = 0x00B30CE8 + GDI_PSDnax = 0x00B4070A + GDI_DPSDoaxn = 0x00B507A9 + GDI_DPSDPaoxx = 0x00B616E9 + GDI_SDPxan = 0x00B70348 + GDI_PSDPxax = 0x00B8074A + GDI_DSPDaoxn = 0x00B906E6 + GDI_DPSnao = 0x00BA0B09 + GDI_MERGEPAINT = 0x00BB0226 + GDI_SPDSanax = 0x00BC1CE4 + GDI_SDxPDxan = 0x00BD0D7D + GDI_DPSxo = 0x00BE0269 + GDI_DPSano = 0x00BF08C9 + GDI_MERGECOPY = 0x00C000CA + GDI_SPDSnaoxn = 0x00C11B04 + GDI_SPDSonoxn = 0x00C21884 + GDI_PSxn = 0x00C3006A + GDI_SPDnoa = 0x00C40E04 + GDI_SPDSxoxn = 0x00C50664 + GDI_SDPnax = 0x00C60708 + GDI_PSDPoaxn = 0x00C707AA + GDI_SDPoa = 0x00C803A8 + GDI_SPDoxn = 0x00C90184 + GDI_DPSDxax = 0x00CA0749 + GDI_SPDSaoxn = 0x00CB06E4 + GDI_SRCCOPY = 0x00CC0020 + GDI_SDPono = 0x00CD0888 + GDI_SDPnao = 0x00CE0B08 + GDI_SPno = 0x00CF0224 + GDI_PSDnoa = 0x00D00E0A + GDI_PSDPxoxn = 0x00D1066A + GDI_PDSnax = 0x00D20705 + GDI_SPDSoaxn = 0x00D307A4 + GDI_SSPxPDxax = 0x00D41D78 + GDI_DPSanan = 0x00D50CE9 + GDI_PSDPSaoxx = 0x00D616EA + GDI_DPSxan = 0x00D70349 + GDI_PDSPxax = 0x00D80745 + GDI_SDPSaoxn = 0x00D906E8 + GDI_DPSDanax = 0x00DA1CE9 + GDI_SPxDSxan = 0x00DB0D75 + GDI_SPDnao = 0x00DC0B04 + GDI_SDno = 0x00DD0228 + GDI_SDPxo = 0x00DE0268 + GDI_SDPano = 0x00DF08C8 + GDI_PDSoa = 0x00E003A5 + GDI_PDSoxn = 0x00E10185 + GDI_DSPDxax = 0x00E20746 + GDI_PSDPaoxn = 0x00E306EA + GDI_SDPSxax = 0x00E40748 + GDI_PDSPaoxn = 0x00E506E5 + GDI_SDPSanax = 0x00E61CE8 + GDI_SPxPDxan = 0x00E70D79 + GDI_SSPxDSxax = 0x00E81D74 + GDI_DSPDSanaxxn = 0x00E95CE6 + GDI_DPSao = 0x00EA02E9 + GDI_DPSxno = 0x00EB0849 + GDI_SDPao = 0x00EC02E8 + GDI_SDPxno = 0x00ED0848 + GDI_SRCPAINT = 0x00EE0086 + GDI_SDPnoo = 0x00EF0A08 + GDI_PATCOPY = 0x00F00021 + GDI_PDSono = 0x00F10885 + GDI_PDSnao = 0x00F20B05 + GDI_PSno = 0x00F3022A + GDI_PSDnao = 0x00F40B0A + GDI_PDno = 0x00F50225 + GDI_PDSxo = 0x00F60265 + GDI_PDSano = 0x00F708C5 + GDI_PDSao = 0x00F802E5 + GDI_PDSxno = 0x00F90845 + GDI_DPo = 0x00FA0089 + GDI_PATPAINT = 0x00FB0A09 + GDI_PSo = 0x00FC008A + GDI_PSDnoo = 0x00FD0A0A + GDI_DPSoo = 0x00FE02A9 + GDI_WHITENESS = 0x00FF0062 + GDI_GLYPH_ORDER = 0xFFFFFFFF +) + +var Rop3CodeTable = map[int]string{ + GDI_BLACKNESS: "0", + GDI_DPSoon: "DPSoon", + GDI_DPSona: "DPSona", + GDI_PSon: "PSon", + GDI_SDPona: "SDPona", + GDI_DPon: "DPon", + GDI_PDSxnon: "PDSxnon", + GDI_PDSaon: "PDSaon", + GDI_SDPnaa: "SDPnaa", + GDI_PDSxon: "PDSxon", + GDI_DPna: "DPna", + GDI_PSDnaon: "PSDnaon", + GDI_SPna: "SPna", + GDI_PDSnaon: "PDSnaon", + GDI_PDSonon: "PDSonon", + GDI_Pn: "Pn", + GDI_PDSona: "PDSona", + GDI_NOTSRCERASE: "DSon", + GDI_SDPxnon: "SDPxnon", + GDI_SDPaon: "SDPaon", + GDI_DPSxnon: "DPSxnon", + GDI_DPSaon: "DPSaon", + GDI_PSDPSanaxx: "PSDPSanaxx", + GDI_SSPxDSxaxn: "SSPxDSxaxn", + GDI_SPxPDxa: "SPxPDxa", + GDI_SDPSanaxn: "SDPSanaxn", + GDI_PDSPaox: "PDSPaox", + GDI_SDPSxaxn: "SDPSxaxn", + GDI_PSDPaox: "PSDPaox", + GDI_DSPDxaxn: "DSPDxaxn", + GDI_PDSox: "PDSox", + GDI_PDSoan: "PDSoan", + GDI_DPSnaa: "DPSnaa", + GDI_SDPxon: "SDPxon", + GDI_DSna: "DSna", + GDI_SPDnaon: "SPDnaon", + GDI_SPxDSxa: "SPxDSxa", + GDI_PDSPanaxn: "PDSPanaxn", + GDI_SDPSaox: "SDPSaox", + GDI_SDPSxnox: "SDPSxnox", + GDI_DPSxa: "DPSxa", + GDI_PSDPSaoxxn: "PSDPSaoxxn", + GDI_DPSana: "DPSana", + GDI_SSPxPDxaxn: "SSPxPDxaxn", + GDI_SPDSoax: "SPDSoax", + GDI_PSDnox: "PSDnox", + GDI_PSDPxox: "PSDPxox", + GDI_PSDnoan: "PSDnoan", + GDI_PSna: "PSna", + GDI_SDPnaon: "SDPnaon", + GDI_SDPSoox: "SDPSoox", + GDI_NOTSRCCOPY: "Sn", + GDI_SPDSaox: "SPDSaox", + GDI_SPDSxnox: "SPDSxnox", + GDI_SDPox: "SDPox", + GDI_SDPoan: "SDPoan", + GDI_PSDPoax: "PSDPoax", + GDI_SPDnox: "SPDnox", + GDI_SPDSxox: "SPDSxox", + GDI_SPDnoan: "SPDnoan", + GDI_PSx: "PSx", + GDI_SPDSonox: "SPDSonox", + GDI_SPDSnaox: "SPDSnaox", + GDI_PSan: "PSan", + GDI_PSDnaa: "PSDnaa", + GDI_DPSxon: "DPSxon", + GDI_SDxPDxa: "SDxPDxa", + GDI_SPDSanaxn: "SPDSanaxn", + GDI_SRCERASE: "SDna", + GDI_DPSnaon: "DPSnaon", + GDI_DSPDaox: "DSPDaox", + GDI_PSDPxaxn: "PSDPxaxn", + GDI_SDPxa: "SDPxa", + GDI_PDSPDaoxxn: "PDSPDaoxxn", + GDI_DPSDoax: "DPSDoax", + GDI_PDSnox: "PDSnox", + GDI_SDPana: "SDPana", + GDI_SSPxDSxoxn: "SSPxDSxoxn", + GDI_PDSPxox: "PDSPxox", + GDI_PDSnoan: "PDSnoan", + GDI_PDna: "PDna", + GDI_DSPnaon: "DSPnaon", + GDI_DPSDaox: "DPSDaox", + GDI_SPDSxaxn: "SPDSxaxn", + GDI_DPSonon: "DPSonon", + GDI_DSTINVERT: "Dn", + GDI_DPSox: "DPSox", + GDI_DPSoan: "DPSoan", + GDI_PDSPoax: "PDSPoax", + GDI_DPSnox: "DPSnox", + GDI_PATINVERT: "DPx", + GDI_DPSDonox: "DPSDonox", + GDI_DPSDxox: "DPSDxox", + GDI_DPSnoan: "DPSnoan", + GDI_DPSDnaox: "DPSDnaox", + GDI_DPan: "DPan", + GDI_PDSxa: "PDSxa", + GDI_DSPDSaoxxn: "DSPDSaoxxn", + GDI_DSPDoax: "DSPDoax", + GDI_SDPnox: "SDPnox", + GDI_SDPSoax: "SDPSoax", + GDI_DSPnox: "DSPnox", + GDI_SRCINVERT: "DSx", + GDI_SDPSonox: "SDPSonox", + GDI_DSPDSonoxxn: "DSPDSonoxxn", + GDI_PDSxxn: "PDSxxn", + GDI_DPSax: "DPSax", + GDI_PSDPSoaxxn: "PSDPSoaxxn", + GDI_SDPax: "SDPax", + GDI_PDSPDoaxxn: "PDSPDoaxxn", + GDI_SDPSnoax: "SDPSnoax", + GDI_PDSxnan: "PDSxnan", + GDI_PDSana: "PDSana", + GDI_SSDxPDxaxn: "SSDxPDxaxn", + GDI_SDPSxox: "SDPSxox", + GDI_SDPnoan: "SDPnoan", + GDI_DSPDxox: "DSPDxox", + GDI_DSPnoan: "DSPnoan", + GDI_SDPSnaox: "SDPSnaox", + GDI_DSan: "DSan", + GDI_PDSax: "PDSax", + GDI_DSPDSoaxxn: "DSPDSoaxxn", + GDI_DPSDnoax: "DPSDnoax", + GDI_SDPxnan: "SDPxnan", + GDI_SPDSnoax: "SPDSnoax", + GDI_DPSxnan: "DPSxnan", + GDI_SPxDSxo: "SPxDSxo", + GDI_DPSaan: "DPSaan", + GDI_DPSaa: "DPSaa", + GDI_SPxDSxon: "SPxDSxon", + GDI_DPSxna: "DPSxna", + GDI_SPDSnoaxn: "SPDSnoaxn", + GDI_SDPxna: "SDPxna", + GDI_PDSPnoaxn: "PDSPnoaxn", + GDI_DSPDSoaxx: "DSPDSoaxx", + GDI_PDSaxn: "PDSaxn", + GDI_SRCAND: "DSa", + GDI_SDPSnaoxn: "SDPSnaoxn", + GDI_DSPnoa: "DSPnoa", + GDI_DSPDxoxn: "DSPDxoxn", + GDI_SDPnoa: "SDPnoa", + GDI_SDPSxoxn: "SDPSxoxn", + GDI_SSDxPDxax: "SSDxPDxax", + GDI_PDSanan: "PDSanan", + GDI_PDSxna: "PDSxna", + GDI_SDPSnoaxn: "SDPSnoaxn", + GDI_DPSDPoaxx: "DPSDPoaxx", + GDI_SPDaxn: "SPDaxn", + GDI_PSDPSoaxx: "PSDPSoaxx", + GDI_DPSaxn: "DPSaxn", + GDI_DPSxx: "DPSxx", + GDI_PSDPSonoxx: "PSDPSonoxx", + GDI_SDPSonoxn: "SDPSonoxn", + GDI_DSxn: "DSxn", + GDI_DPSnax: "DPSnax", + GDI_SDPSoaxn: "SDPSoaxn", + GDI_SPDnax: "SPDnax", + GDI_DSPDoaxn: "DSPDoaxn", + GDI_DSPDSaoxx: "DSPDSaoxx", + GDI_PDSxan: "PDSxan", + GDI_DPa: "DPa", + GDI_PDSPnaoxn: "PDSPnaoxn", + GDI_DPSnoa: "DPSnoa", + GDI_DPSDxoxn: "DPSDxoxn", + GDI_PDSPonoxn: "PDSPonoxn", + GDI_PDxn: "PDxn", + GDI_DSPnax: "DSPnax", + GDI_PDSPoaxn: "PDSPoaxn", + GDI_DPSoa: "DPSoa", + GDI_DPSoxn: "DPSoxn", + GDI_DSTCOPY: "D", + GDI_DPSono: "DPSono", + GDI_SPDSxax: "SPDSxax", + GDI_DPSDaoxn: "DPSDaoxn", + GDI_DSPnao: "DSPnao", + GDI_DPno: "DPno", + GDI_PDSnoa: "PDSnoa", + GDI_PDSPxoxn: "PDSPxoxn", + GDI_SSPxDSxox: "SSPxDSxox", + GDI_SDPanan: "SDPanan", + GDI_PSDnax: "PSDnax", + GDI_DPSDoaxn: "DPSDoaxn", + GDI_DPSDPaoxx: "DPSDPaoxx", + GDI_SDPxan: "SDPxan", + GDI_PSDPxax: "PSDPxax", + GDI_DSPDaoxn: "DSPDaoxn", + GDI_DPSnao: "DPSnao", + GDI_MERGEPAINT: "DSno", + GDI_SPDSanax: "SPDSanax", + GDI_SDxPDxan: "SDxPDxan", + GDI_DPSxo: "DPSxo", + GDI_DPSano: "DPSano", + GDI_MERGECOPY: "PSa", + GDI_SPDSnaoxn: "SPDSnaoxn", + GDI_SPDSonoxn: "SPDSonoxn", + GDI_PSxn: "PSxn", + GDI_SPDnoa: "SPDnoa", + GDI_SPDSxoxn: "SPDSxoxn", + GDI_SDPnax: "SDPnax", + GDI_PSDPoaxn: "PSDPoaxn", + GDI_SDPoa: "SDPoa", + GDI_SPDoxn: "SPDoxn", + GDI_DPSDxax: "DPSDxax", + GDI_SPDSaoxn: "SPDSaoxn", + GDI_SRCCOPY: "S", + GDI_SDPono: "SDPono", + GDI_SDPnao: "SDPnao", + GDI_SPno: "SPno", + GDI_PSDnoa: "PSDnoa", + GDI_PSDPxoxn: "PSDPxoxn", + GDI_PDSnax: "PDSnax", + GDI_SPDSoaxn: "SPDSoaxn", + GDI_SSPxPDxax: "SSPxPDxax", + GDI_DPSanan: "DPSanan", + GDI_PSDPSaoxx: "PSDPSaoxx", + GDI_DPSxan: "DPSxan", + GDI_PDSPxax: "PDSPxax", + GDI_SDPSaoxn: "SDPSaoxn", + GDI_DPSDanax: "DPSDanax", + GDI_SPxDSxan: "SPxDSxan", + GDI_SPDnao: "SPDnao", + GDI_SDno: "SDno", + GDI_SDPxo: "SDPxo", + GDI_SDPano: "SDPano", + GDI_PDSoa: "PDSoa", + GDI_PDSoxn: "PDSoxn", + GDI_DSPDxax: "DSPDxax", + GDI_PSDPaoxn: "PSDPaoxn", + GDI_SDPSxax: "SDPSxax", + GDI_PDSPaoxn: "PDSPaoxn", + GDI_SDPSanax: "SDPSanax", + GDI_SPxPDxan: "SPxPDxan", + GDI_SSPxDSxax: "SSPxDSxax", + GDI_DSPDSanaxxn: "DSPDSanaxxn", + GDI_DPSao: "DPSao", + GDI_DPSxno: "DPSxno", + GDI_SDPao: "SDPao", + GDI_SDPxno: "SDPxno", + GDI_SRCPAINT: "DSo", + GDI_SDPnoo: "SDPnoo", + GDI_PATCOPY: "P", + GDI_PDSono: "PDSono", + GDI_PDSnao: "PDSnao", + GDI_PSno: "PSno", + GDI_PSDnao: "PSDnao", + GDI_PDno: "PDno", + GDI_PDSxo: "PDSxo", + GDI_PDSano: "PDSano", + GDI_PDSao: "PDSao", + GDI_PDSxno: "PDSxno", + GDI_DPo: "DPo", + GDI_PATPAINT: "DPSnoo", + GDI_PSo: "PSo", + GDI_PSDnoo: "PSDnoo", + GDI_DPSoo: "DPSoo", + GDI_WHITENESS: "1", +} + +var rop2Table = [16]int{ + GDI_R2_BLACK, + GDI_R2_NOTMERGEPEN, + GDI_R2_MASKNOTPEN, + GDI_R2_NOTCOPYPEN, + GDI_R2_MASKPENNOT, + GDI_R2_NOT, + GDI_R2_XORPEN, + GDI_R2_NOTMASKPEN, + GDI_R2_MASKPEN, + GDI_R2_NOTXORPEN, + GDI_R2_NOP, + GDI_R2_MERGENOTPEN, + GDI_R2_COPYPEN, + GDI_R2_MERGEPENNOT, + GDI_R2_MERGEPEN, + GDI_R2_WHITE, +} diff --git a/grdp/protocol/pdu/orders.go b/grdp/protocol/pdu/orders.go new file mode 100644 index 0000000..eb3a2bd --- /dev/null +++ b/grdp/protocol/pdu/orders.go @@ -0,0 +1,1237 @@ +package pdu + +import ( + "bytes" + "errors" + "fmt" + "io" + + "ShotRDP/grdp/glog" + + "ShotRDP/grdp/core" +) + +type ControlFlag uint8 + +const ( + TS_STANDARD = 0x01 + TS_SECONDARY = 0x02 + TS_BOUNDS = 0x04 + TS_TYPE_CHANGE = 0x08 + TS_DELTA_COORDINATES = 0x10 + TS_ZERO_BOUNDS_DELTAS = 0x20 + TS_ZERO_FIELD_BYTE_BIT0 = 0x40 + TS_ZERO_FIELD_BYTE_BIT1 = 0x80 +) + +type PrimaryOrderType uint8 + +const ( + ORDER_TYPE_DSTBLT = 0x00 //0 + ORDER_TYPE_PATBLT = 0x01 //1 + ORDER_TYPE_SCRBLT = 0x02 //2 + //ORDER_TYPE_DRAWNINEGRID = 0x07 //7 + //ORDER_TYPE_MULTI_DRAWNINEGRID = 0x08 //8 + ORDER_TYPE_LINETO = 0x09 //9 + ORDER_TYPE_OPAQUERECT = 0x0A //10 + ORDER_TYPE_SAVEBITMAP = 0x0B //11 + ORDER_TYPE_MEMBLT = 0x0D //13 + ORDER_TYPE_MEM3BLT = 0x0E //14 + //ORDER_TYPE_MULTIDSTBLT = 0x0F //15 + //ORDER_TYPE_MULTIPATBLT = 0x10 //16 + //ORDER_TYPE_MULTISCRBLT = 0x11 //17 + //ORDER_TYPE_MULTIOPAQUERECT = 0x12 //18 + //ORDER_TYPE_FAST_INDEX = 0x13 //19 + ORDER_TYPE_POLYGON_SC = 0x14 //20 + ORDER_TYPE_POLYGON_CB = 0x15 //21 + ORDER_TYPE_POLYLINE = 0x16 //22 + //ORDER_TYPE_FAST_GLYPH = 0x18 //24 + ORDER_TYPE_ELLIPSE_SC = 0x19 //25 + ORDER_TYPE_ELLIPSE_CB = 0x1A //26 + ORDER_TYPE_TEXT2 = 0x1B //27 +) + +type SecondaryOrderType uint8 + +const ( + ORDER_TYPE_BITMAP_UNCOMPRESSED = 0x00 + ORDER_TYPE_CACHE_COLOR_TABLE = 0x01 + ORDER_TYPE_CACHE_BITMAP_COMPRESSED = 0x02 + ORDER_TYPE_CACHE_GLYPH = 0x03 + ORDER_TYPE_BITMAP_UNCOMPRESSED_V2 = 0x04 + ORDER_TYPE_BITMAP_COMPRESSED_V2 = 0x05 + ORDER_TYPE_CACHE_BRUSH = 0x07 + ORDER_TYPE_BITMAP_COMPRESSED_V3 = 0x08 +) + +func (s SecondaryOrderType) String() string { + name := "Unknown" + switch s { + case ORDER_TYPE_BITMAP_UNCOMPRESSED: + name = "Cache Bitmap" + case ORDER_TYPE_CACHE_COLOR_TABLE: + name = "Cache Color Table" + case ORDER_TYPE_CACHE_BITMAP_COMPRESSED: + name = "Cache Bitmap (Compressed)" + case ORDER_TYPE_CACHE_GLYPH: + name = "Cache Glyph" + case ORDER_TYPE_BITMAP_UNCOMPRESSED_V2: + name = "Cache Bitmap V2" + case ORDER_TYPE_BITMAP_COMPRESSED_V2: + name = "Cache Bitmap V2 (Compressed)" + case ORDER_TYPE_CACHE_BRUSH: + name = "Cache Brush" + case ORDER_TYPE_BITMAP_COMPRESSED_V3: + name = "Cache Bitmap V3" + } + return fmt.Sprintf("[0x%02d] %s", s, name) +} + +/* Alternate Secondary Drawing Orders */ +const ( + ORDER_TYPE_SWITCH_SURFACE = 0x00 + ORDER_TYPE_CREATE_OFFSCREEN_BITMAP = 0x01 + ORDER_TYPE_STREAM_BITMAP_FIRST = 0x02 + ORDER_TYPE_STREAM_BITMAP_NEXT = 0x03 + ORDER_TYPE_CREATE_NINE_GRID_BITMAP = 0x04 + ORDER_TYPE_GDIPLUS_FIRST = 0x05 + ORDER_TYPE_GDIPLUS_NEXT = 0x06 + ORDER_TYPE_GDIPLUS_END = 0x07 + ORDER_TYPE_GDIPLUS_CACHE_FIRST = 0x08 + ORDER_TYPE_GDIPLUS_CACHE_NEXT = 0x09 + ORDER_TYPE_GDIPLUS_CACHE_END = 0x0A + ORDER_TYPE_WINDOW = 0x0B + ORDER_TYPE_COMPDESK_FIRST = 0x0C + ORDER_TYPE_FRAME_MARKER = 0x0D +) + +const ( + GLYPH_FRAGMENT_NOP = 0x00 + GLYPH_FRAGMENT_USE = 0xFE + GLYPH_FRAGMENT_ADD = 0xFF + + CBR2_HEIGHT_SAME_AS_WIDTH = 0x01 + CBR2_PERSISTENT_KEY_PRESENT = 0x02 + CBR2_NO_BITMAP_COMPRESSION_HDR = 0x08 + CBR2_DO_NOT_CACHE = 0x10 +) + +const ( + ORDER_PRIMARY = iota + ORDER_SECONDARY + ORDER_ALTSEC +) + +type OrderPdu struct { + ControlFlags uint8 + Type int + Altsec *Altsec + Primary *Primary + Secondary *Secondary +} + +func (o *OrderPdu) HasBounds() bool { + return o.ControlFlags&TS_BOUNDS != 0 +} + +type Altsec struct { +} + +type Secondary struct { +} + +type Primary struct { + Bounds Bounds + Data PrimaryOrder +} + +type FastPathOrdersPDU struct { + NumberOrders uint16 + OrderPdus []OrderPdu +} + +func (*FastPathOrdersPDU) FastPathUpdateType() uint8 { + return FASTPATH_UPDATETYPE_ORDERS +} + +func (f *FastPathOrdersPDU) Unpack(r io.Reader) error { + f.NumberOrders, _ = core.ReadUint16LE(r) + //glog.Info("NumberOrders:", f.NumberOrders) + for i := 0; i < int(f.NumberOrders); i++ { + var o OrderPdu + o.ControlFlags, _ = core.ReadUInt8(r) + if o.ControlFlags&TS_STANDARD == 0 { + //glog.Info("Altsec order") + o.processAltsecOrder(r) + o.Type = ORDER_ALTSEC + //return errors.New("Not support") + } else if o.ControlFlags&TS_SECONDARY != 0 { + //glog.Info("Secondary order") + o.processSecondaryOrder(r) + o.Type = ORDER_SECONDARY + } else { + //glog.Info("Primary order") + o.processPrimaryOrder(r) + o.Type = ORDER_PRIMARY + } + + if f.OrderPdus == nil { + f.OrderPdus = make([]OrderPdu, 0, f.NumberOrders) + } + f.OrderPdus = append(f.OrderPdus, o) + } + return nil +} +func (o *OrderPdu) processAltsecOrder(r io.Reader) error { + orderType := o.ControlFlags >> 2 + //glog.Info("Altsec:", orderType) + switch orderType { + case ORDER_TYPE_SWITCH_SURFACE: + case ORDER_TYPE_CREATE_OFFSCREEN_BITMAP: + case ORDER_TYPE_STREAM_BITMAP_FIRST: + case ORDER_TYPE_STREAM_BITMAP_NEXT: + case ORDER_TYPE_CREATE_NINE_GRID_BITMAP: + case ORDER_TYPE_GDIPLUS_FIRST: + case ORDER_TYPE_GDIPLUS_NEXT: + case ORDER_TYPE_GDIPLUS_END: + case ORDER_TYPE_GDIPLUS_CACHE_FIRST: + case ORDER_TYPE_GDIPLUS_CACHE_NEXT: + case ORDER_TYPE_GDIPLUS_CACHE_END: + case ORDER_TYPE_WINDOW: + case ORDER_TYPE_COMPDESK_FIRST: + case ORDER_TYPE_FRAME_MARKER: + core.ReadUInt32LE(r) + } + + return nil +} +func (o *OrderPdu) processSecondaryOrder(r io.Reader) error { + var sec Secondary + length, _ := core.ReadUint16LE(r) + flags, _ := core.ReadUint16LE(r) + orderType, _ := core.ReadUInt8(r) + + glog.Info("Secondary:", SecondaryOrderType(orderType)) + + b, _ := core.ReadBytes(int(length)+13-6, r) + r0 := bytes.NewReader(b) + + switch orderType { + case ORDER_TYPE_BITMAP_UNCOMPRESSED: + fallthrough + case ORDER_TYPE_CACHE_BITMAP_COMPRESSED: + compressed := (orderType == ORDER_TYPE_CACHE_BITMAP_COMPRESSED) + sec.updateCacheBitmapOrder(r0, compressed, flags) + case ORDER_TYPE_BITMAP_UNCOMPRESSED_V2: + fallthrough + case ORDER_TYPE_BITMAP_COMPRESSED_V2: + compressed := (orderType == ORDER_TYPE_BITMAP_COMPRESSED_V2) + sec.updateCacheBitmapV2Order(r0, compressed, flags) + case ORDER_TYPE_BITMAP_COMPRESSED_V3: + sec.updateCacheBitmapV3Order(r0, flags) + case ORDER_TYPE_CACHE_COLOR_TABLE: + sec.updateCacheColorTableOrder(r0, flags) + case ORDER_TYPE_CACHE_GLYPH: + sec.updateCacheGlyphOrder(r0, flags) + case ORDER_TYPE_CACHE_BRUSH: + sec.updateCacheBrushOrder(r0, flags) + default: + glog.Debugf("Unsupport order type 0x%x", orderType) + } + + return nil +} +func (b *Bounds) updateBounds(r io.Reader) { + present, _ := core.ReadUInt8(r) + + if present&1 != 0 { + readOrderCoord(r, &b.left, false) + } else if present&16 != 0 { + readOrderCoord(r, &b.left, true) + } + + if present&2 != 0 { + readOrderCoord(r, &b.top, false) + } else if present&32 != 0 { + readOrderCoord(r, &b.top, true) + } + + if present&4 != 0 { + readOrderCoord(r, &b.right, false) + } else if present&64 != 0 { + readOrderCoord(r, &b.right, true) + } + if present&8 != 0 { + readOrderCoord(r, &b.bottom, false) + } else if present&128 != 0 { + readOrderCoord(r, &b.bottom, true) + } +} + +type PrimaryOrder interface { + Type() int + Unpack(io.Reader, uint32, bool) error +} + +var ( + orderType uint8 + bounds Bounds +) + +func (o *OrderPdu) processPrimaryOrder(r io.Reader) error { + o.Primary = &Primary{} + if o.ControlFlags&TS_TYPE_CHANGE != 0 { + orderType, _ = core.ReadUInt8(r) + } + size := 1 + switch orderType { + case ORDER_TYPE_MEM3BLT, ORDER_TYPE_TEXT2: + size = 3 + + case ORDER_TYPE_PATBLT, ORDER_TYPE_MEMBLT, ORDER_TYPE_LINETO, ORDER_TYPE_POLYGON_CB, ORDER_TYPE_ELLIPSE_CB: + size = 2 + } + + if o.ControlFlags&TS_ZERO_FIELD_BYTE_BIT0 != 0 { + size-- + } + if o.ControlFlags&TS_ZERO_FIELD_BYTE_BIT1 != 0 { + if size < 2 { + size = 0 + } else { + size -= 2 + } + } + var present uint32 + for i := 0; i < size; i++ { + bits, _ := core.ReadUInt8(r) + present |= uint32(bits) << (i * 8) + } + + if o.ControlFlags&TS_BOUNDS != 0 { + if o.ControlFlags&TS_ZERO_BOUNDS_DELTAS == 0 { + bounds.updateBounds(r) + } + //glog.Infof("updateBounds") + o.Primary.Bounds = bounds + } + + delta := o.ControlFlags&TS_DELTA_COORDINATES != 0 + + //glog.Infof("present=%d,delta=%v", present, delta) + + var p PrimaryOrder + switch orderType { + case ORDER_TYPE_DSTBLT: + p = &Dstblt{} + + case ORDER_TYPE_PATBLT: + p = &Patblt{} + + case ORDER_TYPE_SCRBLT: + p = &Scrblt{} + + //case ORDER_TYPE_DRAWNINEGRID: + + //case ORDER_TYPE_MULTI_DRAWNINEGRID: + + case ORDER_TYPE_LINETO: + p = &LineTo{} + + case ORDER_TYPE_OPAQUERECT: + p = &OpaqueRect{} + + case ORDER_TYPE_SAVEBITMAP: + p = &SaveBitmap{} + + case ORDER_TYPE_MEMBLT: + p = &Memblt{} + + case ORDER_TYPE_MEM3BLT: + p = &Mem3blt{} + + //case ORDER_TYPE_MULTIDSTBLT: + + //case ORDER_TYPE_MULTIPATBLT: + + //case ORDER_TYPE_MULTISCRBLT: + + //case ORDER_TYPE_MULTIOPAQUERECT: + + //case ORDER_TYPE_FAST_INDEX: + + case ORDER_TYPE_POLYGON_SC: + p = &PolygonSc{} + + case ORDER_TYPE_POLYGON_CB: + p = &PolygonCb{} + + case ORDER_TYPE_POLYLINE: + p = &Polyline{} + + //case ORDER_TYPE_FAST_GLYPH: + + case ORDER_TYPE_ELLIPSE_SC: + p = &EllipeSc{} + + case ORDER_TYPE_ELLIPSE_CB: + p = &EllipeCb{} + + case ORDER_TYPE_TEXT2: + p = &GlayphIndex{} + default: + glog.Error("Not Support order type:", orderType) + return errors.New("Not Support order type") + } + if p != nil { + if err := p.Unpack(r, present, delta); err != nil { + return err + } + } + + o.Primary.Data = p + return nil +} +func readOrderCoord(r io.Reader, coord *int32, delta bool) { + if delta { + change, _ := core.ReadUInt8(r) + *coord += int32(int8(change)) + } else { + change, _ := core.ReadUint16LE(r) + *coord = int32(int16(change)) + } +} + +type Dstblt struct { + x int32 + y int32 + cx int32 + cy int32 + opcode uint8 +} + +func (d *Dstblt) Type() int { + return ORDER_TYPE_DSTBLT +} +func (d *Dstblt) Unpack(r io.Reader, present uint32, delta bool) error { + glog.Infof("Dstblt Order") + if present&0x01 != 0 { + readOrderCoord(r, &d.x, delta) + } + if present&0x02 != 0 { + readOrderCoord(r, &d.y, delta) + } + if present&0x04 != 0 { + readOrderCoord(r, &d.cx, delta) + } + if present&0x08 != 0 { + readOrderCoord(r, &d.cy, delta) + } + if present&0x10 != 0 { + d.opcode, _ = core.ReadUInt8(r) + } + return nil +} + +type Patblt struct { + x int32 + y int32 + cx int32 + cy int32 + opcode uint8 + bgcolour [4]uint8 + fgcolour [4]uint8 + brush Brush +} + +func (d *Patblt) Type() int { + return ORDER_TYPE_PATBLT +} +func (d *Patblt) Unpack(r io.Reader, present uint32, delta bool) error { + glog.Infof("Patblt Order") + if present&0x01 != 0 { + readOrderCoord(r, &d.x, delta) + } + if present&0x02 != 0 { + readOrderCoord(r, &d.y, delta) + } + if present&0x04 != 0 { + readOrderCoord(r, &d.cx, delta) + } + if present&0x08 != 0 { + readOrderCoord(r, &d.cy, delta) + } + if present&0x10 != 0 { + d.opcode, _ = core.ReadUInt8(r) + } + if present&0x0020 != 0 { + b, g, r, a := updateReadColorRef(r) + d.bgcolour[0], d.bgcolour[1], d.bgcolour[2], d.bgcolour[3] = b, g, r, a + } + if present&0x0040 != 0 { + b, g, r, a := updateReadColorRef(r) + d.fgcolour[0], d.fgcolour[1], d.fgcolour[2], d.fgcolour[3] = b, g, r, a + } + d.brush.updateBrush(r, present>>7) + + return nil +} + +type Brush struct { + X uint8 + Y uint8 + Style uint8 + Hatch uint8 + Data []byte +} + +func (b *Brush) updateBrush(r io.Reader, present uint32) { + if present&1 != 0 { + b.X, _ = core.ReadUInt8(r) + } + + if present&2 != 0 { + b.Y, _ = core.ReadUInt8(r) + } + + if present&4 != 0 { + b.Style, _ = core.ReadUInt8(r) + } + + if present&8 != 0 { + b.Hatch, _ = core.ReadUInt8(r) + } + + if present&16 != 0 { + data, _ := core.ReadBytes(7, r) + b.Data = make([]byte, 0, 8) + b.Data = append(b.Data, b.Hatch) + b.Data = append(b.Data, data...) + } +} + +type Scrblt struct { + X int32 + Y int32 + Cx int32 + Cy int32 + Opcode uint8 + Srcx int32 + Srcy int32 +} + +func (d *Scrblt) Type() int { + return ORDER_TYPE_SCRBLT +} + +var d Scrblt + +func (d1 *Scrblt) Unpack(r io.Reader, present uint32, delta bool) error { + glog.Infof("Scrblt Order") + if present&0x0001 != 0 { + readOrderCoord(r, &d.X, delta) + } + if present&0x0002 != 0 { + readOrderCoord(r, &d.Y, delta) + } + if present&0x0004 != 0 { + readOrderCoord(r, &d.Cx, delta) + } + if present&0x0008 != 0 { + readOrderCoord(r, &d.Cy, delta) + } + if present&0x0010 != 0 { + d.Opcode, _ = core.ReadUInt8(r) + } + if present&0x0020 != 0 { + readOrderCoord(r, &d.Srcx, delta) + } + if present&0x0040 != 0 { + readOrderCoord(r, &d.Srcy, delta) + } + *d1 = d + return nil +} + +type LineTo struct { + Mixmode uint16 + Startx int32 + Starty int32 + Endx int32 + Endy int32 + Bgcolour [4]uint8 + Opcode uint8 + Pen Pen +} + +func (d *LineTo) Type() int { + return ORDER_TYPE_LINETO +} +func (d *LineTo) Unpack(r io.Reader, present uint32, delta bool) error { + glog.Infof("LineTo Order") + if present&0x0001 != 0 { + d.Mixmode, _ = core.ReadUint16LE(r) + } + if present&0x0002 != 0 { + readOrderCoord(r, &d.Startx, delta) + } + if present&0x0004 != 0 { + readOrderCoord(r, &d.Starty, delta) + } + if present&0x008 != 0 { + readOrderCoord(r, &d.Endx, delta) + } + if present&0x0010 != 0 { + readOrderCoord(r, &d.Endy, delta) + } + if present&0x0020 != 0 { + b, g, r, a := updateReadColorRef(r) + d.Bgcolour[0], d.Bgcolour[1], d.Bgcolour[2], d.Bgcolour[3] = b, g, r, a + } + if present&0x0040 != 0 { + d.Opcode, _ = core.ReadUInt8(r) + } + + d.Pen.updatePen(r, present>>7) + + return nil +} + +type Pen struct { + Style uint8 + Width uint8 + Colour [4]uint8 +} + +func (d *Pen) updatePen(r io.Reader, present uint32) { + if present&1 != 0 { + d.Style, _ = core.ReadUInt8(r) + } + + if present&2 != 0 { + d.Width, _ = core.ReadUInt8(r) + } + + if present&4 != 0 { + b, g, r, a := updateReadColorRef(r) + d.Colour[0], d.Colour[1], d.Colour[2], d.Colour[3] = b, g, r, a + } +} + +type OpaqueRect struct { + X int32 + Y int32 + Cx int32 + Cy int32 + Colour [4]uint8 +} + +func (d *OpaqueRect) Type() int { + return ORDER_TYPE_OPAQUERECT +} +func (d *OpaqueRect) Unpack(r io.Reader, present uint32, delta bool) error { + glog.Infof("OpaqueRect Order") + if present&0x0001 != 0 { + readOrderCoord(r, &d.X, delta) + } + if present&0x0002 != 0 { + readOrderCoord(r, &d.Y, delta) + } + if present&0x0004 != 0 { + readOrderCoord(r, &d.Cx, delta) + } + if present&0x0008 != 0 { + readOrderCoord(r, &d.Cy, delta) + } + if present&0x0010 != 0 { + i, _ := core.ReadUInt8(r) + d.Colour[0] = i + } + if present&0x0020 != 0 { + i, _ := core.ReadUInt8(r) + d.Colour[1] = i + } + if present&0x0040 != 0 { + i, _ := core.ReadUInt8(r) + d.Colour[2] = i + } + return nil +} + +type SaveBitmap struct { + Offset uint32 + Left int32 + Top int32 + Right int32 + Bottom int32 + action uint8 +} + +func (d *SaveBitmap) Type() int { + return ORDER_TYPE_SAVEBITMAP +} +func (d *SaveBitmap) Unpack(r io.Reader, present uint32, delta bool) error { + if present&0x0001 != 0 { + d.Offset, _ = core.ReadUInt32LE(r) + } + if present&0x0002 != 0 { + readOrderCoord(r, &d.Left, delta) + } + if present&0x0004 != 0 { + readOrderCoord(r, &d.Top, delta) + } + if present&0x0008 != 0 { + readOrderCoord(r, &d.Right, delta) + } + if present&0x0010 != 0 { + readOrderCoord(r, &d.Bottom, delta) + } + if present&0x0020 != 0 { + d.action, _ = core.ReadUInt8(r) + } + return nil +} + +type Memblt struct { + ColourTable uint8 + CacheId uint8 + X int32 + Y int32 + Cx int32 + Cy int32 + Opcode uint8 + Srcx int32 + Srcy int32 + CacheIdx uint16 +} + +func (d *Memblt) Type() int { + return ORDER_TYPE_MEMBLT +} +func (d *Memblt) Unpack(r io.Reader, present uint32, delta bool) error { + if present&0x0001 != 0 { + d.CacheId, _ = core.ReadUInt8(r) + d.ColourTable, _ = core.ReadUInt8(r) + } + if present&0x0002 != 0 { + readOrderCoord(r, &d.X, delta) + } + if present&0x0004 != 0 { + readOrderCoord(r, &d.Y, delta) + } + if present&0x0008 != 0 { + readOrderCoord(r, &d.Cx, delta) + } + if present&0x0010 != 0 { + readOrderCoord(r, &d.Cy, delta) + } + if present&0x0020 != 0 { + d.Opcode, _ = core.ReadUInt8(r) + } + if present&0x0040 != 0 { + readOrderCoord(r, &d.Srcx, delta) + } + if present&0x0080 != 0 { + readOrderCoord(r, &d.Srcy, delta) + } + if present&0x0100 != 0 { + d.CacheIdx, _ = core.ReadUint16LE(r) + } + return nil +} + +type Mem3blt struct { + ColourTable uint8 + CacheId uint8 + X int32 + Y int32 + Cx int32 + Cy int32 + Opcode uint8 + Srcx int32 + Srcy int32 + Bgcolour [4]uint8 + Fgcolour [4]uint8 + Brush Brush + CacheIdx uint16 +} + +func (d *Mem3blt) Type() int { + return ORDER_TYPE_MEM3BLT +} +func (d *Mem3blt) Unpack(r io.Reader, present uint32, delta bool) error { + if present&0x000001 != 0 { + d.CacheId, _ = core.ReadUInt8(r) + d.ColourTable, _ = core.ReadUInt8(r) + } + if present&0x000002 != 0 { + readOrderCoord(r, &d.X, delta) + } + if present&0x000004 != 0 { + readOrderCoord(r, &d.Y, delta) + } + if present&0x000008 != 0 { + readOrderCoord(r, &d.Cx, delta) + } + if present&0x000010 != 0 { + readOrderCoord(r, &d.Cy, delta) + } + if present&0x000020 != 0 { + d.Opcode, _ = core.ReadUInt8(r) + } + if present&0x000040 != 0 { + readOrderCoord(r, &d.Srcx, delta) + } + if present&0x000080 != 0 { + readOrderCoord(r, &d.Srcy, delta) + } + if present&0x000100 != 0 { + b, g, r, a := updateReadColorRef(r) + d.Bgcolour[0], d.Bgcolour[1], d.Bgcolour[2], d.Bgcolour[3] = b, g, r, a + } + if present&0x000200 != 0 { + b, g, r, a := updateReadColorRef(r) + d.Fgcolour[0], d.Fgcolour[1], d.Fgcolour[2], d.Fgcolour[3] = b, g, r, a + } + d.Brush.updateBrush(r, present>>10) + if present&0x008000 != 0 { + d.CacheIdx, _ = core.ReadUint16LE(r) + } + if present&0x010000 != 0 { + core.ReadUint16LE(r) + } + + return nil +} + +type PolygonSc struct { + X int32 + Y int32 + Opcode uint8 + Fillmode uint8 + Fgcolour [4]uint8 + Npoints uint8 + Points []Point +} + +type Point struct { + X int32 + Y int32 +} + +func (d *PolygonSc) Type() int { + return ORDER_TYPE_POLYGON_SC +} +func (d *PolygonSc) Unpack(r io.Reader, present uint32, delta bool) error { + if present&0x0001 != 0 { + readOrderCoord(r, &d.X, delta) + } + if present&0x0002 != 0 { + readOrderCoord(r, &d.Y, delta) + } + if present&0x0004 != 0 { + d.Opcode, _ = core.ReadUInt8(r) + } + if present&0x0008 != 0 { + d.Fillmode, _ = core.ReadUInt8(r) + } + if present&0x0010 != 0 { + b, g, r, a := updateReadColorRef(r) + d.Fgcolour[0], d.Fgcolour[1], d.Fgcolour[2], d.Fgcolour[3] = b, g, r, a + } + if present&0x0020 != 0 { + d.Npoints, _ = core.ReadUInt8(r) + d.Points = make([]Point, 0, d.Npoints+1) + } + if present&0x0040 != 0 { + size, _ := core.ReadUInt8(r) + data, _ := core.ReadBytes(int(size), r) + d.Points = append(d.Points, Point{d.X, d.Y}) + var flags uint8 + r = bytes.NewReader(data) + for i := 1; i <= int(d.Npoints); i++ { + var p Point + if (i-1)%4 == 0 { + flags, _ = core.ReadUInt8(r) + } + if (^flags)&0x80 != 0 { + p.X = parseDelta(r) + } + if (^flags)&0x40 != 0 { + p.Y = parseDelta(r) + } + flags <<= 2 + } + } + + return nil +} + +func parseDelta(r io.Reader) (v int32) { + b, _ := core.ReadUInt8(r) + if b&0x40 != 0 { + v = int32(b) | (^0x3F) + } else { + v = int32(b & 0x3F) + } + if b&0x80 != 0 { + b, _ := core.ReadUInt8(r) + v = (v << 8) | int32(b) + } + return +} + +type PolygonCb struct { +} + +func (d *PolygonCb) Type() int { + return ORDER_TYPE_POLYGON_CB +} +func (d *PolygonCb) Unpack(r io.Reader, present uint32, delta bool) error { + return nil +} + +type Polyline struct { +} + +func (d *Polyline) Type() int { + return ORDER_TYPE_POLYLINE +} +func (d *Polyline) Unpack(r io.Reader, present uint32, delta bool) error { + return nil +} + +type EllipeSc struct { +} + +func (d *EllipeSc) Type() int { + return ORDER_TYPE_ELLIPSE_SC +} +func (d *EllipeSc) Unpack(r io.Reader, present uint32, delta bool) error { + return nil +} + +type EllipeCb struct { +} + +func (d *EllipeCb) Type() int { + return ORDER_TYPE_ELLIPSE_CB +} +func (d *EllipeCb) Unpack(r io.Reader, present uint32, delta bool) error { + return nil +} + +type GlayphIndex struct { +} + +func (d *GlayphIndex) Type() int { + return ORDER_TYPE_TEXT2 +} +func (d *GlayphIndex) Unpack(r io.Reader, present uint32, delta bool) error { + return nil +} + +/*Secondary*/ +func (s *Secondary) updateCacheBitmapOrder(r io.Reader, compressed bool, flags uint16) { + var cb CacheBitmapOrder + cb.cacheId, _ = core.ReadUInt8(r) + core.ReadUInt8(r) + cb.bitmapWidth, _ = core.ReadUInt8(r) + cb.bitmapHeight, _ = core.ReadUInt8(r) + cb.bitmapBpp, _ = core.ReadUInt8(r) + bitmapLength, _ := core.ReadUint16LE(r) + cb.cacheIndex, _ = core.ReadUint16LE(r) + var bitmapComprHdr []byte + if compressed { + if (flags & NO_BITMAP_COMPRESSION_HDR) == 0 { + bitmapComprHdr, _ = core.ReadBytes(8, r) + bitmapLength -= 8 + } + } + cb.bitmapComprHdr = bitmapComprHdr + cb.bitmapDataStream, _ = core.ReadBytes(int(bitmapLength), r) + cb.bitmapLength = bitmapLength + +} + +type CacheBitmapOrder struct { + cacheId uint8 + bitmapBpp uint8 + bitmapWidth uint8 + bitmapHeight uint8 + bitmapLength uint16 + cacheIndex uint16 + bitmapComprHdr []byte + bitmapDataStream []byte +} + +func getCbV2Bpp(bpp uint32) (b uint32) { + switch bpp { + case 3: + b = 8 + case 4: + b = 16 + case 5: + b = 24 + case 6: + b = 32 + default: + b = 0 + } + return +} + +type CacheBitmapV2Order struct { + cacheId uint32 + flags uint32 + key1 uint32 + key2 uint32 + bitmapBpp uint32 + bitmapWidth uint8 + bitmapHeight uint8 + bitmapLength uint16 + cacheIndex uint32 + compressed bool + cbCompFirstRowSize uint16 + cbCompMainBodySize uint16 + cbScanWidth uint16 + cbUncompressedSize uint16 + bitmapDataStream []byte +} + +func (s *Secondary) updateCacheBitmapV2Order(r io.Reader, compressed bool, flags uint16) { + var cb CacheBitmapV2Order + cb.cacheId = uint32(flags) & 0x0003 + cb.flags = (uint32(flags) & 0xFF80) >> 7 + bitsPerPixelId := (uint32(flags) & 0x0078) >> 3 + cb.bitmapBpp = getCbV2Bpp(bitsPerPixelId) + + if cb.flags&CBR2_PERSISTENT_KEY_PRESENT != 0 { + cb.key1, _ = core.ReadUInt32LE(r) + cb.key2, _ = core.ReadUInt32LE(r) + } + + if cb.flags&CBR2_HEIGHT_SAME_AS_WIDTH != 0 { + cb.bitmapWidth, _ = core.ReadUInt8(r) + cb.bitmapHeight = cb.bitmapWidth + } else { + cb.bitmapWidth, _ = core.ReadUInt8(r) + cb.bitmapHeight, _ = core.ReadUInt8(r) + } + + bitmapLength, _ := core.ReadUint16LE(r) + cacheIndex, _ := core.ReadUInt8(r) + + if cb.flags&CBR2_DO_NOT_CACHE != 0 { + cb.cacheIndex = 0x7FFF + } else { + cb.cacheIndex = uint32(cacheIndex) + } + + if compressed { + if cb.flags&CBR2_NO_BITMAP_COMPRESSION_HDR == 0 { + cb.cbCompFirstRowSize, _ = core.ReadUint16LE(r) + cb.cbCompMainBodySize, _ = core.ReadUint16LE(r) + cb.cbScanWidth, _ = core.ReadUint16LE(r) + cb.cbUncompressedSize, _ = core.ReadUint16LE(r) + bitmapLength = cb.cbCompMainBodySize + } + } + + cb.bitmapDataStream, _ = core.ReadBytes(int(bitmapLength), r) + cb.bitmapLength = bitmapLength + cb.compressed = compressed + +} + +type CacheBitmapV3Order struct { + cacheId uint32 + bpp uint32 + flags uint32 + cacheIndex uint16 + key1 uint32 + key2 uint32 + bitmapData BitmapDataEx +} +type BitmapDataEx struct { + bpp uint8 + codecID uint8 + width uint16 + height uint16 + length uint32 + data []byte +} + +func (s *Secondary) updateCacheBitmapV3Order(r io.Reader, flags uint16) { + var cb CacheBitmapV3Order + + cb.cacheId = uint32(flags) & 0x00000003 + cb.flags = (uint32(flags) & 0x0000FF80) >> 7 + bitsPerPixelId := (uint32(flags) & 0x00000078) >> 3 + cb.bpp = getCbV2Bpp(bitsPerPixelId) + + cacheIndex, _ := core.ReadUint16LE(r) + cb.cacheIndex = cacheIndex + cb.key1, _ = core.ReadUInt32LE(r) + cb.key2, _ = core.ReadUInt32LE(r) + + bitmapData := &cb.bitmapData + bitmapData.bpp, _ = core.ReadUInt8(r) + core.ReadUInt8(r) + core.ReadUInt8(r) + bitmapData.codecID, _ = core.ReadUInt8(r) + bitmapData.width, _ = core.ReadUint16LE(r) + bitmapData.height, _ = core.ReadUint16LE(r) + new_len, _ := core.ReadUInt32LE(r) + + bitmapData.data, _ = core.ReadBytes(int(new_len), r) + bitmapData.length = new_len + +} + +type CacheColorTableOrder struct { + cacheIndex uint8 + numberColors uint16 + colorTable [256 * 4]uint8 +} + +func (s *Secondary) updateCacheColorTableOrder(r io.Reader, flags uint16) { + var cb CacheColorTableOrder + cb.cacheIndex, _ = core.ReadUInt8(r) + cb.numberColors, _ = core.ReadUint16LE(r) + + if cb.numberColors != 256 { + /* This field MUST be set to 256 */ + return + } + + for i := 0; i < int(cb.numberColors)*4; i++ { + cb.colorTable[i], cb.colorTable[i+1], cb.colorTable[i+2], cb.colorTable[i+3] = updateReadColorRef(r) + } +} +func updateReadColorRef(r io.Reader) (uint8, uint8, uint8, uint8) { + blue, _ := core.ReadUInt8(r) + green, _ := core.ReadUInt8(r) + red, _ := core.ReadUInt8(r) + core.ReadUInt8(r) + + return blue, green, red, 255 +} + +type CacheGlyphOrder struct { + cacheId uint8 + nglyphs uint8 + glyphs []CacheGlyph +} +type CacheGlyph struct { + character uint16 + offset uint16 + baseline uint16 + width uint16 + height uint16 + datasize int + data []uint8 +} + +func (s *Secondary) updateCacheGlyphOrder(r io.Reader, flags uint16) { + var cb CacheGlyphOrder + + cb.cacheId, _ = core.ReadUInt8(r) + cb.nglyphs, _ = core.ReadUInt8(r) + cb.glyphs = make([]CacheGlyph, 0, cb.nglyphs) + + for i := 0; i < int(cb.nglyphs); i++ { + var c CacheGlyph + c.character, _ = core.ReadUint16LE(r) + c.offset, _ = core.ReadUint16LE(r) + c.baseline, _ = core.ReadUint16LE(r) + c.width, _ = core.ReadUint16LE(r) + c.height, _ = core.ReadUint16LE(r) + + c.datasize = int(c.height*((c.width+7)/8)+3) & ^3 + c.data, _ = core.ReadBytes(c.datasize, r) + + cb.glyphs = append(cb.glyphs, c) + } +} + +type CacheBrushOrder struct { + index uint8 + bpp uint8 + cx uint8 + cy uint8 + style uint8 + length uint8 + data []uint8 +} + +func (s *Secondary) updateCacheBrushOrder(r io.Reader, flags uint16) { + var cb CacheBrushOrder + cb.index, _ = core.ReadUInt8(r) + cb.bpp, _ = core.ReadUInt8(r) + cb.cx, _ = core.ReadUInt8(r) + cb.cy, _ = core.ReadUInt8(r) + cb.style, _ = core.ReadUInt8(r) + cb.length, _ = core.ReadUInt8(r) + if cb.cx == 8 && cb.cy == 8 { + if cb.bpp == 1 { + for i := 7; i >= 0; i-- { + cb.data[i], _ = core.ReadUInt8(r) + } + } else { + bpp := int(cb.bpp) - 2 + if int(cb.length) == 16+4*bpp { + /* compressed brush */ + data, _ := core.ReadBytes(int(cb.length), r) + cb.data = update_decompress_brush(data, bpp) + } else { + /* uncompressed brush */ + scanline := 8 * 8 * bpp + cb.data, _ = core.ReadBytes(scanline, r) + } + } + } +} +func update_decompress_brush(in []uint8, bpp int) []uint8 { + var pal_index, in_index, shift int + + pal := in[16:] + out := make([]uint8, 8*8*bpp) + /* read it bottom up */ + for y := 7; y >= 0; y-- { + /* 2 bytes per row */ + x := 0 + for do2 := 0; do2 < 2; do2++ { + /* 4 pixels per byte */ + shift = 6 + for shift >= 0 { + pal_index = int((in[in_index] >> shift) & 3) + /* size of palette entries depends on bpp */ + for i := 0; i < bpp; i++ { + out[(y*8+x)*bpp+i] = pal[pal_index*bpp+i] + } + x++ + shift -= 2 + } + in_index++ + } + } + + return out +} + +/*Primary*/ +type Bounds struct { + left int32 + top int32 + right int32 + bottom int32 +} +type OrderInfo struct { + controlFlags uint32 + orderType uint32 + fieldFlags uint32 + boundsFlags uint32 + bounds Bounds + deltaCoordinates bool +} diff --git a/grdp/protocol/pdu/pdu.go b/grdp/protocol/pdu/pdu.go new file mode 100644 index 0000000..27b5d6a --- /dev/null +++ b/grdp/protocol/pdu/pdu.go @@ -0,0 +1,459 @@ +package pdu + +import ( + "bytes" + "encoding/hex" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/emission" + "ShotRDP/grdp/glog" + "ShotRDP/grdp/protocol/t125/gcc" +) + +type PDULayer struct { + emission.Emitter + transport core.Transport + sharedId uint32 + userId uint16 + channelId uint16 + serverCapabilities map[CapsType]Capability + clientCapabilities map[CapsType]Capability + fastPathSender core.FastPathSender + demandActivePDU *DemandActivePDU +} + +func NewPDULayer(t core.Transport) *PDULayer { + p := &PDULayer{ + Emitter: *emission.NewEmitter(), + transport: t, + sharedId: 0x103EA, + serverCapabilities: map[CapsType]Capability{ + CAPSTYPE_GENERAL: &GeneralCapability{ + ProtocolVersion: 0x0200, + }, + CAPSTYPE_BITMAP: &BitmapCapability{ + Receive1BitPerPixel: 0x0001, + Receive4BitsPerPixel: 0x0001, + Receive8BitsPerPixel: 0x0001, + BitmapCompressionFlag: 0x0001, + MultipleRectangleSupport: 0x0001, + }, + CAPSTYPE_ORDER: &OrderCapability{ + DesktopSaveXGranularity: 1, + DesktopSaveYGranularity: 20, + MaximumOrderLevel: 1, + OrderFlags: NEGOTIATEORDERSUPPORT, + DesktopSaveSize: 480 * 480, + }, + CAPSTYPE_POINTER: &PointerCapability{ColorPointerCacheSize: 20}, + CAPSTYPE_INPUT: &InputCapability{}, + CAPSTYPE_VIRTUALCHANNEL: &VirtualChannelCapability{}, + CAPSTYPE_FONT: &FontCapability{SupportFlags: 0x0001}, + CAPSTYPE_COLORCACHE: &ColorCacheCapability{CacheSize: 0x0006}, + CAPSTYPE_SHARE: &ShareCapability{}, + }, + clientCapabilities: map[CapsType]Capability{ + CAPSTYPE_GENERAL: &GeneralCapability{ + ProtocolVersion: 0x0200, + }, + CAPSTYPE_BITMAP: &BitmapCapability{ + Receive1BitPerPixel: 0x0001, + Receive4BitsPerPixel: 0x0001, + Receive8BitsPerPixel: 0x0001, + BitmapCompressionFlag: 0x0001, + MultipleRectangleSupport: 0x0001, + }, + CAPSTYPE_ORDER: &OrderCapability{ + DesktopSaveXGranularity: 1, + DesktopSaveYGranularity: 20, + MaximumOrderLevel: 1, + OrderFlags: NEGOTIATEORDERSUPPORT, + DesktopSaveSize: 480 * 480, + TextANSICodePage: 0x4e4, + }, + CAPSTYPE_CONTROL: &ControlCapability{0, 0, 2, 2}, + CAPSTYPE_ACTIVATION: &WindowActivationCapability{}, + CAPSTYPE_POINTER: &PointerCapability{1, 20, 20}, + CAPSTYPE_SHARE: &ShareCapability{}, + CAPSTYPE_COLORCACHE: &ColorCacheCapability{6, 0}, + CAPSTYPE_SOUND: &SoundCapability{0x0001, 0}, + CAPSTYPE_INPUT: &InputCapability{}, + CAPSTYPE_FONT: &FontCapability{0x0001, 0}, + CAPSTYPE_BRUSH: &BrushCapability{BRUSH_COLOR_8x8}, + CAPSTYPE_GLYPHCACHE: &GlyphCapability{}, + CAPSETTYPE_BITMAP_CODECS: &BitmapCodecsCapability{}, + CAPSTYPE_BITMAPCACHE_REV2: &BitmapCache2Capability{ + BitmapCachePersist: 2, + CachesNum: 5, + BmpC0Cells: 0x258, + BmpC1Cells: 0x258, + BmpC2Cells: 0x800, + BmpC3Cells: 0x1000, + BmpC4Cells: 0x800, + }, + CAPSTYPE_VIRTUALCHANNEL: &VirtualChannelCapability{0, 1600}, + CAPSETTYPE_MULTIFRAGMENTUPDATE: &MultiFragmentUpdate{65535}, + CAPSTYPE_RAIL: &RemoteProgramsCapability{ + RailSupportLevel: RAIL_LEVEL_SUPPORTED | + RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED | + RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED | + RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED | + RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED | + RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED | + RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED | + RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED, + }, + CAPSETTYPE_LARGE_POINTER: &LargePointerCapability{1}, + CAPSETTYPE_SURFACE_COMMANDS: &SurfaceCommandsCapability{ + CmdFlags: SURFCMDS_SET_SURFACE_BITS | SURFCMDS_STREAM_SURFACE_BITS | SURFCMDS_FRAME_MARKER, + }, + CAPSSETTYPE_FRAME_ACKNOWLEDGE: &FrameAcknowledgeCapability{2}, + }, + } + + t.On("close", func() { + p.Emit("close") + }).On("error", func(err error) { + p.Emit("error", err) + }) + return p +} + +func (p *PDULayer) sendPDU(message PDUMessage) { + pdu := NewPDU(p.userId, message) + p.transport.Write(pdu.serialize()) +} + +func (p *PDULayer) sendDataPDU(message DataPDUData) { + dataPdu := NewDataPDU(message, p.sharedId) + p.sendPDU(dataPdu) +} + +func (p *PDULayer) SetFastPathSender(f core.FastPathSender) { + p.fastPathSender = f +} + +type Client struct { + *PDULayer + clientCoreData *gcc.ClientCoreData + buff *bytes.Buffer +} + +func NewClient(t core.Transport) *Client { + c := &Client{ + PDULayer: NewPDULayer(t), + buff: &bytes.Buffer{}, + } + c.transport.Once("connect", c.connect) + return c +} + +func (c *Client) connect(data *gcc.ClientCoreData, userId uint16, channelId uint16) { + glog.Debug("pdu connect:", userId, ",", channelId) + c.clientCoreData = data + c.userId = userId + c.channelId = channelId + c.transport.Once("data", c.recvDemandActivePDU) +} + +func (c *Client) recvDemandActivePDU(s []byte) { + glog.Trace("PDU recvDemandActivePDU", hex.EncodeToString(s)) + r := bytes.NewReader(s) + pdu, err := readPDU(r) + if err != nil { + glog.Error(err) + return + } + if pdu.ShareCtrlHeader.PDUType != PDUTYPE_DEMANDACTIVEPDU { + glog.Info("PDU ignore message during connection sequence, type is", pdu.ShareCtrlHeader.PDUType) + c.transport.Once("data", c.recvDemandActivePDU) + return + } + c.sharedId = pdu.Message.(*DemandActivePDU).SharedId + c.demandActivePDU = pdu.Message.(*DemandActivePDU) + for _, caps := range c.demandActivePDU.CapabilitySets { + glog.Debugf("serverCapabilities<%s>: %+v", caps.Type(), caps) + c.serverCapabilities[caps.Type()] = caps + } + + c.sendConfirmActivePDU() + c.sendClientFinalizeSynchronizePDU() + c.transport.Once("data", c.recvServerSynchronizePDU) +} + +func (c *Client) sendConfirmActivePDU() { + glog.Debug("PDU start sendConfirmActivePDU") + + pdu := NewConfirmActivePDU() + generalCapa := c.clientCapabilities[CAPSTYPE_GENERAL].(*GeneralCapability) + generalCapa.OSMajorType = OSMAJORTYPE_WINDOWS + generalCapa.OSMinorType = OSMINORTYPE_WINDOWS_NT + generalCapa.ExtraFlags = LONG_CREDENTIALS_SUPPORTED | NO_BITMAP_COMPRESSION_HDR | + FASTPATH_OUTPUT_SUPPORTED | AUTORECONNECT_SUPPORTED + generalCapa.RefreshRectSupport = 0 + generalCapa.SuppressOutputSupport = 0 + + bitmapCapa := c.clientCapabilities[CAPSTYPE_BITMAP].(*BitmapCapability) + bitmapCapa.PreferredBitsPerPixel = c.clientCoreData.HighColorDepth + bitmapCapa.DesktopWidth = c.clientCoreData.DesktopWidth + bitmapCapa.DesktopHeight = c.clientCoreData.DesktopHeight + bitmapCapa.DesktopResizeFlag = 0x0001 + + orderCapa := c.clientCapabilities[CAPSTYPE_ORDER].(*OrderCapability) + orderCapa.OrderFlags = NEGOTIATEORDERSUPPORT | ZEROBOUNDSDELTASSUPPORT | COLORINDEXSUPPORT | ORDERFLAGS_EXTRA_FLAGS + orderCapa.OrderSupportExFlags |= ORDERFLAGS_EX_ALTSEC_FRAME_MARKER_SUPPORT + orderCapa.OrderSupport[TS_NEG_DSTBLT_INDEX] = 1 + orderCapa.OrderSupport[TS_NEG_PATBLT_INDEX] = 1 + orderCapa.OrderSupport[TS_NEG_SCRBLT_INDEX] = 1 + //orderCapa.OrderSupport[TS_NEG_LINETO_INDEX] = 1 + //orderCapa.OrderSupport[TS_NEG_MEMBLT_INDEX] = 1 + //orderCapa.OrderSupport[TS_NEG_MEM3BLT_INDEX] = 1 + //orderCapa.OrderSupport[TS_NEG_POLYLINE_INDEX] = 1 + /*orderCapa.OrderSupport[TS_NEG_MULTIOPAQUERECT_INDEX] = 1 + orderCapa.OrderSupport[TS_NEG_GLYPH_INDEX_INDEX] = 1 + //orderCapa.OrderSupport[TS_NEG_DRAWNINEGRID_INDEX] = 1 + orderCapa.OrderSupport[TS_NEG_SAVEBITMAP_INDEX] = 1 + orderCapa.OrderSupport[TS_NEG_POLYGON_SC_INDEX] = 1 + orderCapa.OrderSupport[TS_NEG_POLYGON_CB_INDEX] = 1 + orderCapa.OrderSupport[TS_NEG_ELLIPSE_SC_INDEX] = 1 + orderCapa.OrderSupport[TS_NEG_ELLIPSE_CB_INDEX] = 1*/ + orderCapa.OrderSupport[TS_NEG_FAST_GLYPH_INDEX] = 1 + + inputCapa := c.clientCapabilities[CAPSTYPE_INPUT].(*InputCapability) + inputCapa.Flags = INPUT_FLAG_SCANCODES | INPUT_FLAG_MOUSEX | INPUT_FLAG_UNICODE + inputCapa.KeyboardLayout = c.clientCoreData.KbdLayout + inputCapa.KeyboardType = c.clientCoreData.KeyboardType + inputCapa.KeyboardSubType = c.clientCoreData.KeyboardSubType + inputCapa.KeyboardFunctionKey = c.clientCoreData.KeyboardFnKeys + inputCapa.ImeFileName = c.clientCoreData.ImeFileName + + glyphCapa := c.clientCapabilities[CAPSTYPE_GLYPHCACHE].(*GlyphCapability) + /*glyphCapa.GlyphCache[0] = cacheEntry{254, 4} + glyphCapa.GlyphCache[1] = cacheEntry{254, 4} + glyphCapa.GlyphCache[2] = cacheEntry{254, 8} + glyphCapa.GlyphCache[3] = cacheEntry{254, 8} + glyphCapa.GlyphCache[4] = cacheEntry{254, 16} + glyphCapa.GlyphCache[5] = cacheEntry{254, 32} + glyphCapa.GlyphCache[6] = cacheEntry{254, 64} + glyphCapa.GlyphCache[7] = cacheEntry{254, 128} + glyphCapa.GlyphCache[8] = cacheEntry{254, 256} + glyphCapa.GlyphCache[9] = cacheEntry{64, 2048} + glyphCapa.FragCache = 0x01000100*/ + glyphCapa.SupportLevel = GLYPH_SUPPORT_NONE + + pdu.SharedId = c.sharedId + for _, v := range c.clientCapabilities { + glog.Debugf("clientCapabilities<%s>: %+v", v.Type(), v) + pdu.CapabilitySets = append(pdu.CapabilitySets, v) + } + pdu.NumberCapabilities = uint16(len(pdu.CapabilitySets)) + pdu.LengthSourceDescriptor = c.demandActivePDU.LengthSourceDescriptor + pdu.SourceDescriptor = c.demandActivePDU.SourceDescriptor + pdu.LengthCombinedCapabilities = c.demandActivePDU.LengthCombinedCapabilities + + c.sendPDU(pdu) +} + +func (c *Client) sendClientFinalizeSynchronizePDU() { + glog.Debug("PDU start sendClientFinalizeSynchronizePDU") + c.sendDataPDU(NewSynchronizeDataPDU(c.channelId)) + c.sendDataPDU(&ControlDataPDU{Action: CTRLACTION_COOPERATE}) + c.sendDataPDU(&ControlDataPDU{Action: CTRLACTION_REQUEST_CONTROL}) + //c.sendDataPDU(&PersistKeyPDU{BBitMask: 0x03}) + c.sendDataPDU(&FontListDataPDU{ListFlags: 0x0003, EntrySize: 0x0032}) +} + +func (c *Client) recvServerSynchronizePDU(s []byte) { + glog.Debug("PDU recvServerSynchronizePDU") + r := bytes.NewReader(s) + pdu, err := readPDU(r) + if err != nil { + glog.Error(err) + return + } + dataPdu, ok := pdu.Message.(*DataPDU) + if !ok || dataPdu.Header.PDUType2 != PDUTYPE2_SYNCHRONIZE { + if ok { + glog.Error("recvServerSynchronizePDU ignore datapdu type2", dataPdu.Header.PDUType2) + } else { + glog.Error("recvServerSynchronizePDU ignore message type", pdu.ShareCtrlHeader.PDUType) + } + glog.Infof("%+v", dataPdu) + c.transport.Once("data", c.recvServerSynchronizePDU) + return + } + c.transport.Once("data", c.recvServerControlCooperatePDU) +} + +func (c *Client) recvServerControlCooperatePDU(s []byte) { + glog.Debug("PDU recvServerControlCooperatePDU") + r := bytes.NewReader(s) + pdu, err := readPDU(r) + if err != nil { + glog.Error(err) + return + } + dataPdu, ok := pdu.Message.(*DataPDU) + if !ok || dataPdu.Header.PDUType2 != PDUTYPE2_CONTROL { + if ok { + glog.Error("recvServerControlCooperatePDU ignore datapdu type2", dataPdu.Header.PDUType2) + } else { + glog.Error("recvServerControlCooperatePDU ignore message type", pdu.ShareCtrlHeader.PDUType) + } + c.transport.Once("data", c.recvServerControlCooperatePDU) + return + } + if dataPdu.Data.(*ControlDataPDU).Action != CTRLACTION_COOPERATE { + glog.Error("recvServerControlCooperatePDU ignore action", dataPdu.Data.(*ControlDataPDU).Action) + c.transport.Once("data", c.recvServerControlCooperatePDU) + return + } + c.transport.Once("data", c.recvServerControlGrantedPDU) +} + +func (c *Client) recvServerControlGrantedPDU(s []byte) { + glog.Debug("PDU recvServerControlGrantedPDU") + r := bytes.NewReader(s) + pdu, err := readPDU(r) + if err != nil { + glog.Error(err) + return + } + dataPdu, ok := pdu.Message.(*DataPDU) + if !ok || dataPdu.Header.PDUType2 != PDUTYPE2_CONTROL { + if ok { + glog.Error("recvServerControlGrantedPDU ignore datapdu type2", dataPdu.Header.PDUType2) + } else { + glog.Error("recvServerControlGrantedPDU ignore message type", pdu.ShareCtrlHeader.PDUType) + } + c.transport.Once("data", c.recvServerControlGrantedPDU) + return + } + if dataPdu.Data.(*ControlDataPDU).Action != CTRLACTION_GRANTED_CONTROL { + glog.Error("recvServerControlGrantedPDU ignore action", dataPdu.Data.(*ControlDataPDU).Action) + c.transport.Once("data", c.recvServerControlGrantedPDU) + return + } + c.transport.Once("data", c.recvServerFontMapPDU) +} + +func (c *Client) recvServerFontMapPDU(s []byte) { + glog.Debug("PDU recvServerFontMapPDU") + r := bytes.NewReader(s) + pdu, err := readPDU(r) + if err != nil { + glog.Error(err) + return + } + dataPdu, ok := pdu.Message.(*DataPDU) + if !ok || dataPdu.Header.PDUType2 != PDUTYPE2_FONTMAP { + if ok { + glog.Error("recvServerFontMapPDU ignore datapdu type2", dataPdu.Header.PDUType2) + } else { + glog.Error("recvServerFontMapPDU ignore message type", pdu.ShareCtrlHeader.PDUType) + } + return + } + c.transport.On("data", c.recvPDU) + c.Emit("ready") +} + +func (c *Client) recvPDU(s []byte) { + glog.Trace("PDU recvPDU", hex.EncodeToString(s)) + r := bytes.NewReader(s) + if r.Len() > 0 { + p, err := readPDU(r) + if err != nil { + glog.Error(err) + return + } + if p.ShareCtrlHeader.PDUType == PDUTYPE_DEACTIVATEALLPDU { + c.transport.Once("data", c.recvDemandActivePDU) + } else if p.ShareCtrlHeader.PDUType == PDUTYPE_DATAPDU { + d := p.Message.(*DataPDU) + if d.Header.PDUType2 == PDUTYPE2_UPDATE { + up := d.Data.(*UpdateDataPDU) + p := up.Udata + if up.UpdateType == FASTPATH_UPDATETYPE_BITMAP { + c.Emit("bitmap", p.(*BitmapUpdateDataPDU).Rectangles) + } else if up.UpdateType == FASTPATH_UPDATETYPE_ORDERS { + c.Emit("orders", p.(*FastPathOrdersPDU).OrderPdus) + } + } + } + } +} + +func (c *Client) RecvFastPath(secFlag byte, s []byte) { + glog.Trace("PDU RecvFastPath", hex.EncodeToString(s)) + r := bytes.NewReader(s) + for r.Len() > 0 { + updateHeader, err := core.ReadUInt8(r) + if err != nil { + return + } + updateCode := updateHeader & 0x0f + fragmentation := updateHeader & 0x30 + compression := updateHeader & 0xC0 + + var compressionFlags uint8 = 0 + if compression == FASTPATH_OUTPUT_COMPRESSION_USED { + compressionFlags, err = core.ReadUInt8(r) + } + + size, err := core.ReadUint16LE(r) + + if err != nil { + return + } + glog.Trace("Code:", FastPathUpdateType(updateCode), + "compressionFlags:", compressionFlags, + "fragmentation:", fragmentation, + "size:", size, "len:", r.Len()) + if compressionFlags&RDP_MPPC_COMPRESSED != 0 { + glog.Info("RDP_MPPC_COMPRESSED") + } + if fragmentation != FASTPATH_FRAGMENT_SINGLE { + if fragmentation == FASTPATH_FRAGMENT_FIRST { + c.buff.Reset() + } + b, _ := core.ReadBytes(r.Len(), r) + c.buff.Write(b) + if fragmentation != FASTPATH_FRAGMENT_LAST { + return + } + r = bytes.NewReader(c.buff.Bytes()) + } + + p, err := readFastPathUpdatePDU(r, updateCode) + if err != nil || p == nil || p.Data == nil { + glog.Debug("readFastPathUpdatePDU:", err) + return + } + + if updateCode == FASTPATH_UPDATETYPE_BITMAP { + c.Emit("bitmap", p.Data.(*FastPathBitmapUpdateDataPDU).Rectangles) + } else if updateCode == FASTPATH_UPDATETYPE_COLOR { + c.Emit("color", p.Data.(*FastPathColorPdu)) + } else if updateCode == FASTPATH_UPDATETYPE_ORDERS { + c.Emit("orders", p.Data.(*FastPathOrdersPDU).OrderPdus) + } + } +} + +type InputEventsInterface interface { + Serialize() []byte +} + +func (c *Client) SendInputEvents(msgType uint16, events []InputEventsInterface) { + p := &ClientInputEventPDU{} + p.NumEvents = uint16(len(events)) + p.SlowPathInputEvents = make([]SlowPathInputEvent, 0, p.NumEvents) + for _, in := range events { + seria := in.Serialize() + s := SlowPathInputEvent{0, msgType, len(seria), seria} + p.SlowPathInputEvents = append(p.SlowPathInputEvents, s) + } + + c.sendDataPDU(p) +} diff --git a/grdp/protocol/rfb/rfb.go b/grdp/protocol/rfb/rfb.go new file mode 100644 index 0000000..78b424d --- /dev/null +++ b/grdp/protocol/rfb/rfb.go @@ -0,0 +1,470 @@ +// rfb.go +package rfb + +import ( + "bytes" + "crypto/des" + "encoding/hex" + "errors" + "fmt" + "io" + "log" + "net" + + "github.com/lunixbochs/struc" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/emission" + "ShotRDP/grdp/glog" +) + +// ProtocolVersion +const ( + RFB003003 = "RFB 003.003\n" + RFB003007 = "RFB 003.007\n" + RFB003008 = "RFB 003.008\n" +) + +// SecurityType +const ( + SEC_INVALID uint8 = 0 + SEC_NONE uint8 = 1 + SEC_VNC uint8 = 2 +) + +type RFBConn struct { + emission.Emitter + // The Socket connection to the client + Conn net.Conn + s *ServerInit + NbRect uint16 + BitRect *BitRect + Password string +} + +func NewRFBConn(s net.Conn, passwd string) *RFBConn { + fc := &RFBConn{ + Emitter: *emission.NewEmitter(), + Conn: s, + BitRect: new(BitRect), + Password: passwd, + } + core.StartReadBytes(12, fc, fc.recvProtocolVersion) + + return fc +} +func (fc *RFBConn) Read(b []byte) (n int, err error) { + return fc.Conn.Read(b) +} + +func (fc *RFBConn) Write(data []byte) (n int, err error) { + buff := &bytes.Buffer{} + buff.Write(data) + return fc.Conn.Write(buff.Bytes()) +} +func (fc *RFBConn) Close() error { + return fc.Conn.Close() +} +func (fc *RFBConn) recvProtocolVersion(s []byte, err error) { + version := string(s) + glog.Debug("RFBConn recvProtocolVersion", version, err) + if err != nil { + fc.Emit("error", err) + return + } + fc.Emit("data", version) + + if version == RFB003003 { + fc.Emit("error", fmt.Errorf("%s", "Not Support RFB003003")) + return + //core.StartReadBytes(4, fc, fc.recvSecurityServer) + } else { + core.StartReadBytes(1, fc, fc.checkSecurityList) + } +} +func (fc *RFBConn) checkSecurityList(s []byte, err error) { + r := bytes.NewReader(s) + result, _ := core.ReadUInt8(r) + glog.Debug("RFBConn recvSecurityList", result, err) + + core.StartReadBytes(int(result), fc, fc.recvSecurityList) +} +func (fc *RFBConn) recvSecurityList(s []byte, err error) { + r := bytes.NewReader(s) + secLevel := SEC_VNC + for r.Len() > 0 { + result, _ := core.ReadUInt8(r) + if result == SEC_NONE || result == SEC_VNC { + secLevel = result + break + } + } + + glog.Debug("RFBConn recvSecurityList", secLevel, err) + buff := &bytes.Buffer{} + core.WriteUInt8(secLevel, buff) + fc.Write(buff.Bytes()) + if secLevel == SEC_VNC { + core.StartReadBytes(16, fc, fc.recvVNCChallenge) + } else { + core.StartReadBytes(4, fc, fc.recvSecurityResult) + } + +} + +func fixDesKeyByte(val byte) byte { + var newval byte = 0 + for i := 0; i < 8; i++ { + newval <<= 1 + newval += (val & 1) + val >>= 1 + } + return newval +} + +// fixDesKey will make sure that exactly 8 bytes is used either by truncating or padding with nulls +// The bytes are then bit mirrored and returned +func fixDesKey(key []byte) []byte { + tmp := key + buf := make([]byte, 8) + if len(tmp) <= 8 { + copy(buf, tmp) + } else { + copy(buf, tmp[:8]) + } + for i := 0; i < 8; i++ { + buf[i] = fixDesKeyByte(buf[i]) + } + return buf +} + +func (fc *RFBConn) recvVNCChallenge(s []byte, err error) { + glog.Debug("RFBConn recvVNCChallenge", hex.EncodeToString(s), len(s), err) + key := core.UnicodeEncode(fc.Password) + bk, err := des.NewCipher(fixDesKey(key)) + if err != nil { + log.Printf("Error generating authentication cipher: %s\n", err.Error()) + return + } + result := make([]byte, 16) + bk.Encrypt(result, s) //Encrypt first 8 bytes + bk.Encrypt(result[8:], s[8:]) + if err != nil { + fmt.Println(err) + } + fmt.Println(string(result)) + fc.Write(result) + core.StartReadBytes(4, fc, fc.recvSecurityResult) +} +func (fc *RFBConn) recvSecurityResult(s []byte, err error) { + r := bytes.NewReader(s) + result, _ := core.ReadUInt32BE(r) + glog.Debug("RFBConn recvSecurityResult", result, err) + if result == 1 { + fc.Emit("error", fmt.Errorf("%s", "Authentification failed")) + return + } + buff := &bytes.Buffer{} + core.WriteUInt8(0, buff) //share + fc.Write(buff.Bytes()) + core.StartReadBytes(20, fc, fc.recvServerInit) +} + +type ServerInit struct { + Width uint16 `struc:"little"` + Height uint16 `struc:"little"` + PixelFormat *PixelFormat `struc:"little"` +} + +func (fc *RFBConn) recvServerInit(s []byte, err error) { + glog.Debug("RFBConn recvServerInit", len(s), err) + r := bytes.NewReader(s) + si := &ServerInit{} + si.Width, err = core.ReadUint16BE(r) + si.Height, err = core.ReadUint16BE(r) + si.PixelFormat = ReadPixelFormat(r) + glog.Infof("serverInit:%+v, %+v", si, si.PixelFormat) + fc.s = si + fc.BitRect.Pf = si.PixelFormat + core.StartReadBytes(4, fc, fc.checkServerName) +} +func (fc *RFBConn) checkServerName(s []byte, err error) { + r := bytes.NewReader(s) + result, _ := core.ReadUInt32BE(r) + glog.Debug("RFBConn recvSecurityList", result, err) + + core.StartReadBytes(int(result), fc, fc.recvServerName) +} +func (fc *RFBConn) recvServerName(s []byte, err error) { + glog.Debug("RFBConn recvServerName", string(s), err) + //fc.sendPixelFormat() + fc.sendSetEncoding() + fc.sendFramebufferUpdateRequest(0, 0, 0, fc.s.Width, fc.s.Height) + + fc.Emit("ready") + core.StartReadBytes(1, fc, fc.recvServerOrder) +} + +func (fc *RFBConn) sendPixelFormat() { + glog.Debug("sendPixelFormat") + buff := &bytes.Buffer{} + core.WriteUInt8(0, buff) + core.WriteUInt16BE(0, buff) + core.WriteUInt8(0, buff) + err := struc.Pack(buff, NewPixelFormat()) + if err != nil { + fc.Emit("error", err) + return + } + fc.Write(buff.Bytes()) +} +func (fc *RFBConn) sendSetEncoding() { + glog.Debug("sendSetEncoding") + buff := &bytes.Buffer{} + core.WriteUInt8(2, buff) + core.WriteUInt8(0, buff) + core.WriteUInt16BE(1, buff) + core.WriteUInt32BE(0, buff) + fc.Write(buff.Bytes()) +} + +type FrameBufferUpdateRequest struct { + Incremental uint8 + X uint16 + Y uint16 + Width uint16 + Height uint16 +} + +func (fc *RFBConn) sendFramebufferUpdateRequest(Incremental uint8, + X uint16, + Y uint16, + Width uint16, + Height uint16) { + glog.Debug("sendFramebufferUpdateRequest") + buff := &bytes.Buffer{} + core.WriteUInt8(3, buff) + core.WriteUInt8(Incremental, buff) + core.WriteUInt16BE(X, buff) + core.WriteUInt16BE(Y, buff) + core.WriteUInt16BE(Width, buff) + core.WriteUInt16BE(Height, buff) + fc.Write(buff.Bytes()) +} +func (fc *RFBConn) recvServerOrder(s []byte, err error) { + glog.Debug("RFBConn recvServerOrder", hex.EncodeToString(s), err) + r := bytes.NewReader(s) + packetType, _ := core.ReadUInt8(r) + switch packetType { + case 0: + core.StartReadBytes(3, fc, fc.recvFrameBufferUpdateHeader) + case 2: + //TODO + case 3: + core.StartReadBytes(7, fc, fc.recvServerCutTextHeader) + default: + glog.Errorf("Unknown message type %s", packetType) + } + +} + +type BitRect struct { + Rects []Rectangles + Pf *PixelFormat +} + +type Rectangles struct { + Rect *Rectangle + Data []byte +} + +func (fc *RFBConn) recvFrameBufferUpdateHeader(s []byte, err error) { + glog.Debug("RFBConn recvFrameBufferUpdateHeader", hex.EncodeToString(s), err) + r := bytes.NewReader(s) + core.ReadUInt8(r) + NbRect, _ := core.ReadUint16BE(r) + fc.NbRect = NbRect + fc.BitRect.Rects = make([]Rectangles, fc.NbRect) + if NbRect == 0 { + return + } + glog.Info("NbRect:", NbRect) + core.StartReadBytes(12, fc, fc.recvRectHeader) +} + +type Rectangle struct { + X uint16 `struc:"little"` + Y uint16 `struc:"little"` + Width uint16 `struc:"little"` + Height uint16 `struc:"little"` + Encoding uint32 `struc:"little"` +} + +func (fc *RFBConn) recvRectHeader(s []byte, err error) { + glog.Debug("RFBConn recvRectHeader", hex.EncodeToString(s), err) + r := bytes.NewReader(s) + x, err := core.ReadUint16BE(r) + y, err := core.ReadUint16BE(r) + w, err := core.ReadUint16BE(r) + h, err := core.ReadUint16BE(r) + e, err := core.ReadUInt32BE(r) + rect := &Rectangle{x, y, w, h, e} + + fc.BitRect.Rects[fc.NbRect-1].Rect = rect + glog.Infof("rect:%+v, len=%d", rect, int(rect.Width)*int(rect.Height)*4) + core.StartReadBytes(int(rect.Width)*int(rect.Height)*4, fc, fc.recvRectBody) +} +func (fc *RFBConn) recvRectBody(s []byte, err error) { + glog.Debug("RFBConn recvRectBody", hex.EncodeToString(s), err) + fc.BitRect.Rects[fc.NbRect-1].Data = s + fc.NbRect-- + glog.Info("fc.NbRect:", fc.NbRect) + if fc.NbRect == 0 { + fc.Emit("bitmap", fc.BitRect) + fc.sendFramebufferUpdateRequest(1, 0, 0, fc.s.Width, fc.s.Height) + core.StartReadBytes(1, fc, fc.recvServerOrder) + } else { + core.StartReadBytes(12, fc, fc.recvRectHeader) + } +} + +type ServerCutTextHeader struct { + Padding [3]byte `struc:"little"` + Size uint32 `struc:"little"` +} + +func (fc *RFBConn) recvServerCutTextHeader(s []byte, err error) { + glog.Debug("RFBConn recvServerCutTextHeader", string(s), err) + r := bytes.NewReader(s) + header := &ServerCutTextHeader{} + err = struc.Unpack(r, header) + if err != nil { + fc.Emit("error", err) + return + } + + core.StartReadBytes(int(header.Size), fc, fc.recvServerCutTextBody) +} +func (fc *RFBConn) recvServerCutTextBody(s []byte, err error) { + glog.Debug("RFBConn recvServerCutTextBody", string(s), err) + fc.Emit("CutText", s) + core.StartReadBytes(1, fc, fc.recvServerOrder) +} + +type PixelFormat struct { + BitsPerPixel uint8 `struc:"little"` + Depth uint8 `struc:"little"` + BigEndianFlag uint8 `struc:"little"` + TrueColorFlag uint8 `struc:"little"` + RedMax uint16 `struc:"little"` + GreenMax uint16 `struc:"little"` + BlueMax uint16 `struc:"little"` + RedShift uint8 `struc:"little"` + GreenShift uint8 `struc:"little"` + BlueShift uint8 `struc:"little"` + Padding uint16 `struc:"little"` + Padding1 uint8 `struc:"little"` +} + +func ReadPixelFormat(r io.Reader) *PixelFormat { + p := NewPixelFormat() + p.BitsPerPixel, _ = core.ReadUInt8(r) + p.Depth, _ = core.ReadUInt8(r) + p.BigEndianFlag, _ = core.ReadUInt8(r) + p.TrueColorFlag, _ = core.ReadUInt8(r) + p.RedMax, _ = core.ReadUint16BE(r) + p.GreenMax, _ = core.ReadUint16BE(r) + p.BlueMax, _ = core.ReadUint16BE(r) + p.RedShift, _ = core.ReadUInt8(r) + p.GreenShift, _ = core.ReadUInt8(r) + p.BlueShift, _ = core.ReadUInt8(r) + p.Padding, _ = core.ReadUint16BE(r) + p.Padding1, _ = core.ReadUInt8(r) + + return p +} +func NewPixelFormat() *PixelFormat { + return &PixelFormat{ + 32, 24, 0, 1, 65280, 65280, 65280, 16, 8, 0, 0, 0, + } +} + +type RFB struct { + core.Transport + Version string + SecurityLevel uint8 + ServerName string + PixelFormat *PixelFormat + NbRect int + CurrentRect *Rectangle +} + +func NewRFB(t core.Transport) *RFB { + fb := &RFB{t, RFB003008, SEC_INVALID, "", NewPixelFormat(), 0, &Rectangle{}} + + return fb +} + +func (fb *RFB) Connect() error { + if fb.Transport == nil { + return errors.New("no transport") + } + fb.Once("data", fb.recvProtocolVersion) + return nil +} + +func (fb *RFB) recvProtocolVersion(version string) { + if version != RFB003003 || version != RFB003007 || version != RFB003008 { + version = RFB003008 + } + glog.Infof("version:%s", version) + b := &bytes.Buffer{} + b.WriteString(version) + fb.Write(b.Bytes()) +} + +type KeyEvent struct { + DownFlag uint8 `struc:"little"` + Padding uint16 `struc:"little"` + Key uint32 `struc:"little"` +} + +func (fb *RFB) SendKeyEvent(k *KeyEvent) { + b := &bytes.Buffer{} + core.WriteUInt8(4, b) + core.WriteUInt8(k.DownFlag, b) + core.WriteUInt16BE(k.Padding, b) + core.WriteUInt32BE(k.Key, b) + fmt.Println(b.Bytes()) + fb.Write(b.Bytes()) +} + +type PointerEvent struct { + Mask uint8 `struc:"little"` + XPos uint16 `struc:"little"` + YPos uint16 `struc:"little"` +} + +func (fb *RFB) SendPointEvent(p *PointerEvent) { + b := &bytes.Buffer{} + core.WriteUInt8(5, b) + core.WriteUInt8(p.Mask, b) + core.WriteUInt16BE(p.XPos, b) + core.WriteUInt16BE(p.YPos, b) + fmt.Println(b.Bytes()) + fb.Write(b.Bytes()) +} + +type ClientCutText struct { + Padding uint16 `struc:"little"` + Padding1 uint8 `struc:"little"` + Size uint32 `struc:"little"` + Message string `struc:"little"` +} + +func (fb *RFB) SendClientCutText(t *ClientCutText) { + b := &bytes.Buffer{} + core.WriteUInt8(6, b) + struc.Pack(b, t) + fb.Write(b.Bytes()) +} diff --git a/grdp/protocol/sec/sec.go b/grdp/protocol/sec/sec.go new file mode 100644 index 0000000..704ba5a --- /dev/null +++ b/grdp/protocol/sec/sec.go @@ -0,0 +1,899 @@ +package sec + +import ( + "bytes" + "crypto/md5" + "crypto/rand" + "crypto/rc4" + "crypto/rsa" + "crypto/sha1" + "encoding/hex" + "errors" + "io" + "unicode/utf16" + + "github.com/lunixbochs/struc" + + "ShotRDP/grdp/protocol/nla" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/emission" + "ShotRDP/grdp/glog" + "ShotRDP/grdp/protocol/lic" + "ShotRDP/grdp/protocol/t125" + "ShotRDP/grdp/protocol/t125/gcc" +) + +/** + * SecurityFlag + * @see http://msdn.microsoft.com/en-us/library/cc240579.aspx + */ +const ( + EXCHANGE_PKT uint16 = 0x0001 + TRANSPORT_REQ = 0x0002 + TRANSPORT_RSP = 0x0004 + ENCRYPT = 0x0008 + RESET_SEQNO = 0x0010 + IGNORE_SEQNO = 0x0020 + INFO_PKT = 0x0040 + LICENSE_PKT = 0x0080 + LICENSE_ENCRYPT_CS = 0x0200 + LICENSE_ENCRYPT_SC = 0x0200 + REDIRECTION_PKT = 0x0400 + SECURE_CHECKSUM = 0x0800 + AUTODETECT_REQ = 0x1000 + AUTODETECT_RSP = 0x2000 + HEARTBEAT = 0x4000 + FLAGSHI_VALID = 0x8000 +) + +const ( + INFO_MOUSE uint32 = 0x00000001 + INFO_DISABLECTRLALTDEL = 0x00000002 + INFO_AUTOLOGON = 0x00000008 + INFO_UNICODE = 0x00000010 + INFO_MAXIMIZESHELL = 0x00000020 + INFO_LOGONNOTIFY = 0x00000040 + INFO_COMPRESSION = 0x00000080 + INFO_ENABLEWINDOWSKEY = 0x00000100 + INFO_REMOTECONSOLEAUDIO = 0x00002000 + INFO_FORCE_ENCRYPTED_CS_PDU = 0x00004000 + INFO_RAIL = 0x00008000 + INFO_LOGONERRORS = 0x00010000 + INFO_MOUSE_HAS_WHEEL = 0x00020000 + INFO_PASSWORD_IS_SC_PIN = 0x00040000 + INFO_NOAUDIOPLAYBACK = 0x00080000 + INFO_USING_SAVED_CREDS = 0x00100000 + INFO_AUDIOCAPTURE = 0x00200000 + INFO_VIDEO_DISABLE = 0x00400000 + INFO_CompressionTypeMask = 0x00001E00 +) + +const ( + AF_INET uint16 = 0x00002 + AF_INET6 = 0x0017 +) + +const ( + PERF_DISABLE_WALLPAPER uint32 = 0x00000001 + PERF_DISABLE_FULLWINDOWDRAG = 0x00000002 + PERF_DISABLE_MENUANIMATIONS = 0x00000004 + PERF_DISABLE_THEMING = 0x00000008 + PERF_DISABLE_CURSOR_SHADOW = 0x00000020 + PERF_DISABLE_CURSORSETTINGS = 0x00000040 + PERF_ENABLE_FONT_SMOOTHING = 0x00000080 + PERF_ENABLE_DESKTOP_COMPOSITION = 0x00000100 +) + +const ( + FASTPATH_OUTPUT_SECURE_CHECKSUM = 0x1 + FASTPATH_OUTPUT_ENCRYPTED = 0x2 +) + +type ClientAutoReconnect struct { + CbAutoReconnectLen uint16 + CbLen uint32 + Version uint32 + LogonId uint32 + SecVerifier []byte +} + +func NewClientAutoReconnect(id uint32, random []byte) *ClientAutoReconnect { + return &ClientAutoReconnect{ + CbAutoReconnectLen: 28, + CbLen: 28, + Version: 1, + LogonId: id, + SecVerifier: nla.HMAC_MD5(random, random), + } +} + +type RDPExtendedInfo struct { + ClientAddressFamily uint16 `struc:"little"` + CbClientAddress uint16 `struc:"little,sizeof=ClientAddress"` + ClientAddress []byte `struc:"[]byte"` + CbClientDir uint16 `struc:"little,sizeof=ClientDir"` + ClientDir []byte `struc:"[]byte"` + ClientTimeZone []byte `struc:"[172]byte"` + ClientSessionId uint32 `struc:"litttle"` + PerformanceFlags uint32 `struc:"little"` + AutoReconnect *ClientAutoReconnect +} + +func NewExtendedInfo(auto *ClientAutoReconnect) *RDPExtendedInfo { + return &RDPExtendedInfo{ + ClientAddressFamily: AF_INET, + ClientAddress: []byte{0, 0}, + ClientDir: []byte{0, 0}, + ClientTimeZone: make([]byte, 172), + ClientSessionId: 0, + AutoReconnect: auto, + } +} + +func (o *RDPExtendedInfo) Serialize() []byte { + buff := &bytes.Buffer{} + core.WriteUInt16LE(o.ClientAddressFamily, buff) + core.WriteUInt16LE(uint16(len(o.ClientAddress)), buff) + core.WriteBytes(o.ClientAddress, buff) + core.WriteUInt16LE(uint16(len(o.ClientDir)), buff) + core.WriteBytes(o.ClientDir, buff) + core.WriteBytes(o.ClientTimeZone, buff) + core.WriteUInt32LE(o.ClientSessionId, buff) + core.WriteUInt32LE(o.PerformanceFlags, buff) + + if o.AutoReconnect != nil { + core.WriteUInt16LE(o.AutoReconnect.CbAutoReconnectLen, buff) + core.WriteUInt32LE(o.AutoReconnect.CbLen, buff) + core.WriteUInt32LE(o.AutoReconnect.Version, buff) + core.WriteUInt32LE(o.AutoReconnect.LogonId, buff) + core.WriteBytes(o.AutoReconnect.SecVerifier, buff) + } + + return buff.Bytes() +} + +type RDPInfo struct { + CodePage uint32 + Flag uint32 + CbDomain uint16 + CbUserName uint16 + CbPassword uint16 + CbAlternateShell uint16 + CbWorkingDir uint16 + Domain []byte + UserName []byte + Password []byte + AlternateShell []byte + WorkingDir []byte + ExtendedInfo *RDPExtendedInfo +} + +func NewRDPInfo() *RDPInfo { + info := &RDPInfo{ + Flag: INFO_MOUSE | INFO_UNICODE | INFO_MAXIMIZESHELL | + INFO_ENABLEWINDOWSKEY | INFO_DISABLECTRLALTDEL | INFO_MOUSE_HAS_WHEEL | + INFO_FORCE_ENCRYPTED_CS_PDU | INFO_AUTOLOGON, + Domain: []byte{0, 0}, + UserName: []byte{0, 0}, + Password: []byte{0, 0}, + AlternateShell: []byte{0, 0}, + WorkingDir: []byte{0, 0}, + ExtendedInfo: NewExtendedInfo(nil), + } + return info +} + +func (o *RDPInfo) SetClientAutoReconnect(auto *ClientAutoReconnect) { + o.ExtendedInfo.AutoReconnect = auto +} + +func (o *RDPInfo) SetClientInfo() { + o.Flag |= INFO_LOGONNOTIFY | INFO_LOGONERRORS +} + +func (o *RDPInfo) Serialize(hasExtended bool) []byte { + buff := &bytes.Buffer{} + core.WriteUInt32LE(o.CodePage, buff) // 0000000 + core.WriteUInt32LE(o.Flag, buff) // 0530101 + core.WriteUInt16LE(uint16(len(o.Domain)-2), buff) // 001c + core.WriteUInt16LE(uint16(len(o.UserName)-2), buff) // 0008 + core.WriteUInt16LE(uint16(len(o.Password)-2), buff) //000c + core.WriteUInt16LE(uint16(len(o.AlternateShell)-2), buff) //0000 + core.WriteUInt16LE(uint16(len(o.WorkingDir)-2), buff) //0000 + core.WriteBytes(o.Domain, buff) + core.WriteBytes(o.UserName, buff) + core.WriteBytes(o.Password, buff) + core.WriteBytes(o.AlternateShell, buff) + core.WriteBytes(o.WorkingDir, buff) + if hasExtended { + core.WriteBytes(o.ExtendedInfo.Serialize(), buff) + } + return buff.Bytes() +} + +type SecurityHeader struct { + securityFlag uint16 + securityFlagHi uint16 +} + +func readSecurityHeader(r io.Reader) *SecurityHeader { + s := &SecurityHeader{} + s.securityFlag, _ = core.ReadUint16LE(r) + s.securityFlagHi, _ = core.ReadUint16LE(r) + return s +} + +type SEC struct { + emission.Emitter + transport core.Transport + info *RDPInfo + machineName string + clientData []interface{} + serverData []interface{} + + enableEncryption bool + //Enable Secure Mac generation + enableSecureCheckSum bool + //counter before update + nbEncryptedPacket int + nbDecryptedPacket int + + currentDecrytKey []byte + currentEncryptKey []byte + + //current rc4 tab + decryptRc4 *rc4.Cipher + encryptRc4 *rc4.Cipher + + macKey []byte +} + +func NewSEC(t core.Transport) *SEC { + sec := &SEC{ + *emission.NewEmitter(), + t, + NewRDPInfo(), + "", + nil, + nil, + false, + false, + 0, + 0, + nil, + nil, + nil, + nil, + nil, + } + + t.On("close", func() { + sec.Emit("close") + }).On("error", func(err error) { + sec.Emit("error", err) + }) + return sec +} + +func (s *SEC) Read(data []byte) (n int, err error) { + return s.transport.Read(data) +} + +func (s *SEC) Write(b []byte) (n int, err error) { + if !s.enableEncryption { + return s.transport.Write(b) + } + data := s.encrytData(b) + return s.transport.Write(data) +} + +func (s *SEC) Close() error { + return s.transport.Close() +} + +func (s *SEC) sendFlagged(flag uint16, data []byte) (n int, err error) { + glog.Trace("sendFlagged:", hex.EncodeToString(data)) + b := s.encryt(flag, data) + return s.transport.Write(b) +} + +/* +@see: http://msdn.microsoft.com/en-us/library/cc241995.aspx +@param macSaltKey: {str} mac key +@param data: {str} data to sign +@return: {str} signature +*/ +func macData(macSaltKey, data []byte) []byte { + sha1Digest := sha1.New() + md5Digest := md5.New() + + b := &bytes.Buffer{} + core.WriteUInt32LE(uint32(len(data)), b) + + sha1Digest.Write(macSaltKey) + for i := 0; i < 40; i++ { + sha1Digest.Write([]byte("\x36")) + } + + sha1Digest.Write(b.Bytes()) + sha1Digest.Write(data) + + sha1Sig := sha1Digest.Sum(nil) + + md5Digest.Write(macSaltKey) + for i := 0; i < 48; i++ { + md5Digest.Write([]byte("\x5c")) + } + + md5Digest.Write(sha1Sig) + + return md5Digest.Sum(nil) +} +func (s *SEC) readEncryptedPayload(data []byte, checkSum bool) []byte { + r := bytes.NewReader(data) + sign, _ := core.ReadBytes(8, r) + glog.Debug("read sign:", sign) + encryptedPayload, _ := core.ReadBytes(r.Len(), r) + if s.decryptRc4 == nil { + s.decryptRc4, _ = rc4.NewCipher(s.currentDecrytKey) + } + s.nbDecryptedPacket++ + glog.Debug("nbDecryptedPacket:", s.nbDecryptedPacket) + plaintext := make([]byte, len(encryptedPayload)) + s.decryptRc4.XORKeyStream(plaintext, encryptedPayload) + + return plaintext + +} +func (s *SEC) writeEncryptedPayload(data []byte, checkSum bool) []byte { + if s.nbEncryptedPacket == 4096 { + + } + + if checkSum { + glog.Debug("need checkSum") + return []byte{} + } + + s.nbEncryptedPacket++ + glog.Debug("nbEncryptedPacket:", s.nbEncryptedPacket) + b := &bytes.Buffer{} + + sign := macData(s.macKey, data)[:8] + if s.encryptRc4 == nil { + s.encryptRc4, _ = rc4.NewCipher(s.currentEncryptKey) + } + + plaintext := make([]byte, len(data)) + s.encryptRc4.XORKeyStream(plaintext, data) + b.Write(sign) + b.Write(plaintext) + glog.Debug("sign:", hex.EncodeToString(sign), "plaintext:", hex.EncodeToString(plaintext)) + return b.Bytes() +} + +func (s *SEC) encryt(flag uint16, b []byte) []byte { + data := b + if flag&ENCRYPT != 0 { + data = s.writeEncryptedPayload(b, flag&SECURE_CHECKSUM != 0) + } + buff := &bytes.Buffer{} + core.WriteUInt16LE(flag, buff) + core.WriteUInt16LE(0, buff) + core.WriteBytes(data, buff) + + return buff.Bytes() +} +func (s *SEC) encrytData(b []byte) []byte { + if !s.enableEncryption { + return b + } + + var flag uint16 = ENCRYPT + if s.enableSecureCheckSum { + flag |= SECURE_CHECKSUM + } + return s.encryt(flag, b) +} + +func (s *SEC) decrytData(b []byte) []byte { + if !s.enableEncryption { + return b + } + + r := bytes.NewReader(b) + securityFlag, _ := core.ReadUint16LE(r) + _, _ = core.ReadUint16LE(r) //securityFlagHi + data, _ := core.ReadBytes(r.Len(), r) + if securityFlag&ENCRYPT != 0 { + data = s.readEncryptedPayload(data, securityFlag&SECURE_CHECKSUM != 0) + } + return data +} + +type Client struct { + *SEC + userId uint16 + channelId uint16 + //initialise decrypt and encrypt keys + initialDecrytKey []byte + initialEncryptKey []byte + + fastPathListener core.FastPathListener + channelSender core.ChannelSender +} + +func NewClient(t core.Transport) *Client { + c := &Client{ + SEC: NewSEC(t), + } + t.On("connect", c.connect) + return c +} + +func (c *Client) SetClientAutoReconnect(id uint32, random []byte) { + auto := NewClientAutoReconnect(id, random) + c.info.SetClientAutoReconnect(auto) +} + +func (c *Client) SetAlternateShell(shell string) { + buff := &bytes.Buffer{} + for _, ch := range utf16.Encode([]rune(shell)) { + core.WriteUInt16LE(ch, buff) + } + core.WriteUInt16LE(0, buff) + c.info.AlternateShell = buff.Bytes() + c.info.Flag |= INFO_RAIL +} + +func (c *Client) SetUsername(user string) { + buff := &bytes.Buffer{} + for _, ch := range utf16.Encode([]rune(user)) { + core.WriteUInt16LE(ch, buff) + } + core.WriteUInt16LE(0, buff) + c.info.UserName = buff.Bytes() +} + +func (c *Client) SetPassword(pwd string) { + buff := &bytes.Buffer{} + for _, ch := range utf16.Encode([]rune(pwd)) { + core.WriteUInt16LE(ch, buff) + } + core.WriteUInt16LE(0, buff) + c.info.Password = buff.Bytes() +} + +func (c *Client) SetDomain(domain string) { + buff := &bytes.Buffer{} + for _, ch := range utf16.Encode([]rune(domain)) { + core.WriteUInt16LE(ch, buff) + } + core.WriteUInt16LE(0, buff) + c.info.Domain = buff.Bytes() +} + +func (c *Client) connect(clientData []interface{}, serverData []interface{}, userId uint16, channels []t125.MCSChannelInfo) { + glog.Debug("sec on connect:", clientData) + glog.Debug("sec on connect:", serverData) + glog.Debug("sec on connect:", userId) + glog.Debug("sec on connect:", channels) + c.clientData = clientData + c.serverData = serverData + c.userId = userId + for _, channel := range channels { + glog.Infof("channel: %s <%d>:", channel.Name, channel.ID) + if channel.Name == t125.GLOBAL_CHANNEL_NAME { + c.channelId = channel.ID + //break + } + } + c.enableEncryption = c.ClientCoreData().ServerSelectedProtocol == 0 + + if c.enableEncryption { + c.sendClientRandom() + } + + c.sendInfoPkt() + c.transport.Once("sec", c.recvLicenceInfo) +} + +func (c *Client) ClientCoreData() *gcc.ClientCoreData { + return c.clientData[0].(*gcc.ClientCoreData) +} +func (c *Client) ClientSecurityData() *gcc.ClientSecurityData { + return c.clientData[1].(*gcc.ClientSecurityData) +} +func (c *Client) ClientNetworkData() *gcc.ClientNetworkData { + return c.clientData[2].(*gcc.ClientNetworkData) +} + +func (c *Client) serverCoreData() *gcc.ServerCoreData { + return c.serverData[0].(*gcc.ServerCoreData) +} +func (c *Client) ServerSecurityData() *gcc.ServerSecurityData { + return c.serverData[1].(*gcc.ServerSecurityData) +} + +/* +@summary: generate 40 bits data from 128 bits data +@param data: {str} 128 bits data +@return: {str} 40 bits data +@see: http://msdn.microsoft.com/en-us/library/cc240785.aspx +*/ +func gen40bits(data []byte) []byte { + return append([]byte("\xd1\x26\x9e"), data[3:8]...) +} + +/* +@summary: generate 56 bits data from 128 bits data +@param data: {str} 128 bits data +@return: {str} 56 bits data +@see: http://msdn.microsoft.com/en-us/library/cc240785.aspx +*/ +func gen56bits(data []byte) []byte { + return append([]byte("\xd1"), data[1:8]...) +} + +/* +@summary: Generate particular signature from combination of sha1 and md5 +@see: http://msdn.microsoft.com/en-us/library/cc241992.aspx +@param inputData: strange input (see doc) +@param salt: salt for context call +@param salt1: another salt (ex : client random) +@param salt2: another another salt (ex: server random) +@return : MD5(Salt + SHA1(Input + Salt + Salt1 + Salt2)) +*/ +func saltedHash(inputData, salt, salt1, salt2 []byte) []byte { + sha1Digest := sha1.New() + md5Digest := md5.New() + + sha1Digest.Write(inputData) + sha1Digest.Write(salt[:48]) + sha1Digest.Write(salt1) + sha1Digest.Write(salt2) + sha1Sig := sha1Digest.Sum(nil) + + md5Digest.Write(salt[:48]) + md5Digest.Write(sha1Sig) + + return md5Digest.Sum(nil)[:16] +} + +/* +@summary: MD5(in0[:16] + in1[:32] + in2[:32]) +@param key: in 16 +@param random1: in 32 +@param random2: in 32 +@return MD5(in0[:16] + in1[:32] + in2[:32]) +*/ +func finalHash(key, random1, random2 []byte) []byte { + md5Digest := md5.New() + md5Digest.Write(key) + md5Digest.Write(random1) + md5Digest.Write(random2) + return md5Digest.Sum(nil) +} + +/* +@summary: Generate master secret +@param secret: {str} secret +@param clientRandom : {str} client random +@param serverRandom : {str} server random +@see: http://msdn.microsoft.com/en-us/library/cc241992.aspx +*/ +func masterSecret(secret, random1, random2 []byte) []byte { + sh1 := saltedHash([]byte("A"), secret, random1, random2) + sh2 := saltedHash([]byte("BB"), secret, random1, random2) + sh3 := saltedHash([]byte("CCC"), secret, random1, random2) + ms := bytes.NewBuffer(nil) + ms.Write(sh1) + ms.Write(sh2) + ms.Write(sh3) + return ms.Bytes() +} + +/* +@summary: Generate master secret +@param secret: secret +@param clientRandom : client random +@param serverRandom : server random +*/ +func sessionKeyBlob(secret, random1, random2 []byte) []byte { + sh1 := saltedHash([]byte("X"), secret, random1, random2) + sh2 := saltedHash([]byte("YY"), secret, random1, random2) + sh3 := saltedHash([]byte("ZZZ"), secret, random1, random2) + ms := bytes.NewBuffer(nil) + ms.Write(sh1) + ms.Write(sh2) + ms.Write(sh3) + return ms.Bytes() + +} +func generateKeys(clientRandom, serverRandom []byte, method uint32) ([]byte, []byte, []byte) { + b := &bytes.Buffer{} + b.Write(clientRandom[:24]) + b.Write(serverRandom[:24]) + preMasterHash := b.Bytes() + glog.Debug("preMasterHash:", hex.EncodeToString(preMasterHash)) + + masterHash := masterSecret(preMasterHash, clientRandom, serverRandom) + glog.Debug("masterHash:", hex.EncodeToString(masterHash)) + + sessionKey := sessionKeyBlob(masterHash, clientRandom, serverRandom) + glog.Debug("sessionKey:", hex.EncodeToString(sessionKey)) + + macKey128 := sessionKey[:16] + initialFirstKey128 := finalHash(sessionKey[16:32], clientRandom, serverRandom) + initialSecondKey128 := finalHash(sessionKey[32:48], clientRandom, serverRandom) + + glog.Debug("macKey128:", hex.EncodeToString(macKey128)) + glog.Debug("FirstKey128:", hex.EncodeToString(initialFirstKey128)) + glog.Debug("SecondKey128:", hex.EncodeToString(initialSecondKey128)) + //generate valid key + if method == gcc.ENCRYPTION_FLAG_40BIT { + return gen40bits(macKey128), gen40bits(initialFirstKey128), gen40bits(initialSecondKey128) + } else if method == gcc.ENCRYPTION_FLAG_56BIT { + return gen56bits(macKey128), gen56bits(initialFirstKey128), gen56bits(initialSecondKey128) + } + // method == gcc.ENCRYPTION_FLAG_128BIT + return macKey128, initialFirstKey128, initialSecondKey128 + +} + +type ClientSecurityExchangePDU struct { + Length uint32 `struc:"little"` + EncryptedClientRandom []byte `struc:"little"` + Padding []byte `struc:"[8]byte"` +} + +func (e *ClientSecurityExchangePDU) serialize() []byte { + buff := &bytes.Buffer{} + core.WriteUInt32LE(e.Length, buff) + core.WriteBytes(e.EncryptedClientRandom, buff) + core.WriteBytes(e.Padding, buff) + + return buff.Bytes() +} +func (c *Client) sendClientRandom() { + glog.Debug("send Client Random") + + clientRandom := core.Random(32) + glog.Debug("clientRandom:", hex.EncodeToString(clientRandom)) + + serverRandom := c.ServerSecurityData().ServerRandom + glog.Debug("ServerRandom:", hex.EncodeToString(serverRandom)) + + c.macKey, c.initialDecrytKey, c.initialEncryptKey = generateKeys(clientRandom, + serverRandom, c.ServerSecurityData().EncryptionMethod) + + //initialize keys + c.currentDecrytKey = c.initialDecrytKey + c.currentEncryptKey = c.initialEncryptKey + + //verify certificate + if !c.ServerSecurityData().ServerCertificate.CertData.Verify() { + glog.Warn("Cannot verify server identity") + } + + serverPubKey, _ := c.ServerSecurityData().ServerCertificate.CertData.GetPublicKey() + ret, err := rsa.EncryptPKCS1v15(rand.Reader, serverPubKey, core.Reverse(clientRandom)) + if err != nil { + glog.Error("err:", err) + } + message := ClientSecurityExchangePDU{} + message.EncryptedClientRandom = core.Reverse(ret) + message.Length = uint32(len(message.EncryptedClientRandom) + 8) + message.Padding = make([]byte, 8) + + glog.Debug("message:", message) + + c.sendFlagged(EXCHANGE_PKT, message.serialize()) +} +func (c *Client) sendInfoPkt() { + var secFlag uint16 = INFO_PKT + if c.enableEncryption { + secFlag |= ENCRYPT + } + + glog.Debug("RdpVersion:", c.ClientCoreData().RdpVersion, ":", gcc.RDP_VERSION_5_PLUS) + c.sendFlagged(secFlag, c.info.Serialize(c.ClientCoreData().RdpVersion == gcc.RDP_VERSION_5_PLUS)) +} + +func (c *Client) recvLicenceInfo(channel string, s []byte) { + glog.Debug("sec recvLicenceInfo", hex.EncodeToString(s)) + r := bytes.NewReader(s) + h := readSecurityHeader(r) + if (h.securityFlag & LICENSE_PKT) == 0 { + c.Emit("error", errors.New("NODE_RDP_PROTOCOL_PDU_SEC_BAD_LICENSE_HEADER")) + return + } + + p := lic.ReadLicensePacket(r) + switch p.BMsgtype { + case lic.NEW_LICENSE: + glog.Info("sec NEW_LICENSE") + c.Emit("success") + goto connect + case lic.ERROR_ALERT: + message := p.LicensingMessage.(*lic.ErrorMessage) + glog.Info("sec ERROR_ALERT and ErrorCode:", message.DwErrorCode) + if message.DwErrorCode == lic.STATUS_VALID_CLIENT && message.DwStateTransaction == lic.ST_NO_TRANSITION { + goto connect + } + goto retry + case lic.LICENSE_REQUEST: + glog.Info("sec LICENSE_REQUEST") + c.sendClientNewLicenseRequest(p.LicensingMessage.([]byte)) + goto retry + case lic.PLATFORM_CHALLENGE: + glog.Info("sec PLATFORM_CHALLENGE") + c.sendClientChallengeResponse(p.LicensingMessage.([]byte)) + goto retry + default: + glog.Error("Not a valid license packet") + c.Emit("error", errors.New("Not a valid license packet")) + return + } + +connect: + c.transport.On("sec", c.recvData) + c.Emit("connect", c.clientData[0].(*gcc.ClientCoreData), c.userId, c.channelId) + return + +retry: + c.transport.Once("sec", c.recvLicenceInfo) + return +} + +func (c *Client) sendClientNewLicenseRequest(data []byte) { + var req lic.ServerLicenseRequest + struc.Unpack(bytes.NewReader(data), &req) + + var sc gcc.ServerCertificate + if c.ServerSecurityData().ServerCertificate.DwVersion != 0 { + sc = c.ServerSecurityData().ServerCertificate + } else { + rd := bytes.NewReader(req.ServerCertificate.BlobData) + err := sc.Unpack(rd) + if err != nil { + glog.Error("read serverCertificate err:", err) + return + } + } + + serverRandom := req.ServerRandom + clientRandom := core.Random(32) + preMasterSecret := core.Random(48) + masSecret := masterSecret(preMasterSecret, clientRandom, serverRandom) + sessionKeyBlob := masterSecret(masSecret, serverRandom, clientRandom) + c.macKey = sessionKeyBlob[:16] + c.initialDecrytKey = finalHash(sessionKeyBlob[16:32], clientRandom, serverRandom) + + //format message + message := &lic.ClientNewLicenseRequest{} + message.PreferredKeyExchangeAlg = 0x00000001 + message.PlatformId = 0x04000000 | 0x00010000 + message.ClientRandom = clientRandom + + buff := &bytes.Buffer{} + + serverPubKey, _ := sc.CertData.GetPublicKey() + ret, err := rsa.EncryptPKCS1v15(rand.Reader, serverPubKey, core.Reverse(preMasterSecret)) + if err != nil { + glog.Error("err:", err) + } + + buff.Write(core.Reverse(ret)) + buff.Write([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}) + message.EncryptedPreMasterSecret.BlobData = buff.Bytes() + message.EncryptedPreMasterSecret.WBlobLen = uint16(buff.Len()) + message.EncryptedPreMasterSecret.WBlobType = lic.BB_RANDOM_BLOB + + buff.Reset() + buff.Write(c.info.UserName) + buff.Write([]byte{0x00}) + message.ClientUserName.BlobData = buff.Bytes() + message.ClientUserName.WBlobLen = uint16(buff.Len()) + message.ClientUserName.WBlobType = lic.BB_CLIENT_USER_NAME_BLOB + + buff.Reset() + buff.Write(c.ClientCoreData().ClientName[:]) + buff.Write([]byte{0x00}) + message.ClientMachineName.BlobData = buff.Bytes() + message.ClientMachineName.WBlobLen = uint16(buff.Len()) + message.ClientMachineName.WBlobType = lic.BB_CLIENT_MACHINE_NAME_BLOB + + buff.Reset() + err = struc.Pack(buff, message) + if err != nil { + glog.Error("err:", err) + } + + c.sendFlagged(LICENSE_PKT, buff.Bytes()) +} + +func (c *Client) sendClientChallengeResponse(data []byte) { + var pc lic.ServerPlatformChallenge + struc.Unpack(bytes.NewReader(data), &pc) + + serverEncryptedChallenge := pc.EncryptedPlatformChallenge.BlobData + //decrypt server challenge + //it should be TEST word in unicode format + rc, _ := rc4.NewCipher(c.initialDecrytKey) + serverChallenge := make([]byte, 20) + rc.XORKeyStream(serverChallenge, serverEncryptedChallenge) + //if serverChallenge != "T\x00E\x00S\x00T\x00\x00\x00": + //raise InvalidExpectedDataException("bad license server challenge") + + //generate hwid + b := &bytes.Buffer{} + b.Write(c.ClientCoreData().ClientName[:]) + b.Write(c.info.UserName) + for i := 0; i < 2; i++ { + b.Write([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}) + } + hwid := b.Bytes()[:20] + + encryptedHWID := make([]byte, 20) + rc.XORKeyStream(encryptedHWID, hwid) + + b.Reset() + b.Write(serverChallenge) + b.Write(hwid) + + message := &lic.ClientPLatformChallengeResponse{} + message.EncryptedPlatformChallengeResponse.BlobData = serverEncryptedChallenge + message.EncryptedHWID.BlobData = encryptedHWID + message.MACData = macData(c.macKey, b.Bytes())[:16] + + b.Reset() + struc.Pack(b, message) + c.sendFlagged(LICENSE_PKT, b.Bytes()) +} + +func (c *Client) recvData(channel string, s []byte) { + glog.Trace("sec recvData", hex.EncodeToString(s)) + glog.Debugf("channel<%s> data len: %d", channel, len(s)) + data := c.decrytData(s) + if channel != t125.GLOBAL_CHANNEL_NAME { + c.Emit("channel", channel, data) + return + } + c.Emit("data", data) +} +func (c *Client) SetFastPathListener(f core.FastPathListener) { + c.fastPathListener = f +} + +func (c *Client) RecvFastPath(secFlag byte, s []byte) { + data := s + if c.enableEncryption && secFlag&FASTPATH_OUTPUT_ENCRYPTED != 0 { + data = c.readEncryptedPayload(s, secFlag&FASTPATH_OUTPUT_SECURE_CHECKSUM != 0) + } + c.fastPathListener.RecvFastPath(secFlag, data) +} + +func (c *Client) SetChannelSender(f core.ChannelSender) { + c.channelSender = f +} + +func (c *Client) SendToChannel(channel string, b []byte) (int, error) { + if !c.enableEncryption { + glog.Debug("Sec Client write", hex.EncodeToString(b)) + return c.channelSender.SendToChannel(channel, b) + } + var flag uint16 = ENCRYPT + if c.enableSecureCheckSum { + flag |= SECURE_CHECKSUM + } + data := c.writeEncryptedPayload(b, c.enableSecureCheckSum) + + buff := &bytes.Buffer{} + core.WriteUInt16LE(flag, buff) + core.WriteUInt16LE(0, buff) + core.WriteBytes(data, buff) + glog.Debug("Sec Client write", channel, hex.EncodeToString(buff.Bytes())) + return c.channelSender.SendToChannel(channel, buff.Bytes()) +} diff --git a/grdp/protocol/t125/ber/ber.go b/grdp/protocol/t125/ber/ber.go new file mode 100644 index 0000000..5716349 --- /dev/null +++ b/grdp/protocol/t125/ber/ber.go @@ -0,0 +1,189 @@ +package ber + +import ( + "errors" + "fmt" + "io" + + "ShotRDP/grdp/core" +) + +const ( + CLASS_MASK uint8 = 0xC0 + CLASS_UNIV = 0x00 + CLASS_APPL = 0x40 + CLASS_CTXT = 0x80 + CLASS_PRIV = 0xC0 +) + +const ( + PC_MASK uint8 = 0x20 + PC_PRIMITIVE = 0x00 + PC_CONSTRUCT = 0x20 +) + +const ( + TAG_MASK uint8 = 0x1F + TAG_BOOLEAN = 0x01 + TAG_INTEGER = 0x02 + TAG_BIT_STRING = 0x03 + TAG_OCTET_STRING = 0x04 + TAG_OBJECT_IDENFIER = 0x06 + TAG_ENUMERATED = 0x0A + TAG_SEQUENCE = 0x10 + TAG_SEQUENCE_OF = 0x10 +) + +func berPC(pc bool) uint8 { + if pc { + return PC_CONSTRUCT + } + return PC_PRIMITIVE +} + +func ReadEnumerated(r io.Reader) (uint8, error) { + if !ReadUniversalTag(TAG_ENUMERATED, false, r) { + return 0, errors.New("invalid ber tag") + } + length, err := ReadLength(r) + if err != nil { + return 0, err + } + if length != 1 { + return 0, errors.New(fmt.Sprintf("enumerate size is wrong, get %v, expect 1", length)) + } + return core.ReadUInt8(r) +} + +func ReadUniversalTag(tag uint8, pc bool, r io.Reader) bool { + bb, _ := core.ReadUInt8(r) + return bb == (CLASS_UNIV|berPC(pc))|(TAG_MASK&tag) +} + +func WriteUniversalTag(tag uint8, pc bool, w io.Writer) { + core.WriteUInt8((CLASS_UNIV|berPC(pc))|(TAG_MASK&tag), w) +} + +func ReadLength(r io.Reader) (int, error) { + ret := 0 + size, _ := core.ReadUInt8(r) + if size&0x80 > 0 { + size = size &^ 0x80 + if size == 1 { + r, err := core.ReadUInt8(r) + if err != nil { + return 0, err + } + ret = int(r) + } else if size == 2 { + r, err := core.ReadUint16BE(r) + if err != nil { + return 0, err + } + ret = int(r) + } else { + return 0, errors.New("BER length may be 1 or 2") + } + } else { + ret = int(size) + } + return ret, nil +} + +func WriteLength(size int, w io.Writer) { + if size > 0x7f { + core.WriteUInt8(0x82, w) + core.WriteUInt16BE(uint16(size), w) + } else { + core.WriteUInt8(uint8(size), w) + } +} + +func ReadInteger(r io.Reader) (int, error) { + if !ReadUniversalTag(TAG_INTEGER, false, r) { + return 0, errors.New("Bad integer tag") + } + size, _ := ReadLength(r) + switch size { + case 1: + num, _ := core.ReadUInt8(r) + return int(num), nil + case 2: + num, _ := core.ReadUint16BE(r) + return int(num), nil + case 3: + integer1, _ := core.ReadUInt8(r) + integer2, _ := core.ReadUint16BE(r) + return int(integer2) + int(integer1<<16), nil + case 4: + num, _ := core.ReadUInt32BE(r) + return int(num), nil + default: + return 0, errors.New("wrong size") + } +} + +func WriteInteger(n int, w io.Writer) { + WriteUniversalTag(TAG_INTEGER, false, w) + if n <= 0xff { + WriteLength(1, w) + core.WriteUInt8(uint8(n), w) + } else if n <= 0xffff { + WriteLength(2, w) + core.WriteUInt16BE(uint16(n), w) + } else { + WriteLength(4, w) + core.WriteUInt32BE(uint32(n), w) + } +} + +func WriteOctetstring(str string, w io.Writer) { + WriteUniversalTag(TAG_OCTET_STRING, false, w) + WriteLength(len(str), w) + core.WriteBytes([]byte(str), w) +} + +func WriteBoolean(b bool, w io.Writer) { + bb := uint8(0) + if b { + bb = uint8(0xff) + } + WriteUniversalTag(TAG_BOOLEAN, false, w) + WriteLength(1, w) + core.WriteUInt8(bb, w) +} + +func ReadApplicationTag(tag uint8, r io.Reader) (int, error) { + bb, _ := core.ReadUInt8(r) + if tag > 30 { + if bb != (CLASS_APPL|PC_CONSTRUCT)|TAG_MASK { + return 0, errors.New("ReadApplicationTag invalid data") + } + bb, _ := core.ReadUInt8(r) + if bb != tag { + return 0, errors.New("ReadApplicationTag bad tag") + } + } else { + if bb != (CLASS_APPL|PC_CONSTRUCT)|(TAG_MASK&tag) { + return 0, errors.New("ReadApplicationTag invalid data2") + } + } + return ReadLength(r) +} + +func WriteApplicationTag(tag uint8, size int, w io.Writer) { + if tag > 30 { + core.WriteUInt8((CLASS_APPL|PC_CONSTRUCT)|TAG_MASK, w) + core.WriteUInt8(tag, w) + WriteLength(size, w) + } else { + core.WriteUInt8((CLASS_APPL|PC_CONSTRUCT)|(TAG_MASK&tag), w) + WriteLength(size, w) + } +} + +func WriteEncodedDomainParams(data []byte, w io.Writer) { + WriteUniversalTag(TAG_SEQUENCE, true, w) + WriteLength(len(data), w) + core.WriteBytes(data, w) +} diff --git a/grdp/protocol/t125/gcc/gcc.go b/grdp/protocol/t125/gcc/gcc.go new file mode 100644 index 0000000..015294b --- /dev/null +++ b/grdp/protocol/t125/gcc/gcc.go @@ -0,0 +1,638 @@ +package gcc + +import ( + "bytes" + "crypto/rsa" + "crypto/x509" + "crypto/x509/pkix" + "encoding/asn1" + "errors" + "io" + "math/big" + "os" + + "ShotRDP/grdp/glog" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/protocol/t125/per" + "github.com/lunixbochs/struc" +) + +var t124_02_98_oid = []byte{0, 0, 20, 124, 0, 1} +var h221_cs_key = "Duca" +var h221_sc_key = "McDn" + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240509.aspx + */ +type Message uint16 + +const ( + //server -> client + SC_CORE Message = 0x0C01 + SC_SECURITY = 0x0C02 + SC_NET = 0x0C03 + //client -> server + CS_CORE = 0xC001 + CS_SECURITY = 0xC002 + CS_NET = 0xC003 + CS_CLUSTER = 0xC004 + CS_MONITOR = 0xC005 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240510.aspx + */ +type ColorDepth uint16 + +const ( + RNS_UD_COLOR_8BPP ColorDepth = 0xCA01 + RNS_UD_COLOR_16BPP_555 = 0xCA02 + RNS_UD_COLOR_16BPP_565 = 0xCA03 + RNS_UD_COLOR_24BPP = 0xCA04 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240510.aspx + */ +type HighColor uint16 + +const ( + HIGH_COLOR_4BPP HighColor = 0x0004 + HIGH_COLOR_8BPP = 0x0008 + HIGH_COLOR_15BPP = 0x000f + HIGH_COLOR_16BPP = 0x0010 + HIGH_COLOR_24BPP = 0x0018 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240510.aspx + */ +type Support uint16 + +const ( + RNS_UD_24BPP_SUPPORT uint16 = 0x0001 + RNS_UD_16BPP_SUPPORT = 0x0002 + RNS_UD_15BPP_SUPPORT = 0x0004 + RNS_UD_32BPP_SUPPORT = 0x0008 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240510.aspx + */ +type CapabilityFlag uint16 + +const ( + RNS_UD_CS_SUPPORT_ERRINFO_PDU uint16 = 0x0001 + RNS_UD_CS_WANT_32BPP_SESSION = 0x0002 + RNS_UD_CS_SUPPORT_STATUSINFO_PDU = 0x0004 + RNS_UD_CS_STRONG_ASYMMETRIC_KEYS = 0x0008 + RNS_UD_CS_UNUSED = 0x0010 + RNS_UD_CS_VALID_CONNECTION_TYPE = 0x0020 + RNS_UD_CS_SUPPORT_MONITOR_LAYOUT_PDU = 0x0040 + RNS_UD_CS_SUPPORT_NETCHAR_AUTODETECT = 0x0080 + RNS_UD_CS_SUPPORT_DYNVC_GFX_PROTOCOL = 0x0100 + RNS_UD_CS_SUPPORT_DYNAMIC_TIME_ZONE = 0x0200 + RNS_UD_CS_SUPPORT_HEARTBEAT_PDU = 0x0400 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240510.aspx + */ +type ConnectionType uint8 + +const ( + CONNECTION_TYPE_MODEM ConnectionType = 0x01 + CONNECTION_TYPE_BROADBAND_LOW = 0x02 + CONNECTION_TYPE_SATELLITEV = 0x03 + CONNECTION_TYPE_BROADBAND_HIGH = 0x04 + CONNECTION_TYPE_WAN = 0x05 + CONNECTION_TYPE_LAN = 0x06 + CONNECTION_TYPE_AUTODETECT = 0x07 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240510.aspx + */ +type VERSION uint32 + +const ( + RDP_VERSION_4 VERSION = 0x00080001 + RDP_VERSION_5_PLUS = 0x00080004 +) + +type Sequence uint16 + +const ( + RNS_UD_SAS_DEL Sequence = 0xAA03 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240511.aspx + */ +type EncryptionMethod uint32 + +const ( + ENCRYPTION_FLAG_40BIT uint32 = 0x00000001 + ENCRYPTION_FLAG_128BIT = 0x00000002 + ENCRYPTION_FLAG_56BIT = 0x00000008 + FIPS_ENCRYPTION_FLAG = 0x00000010 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240518.aspx + */ +type EncryptionLevel uint32 + +const ( + ENCRYPTION_LEVEL_NONE EncryptionLevel = 0x00000000 + ENCRYPTION_LEVEL_LOW = 0x00000001 + ENCRYPTION_LEVEL_CLIENT_COMPATIBLE = 0x00000002 + ENCRYPTION_LEVEL_HIGH = 0x00000003 + ENCRYPTION_LEVEL_FIPS = 0x00000004 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240513.aspx + */ +type ChannelOptions uint32 + +const ( + CHANNEL_OPTION_INITIALIZED ChannelOptions = 0x80000000 + CHANNEL_OPTION_ENCRYPT_RDP = 0x40000000 + CHANNEL_OPTION_ENCRYPT_SC = 0x20000000 + CHANNEL_OPTION_ENCRYPT_CS = 0x10000000 + CHANNEL_OPTION_PRI_HIGH = 0x08000000 + CHANNEL_OPTION_PRI_MED = 0x04000000 + CHANNEL_OPTION_PRI_LOW = 0x02000000 + CHANNEL_OPTION_COMPRESS_RDP = 0x00800000 + CHANNEL_OPTION_COMPRESS = 0x00400000 + CHANNEL_OPTION_SHOW_PROTOCOL = 0x00200000 + REMOTE_CONTROL_PERSISTENT = 0x00100000 +) + +/** + * IBM_101_102_KEYS is the most common keyboard type + */ +type KeyboardType uint32 + +const ( + KT_IBM_PC_XT_83_KEY KeyboardType = 0x00000001 + KT_OLIVETTI = 0x00000002 + KT_IBM_PC_AT_84_KEY = 0x00000003 + KT_IBM_101_102_KEYS = 0x00000004 + KT_NOKIA_1050 = 0x00000005 + KT_NOKIA_9140 = 0x00000006 + KT_JAPANESE = 0x00000007 +) + +/** + * @see http://technet.microsoft.com/en-us/library/cc766503%28WS.10%29.aspx + */ +type KeyboardLayout uint32 + +const ( + ARABIC KeyboardLayout = 0x00000401 + BULGARIAN = 0x00000402 + CHINESE_US_KEYBOARD = 0x00000404 + CZECH = 0x00000405 + DANISH = 0x00000406 + GERMAN = 0x00000407 + GREEK = 0x00000408 + US = 0x00000409 + SPANISH = 0x0000040a + FINNISH = 0x0000040b + FRENCH = 0x0000040c + HEBREW = 0x0000040d + HUNGARIAN = 0x0000040e + ICELANDIC = 0x0000040f + ITALIAN = 0x00000410 + JAPANESE = 0x00000411 + KOREAN = 0x00000412 + DUTCH = 0x00000413 + NORWEGIAN = 0x00000414 +) + +/** + * @see http://msdn.microsoft.com/en-us/library/cc240521.aspx + */ +type CertificateType uint32 + +const ( + CERT_CHAIN_VERSION_1 CertificateType = 0x00000001 + CERT_CHAIN_VERSION_2 = 0x00000002 +) + +type ChannelDef struct { + Name string `struc:"little"` + Options uint32 `struc:"little"` +} + +type ClientCoreData struct { + RdpVersion VERSION `struc:"uint32,little"` + DesktopWidth uint16 `struc:"little"` + DesktopHeight uint16 `struc:"little"` + ColorDepth ColorDepth `struc:"little"` + SasSequence Sequence `struc:"little"` + KbdLayout KeyboardLayout `struc:"little"` + ClientBuild uint32 `struc:"little"` + ClientName [32]byte `struc:"[32]byte"` + KeyboardType uint32 `struc:"little"` + KeyboardSubType uint32 `struc:"little"` + KeyboardFnKeys uint32 `struc:"little"` + ImeFileName [64]byte `struc:"[64]byte"` + PostBeta2ColorDepth ColorDepth `struc:"little"` + ClientProductId uint16 `struc:"little"` + SerialNumber uint32 `struc:"little"` + HighColorDepth HighColor `struc:"little"` + SupportedColorDepths uint16 `struc:"little"` + EarlyCapabilityFlags uint16 `struc:"little"` + ClientDigProductId [64]byte `struc:"[64]byte"` + ConnectionType uint8 `struc:"uint8"` + Pad1octet uint8 `struc:"uint8"` + ServerSelectedProtocol uint32 `struc:"little"` +} + +func NewClientCoreData() *ClientCoreData { + name, _ := os.Hostname() + var ClientName [32]byte + copy(ClientName[:], core.UnicodeEncode(name)[:]) + return &ClientCoreData{ + RDP_VERSION_5_PLUS, 1280, 800, RNS_UD_COLOR_8BPP, + RNS_UD_SAS_DEL, US, 3790, ClientName, KT_IBM_101_102_KEYS, + 0, 12, [64]byte{}, RNS_UD_COLOR_8BPP, 1, 0, HIGH_COLOR_24BPP, + RNS_UD_15BPP_SUPPORT | RNS_UD_16BPP_SUPPORT | RNS_UD_24BPP_SUPPORT | RNS_UD_32BPP_SUPPORT, + RNS_UD_CS_SUPPORT_ERRINFO_PDU, [64]byte{}, 0, 0, 0} +} + +func (data *ClientCoreData) Pack() []byte { + buff := &bytes.Buffer{} + core.WriteUInt16LE(CS_CORE, buff) // 01C0 + core.WriteUInt16LE(0xd8, buff) // d800 + struc.Pack(buff, data) + return buff.Bytes() +} + +type ClientNetworkData struct { + ChannelCount uint32 + ChannelDefArray []ChannelDef +} + +func NewClientNetworkData() *ClientNetworkData { + n := &ClientNetworkData{ChannelDefArray: make([]ChannelDef, 0, 100)} + + /*var d1 ChannelDef + d1.Name = plugin.RDPDR_SVC_CHANNEL_NAME + d1.Options = uint32(CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | + CHANNEL_OPTION_COMPRESS_RDP) + n.ChannelDefArray = append(n.ChannelDefArray, d1) + + var d2 ChannelDef + d2.Name = plugin.RDPSND_SVC_CHANNEL_NAME + d2.Options = uint32(CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | + CHANNEL_OPTION_COMPRESS_RDP | CHANNEL_OPTION_SHOW_PROTOCOL) + n.ChannelDefArray = append(n.ChannelDefArray, d2)*/ + + return n +} + +func (n *ClientNetworkData) AddVirtualChannel(name string, option uint32) { + var d ChannelDef + d.Name = name + d.Options = option + n.ChannelDefArray = append(n.ChannelDefArray, d) + n.ChannelCount++ +} + +func (n *ClientNetworkData) Pack() []byte { + buff := &bytes.Buffer{} + core.WriteUInt16LE(CS_NET, buff) // type + length := uint16(n.ChannelCount*12 + 8) + core.WriteUInt16LE(length, buff) // len 8 + core.WriteUInt32LE(n.ChannelCount, buff) + for i := 0; i < int(n.ChannelCount); i++ { + v := n.ChannelDefArray[i] + name := make([]byte, 8) + copy(name, []byte(v.Name)) + core.WriteBytes(name[:], buff) + core.WriteUInt32LE(v.Options, buff) + } + return buff.Bytes() +} + +type ClientSecurityData struct { + EncryptionMethods uint32 + ExtEncryptionMethods uint32 +} + +func NewClientSecurityData() *ClientSecurityData { + return &ClientSecurityData{ + ENCRYPTION_FLAG_40BIT | ENCRYPTION_FLAG_56BIT | ENCRYPTION_FLAG_128BIT, + 00} +} + +func (d *ClientSecurityData) Pack() []byte { + buff := &bytes.Buffer{} + core.WriteUInt16LE(CS_SECURITY, buff) // type + core.WriteUInt16LE(0x0c, buff) // len 12 + core.WriteUInt32LE(d.EncryptionMethods, buff) + core.WriteUInt32LE(d.ExtEncryptionMethods, buff) + return buff.Bytes() +} + +type RSAPublicKey struct { + Magic uint32 `struc:"little"` //0x31415352 + Keylen uint32 `struc:"little,sizeof=Modulus"` + Bitlen uint32 `struc:"little"` + Datalen uint32 `struc:"little"` + PubExp uint32 `struc:"little"` + Modulus []byte `struc:"little"` + Padding []byte `struc:"[8]byte"` +} + +type ProprietaryServerCertificate struct { + DwSigAlgId uint32 `struc:"little"` //0x00000001 + DwKeyAlgId uint32 `struc:"little"` //0x00000001 + PublicKeyBlobType uint16 `struc:"little"` //0x0006 + PublicKeyBlobLen uint16 `struc:"little,sizeof=PublicKeyBlob"` + PublicKeyBlob RSAPublicKey `struc:"little"` + SignatureBlobType uint16 `struc:"little"` //0x0008 + SignatureBlobLen uint16 `struc:"little,sizeof=SignatureBlob"` + SignatureBlob []byte `struc:"little"` + //PaddingLen uint16 `struc:"little,sizeof=Padding,skip"` + Padding []byte `struc:"[8]byte"` +} + +func (p *ProprietaryServerCertificate) GetPublicKey() (*rsa.PublicKey, error) { + b := new(big.Int).SetBytes(core.Reverse(p.PublicKeyBlob.Modulus)) + e := new(big.Int).SetInt64(int64(p.PublicKeyBlob.PubExp)) + return &rsa.PublicKey{b, int(e.Int64())}, nil +} +func (p *ProprietaryServerCertificate) Verify() bool { + return true +} +func (p *ProprietaryServerCertificate) Encrypt() []byte { + //todo + return nil +} +func (p *ProprietaryServerCertificate) Unpack(r io.Reader) error { + p.DwSigAlgId, _ = core.ReadUInt32LE(r) + p.DwKeyAlgId, _ = core.ReadUInt32LE(r) + p.PublicKeyBlobType, _ = core.ReadUint16LE(r) + p.PublicKeyBlobLen, _ = core.ReadUint16LE(r) + var b RSAPublicKey + b.Magic, _ = core.ReadUInt32LE(r) + b.Keylen, _ = core.ReadUInt32LE(r) + b.Bitlen, _ = core.ReadUInt32LE(r) + b.Datalen, _ = core.ReadUInt32LE(r) + b.PubExp, _ = core.ReadUInt32LE(r) + b.Modulus, _ = core.ReadBytes(int(b.Keylen)-8, r) + b.Padding, _ = core.ReadBytes(8, r) + p.PublicKeyBlob = b + p.SignatureBlobType, _ = core.ReadUint16LE(r) + p.SignatureBlobLen, _ = core.ReadUint16LE(r) + p.SignatureBlob, _ = core.ReadBytes(int(p.SignatureBlobLen)-8, r) + p.Padding, _ = core.ReadBytes(8, r) + + return nil +} + +type CertBlob struct { + CbCert uint32 `struc:"little,sizeof=AbCert"` + AbCert []byte `struc:"little"` +} +type X509CertificateChain struct { + NumCertBlobs uint32 `struc:"little,sizeof=CertBlobArray"` + CertBlobArray []CertBlob `struc:"little"` + Padding []byte `struc:"[12]byte"` +} + +func (x *X509CertificateChain) GetPublicKey() (*rsa.PublicKey, error) { + data := x.CertBlobArray[len(x.CertBlobArray)-1].AbCert + cert, err := x509.ParseCertificate(data) + if err != nil { + glog.Error("X509 ParseCertificate err:", err) + return nil, err + } + var rsaPublicKey *rsa.PublicKey + if cert.PublicKey == nil { + var pubKeyInfo struct { + Algorithm pkix.AlgorithmIdentifier + SubjectPublicKey asn1.BitString + } + _, err = asn1.Unmarshal(cert.RawSubjectPublicKeyInfo, &pubKeyInfo) + if err != nil { + return nil, err + } + rsaPublicKey, err = x509.ParsePKCS1PublicKey(pubKeyInfo.SubjectPublicKey.Bytes) + if err != nil { + return nil, err + } + } else { + rsaPublicKey = cert.PublicKey.(*rsa.PublicKey) + } + + return rsaPublicKey, nil +} +func (x *X509CertificateChain) Verify() bool { + return true +} +func (x *X509CertificateChain) Encrypt() []byte { + //todo + return nil +} +func (x *X509CertificateChain) Unpack(r io.Reader) error { + return struc.Unpack(r, x) +} + +type ServerCoreData struct { + RdpVersion VERSION `struc:"uint32,little"` + ClientRequestedProtocol uint32 `struc:"little"` + EarlyCapabilityFlags uint32 `struc:"little"` +} + +func NewServerCoreData() *ServerCoreData { + return &ServerCoreData{ + RDP_VERSION_5_PLUS, 0, 0} +} + +func (d *ServerCoreData) Serialize() []byte { + return []byte{} +} + +func (d *ServerCoreData) ScType() Message { + return SC_CORE +} +func (d *ServerCoreData) Unpack(r io.Reader) error { + version, _ := core.ReadUInt32LE(r) + d.RdpVersion = VERSION(version) + d.ClientRequestedProtocol, _ = core.ReadUInt32LE(r) + d.EarlyCapabilityFlags, _ = core.ReadUInt32LE(r) + + return nil + //return struc.Unpack(r, d) +} + +type ServerNetworkData struct { + MCSChannelId uint16 `struc:"little"` + ChannelCount uint16 `struc:"little,sizeof=ChannelIdArray"` + ChannelIdArray []uint16 `struc:"little"` +} + +func NewServerNetworkData() *ServerNetworkData { + return &ServerNetworkData{} +} +func (d *ServerNetworkData) ScType() Message { + return SC_NET +} +func (d *ServerNetworkData) Unpack(r io.Reader) error { + return struc.Unpack(r, d) +} + +type CertData interface { + GetPublicKey() (*rsa.PublicKey, error) + Verify() bool + Unpack(io.Reader) error +} +type ServerCertificate struct { + DwVersion uint32 + CertData CertData +} + +func (sc *ServerCertificate) Unpack(r io.Reader) error { + sc.DwVersion, _ = core.ReadUInt32LE(r) + var cd CertData + switch CertificateType(sc.DwVersion & 0x7fffffff) { + case CERT_CHAIN_VERSION_1: + glog.Debug("ProprietaryServerCertificate") + cd = &ProprietaryServerCertificate{} + case CERT_CHAIN_VERSION_2: + glog.Debug("X509CertificateChain") + cd = &X509CertificateChain{} + default: + glog.Error("Unsupported version:", sc.DwVersion&0x7fffffff) + return errors.New("Unsupported version") + } + if cd != nil { + err := cd.Unpack(r) + if err != nil { + glog.Error("Unpack:", err) + return err + } + } + sc.CertData = cd + + return nil +} + +type ServerSecurityData struct { + EncryptionMethod uint32 `struc:"little"` + EncryptionLevel uint32 `struc:"little"` + ServerRandomLen uint32 //0x00000020 + ServerCertLen uint32 + ServerRandom []byte + ServerCertificate ServerCertificate +} + +func NewServerSecurityData() *ServerSecurityData { + return &ServerSecurityData{ + 0, 0, 0x00000020, 0, []byte{}, ServerCertificate{}} +} +func (d *ServerSecurityData) ScType() Message { + return SC_SECURITY +} +func (s *ServerSecurityData) Unpack(r io.Reader) error { + s.EncryptionMethod, _ = core.ReadUInt32LE(r) + s.EncryptionLevel, _ = core.ReadUInt32LE(r) + if !(s.EncryptionMethod == 0 && s.EncryptionLevel == 0) { + s.ServerRandomLen, _ = core.ReadUInt32LE(r) + s.ServerCertLen, _ = core.ReadUInt32LE(r) + s.ServerRandom, _ = core.ReadBytes(int(s.ServerRandomLen), r) + var sc ServerCertificate + data, _ := core.ReadBytes(int(s.ServerCertLen), r) + rd := bytes.NewReader(data) + err := sc.Unpack(rd) + if err != nil { + return err + } + s.ServerCertificate = sc + } + + return nil +} + +func MakeConferenceCreateRequest(userData []byte) []byte { + buff := &bytes.Buffer{} + per.WriteChoice(0, buff) // 00 + per.WriteObjectIdentifier(t124_02_98_oid, buff) // 05:00:14:7c:00:01 + per.WriteLength(len(userData)+14, buff) + per.WriteChoice(0, buff) // 00 + per.WriteSelection(0x08, buff) // 08 + per.WriteNumericString("1", 1, buff) // 00 10 + per.WritePadding(1, buff) // 00 + per.WriteNumberOfSet(1, buff) // 01 + per.WriteChoice(0xc0, buff) // c0 + per.WriteOctetStream(h221_cs_key, 4, buff) // 00 44:75:63:61 + per.WriteOctetStream(string(userData), 0, buff) + return buff.Bytes() +} + +type ScData interface { + ScType() Message + Unpack(io.Reader) error +} + +func ReadConferenceCreateResponse(data []byte) []interface{} { + ret := make([]interface{}, 0, 3) + + r := bytes.NewReader(data) + per.ReadChoice(r) + if !per.ReadObjectIdentifier(r, t124_02_98_oid) { + glog.Error("NODE_RDP_PROTOCOL_T125_GCC_BAD_OBJECT_IDENTIFIER_T124") + return ret + } + per.ReadLength(r) + per.ReadChoice(r) + per.ReadInteger16(r) + per.ReadInteger(r) + per.ReadEnumerates(r) + per.ReadNumberOfSet(r) + per.ReadChoice(r) + + if !per.ReadOctetStream(r, h221_sc_key, 4) { + glog.Error("NODE_RDP_PROTOCOL_T125_GCC_BAD_H221_SC_KEY") + return ret + } + + ln, _ := per.ReadLength(r) + for ln > 0 { + t, _ := core.ReadUint16LE(r) + glog.Debugf("Message type 0x%x,ln:%v", t, ln) + l, _ := core.ReadUint16LE(r) + dataBytes, _ := core.ReadBytes(int(l)-4, r) + ln = ln - l + var d ScData + switch Message(t) { + case SC_CORE: + d = &ServerCoreData{} + case SC_SECURITY: + d = &ServerSecurityData{} + case SC_NET: + d = &ServerNetworkData{} + default: + glog.Error("Unknown type", t) + continue + } + + if d != nil { + r := bytes.NewReader(dataBytes) + err := d.Unpack(r) + if err != nil { + glog.Warn("Unpack:", err) + } + ret = append(ret, d) + } + } + + return ret +} diff --git a/grdp/protocol/t125/mcs.go b/grdp/protocol/t125/mcs.go new file mode 100644 index 0000000..f49d42b --- /dev/null +++ b/grdp/protocol/t125/mcs.go @@ -0,0 +1,575 @@ +package t125 + +import ( + "bytes" + "encoding/hex" + "errors" + "fmt" + "io" + "reflect" + + "ShotRDP/grdp/plugin/cliprdr" + "ShotRDP/grdp/plugin/rail" + + "ShotRDP/grdp/plugin/drdynvc" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/emission" + "ShotRDP/grdp/glog" + "ShotRDP/grdp/protocol/t125/ber" + "ShotRDP/grdp/protocol/t125/gcc" + "ShotRDP/grdp/protocol/t125/per" +) + +// take idea from https://github.com/Madnikulin50/gordp + +// Multiple Channel Service layer + +type MCSMessage uint8 + +const ( + MCS_TYPE_CONNECT_INITIAL MCSMessage = 0x65 + MCS_TYPE_CONNECT_RESPONSE = 0x66 +) + +type MCSDomainPDU uint16 + +const ( + ERECT_DOMAIN_REQUEST MCSDomainPDU = 1 + DISCONNECT_PROVIDER_ULTIMATUM = 8 + ATTACH_USER_REQUEST = 10 + ATTACH_USER_CONFIRM = 11 + CHANNEL_JOIN_REQUEST = 14 + CHANNEL_JOIN_CONFIRM = 15 + SEND_DATA_REQUEST = 25 + SEND_DATA_INDICATION = 26 +) + +const ( + MCS_GLOBAL_CHANNEL_ID uint16 = 1003 + MCS_USERCHANNEL_BASE = 1001 +) + +const ( + GLOBAL_CHANNEL_NAME = "global" +) + +/** + * Format MCS PDULayer header packet + * @param mcsPdu {integer} + * @param options {integer} + * @returns {type.UInt8} headers + */ +func writeMCSPDUHeader(mcsPdu MCSDomainPDU, options uint8, w io.Writer) { + core.WriteUInt8((uint8(mcsPdu)<<2)|options, w) +} + +func readMCSPDUHeader(options uint8, mcsPdu MCSDomainPDU) bool { + return (options >> 2) == uint8(mcsPdu) +} + +type DomainParameters struct { + MaxChannelIds int + MaxUserIds int + MaxTokenIds int + NumPriorities int + MinThoughput int + MaxHeight int + MaxMCSPDUsize int + ProtocolVersion int +} + +/** + * @see http://www.itu.int/rec/T-REC-T.125-199802-I/en page 25 + * @returns {asn1.univ.Sequence} + */ +func NewDomainParameters( + maxChannelIds int, + maxUserIds int, + maxTokenIds int, + numPriorities int, + minThoughput int, + maxHeight int, + maxMCSPDUsize int, + protocolVersion int) *DomainParameters { + return &DomainParameters{maxChannelIds, maxUserIds, maxTokenIds, + numPriorities, minThoughput, maxHeight, maxMCSPDUsize, protocolVersion} +} + +func (d *DomainParameters) BER() []byte { + buff := &bytes.Buffer{} + ber.WriteInteger(d.MaxChannelIds, buff) + ber.WriteInteger(d.MaxUserIds, buff) + ber.WriteInteger(d.MaxTokenIds, buff) + ber.WriteInteger(1, buff) + ber.WriteInteger(0, buff) + ber.WriteInteger(1, buff) + ber.WriteInteger(d.MaxMCSPDUsize, buff) + ber.WriteInteger(2, buff) + return buff.Bytes() +} + +func ReadDomainParameters(r io.Reader) (*DomainParameters, error) { + if !ber.ReadUniversalTag(ber.TAG_SEQUENCE, true, r) { + return nil, errors.New("bad BER tags") + } + d := &DomainParameters{} + ber.ReadLength(r) + + d.MaxChannelIds, _ = ber.ReadInteger(r) + d.MaxUserIds, _ = ber.ReadInteger(r) + d.MaxTokenIds, _ = ber.ReadInteger(r) + ber.ReadInteger(r) + ber.ReadInteger(r) + ber.ReadInteger(r) + d.MaxMCSPDUsize, _ = ber.ReadInteger(r) + ber.ReadInteger(r) + return d, nil +} + +/** + * @see http://www.itu.int/rec/T-REC-T.125-199802-I/en page 25 + * @param userData {Buffer} + * @returns {asn1.univ.Sequence} + */ +type ConnectInitial struct { + CallingDomainSelector []byte + CalledDomainSelector []byte + UpwardFlag bool + TargetParameters DomainParameters + MinimumParameters DomainParameters + MaximumParameters DomainParameters + UserData []byte +} + +func NewConnectInitial(userData []byte) ConnectInitial { + return ConnectInitial{[]byte{0x1}, + []byte{0x1}, + true, + *NewDomainParameters(34, 2, 0, 1, 0, 1, 0xffff, 2), + *NewDomainParameters(1, 1, 1, 1, 0, 1, 0x420, 2), + *NewDomainParameters(0xffff, 0xfc17, 0xffff, 1, 0, 1, 0xffff, 2), + userData} +} + +func (c *ConnectInitial) BER() []byte { + buff := &bytes.Buffer{} + ber.WriteOctetstring(string(c.CallingDomainSelector), buff) + ber.WriteOctetstring(string(c.CalledDomainSelector), buff) + ber.WriteBoolean(c.UpwardFlag, buff) + ber.WriteEncodedDomainParams(c.TargetParameters.BER(), buff) + ber.WriteEncodedDomainParams(c.MinimumParameters.BER(), buff) + ber.WriteEncodedDomainParams(c.MaximumParameters.BER(), buff) + ber.WriteOctetstring(string(c.UserData), buff) + return buff.Bytes() +} + +/** + * @see http://www.itu.int/rec/T-REC-T.125-199802-I/en page 25 + * @returns {asn1.univ.Sequence} + */ + +type ConnectResponse struct { + result uint8 + calledConnectId int + domainParameters *DomainParameters + userData []byte +} + +func NewConnectResponse(userData []byte) *ConnectResponse { + return &ConnectResponse{0, + 0, + NewDomainParameters(22, 3, 0, 1, 0, 1, 0xfff8, 2), + userData} +} + +func ReadConnectResponse(r io.Reader) (*ConnectResponse, error) { + c := &ConnectResponse{} + var err error + _, err = ber.ReadApplicationTag(MCS_TYPE_CONNECT_RESPONSE, r) + if err != nil { + return nil, err + } + c.result, err = ber.ReadEnumerated(r) + if err != nil { + return nil, err + } + + c.calledConnectId, err = ber.ReadInteger(r) + c.domainParameters, err = ReadDomainParameters(r) + if err != nil { + return nil, err + } + if !ber.ReadUniversalTag(ber.TAG_OCTET_STRING, false, r) { + return nil, errors.New("invalid expected BER tag") + } + dataLen, _ := ber.ReadLength(r) + c.userData, err = core.ReadBytes(dataLen, r) + return c, err +} + +type MCSChannelInfo struct { + ID uint16 + Name string +} + +type MCS struct { + emission.Emitter + transport core.Transport + recvOpCode MCSDomainPDU + sendOpCode MCSDomainPDU + channels []MCSChannelInfo +} + +func NewMCS(t core.Transport, recvOpCode MCSDomainPDU, sendOpCode MCSDomainPDU) *MCS { + m := &MCS{ + *emission.NewEmitter(), + t, + recvOpCode, + sendOpCode, + []MCSChannelInfo{{MCS_GLOBAL_CHANNEL_ID, GLOBAL_CHANNEL_NAME}}, + } + + m.transport.On("close", func() { + m.Emit("close") + }).On("error", func(err error) { + m.Emit("error", err) + }) + return m +} + +func (x *MCS) Read(b []byte) (n int, err error) { + return x.transport.Read(b) +} + +func (x *MCS) Write(b []byte) (n int, err error) { + return x.transport.Write(b) +} + +func (m *MCS) Close() error { + return m.transport.Close() +} + +type MCSClient struct { + *MCS + clientCoreData *gcc.ClientCoreData + clientNetworkData *gcc.ClientNetworkData + clientSecurityData *gcc.ClientSecurityData + + serverCoreData *gcc.ServerCoreData + serverNetworkData *gcc.ServerNetworkData + serverSecurityData *gcc.ServerSecurityData + + channelsConnected int + userId uint16 + nbChannelRequested int +} + +func NewMCSClient(t core.Transport) *MCSClient { + c := &MCSClient{ + MCS: NewMCS(t, SEND_DATA_INDICATION, SEND_DATA_REQUEST), + clientCoreData: gcc.NewClientCoreData(), + clientNetworkData: gcc.NewClientNetworkData(), + clientSecurityData: gcc.NewClientSecurityData(), + userId: 1 + MCS_USERCHANNEL_BASE, + } + c.transport.On("connect", c.connect) + return c +} + +func (c *MCSClient) SetClientDesktop(width, height uint16) { + c.clientCoreData.DesktopWidth = width + c.clientCoreData.DesktopHeight = height +} + +func (c *MCSClient) SetClientDynvcProtocol() { + c.clientCoreData.EarlyCapabilityFlags = gcc.RNS_UD_CS_SUPPORT_DYNVC_GFX_PROTOCOL + c.clientNetworkData.AddVirtualChannel(drdynvc.ChannelName, drdynvc.ChannelOption) +} + +func (c *MCSClient) SetClientRemoteProgram() { + c.clientNetworkData.AddVirtualChannel(rail.ChannelName, rail.ChannelOption) +} + +func (c *MCSClient) SetClientCliprdr() { + c.clientNetworkData.AddVirtualChannel(cliprdr.ChannelName, cliprdr.ChannelOption) +} + +func (c *MCSClient) connect(selectedProtocol uint32) { + glog.Debug("mcs client on connect", selectedProtocol) + c.clientCoreData.ServerSelectedProtocol = selectedProtocol + + glog.Debugf("clientCoreData:%+v", c.clientCoreData) + glog.Debugf("clientNetworkData:%+v", c.clientNetworkData) + glog.Debugf("clientSecurityData:%+v", c.clientSecurityData) + // sendConnectclientCoreDataInitial + userDataBuff := bytes.Buffer{} + userDataBuff.Write(c.clientCoreData.Pack()) + userDataBuff.Write(c.clientNetworkData.Pack()) + userDataBuff.Write(c.clientSecurityData.Pack()) + + ccReq := gcc.MakeConferenceCreateRequest(userDataBuff.Bytes()) + connectInitial := NewConnectInitial(ccReq) + connectInitialBerEncoded := connectInitial.BER() + + dataBuff := &bytes.Buffer{} + ber.WriteApplicationTag(uint8(MCS_TYPE_CONNECT_INITIAL), len(connectInitialBerEncoded), dataBuff) + dataBuff.Write(connectInitialBerEncoded) + + _, err := c.transport.Write(dataBuff.Bytes()) + if err != nil { + c.Emit("error", errors.New(fmt.Sprintf("mcs sendConnectInitial write error %v", err))) + return + } + glog.Debug("mcs wait for data event") + c.transport.Once("data", c.recvConnectResponse) +} + +func (c *MCSClient) recvConnectResponse(s []byte) { + glog.Trace("mcs recvConnectResponse", hex.EncodeToString(s)) + cResp, err := ReadConnectResponse(bytes.NewReader(s)) + if err != nil { + c.Emit("error", errors.New(fmt.Sprintf("ReadConnectResponse %v", err))) + return + } + // record server gcc block + serverSettings := gcc.ReadConferenceCreateResponse(cResp.userData) + for _, v := range serverSettings { + switch v.(type) { + case *gcc.ServerSecurityData: + c.serverSecurityData = v.(*gcc.ServerSecurityData) + + case *gcc.ServerCoreData: + c.serverCoreData = v.(*gcc.ServerCoreData) + + case *gcc.ServerNetworkData: + c.serverNetworkData = v.(*gcc.ServerNetworkData) + + default: + err := errors.New(fmt.Sprintf("unhandle server gcc block %v", reflect.TypeOf(v))) + glog.Error(err) + c.Emit("error", err) + return + } + } + glog.Debugf("serverSecurityData: %+v", c.serverSecurityData) + glog.Debugf("serverCoreData: %+v", c.serverCoreData) + glog.Debugf("serverNetworkData: %+v", c.serverNetworkData) + glog.Debug("mcs sendErectDomainRequest") + c.sendErectDomainRequest() + + glog.Debug("mcs sendAttachUserRequest") + c.sendAttachUserRequest() + + c.transport.Once("data", c.recvAttachUserConfirm) +} + +func (c *MCSClient) sendErectDomainRequest() { + buff := &bytes.Buffer{} + writeMCSPDUHeader(ERECT_DOMAIN_REQUEST, 0, buff) + per.WriteInteger(0, buff) + per.WriteInteger(0, buff) + c.transport.Write(buff.Bytes()) +} + +func (c *MCSClient) sendAttachUserRequest() { + buff := &bytes.Buffer{} + writeMCSPDUHeader(ATTACH_USER_REQUEST, 0, buff) + c.transport.Write(buff.Bytes()) +} + +func (c *MCSClient) recvAttachUserConfirm(s []byte) { + glog.Debug("mcs recvAttachUserConfirm", hex.EncodeToString(s)) + r := bytes.NewReader(s) + + option, err := core.ReadUInt8(r) + if err != nil { + c.Emit("error", err) + return + } + + if !readMCSPDUHeader(option, ATTACH_USER_CONFIRM) { + c.Emit("error", errors.New("NODE_RDP_PROTOCOL_T125_MCS_BAD_HEADER")) + return + } + + e, err := per.ReadEnumerates(r) + if err != nil { + c.Emit("error", err) + return + } + if e != 0 { + c.Emit("error", errors.New("NODE_RDP_PROTOCOL_T125_MCS_SERVER_REJECT_USER'")) + return + } + + userId, _ := per.ReadInteger16(r) + userId += MCS_USERCHANNEL_BASE + c.userId = userId + + c.channels = append(c.channels, MCSChannelInfo{userId, "user"}) + c.connectChannels() +} + +func (c *MCSClient) connectChannels() { + glog.Debug("mcs connectChannels:", c.channelsConnected, ":", len(c.channels)) + if c.channelsConnected == len(c.channels) { + if c.nbChannelRequested < int(c.serverNetworkData.ChannelCount) { + //static virtual channel + chanId := c.serverNetworkData.ChannelIdArray[c.nbChannelRequested] + c.nbChannelRequested++ + c.sendChannelJoinRequest(chanId) + c.transport.Once("data", c.recvChannelJoinConfirm) + return + } + c.transport.On("data", c.recvData) + // send client and sever gcc informations callback to sec + clientData := make([]interface{}, 0) + clientData = append(clientData, c.clientCoreData) + clientData = append(clientData, c.clientSecurityData) + clientData = append(clientData, c.clientNetworkData) + + serverData := make([]interface{}, 0) + serverData = append(serverData, c.serverCoreData) + serverData = append(serverData, c.serverSecurityData) + glog.Debug("msc connectChannels callback to sec") + c.Emit("connect", clientData, serverData, c.userId, c.channels) + return + } + + // sendChannelJoinRequest + glog.Debug("sendChannelJoinRequest:", c.channels[c.channelsConnected].Name) + c.sendChannelJoinRequest(c.channels[c.channelsConnected].ID) + + c.transport.Once("data", c.recvChannelJoinConfirm) +} + +func (c *MCSClient) sendChannelJoinRequest(channelId uint16) { + glog.Debug("mcs sendChannelJoinRequest", channelId) + buff := &bytes.Buffer{} + writeMCSPDUHeader(CHANNEL_JOIN_REQUEST, 0, buff) + per.WriteInteger16(c.userId-MCS_USERCHANNEL_BASE, buff) + per.WriteInteger16(channelId, buff) + c.transport.Write(buff.Bytes()) +} + +func (c *MCSClient) recvData(s []byte) { + glog.Trace("msc on data recvData:", hex.EncodeToString(s)) + + r := bytes.NewReader(s) + option, err := core.ReadUInt8(r) + if err != nil { + c.Emit("error", err) + return + } + + if readMCSPDUHeader(option, DISCONNECT_PROVIDER_ULTIMATUM) { + c.Emit("error", errors.New("MCS DISCONNECT_PROVIDER_ULTIMATUM")) + c.transport.Close() + return + } else if !readMCSPDUHeader(option, c.recvOpCode) { + c.Emit("error", errors.New("Invalid expected MCS opcode receive data")) + return + } + + userId, _ := per.ReadInteger16(r) + userId += MCS_USERCHANNEL_BASE + + channelId, _ := per.ReadInteger16(r) + per.ReadEnumerates(r) + size, _ := per.ReadLength(r) + // channel ID doesn't match a requested layer + found := false + channelName := "" + for _, channel := range c.channels { + if channel.ID == channelId { + found = true + channelName = channel.Name + break + } + } + if !found { + glog.Error("mcs receive data for an unconnected layer") + return + } + left, err := core.ReadBytes(int(size), r) + if err != nil { + c.Emit("error", errors.New(fmt.Sprintf("mcs recvData get data error %v", err))) + return + } + glog.Debugf("mcs emit channel<%s>", channelName) + c.Emit("sec", channelName, left) +} + +func (c *MCSClient) recvChannelJoinConfirm(s []byte) { + glog.Debug("mcs recvChannelJoinConfirm", hex.EncodeToString(s)) + r := bytes.NewReader(s) + option, err := core.ReadUInt8(r) + if err != nil { + c.Emit("error", err) + return + } + + if !readMCSPDUHeader(option, CHANNEL_JOIN_CONFIRM) { + c.Emit("error", errors.New("NODE_RDP_PROTOCOL_T125_MCS_WAIT_CHANNEL_JOIN_CONFIRM")) + return + } + + confirm, _ := per.ReadEnumerates(r) + userId, _ := per.ReadInteger16(r) + userId += MCS_USERCHANNEL_BASE + + if c.userId != userId { + c.Emit("error", errors.New("NODE_RDP_PROTOCOL_T125_MCS_INVALID_USER_ID")) + return + } + + channelId, _ := per.ReadInteger16(r) + if (confirm != 0) && (channelId == uint16(MCS_GLOBAL_CHANNEL_ID) || channelId == c.userId) { + c.Emit("error", errors.New("NODE_RDP_PROTOCOL_T125_MCS_SERVER_MUST_CONFIRM_STATIC_CHANNEL")) + return + } + glog.Debug("Confirm channelId:", channelId) + if confirm == 0 { + for i := 0; i < int(c.serverNetworkData.ChannelCount); i++ { + if channelId == c.serverNetworkData.ChannelIdArray[i] { + var t MCSChannelInfo + t.ID = channelId + t.Name = string(c.clientNetworkData.ChannelDefArray[i].Name[:]) + c.channels = append(c.channels, t) + } + } + } + c.channelsConnected++ + c.connectChannels() +} + +func (c *MCSClient) Pack(data []byte, channelId uint16) []byte { + buff := &bytes.Buffer{} + writeMCSPDUHeader(c.sendOpCode, 0, buff) + per.WriteInteger16(c.userId-MCS_USERCHANNEL_BASE, buff) + per.WriteInteger16(channelId, buff) + core.WriteUInt8(0x70, buff) + per.WriteLength(len(data), buff) + core.WriteBytes(data, buff) + glog.Trace("MCSClient write", channelId, ":", hex.EncodeToString(buff.Bytes())) + return buff.Bytes() +} + +func (c *MCSClient) Write(data []byte) (n int, err error) { + data = c.Pack(data, c.channels[0].ID) + return c.transport.Write(data) +} + +func (c *MCSClient) SendToChannel(channel string, data []byte) (n int, err error) { + channelId := c.channels[0].ID + for _, ch := range c.channels { + if channel == ch.Name { + channelId = ch.ID + break + } + } + + data = c.Pack(data, channelId) + return c.transport.Write(data) +} diff --git a/grdp/protocol/t125/per/per.go b/grdp/protocol/t125/per/per.go new file mode 100644 index 0000000..de3e64a --- /dev/null +++ b/grdp/protocol/t125/per/per.go @@ -0,0 +1,203 @@ +package per + +import ( + "bytes" + "io" + + "ShotRDP/grdp/glog" + + "ShotRDP/grdp/core" +) + +func ReadEnumerates(r io.Reader) (uint8, error) { + return core.ReadUInt8(r) +} + +func WriteInteger(n int, w io.Writer) { + if n <= 0xff { + WriteLength(1, w) + core.WriteUInt8(uint8(n), w) + } else if n <= 0xffff { + WriteLength(2, w) + core.WriteUInt16BE(uint16(n), w) + } else { + WriteLength(4, w) + core.WriteUInt32BE(uint32(n), w) + } +} + +func ReadInteger16(r io.Reader) (uint16, error) { + return core.ReadUint16BE(r) +} + +func WriteInteger16(value uint16, w io.Writer) { + core.WriteUInt16BE(value, w) +} + +/** + * @param choice {integer} + * @returns {type.UInt8} choice per encoded + */ +func WriteChoice(choice uint8, w io.Writer) { + core.WriteUInt8(choice, w) +} + +/** + * @param value {raw} value to convert to per format + * @returns type objects per encoding value + */ +func WriteLength(value int, w io.Writer) { + if value > 0x7f { + core.WriteUInt16BE(uint16(value|0x8000), w) + } else { + core.WriteUInt8(uint8(value), w) + } +} + +func ReadLength(r io.Reader) (uint16, error) { + b, err := core.ReadUInt8(r) + if err != nil { + return 0, nil + } + var size uint16 + if b&0x80 > 0 { + b = b &^ 0x80 + size = uint16(b) << 8 + left, _ := core.ReadUInt8(r) + size += uint16(left) + } else { + size = uint16(b) + } + return size, nil +} + +/** + * @param oid {array} oid to write + * @returns {type.Component} per encoded object identifier + */ +func WriteObjectIdentifier(oid []byte, w io.Writer) { + core.WriteUInt8(5, w) + core.WriteByte((oid[0]<<4)&(oid[1]&0x0f), w) + core.WriteByte(oid[2], w) + core.WriteByte(oid[3], w) + core.WriteByte(oid[4], w) + core.WriteByte(oid[5], w) +} + +/** + * @param selection {integer} + * @returns {type.UInt8} per encoded selection + */ +func WriteSelection(selection uint8, w io.Writer) { + core.WriteUInt8(selection, w) +} + +func WriteNumericString(s string, minValue int, w io.Writer) { + length := len(s) + mLength := minValue + if length >= minValue { + mLength = length - minValue + } + buff := &bytes.Buffer{} + for i := 0; i < length; i += 2 { + c1 := int(s[i]) + c2 := 0x30 + if i+1 < length { + c2 = int(s[i+1]) + } + c1 = (c1 - 0x30) % 10 + c2 = (c2 - 0x30) % 10 + core.WriteUInt8(uint8((c1<<4)|c2), buff) + } + WriteLength(mLength, w) + w.Write(buff.Bytes()) +} + +func WritePadding(length int, w io.Writer) { + b := make([]byte, length) + w.Write(b) +} + +func WriteNumberOfSet(n int, w io.Writer) { + core.WriteUInt8(uint8(n), w) +} + +/** + * @param oStr {String} + * @param minValue {integer} default 0 + * @returns {type.Component} per encoded octet stream + */ +func WriteOctetStream(oStr string, minValue int, w io.Writer) { + length := len(oStr) + mlength := minValue + + if length-minValue >= 0 { + mlength = length - minValue + } + WriteLength(mlength, w) + w.Write([]byte(oStr)[:length]) +} + +func ReadChoice(r io.Reader) uint8 { + choice, _ := core.ReadUInt8(r) + return choice +} +func ReadNumberOfSet(r io.Reader) uint8 { + choice, _ := core.ReadUInt8(r) + return choice +} +func ReadInteger(r io.Reader) uint32 { + size, _ := ReadLength(r) + switch size { + case 1: + ret, _ := core.ReadUInt8(r) + return uint32(ret) + case 2: + ret, _ := core.ReadUint16BE(r) + return uint32(ret) + case 4: + ret, _ := core.ReadUInt32BE(r) + return ret + default: + glog.Info("ReadInteger") + } + return 0 +} + +func ReadObjectIdentifier(r io.Reader, oid []byte) bool { + size, _ := ReadLength(r) + if size != 5 { + return false + } + + a_oid := []byte{0, 0, 0, 0, 0, 0} + t12, _ := core.ReadByte(r) + a_oid[0] = t12 >> 4 + a_oid[1] = t12 & 0x0f + a_oid[2], _ = core.ReadByte(r) + a_oid[3], _ = core.ReadByte(r) + a_oid[4], _ = core.ReadByte(r) + a_oid[5], _ = core.ReadByte(r) + + for i, _ := range oid { + if oid[i] != a_oid[i] { + return false + } + } + return true +} +func ReadOctetStream(r io.Reader, s string, min int) bool { + ln, _ := ReadLength(r) + size := int(ln) + min + if size != len(s) { + return false + } + for i := 0; i < size; i++ { + b, _ := core.ReadByte(r) + if b != s[i] { + return false + } + } + + return true +} diff --git a/grdp/protocol/tpkt/tpkt.go b/grdp/protocol/tpkt/tpkt.go new file mode 100644 index 0000000..e7b7aa2 --- /dev/null +++ b/grdp/protocol/tpkt/tpkt.go @@ -0,0 +1,229 @@ +package tpkt + +import ( + "bytes" + "encoding/hex" + "fmt" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/emission" + "ShotRDP/grdp/glog" + "ShotRDP/grdp/protocol/nla" +) + +// take idea from https://github.com/Madnikulin50/gordp + +/** + * Type of tpkt packet + * Fastpath is use to shortcut RDP stack + * @see http://msdn.microsoft.com/en-us/library/cc240621.aspx + * @see http://msdn.microsoft.com/en-us/library/cc240589.aspx + */ +const ( + FASTPATH_ACTION_FASTPATH = 0x0 + FASTPATH_ACTION_X224 = 0x3 +) + +/** + * TPKT layer of rdp stack + */ +type TPKT struct { + emission.Emitter + Conn *core.SocketLayer + ntlm *nla.NTLMv2 + secFlag byte + lastShortLength int + fastPathListener core.FastPathListener + ntlmSec *nla.NTLMv2Security +} + +func New(s *core.SocketLayer, ntlm *nla.NTLMv2) *TPKT { + t := &TPKT{ + Emitter: *emission.NewEmitter(), + Conn: s, + secFlag: 0, + ntlm: ntlm} + core.StartReadBytes(2, s, t.recvHeader) + return t +} + +func (t *TPKT) StartTLS() error { + return t.Conn.StartTLS() +} + +func (t *TPKT) StartNLA() error { + err := t.StartTLS() + if err != nil { + glog.Info("start tls failed", err) + return err + } + req := nla.EncodeDERTRequest([]nla.Message{t.ntlm.GetNegotiateMessage()}, nil, nil) + _, err = t.Conn.Write(req) + if err != nil { + glog.Info("send NegotiateMessage", err) + return err + } + + resp := make([]byte, 1024) + n, err := t.Conn.Read(resp) + if err != nil { + return fmt.Errorf("read %s", err) + } else { + glog.Debug("StartNLA Read success") + } + return t.recvChallenge(resp[:n]) +} + +func (t *TPKT) recvChallenge(data []byte) error { + glog.Trace("recvChallenge", hex.EncodeToString(data)) + tsreq, err := nla.DecodeDERTRequest(data) + if err != nil { + glog.Info("DecodeDERTRequest", err) + return err + } + glog.Debugf("tsreq:%+v", tsreq) + // get pubkey + pubkey, err := t.Conn.TlsPubKey() + glog.Debugf("pubkey=%+v", pubkey) + + authMsg, ntlmSec := t.ntlm.GetAuthenticateMessage(tsreq.NegoTokens[0].Data) + t.ntlmSec = ntlmSec + + encryptPubkey := ntlmSec.GssEncrypt(pubkey) + req := nla.EncodeDERTRequest([]nla.Message{authMsg}, nil, encryptPubkey) + _, err = t.Conn.Write(req) + if err != nil { + glog.Info("send AuthenticateMessage", err) + return err + } + resp := make([]byte, 1024) + n, err := t.Conn.Read(resp) + if err != nil { + glog.Error("Read:", err) + return fmt.Errorf("read %s", err) + } else { + glog.Debug("recvChallenge Read success") + } + return t.recvPubKeyInc(resp[:n]) +} + +func (t *TPKT) recvPubKeyInc(data []byte) error { + glog.Trace("recvPubKeyInc", hex.EncodeToString(data)) + tsreq, err := nla.DecodeDERTRequest(data) + if err != nil { + glog.Info("DecodeDERTRequest", err) + return err + } + glog.Trace("PubKeyAuth:", tsreq.PubKeyAuth) + //ignore + //pubkey := t.ntlmSec.GssDecrypt([]byte(tsreq.PubKeyAuth)) + domain, username, password := t.ntlm.GetEncodedCredentials() + credentials := nla.EncodeDERTCredentials(domain, username, password) + authInfo := t.ntlmSec.GssEncrypt(credentials) + req := nla.EncodeDERTRequest(nil, authInfo, nil) + _, err = t.Conn.Write(req) + if err != nil { + glog.Info("send AuthenticateMessage", err) + return err + } + + return nil +} + +func (t *TPKT) Read(b []byte) (n int, err error) { + return t.Conn.Read(b) +} + +func (t *TPKT) Write(data []byte) (n int, err error) { + buff := &bytes.Buffer{} + core.WriteUInt8(FASTPATH_ACTION_X224, buff) + core.WriteUInt8(0, buff) + core.WriteUInt16BE(uint16(len(data)+4), buff) + buff.Write(data) + glog.Trace("tpkt Write", hex.EncodeToString(buff.Bytes())) + return t.Conn.Write(buff.Bytes()) +} + +func (t *TPKT) Close() error { + return t.Conn.Close() +} + +func (t *TPKT) SetFastPathListener(f core.FastPathListener) { + t.fastPathListener = f +} + +func (t *TPKT) SendFastPath(secFlag byte, data []byte) (n int, err error) { + buff := &bytes.Buffer{} + core.WriteUInt8(FASTPATH_ACTION_FASTPATH|((secFlag&0x3)<<6), buff) + core.WriteUInt16BE(uint16(len(data)+3)|0x8000, buff) + buff.Write(data) + glog.Trace("TPTK SendFastPath", hex.EncodeToString(buff.Bytes())) + return t.Conn.Write(buff.Bytes()) +} + +func (t *TPKT) recvHeader(s []byte, err error) { + glog.Trace("tpkt recvHeader", hex.EncodeToString(s), err) + if err != nil { + t.Emit("error", err) + return + } + r := bytes.NewReader(s) + version, _ := core.ReadUInt8(r) + if version == FASTPATH_ACTION_X224 { + glog.Debug("tptk recvHeader FASTPATH_ACTION_X224, wait for recvExtendedHeader") + core.StartReadBytes(2, t.Conn, t.recvExtendedHeader) + } else { + t.secFlag = (version >> 6) & 0x3 + length, _ := core.ReadUInt8(r) + t.lastShortLength = int(length) + if t.lastShortLength&0x80 != 0 { + core.StartReadBytes(1, t.Conn, t.recvExtendedFastPathHeader) + } else { + core.StartReadBytes(t.lastShortLength-2, t.Conn, t.recvFastPath) + } + } +} + +func (t *TPKT) recvExtendedHeader(s []byte, err error) { + glog.Trace("tpkt recvExtendedHeader", hex.EncodeToString(s), err) + if err != nil { + return + } + r := bytes.NewReader(s) + size, _ := core.ReadUint16BE(r) + glog.Debug("tpkt wait recvData:", size) + core.StartReadBytes(int(size-4), t.Conn, t.recvData) +} + +func (t *TPKT) recvData(s []byte, err error) { + glog.Trace("tpkt recvData", hex.EncodeToString(s), err) + if err != nil { + return + } + t.Emit("data", s) + core.StartReadBytes(2, t.Conn, t.recvHeader) +} + +func (t *TPKT) recvExtendedFastPathHeader(s []byte, err error) { + glog.Trace("tpkt recvExtendedFastPathHeader", hex.EncodeToString(s)) + r := bytes.NewReader(s) + rightPart, err := core.ReadUInt8(r) + if err != nil { + glog.Error("TPTK recvExtendedFastPathHeader", err) + return + } + + leftPart := t.lastShortLength & ^0x80 + packetSize := (leftPart << 8) + int(rightPart) + core.StartReadBytes(packetSize-3, t.Conn, t.recvFastPath) +} + +func (t *TPKT) recvFastPath(s []byte, err error) { + glog.Trace("tpkt recvFastPath") + if err != nil { + return + } + + t.fastPathListener.RecvFastPath(t.secFlag, s) + core.StartReadBytes(2, t.Conn, t.recvHeader) +} diff --git a/grdp/protocol/x224/x224.go b/grdp/protocol/x224/x224.go new file mode 100644 index 0000000..21142f9 --- /dev/null +++ b/grdp/protocol/x224/x224.go @@ -0,0 +1,323 @@ +package x224 + +import ( + "bytes" + "encoding/hex" + "errors" + "fmt" + + "ShotRDP/grdp/glog" + + "ShotRDP/grdp/core" + "ShotRDP/grdp/emission" + "ShotRDP/grdp/protocol/tpkt" + "github.com/lunixbochs/struc" +) + +// take idea from https://github.com/Madnikulin50/gordp + +/** + * Message type present in X224 packet header + */ +type MessageType byte + +const ( + TPDU_CONNECTION_REQUEST MessageType = 0xE0 + TPDU_CONNECTION_CONFIRM = 0xD0 + TPDU_DISCONNECT_REQUEST = 0x80 + TPDU_DATA = 0xF0 + TPDU_ERROR = 0x70 +) + +/** + * Type of negotiation present in negotiation packet + */ +type NegotiationType byte + +const ( + TYPE_RDP_NEG_REQ NegotiationType = 0x01 + TYPE_RDP_NEG_RSP = 0x02 + TYPE_RDP_NEG_FAILURE = 0x03 +) + +/** + * Protocols available for x224 layer + */ + +const ( + PROTOCOL_RDP uint32 = 0x00000000 + PROTOCOL_SSL = 0x00000001 + PROTOCOL_HYBRID = 0x00000002 + PROTOCOL_HYBRID_EX = 0x00000008 +) + +/** + * Use to negotiate security layer of RDP stack + * In node-rdpjs only ssl is available + * @param opt {object} component type options + * @see request -> http://msdn.microsoft.com/en-us/library/cc240500.aspx + * @see response -> http://msdn.microsoft.com/en-us/library/cc240506.aspx + * @see failure ->http://msdn.microsoft.com/en-us/library/cc240507.aspx + */ +type Negotiation struct { + Type NegotiationType `struc:"byte"` + Flag uint8 `struc:"uint8"` + Length uint16 `struc:"little"` + Result uint32 `struc:"little"` +} + +func NewNegotiation() *Negotiation { + return &Negotiation{0, 0, 0x0008 /*constant*/, PROTOCOL_RDP} +} + +type failureCode int + +const ( + //The server requires that the client support Enhanced RDP Security (section 5.4) with either TLS 1.0, 1.1 or 1.2 (section 5.4.5.1) or CredSSP (section 5.4.5.2). If only CredSSP was requested then the server only supports TLS. + SSL_REQUIRED_BY_SERVER = 0x00000001 + + //The server is configured to only use Standard RDP Security mechanisms (section 5.3) and does not support any External Security Protocols (section 5.4.5). + SSL_NOT_ALLOWED_BY_SERVER = 0x00000002 + + //The server does not possess a valid authentication certificate and cannot initialize the External Security Protocol Provider (section 5.4.5). + SSL_CERT_NOT_ON_SERVER = 0x00000003 + + //The list of requested security protocols is not consistent with the current security protocol in effect. This error is only possible when the Direct Approach (sections 5.4.2.2 and 1.3.1.2) is used and an External Security Protocol (section 5.4.5) is already being used. + INCONSISTENT_FLAGS = 0x00000004 + + //The server requires that the client support Enhanced RDP Security (section 5.4) with CredSSP (section 5.4.5.2). + HYBRID_REQUIRED_BY_SERVER = 0x00000005 + + //The server requires that the client support Enhanced RDP Security (section 5.4) with TLS 1.0, 1.1 or 1.2 (section 5.4.5.1) and certificate-based client authentication.<4> + SSL_WITH_USER_AUTH_REQUIRED_BY_SERVER = 0x00000006 +) + +/** + * X224 client connection request + * @param opt {object} component type options + * @see http://msdn.microsoft.com/en-us/library/cc240470.aspx + */ +type ClientConnectionRequestPDU struct { + Len uint8 + Code MessageType + Padding1 uint16 + Padding2 uint16 + Padding3 uint8 + Cookie []byte + requestedProtocol uint32 + ProtocolNeg *Negotiation +} + +func NewClientConnectionRequestPDU(cookie []byte, requestedProtocol uint32) *ClientConnectionRequestPDU { + x := ClientConnectionRequestPDU{0, TPDU_CONNECTION_REQUEST, 0, 0, 0, + cookie, requestedProtocol, NewNegotiation()} + + x.Len = 6 + if len(cookie) > 0 { + x.Len += uint8(len(cookie) + 2) + } + if x.requestedProtocol > PROTOCOL_RDP { + x.Len += 8 + } + + return &x +} + +func (x *ClientConnectionRequestPDU) Serialize() []byte { + buff := &bytes.Buffer{} + core.WriteUInt8(x.Len, buff) + core.WriteUInt8(uint8(x.Code), buff) + core.WriteUInt16BE(x.Padding1, buff) + core.WriteUInt16BE(x.Padding2, buff) + core.WriteUInt8(x.Padding3, buff) + + if len(x.Cookie) > 0 { + buff.Write(x.Cookie) + core.WriteUInt8(0x0D, buff) + core.WriteUInt8(0x0A, buff) + } + + if x.requestedProtocol > PROTOCOL_RDP { + struc.Pack(buff, x.ProtocolNeg) + } + + return buff.Bytes() +} + +/** + * X224 Server connection confirm + * @param opt {object} component type options + * @see http://msdn.microsoft.com/en-us/library/cc240506.aspx + */ +type ServerConnectionConfirm struct { + Len uint8 + Code MessageType + Padding1 uint16 + Padding2 uint16 + Padding3 uint8 + ProtocolNeg *Negotiation +} + +/** + * Header of each data message from x224 layer + * @returns {type.Component} + */ +type DataHeader struct { + Header uint8 `struc:"little"` + MessageType MessageType `struc:"uint8"` + Separator uint8 `struc:"little"` +} + +func NewDataHeader() *DataHeader { + return &DataHeader{2, TPDU_DATA /* constant */, 0x80 /*constant*/} +} + +/** + * Common X224 Automata + * @param presentation {Layer} presentation layer + */ +type X224 struct { + emission.Emitter + transport core.Transport + requestedProtocol uint32 + selectedProtocol uint32 + dataHeader *DataHeader +} + +func New(t core.Transport) *X224 { + //TODO: 修改RDP验证方式 + //x := &X224{ + // *emission.NewEmitter(), + // t, + // PROTOCOL_RDP | PROTOCOL_SSL | PROTOCOL_HYBRID, + // PROTOCOL_SSL, + // NewDataHeader(), + //} + + x := &X224{ + *emission.NewEmitter(), + t, + PROTOCOL_RDP | PROTOCOL_SSL, + PROTOCOL_RDP, + NewDataHeader(), + } + + t.On("close", func() { + x.Emit("close") + }).On("error", func(err error) { + x.Emit("error", err) + }) + + return x +} + +func (x *X224) Read(b []byte) (n int, err error) { + return x.transport.Read(b) +} + +func (x *X224) Write(b []byte) (n int, err error) { + buff := &bytes.Buffer{} + err = struc.Pack(buff, x.dataHeader) + if err != nil { + return 0, err + } + buff.Write(b) + + glog.Trace("x224 write:", hex.EncodeToString(buff.Bytes())) + return x.transport.Write(buff.Bytes()) +} + +func (x *X224) Close() error { + return x.transport.Close() +} + +func (x *X224) SetRequestedProtocol(p uint32) { + x.requestedProtocol = p +} + +func (x *X224) Connect() error { + if x.transport == nil { + return errors.New("no transport") + } + cookie := "Cookie: mstshash=test" + message := NewClientConnectionRequestPDU([]byte(cookie), x.requestedProtocol) + message.ProtocolNeg.Type = TYPE_RDP_NEG_REQ + message.ProtocolNeg.Result = uint32(x.requestedProtocol) + + glog.Debug("x224 sendConnectionRequest", hex.EncodeToString(message.Serialize())) + _, err := x.transport.Write(message.Serialize()) + x.transport.Once("data", x.recvConnectionConfirm) + return err +} + +func (x *X224) recvConnectionConfirm(s []byte) { + glog.Debug("x224 recvConnectionConfirm ", hex.EncodeToString(s)) + r := bytes.NewReader(s) + ln, _ := core.ReadUInt8(r) + if ln > 6 { + message := &ServerConnectionConfirm{} + if err := struc.Unpack(bytes.NewReader(s), message); err != nil { + glog.Error("ReadServerConnectionConfirm err", err) + return + } + glog.Debugf("message: %+v", *message.ProtocolNeg) + if message.ProtocolNeg.Type == TYPE_RDP_NEG_FAILURE { + glog.Error(fmt.Sprintf("NODE_RDP_PROTOCOL_X224_NEG_FAILURE with code: %d,see https://msdn.microsoft.com/en-us/library/cc240507.aspx", + message.ProtocolNeg.Result)) + //only use Standard RDP Security mechanisms + if message.ProtocolNeg.Result == 2 { + glog.Info("Only use Standard RDP Security mechanisms, Reconnect with Standard RDP") + } + x.Close() + return + } + + if message.ProtocolNeg.Type == TYPE_RDP_NEG_RSP { + glog.Info("TYPE_RDP_NEG_RSP") + x.selectedProtocol = message.ProtocolNeg.Result + } + } else { + x.selectedProtocol = PROTOCOL_RDP + } + + if x.selectedProtocol == PROTOCOL_HYBRID_EX { + glog.Error("NODE_RDP_PROTOCOL_HYBRID_EX_NOT_SUPPORTED") + return + } + + x.transport.On("data", x.recvData) + + if x.selectedProtocol == PROTOCOL_RDP { + glog.Info("*** RDP security selected ***") + x.Emit("connect", x.selectedProtocol) + return + } + + if x.selectedProtocol == PROTOCOL_SSL { + glog.Info("*** SSL security selected ***") + err := x.transport.(*tpkt.TPKT).StartTLS() + if err != nil { + glog.Error("start tls failed:", err) + return + } + x.Emit("connect", x.selectedProtocol) + return + } + + if x.selectedProtocol == PROTOCOL_HYBRID { + glog.Info("*** NLA Security selected ***") + err := x.transport.(*tpkt.TPKT).StartNLA() + if err != nil { + glog.Error("start NLA failed:", err) + return + } + x.Emit("connect", x.selectedProtocol) + return + } +} + +func (x *X224) recvData(s []byte) { + glog.Trace("x224 recvData", hex.EncodeToString(s), "emit data") + // x224 header takes 3 bytes + x.Emit("data", s[3:]) +} diff --git a/grdp/win/advapi32.go b/grdp/win/advapi32.go new file mode 100644 index 0000000..cc3263d --- /dev/null +++ b/grdp/win/advapi32.go @@ -0,0 +1,4080 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "syscall" + "unsafe" +) + +var ( + // Library + libadvapi32 uintptr + + // Functions + abortSystemShutdown uintptr + accessCheck uintptr + accessCheckAndAuditAlarm uintptr + accessCheckByType uintptr + accessCheckByTypeResultList uintptr + addAccessAllowedAce uintptr + addAccessAllowedAceEx uintptr + addAccessAllowedObjectAce uintptr + addAccessDeniedAce uintptr + addAccessDeniedAceEx uintptr + addAccessDeniedObjectAce uintptr + addAce uintptr + addAuditAccessAce uintptr + addAuditAccessAceEx uintptr + addAuditAccessObjectAce uintptr + addConditionalAce uintptr + addMandatoryAce uintptr + addUsersToEncryptedFile uintptr + adjustTokenGroups uintptr + adjustTokenPrivileges uintptr + allocateAndInitializeSid uintptr + allocateLocallyUniqueId uintptr + areAllAccessesGranted uintptr + areAnyAccessesGranted uintptr + auditComputeEffectivePolicyBySid uintptr + auditComputeEffectivePolicyByToken uintptr + auditEnumerateCategories uintptr + auditEnumeratePerUserPolicy uintptr + auditEnumerateSubCategories uintptr + auditFree uintptr + auditLookupCategoryGuidFromCategoryId uintptr + auditLookupCategoryIdFromCategoryGuid uintptr + auditLookupCategoryName uintptr + auditLookupSubCategoryName uintptr + auditQueryPerUserPolicy uintptr + auditQuerySecurity uintptr + auditQuerySystemPolicy uintptr + auditSetPerUserPolicy uintptr + auditSetSecurity uintptr + auditSetSystemPolicy uintptr + backupEventLog uintptr + buildExplicitAccessWithName uintptr + buildImpersonateExplicitAccessWithName uintptr + buildImpersonateTrustee uintptr + buildSecurityDescriptor uintptr + buildTrusteeWithName uintptr + buildTrusteeWithObjectsAndName uintptr + buildTrusteeWithObjectsAndSid uintptr + buildTrusteeWithSid uintptr + changeServiceConfig2 uintptr + changeServiceConfig uintptr + checkTokenMembership uintptr + clearEventLog uintptr + closeEncryptedFileRaw uintptr + closeEventLog uintptr + closeServiceHandle uintptr + closeThreadWaitChainSession uintptr + commandLineFromMsiDescriptor uintptr + controlService uintptr + controlServiceEx uintptr + convertSecurityDescriptorToStringSecurityDescriptor uintptr + convertSidToStringSid uintptr + convertStringSecurityDescriptorToSecurityDescriptor uintptr + convertStringSidToSid uintptr + convertToAutoInheritPrivateObjectSecurity uintptr + copySid uintptr + createPrivateObjectSecurity uintptr + createPrivateObjectSecurityEx uintptr + createPrivateObjectSecurityWithMultipleInheritance uintptr + createProcessAsUser uintptr + createProcessWithLogonW uintptr + createProcessWithTokenW uintptr + createService uintptr + credDelete uintptr + credEnumerate uintptr + credFree uintptr + credGetSessionTypes uintptr + credIsMarshaledCredential uintptr + credRename uintptr + credUnprotect uintptr + credWrite uintptr + cryptAcquireContext uintptr + cryptContextAddRef uintptr + cryptCreateHash uintptr + cryptDecrypt uintptr + cryptDeriveKey uintptr + cryptDestroyHash uintptr + cryptDestroyKey uintptr + cryptDuplicateHash uintptr + cryptDuplicateKey uintptr + cryptEncrypt uintptr + cryptEnumProviderTypes uintptr + cryptEnumProviders uintptr + cryptExportKey uintptr + cryptGenKey uintptr + cryptGenRandom uintptr + cryptGetDefaultProvider uintptr + cryptGetHashParam uintptr + cryptGetKeyParam uintptr + cryptGetProvParam uintptr + cryptGetUserKey uintptr + cryptHashData uintptr + cryptHashSessionKey uintptr + cryptImportKey uintptr + cryptReleaseContext uintptr + cryptSetHashParam uintptr + cryptSetKeyParam uintptr + cryptSetProvParam uintptr + cryptSetProviderEx uintptr + cryptSetProvider uintptr + cryptSignHash uintptr + cryptVerifySignature uintptr + decryptFile uintptr + deleteAce uintptr + deleteService uintptr + deregisterEventSource uintptr + destroyPrivateObjectSecurity uintptr + duplicateEncryptionInfoFile uintptr + duplicateToken uintptr + encryptFile uintptr + encryptionDisable uintptr + equalDomainSid uintptr + equalPrefixSid uintptr + equalSid uintptr + fileEncryptionStatus uintptr + findFirstFreeAce uintptr + freeSid uintptr + getAce uintptr + getEventLogInformation uintptr + getFileSecurity uintptr + getKernelObjectSecurity uintptr + getLengthSid uintptr + getLocalManagedApplicationData uintptr + getMultipleTrusteeOperation uintptr + getMultipleTrustee uintptr + getNumberOfEventLogRecords uintptr + getOldestEventLogRecord uintptr + getPrivateObjectSecurity uintptr + getSecurityDescriptorControl uintptr + getSecurityDescriptorGroup uintptr + getSecurityDescriptorLength uintptr + getSecurityDescriptorOwner uintptr + getSecurityDescriptorRMControl uintptr + getServiceDisplayName uintptr + getServiceKeyName uintptr + getSidIdentifierAuthority uintptr + getSidLengthRequired uintptr + getSidSubAuthority uintptr + getSidSubAuthorityCount uintptr + getTrusteeForm uintptr + getTrusteeName uintptr + getTrusteeType uintptr + getUserName uintptr + getWindowsAccountDomainSid uintptr + impersonateAnonymousToken uintptr + impersonateLoggedOnUser uintptr + impersonateNamedPipeClient uintptr + impersonateSelf uintptr + initializeAcl uintptr + initializeSecurityDescriptor uintptr + initializeSid uintptr + initiateShutdown uintptr + initiateSystemShutdownEx uintptr + initiateSystemShutdown uintptr + isTextUnicode uintptr + isTokenRestricted uintptr + isTokenUntrusted uintptr + isValidAcl uintptr + isValidSecurityDescriptor uintptr + isValidSid uintptr + lockServiceDatabase uintptr + logonUser uintptr + lookupPrivilegeDisplayName uintptr + lookupPrivilegeName uintptr + lookupPrivilegeValue uintptr + makeAbsoluteSD uintptr + makeSelfRelativeSD uintptr + mapGenericMask uintptr + notifyBootConfigStatus uintptr + notifyChangeEventLog uintptr + objectCloseAuditAlarm uintptr + objectDeleteAuditAlarm uintptr + objectOpenAuditAlarm uintptr + objectPrivilegeAuditAlarm uintptr + openBackupEventLog uintptr + openEncryptedFileRaw uintptr + openEventLog uintptr + openProcessToken uintptr + openSCManager uintptr + openService uintptr + openThreadToken uintptr + perfCreateInstance uintptr + perfDecrementULongCounterValue uintptr + perfDecrementULongLongCounterValue uintptr + perfDeleteInstance uintptr + perfIncrementULongCounterValue uintptr + perfIncrementULongLongCounterValue uintptr + perfQueryInstance uintptr + perfSetCounterRefValue uintptr + perfSetULongCounterValue uintptr + perfSetULongLongCounterValue uintptr + perfStopProvider uintptr + privilegeCheck uintptr + privilegedServiceAuditAlarm uintptr + querySecurityAccessMask uintptr + queryServiceConfig2 uintptr + queryServiceObjectSecurity uintptr + queryServiceStatus uintptr + readEventLog uintptr + regCloseKey uintptr + regConnectRegistryEx uintptr + regConnectRegistry uintptr + regCopyTree uintptr + regCreateKeyEx uintptr + regCreateKeyTransacted uintptr + regCreateKey uintptr + regDeleteKeyEx uintptr + regDeleteKeyTransacted uintptr + regDeleteKeyValue uintptr + regDeleteKey uintptr + regDeleteTree uintptr + regDeleteValue uintptr + regDisablePredefinedCache uintptr + regDisablePredefinedCacheEx uintptr + regDisableReflectionKey uintptr + regEnableReflectionKey uintptr + regEnumKey uintptr + regEnumValue uintptr + regFlushKey uintptr + regGetKeySecurity uintptr + regGetValue uintptr + regLoadAppKey uintptr + regLoadKey uintptr + regLoadMUIString uintptr + regNotifyChangeKeyValue uintptr + regOpenCurrentUser uintptr + regOpenKeyEx uintptr + regOpenKeyTransacted uintptr + regOpenKey uintptr + regOpenUserClassesRoot uintptr + regOverridePredefKey uintptr + regQueryReflectionKey uintptr + regQueryValueEx uintptr + regQueryValue uintptr + regReplaceKey uintptr + regRestoreKey uintptr + regSaveKeyEx uintptr + regSaveKey uintptr + regSetKeySecurity uintptr + regSetKeyValue uintptr + regSetValueEx uintptr + regSetValue uintptr + regUnLoadKey uintptr + registerEventSource uintptr + registerServiceCtrlHandlerEx uintptr + reportEvent uintptr + revertToSelf uintptr + saferCloseLevel uintptr + saferComputeTokenFromLevel uintptr + saferCreateLevel uintptr + saferRecordEventLogEntry uintptr + saferiIsExecutableFileType uintptr + setFileSecurity uintptr + setKernelObjectSecurity uintptr + setNamedSecurityInfo uintptr + setPrivateObjectSecurity uintptr + setPrivateObjectSecurityEx uintptr + setSecurityAccessMask uintptr + setSecurityDescriptorControl uintptr + setSecurityDescriptorDacl uintptr + setSecurityDescriptorGroup uintptr + setSecurityDescriptorOwner uintptr + setSecurityDescriptorRMControl uintptr + setSecurityDescriptorSacl uintptr + setSecurityInfo uintptr + setServiceBits uintptr + setServiceObjectSecurity uintptr + setServiceStatus uintptr + setThreadToken uintptr + setUserFileEncryptionKey uintptr + startService uintptr + uninstallApplication uintptr + unlockServiceDatabase uintptr + wow64Win32ApiEntry uintptr + eventActivityIdControl uintptr + lsaNtStatusToWinError uintptr + systemFunction001 uintptr + systemFunction002 uintptr + systemFunction003 uintptr + systemFunction006 uintptr + systemFunction008 uintptr + systemFunction009 uintptr + systemFunction010 uintptr + systemFunction012 uintptr + systemFunction013 uintptr + systemFunction024 uintptr + systemFunction025 uintptr + systemFunction030 uintptr + systemFunction035 uintptr + systemFunction036 uintptr + systemFunction040 uintptr + systemFunction041 uintptr +) + +func init() { + // Library + libadvapi32 = doLoadLibrary("advapi32.dll") + + // Functions + abortSystemShutdown = doGetProcAddress(libadvapi32, "AbortSystemShutdownW") + accessCheck = doGetProcAddress(libadvapi32, "AccessCheck") + accessCheckAndAuditAlarm = doGetProcAddress(libadvapi32, "AccessCheckAndAuditAlarmW") + accessCheckByType = doGetProcAddress(libadvapi32, "AccessCheckByType") + accessCheckByTypeResultList = doGetProcAddress(libadvapi32, "AccessCheckByTypeResultList") + addAccessAllowedAce = doGetProcAddress(libadvapi32, "AddAccessAllowedAce") + addAccessAllowedAceEx = doGetProcAddress(libadvapi32, "AddAccessAllowedAceEx") + addAccessAllowedObjectAce = doGetProcAddress(libadvapi32, "AddAccessAllowedObjectAce") + addAccessDeniedAce = doGetProcAddress(libadvapi32, "AddAccessDeniedAce") + addAccessDeniedAceEx = doGetProcAddress(libadvapi32, "AddAccessDeniedAceEx") + addAccessDeniedObjectAce = doGetProcAddress(libadvapi32, "AddAccessDeniedObjectAce") + addAce = doGetProcAddress(libadvapi32, "AddAce") + addAuditAccessAce = doGetProcAddress(libadvapi32, "AddAuditAccessAce") + addAuditAccessAceEx = doGetProcAddress(libadvapi32, "AddAuditAccessAceEx") + addAuditAccessObjectAce = doGetProcAddress(libadvapi32, "AddAuditAccessObjectAce") + addConditionalAce = doGetProcAddress(libadvapi32, "AddConditionalAce") + addMandatoryAce = doGetProcAddress(libadvapi32, "AddMandatoryAce") + addUsersToEncryptedFile = doGetProcAddress(libadvapi32, "AddUsersToEncryptedFile") + adjustTokenGroups = doGetProcAddress(libadvapi32, "AdjustTokenGroups") + adjustTokenPrivileges = doGetProcAddress(libadvapi32, "AdjustTokenPrivileges") + allocateAndInitializeSid = doGetProcAddress(libadvapi32, "AllocateAndInitializeSid") + allocateLocallyUniqueId = doGetProcAddress(libadvapi32, "AllocateLocallyUniqueId") + areAllAccessesGranted = doGetProcAddress(libadvapi32, "AreAllAccessesGranted") + areAnyAccessesGranted = doGetProcAddress(libadvapi32, "AreAnyAccessesGranted") + auditComputeEffectivePolicyBySid = doGetProcAddress(libadvapi32, "AuditComputeEffectivePolicyBySid") + auditComputeEffectivePolicyByToken = doGetProcAddress(libadvapi32, "AuditComputeEffectivePolicyByToken") + auditEnumerateCategories = doGetProcAddress(libadvapi32, "AuditEnumerateCategories") + auditEnumeratePerUserPolicy = doGetProcAddress(libadvapi32, "AuditEnumeratePerUserPolicy") + auditEnumerateSubCategories = doGetProcAddress(libadvapi32, "AuditEnumerateSubCategories") + auditFree = doGetProcAddress(libadvapi32, "AuditFree") + auditLookupCategoryGuidFromCategoryId = doGetProcAddress(libadvapi32, "AuditLookupCategoryGuidFromCategoryId") + auditLookupCategoryIdFromCategoryGuid = doGetProcAddress(libadvapi32, "AuditLookupCategoryIdFromCategoryGuid") + auditLookupCategoryName = doGetProcAddress(libadvapi32, "AuditLookupCategoryNameW") + auditLookupSubCategoryName = doGetProcAddress(libadvapi32, "AuditLookupSubCategoryNameW") + auditQueryPerUserPolicy = doGetProcAddress(libadvapi32, "AuditQueryPerUserPolicy") + auditQuerySecurity = doGetProcAddress(libadvapi32, "AuditQuerySecurity") + auditQuerySystemPolicy = doGetProcAddress(libadvapi32, "AuditQuerySystemPolicy") + auditSetPerUserPolicy = doGetProcAddress(libadvapi32, "AuditSetPerUserPolicy") + auditSetSecurity = doGetProcAddress(libadvapi32, "AuditSetSecurity") + auditSetSystemPolicy = doGetProcAddress(libadvapi32, "AuditSetSystemPolicy") + backupEventLog = doGetProcAddress(libadvapi32, "BackupEventLogW") + buildExplicitAccessWithName = doGetProcAddress(libadvapi32, "BuildExplicitAccessWithNameW") + buildImpersonateExplicitAccessWithName = doGetProcAddress(libadvapi32, "BuildImpersonateExplicitAccessWithNameW") + buildImpersonateTrustee = doGetProcAddress(libadvapi32, "BuildImpersonateTrusteeW") + buildSecurityDescriptor = doGetProcAddress(libadvapi32, "BuildSecurityDescriptorW") + buildTrusteeWithName = doGetProcAddress(libadvapi32, "BuildTrusteeWithNameW") + buildTrusteeWithObjectsAndName = doGetProcAddress(libadvapi32, "BuildTrusteeWithObjectsAndNameW") + buildTrusteeWithObjectsAndSid = doGetProcAddress(libadvapi32, "BuildTrusteeWithObjectsAndSidW") + buildTrusteeWithSid = doGetProcAddress(libadvapi32, "BuildTrusteeWithSidW") + changeServiceConfig2 = doGetProcAddress(libadvapi32, "ChangeServiceConfig2W") + changeServiceConfig = doGetProcAddress(libadvapi32, "ChangeServiceConfigW") + checkTokenMembership = doGetProcAddress(libadvapi32, "CheckTokenMembership") + clearEventLog = doGetProcAddress(libadvapi32, "ClearEventLogW") + closeEncryptedFileRaw = doGetProcAddress(libadvapi32, "CloseEncryptedFileRaw") + closeEventLog = doGetProcAddress(libadvapi32, "CloseEventLog") + closeServiceHandle = doGetProcAddress(libadvapi32, "CloseServiceHandle") + closeThreadWaitChainSession = doGetProcAddress(libadvapi32, "CloseThreadWaitChainSession") + commandLineFromMsiDescriptor = doGetProcAddress(libadvapi32, "CommandLineFromMsiDescriptor") + controlService = doGetProcAddress(libadvapi32, "ControlService") + controlServiceEx = doGetProcAddress(libadvapi32, "ControlServiceExW") + convertSecurityDescriptorToStringSecurityDescriptor = doGetProcAddress(libadvapi32, "ConvertSecurityDescriptorToStringSecurityDescriptorW") + convertSidToStringSid = doGetProcAddress(libadvapi32, "ConvertSidToStringSidW") + convertStringSecurityDescriptorToSecurityDescriptor = doGetProcAddress(libadvapi32, "ConvertStringSecurityDescriptorToSecurityDescriptorW") + convertStringSidToSid = doGetProcAddress(libadvapi32, "ConvertStringSidToSidW") + convertToAutoInheritPrivateObjectSecurity = doGetProcAddress(libadvapi32, "ConvertToAutoInheritPrivateObjectSecurity") + copySid = doGetProcAddress(libadvapi32, "CopySid") + createPrivateObjectSecurity = doGetProcAddress(libadvapi32, "CreatePrivateObjectSecurity") + createPrivateObjectSecurityEx = doGetProcAddress(libadvapi32, "CreatePrivateObjectSecurityEx") + createPrivateObjectSecurityWithMultipleInheritance = doGetProcAddress(libadvapi32, "CreatePrivateObjectSecurityWithMultipleInheritance") + createProcessAsUser = doGetProcAddress(libadvapi32, "CreateProcessAsUserW") + createProcessWithLogonW = doGetProcAddress(libadvapi32, "CreateProcessWithLogonW") + createProcessWithTokenW = doGetProcAddress(libadvapi32, "CreateProcessWithTokenW") + createService = doGetProcAddress(libadvapi32, "CreateServiceW") + credDelete = doGetProcAddress(libadvapi32, "CredDeleteW") + credEnumerate = doGetProcAddress(libadvapi32, "CredEnumerateW") + credFree = doGetProcAddress(libadvapi32, "CredFree") + credGetSessionTypes = doGetProcAddress(libadvapi32, "CredGetSessionTypes") + credIsMarshaledCredential = doGetProcAddress(libadvapi32, "CredIsMarshaledCredentialW") + credRename = doGetProcAddress(libadvapi32, "CredRenameW") + credUnprotect = doGetProcAddress(libadvapi32, "CredUnprotectW") + credWrite = doGetProcAddress(libadvapi32, "CredWriteW") + cryptAcquireContext = doGetProcAddress(libadvapi32, "CryptAcquireContextW") + cryptContextAddRef = doGetProcAddress(libadvapi32, "CryptContextAddRef") + cryptCreateHash = doGetProcAddress(libadvapi32, "CryptCreateHash") + cryptDecrypt = doGetProcAddress(libadvapi32, "CryptDecrypt") + cryptDeriveKey = doGetProcAddress(libadvapi32, "CryptDeriveKey") + cryptDestroyHash = doGetProcAddress(libadvapi32, "CryptDestroyHash") + cryptDestroyKey = doGetProcAddress(libadvapi32, "CryptDestroyKey") + cryptDuplicateHash = doGetProcAddress(libadvapi32, "CryptDuplicateHash") + cryptDuplicateKey = doGetProcAddress(libadvapi32, "CryptDuplicateKey") + cryptEncrypt = doGetProcAddress(libadvapi32, "CryptEncrypt") + cryptEnumProviderTypes = doGetProcAddress(libadvapi32, "CryptEnumProviderTypesW") + cryptEnumProviders = doGetProcAddress(libadvapi32, "CryptEnumProvidersW") + cryptExportKey = doGetProcAddress(libadvapi32, "CryptExportKey") + cryptGenKey = doGetProcAddress(libadvapi32, "CryptGenKey") + cryptGenRandom = doGetProcAddress(libadvapi32, "CryptGenRandom") + cryptGetDefaultProvider = doGetProcAddress(libadvapi32, "CryptGetDefaultProviderW") + cryptGetHashParam = doGetProcAddress(libadvapi32, "CryptGetHashParam") + cryptGetKeyParam = doGetProcAddress(libadvapi32, "CryptGetKeyParam") + cryptGetProvParam = doGetProcAddress(libadvapi32, "CryptGetProvParam") + cryptGetUserKey = doGetProcAddress(libadvapi32, "CryptGetUserKey") + cryptHashData = doGetProcAddress(libadvapi32, "CryptHashData") + cryptHashSessionKey = doGetProcAddress(libadvapi32, "CryptHashSessionKey") + cryptImportKey = doGetProcAddress(libadvapi32, "CryptImportKey") + cryptReleaseContext = doGetProcAddress(libadvapi32, "CryptReleaseContext") + cryptSetHashParam = doGetProcAddress(libadvapi32, "CryptSetHashParam") + cryptSetKeyParam = doGetProcAddress(libadvapi32, "CryptSetKeyParam") + cryptSetProvParam = doGetProcAddress(libadvapi32, "CryptSetProvParam") + cryptSetProviderEx = doGetProcAddress(libadvapi32, "CryptSetProviderExW") + cryptSetProvider = doGetProcAddress(libadvapi32, "CryptSetProviderW") + cryptSignHash = doGetProcAddress(libadvapi32, "CryptSignHashW") + cryptVerifySignature = doGetProcAddress(libadvapi32, "CryptVerifySignatureW") + decryptFile = doGetProcAddress(libadvapi32, "DecryptFileW") + deleteAce = doGetProcAddress(libadvapi32, "DeleteAce") + deleteService = doGetProcAddress(libadvapi32, "DeleteService") + deregisterEventSource = doGetProcAddress(libadvapi32, "DeregisterEventSource") + destroyPrivateObjectSecurity = doGetProcAddress(libadvapi32, "DestroyPrivateObjectSecurity") + duplicateEncryptionInfoFile = doGetProcAddress(libadvapi32, "DuplicateEncryptionInfoFile") + duplicateToken = doGetProcAddress(libadvapi32, "DuplicateToken") + encryptFile = doGetProcAddress(libadvapi32, "EncryptFileW") + encryptionDisable = doGetProcAddress(libadvapi32, "EncryptionDisable") + equalDomainSid = doGetProcAddress(libadvapi32, "EqualDomainSid") + equalPrefixSid = doGetProcAddress(libadvapi32, "EqualPrefixSid") + equalSid = doGetProcAddress(libadvapi32, "EqualSid") + fileEncryptionStatus = doGetProcAddress(libadvapi32, "FileEncryptionStatusW") + findFirstFreeAce = doGetProcAddress(libadvapi32, "FindFirstFreeAce") + freeSid = doGetProcAddress(libadvapi32, "FreeSid") + getAce = doGetProcAddress(libadvapi32, "GetAce") + getEventLogInformation = doGetProcAddress(libadvapi32, "GetEventLogInformation") + getFileSecurity = doGetProcAddress(libadvapi32, "GetFileSecurityW") + getKernelObjectSecurity = doGetProcAddress(libadvapi32, "GetKernelObjectSecurity") + getLengthSid = doGetProcAddress(libadvapi32, "GetLengthSid") + getLocalManagedApplicationData = doGetProcAddress(libadvapi32, "GetLocalManagedApplicationData") + getMultipleTrusteeOperation = doGetProcAddress(libadvapi32, "GetMultipleTrusteeOperationW") + getMultipleTrustee = doGetProcAddress(libadvapi32, "GetMultipleTrusteeW") + getNumberOfEventLogRecords = doGetProcAddress(libadvapi32, "GetNumberOfEventLogRecords") + getOldestEventLogRecord = doGetProcAddress(libadvapi32, "GetOldestEventLogRecord") + getPrivateObjectSecurity = doGetProcAddress(libadvapi32, "GetPrivateObjectSecurity") + getSecurityDescriptorControl = doGetProcAddress(libadvapi32, "GetSecurityDescriptorControl") + getSecurityDescriptorGroup = doGetProcAddress(libadvapi32, "GetSecurityDescriptorGroup") + getSecurityDescriptorLength = doGetProcAddress(libadvapi32, "GetSecurityDescriptorLength") + getSecurityDescriptorOwner = doGetProcAddress(libadvapi32, "GetSecurityDescriptorOwner") + getSecurityDescriptorRMControl = doGetProcAddress(libadvapi32, "GetSecurityDescriptorRMControl") + getServiceDisplayName = doGetProcAddress(libadvapi32, "GetServiceDisplayNameW") + getServiceKeyName = doGetProcAddress(libadvapi32, "GetServiceKeyNameW") + getSidIdentifierAuthority = doGetProcAddress(libadvapi32, "GetSidIdentifierAuthority") + getSidLengthRequired = doGetProcAddress(libadvapi32, "GetSidLengthRequired") + getSidSubAuthority = doGetProcAddress(libadvapi32, "GetSidSubAuthority") + getSidSubAuthorityCount = doGetProcAddress(libadvapi32, "GetSidSubAuthorityCount") + getTrusteeForm = doGetProcAddress(libadvapi32, "GetTrusteeFormW") + getTrusteeName = doGetProcAddress(libadvapi32, "GetTrusteeNameW") + getTrusteeType = doGetProcAddress(libadvapi32, "GetTrusteeTypeW") + getUserName = doGetProcAddress(libadvapi32, "GetUserNameW") + getWindowsAccountDomainSid = doGetProcAddress(libadvapi32, "GetWindowsAccountDomainSid") + impersonateAnonymousToken = doGetProcAddress(libadvapi32, "ImpersonateAnonymousToken") + impersonateLoggedOnUser = doGetProcAddress(libadvapi32, "ImpersonateLoggedOnUser") + impersonateNamedPipeClient = doGetProcAddress(libadvapi32, "ImpersonateNamedPipeClient") + impersonateSelf = doGetProcAddress(libadvapi32, "ImpersonateSelf") + initializeAcl = doGetProcAddress(libadvapi32, "InitializeAcl") + initializeSecurityDescriptor = doGetProcAddress(libadvapi32, "InitializeSecurityDescriptor") + initializeSid = doGetProcAddress(libadvapi32, "InitializeSid") + initiateShutdown = doGetProcAddress(libadvapi32, "InitiateShutdownW") + initiateSystemShutdownEx = doGetProcAddress(libadvapi32, "InitiateSystemShutdownExW") + initiateSystemShutdown = doGetProcAddress(libadvapi32, "InitiateSystemShutdownW") + isTextUnicode = doGetProcAddress(libadvapi32, "IsTextUnicode") + isTokenRestricted = doGetProcAddress(libadvapi32, "IsTokenRestricted") + isTokenUntrusted = doGetProcAddress(libadvapi32, "IsTokenUntrusted") + isValidAcl = doGetProcAddress(libadvapi32, "IsValidAcl") + isValidSecurityDescriptor = doGetProcAddress(libadvapi32, "IsValidSecurityDescriptor") + isValidSid = doGetProcAddress(libadvapi32, "IsValidSid") + lockServiceDatabase = doGetProcAddress(libadvapi32, "LockServiceDatabase") + logonUser = doGetProcAddress(libadvapi32, "LogonUserW") + lookupPrivilegeDisplayName = doGetProcAddress(libadvapi32, "LookupPrivilegeDisplayNameW") + lookupPrivilegeName = doGetProcAddress(libadvapi32, "LookupPrivilegeNameW") + lookupPrivilegeValue = doGetProcAddress(libadvapi32, "LookupPrivilegeValueW") + makeAbsoluteSD = doGetProcAddress(libadvapi32, "MakeAbsoluteSD") + makeSelfRelativeSD = doGetProcAddress(libadvapi32, "MakeSelfRelativeSD") + mapGenericMask = doGetProcAddress(libadvapi32, "MapGenericMask") + notifyBootConfigStatus = doGetProcAddress(libadvapi32, "NotifyBootConfigStatus") + notifyChangeEventLog = doGetProcAddress(libadvapi32, "NotifyChangeEventLog") + objectCloseAuditAlarm = doGetProcAddress(libadvapi32, "ObjectCloseAuditAlarmW") + objectDeleteAuditAlarm = doGetProcAddress(libadvapi32, "ObjectDeleteAuditAlarmW") + objectOpenAuditAlarm = doGetProcAddress(libadvapi32, "ObjectOpenAuditAlarmW") + objectPrivilegeAuditAlarm = doGetProcAddress(libadvapi32, "ObjectPrivilegeAuditAlarmW") + openBackupEventLog = doGetProcAddress(libadvapi32, "OpenBackupEventLogW") + openEncryptedFileRaw = doGetProcAddress(libadvapi32, "OpenEncryptedFileRawW") + openEventLog = doGetProcAddress(libadvapi32, "OpenEventLogW") + openProcessToken = doGetProcAddress(libadvapi32, "OpenProcessToken") + openSCManager = doGetProcAddress(libadvapi32, "OpenSCManagerW") + openService = doGetProcAddress(libadvapi32, "OpenServiceW") + openThreadToken = doGetProcAddress(libadvapi32, "OpenThreadToken") + perfCreateInstance = doGetProcAddress(libadvapi32, "PerfCreateInstance") + perfDecrementULongCounterValue = doGetProcAddress(libadvapi32, "PerfDecrementULongCounterValue") + perfDecrementULongLongCounterValue = doGetProcAddress(libadvapi32, "PerfDecrementULongLongCounterValue") + perfDeleteInstance = doGetProcAddress(libadvapi32, "PerfDeleteInstance") + perfIncrementULongCounterValue = doGetProcAddress(libadvapi32, "PerfIncrementULongCounterValue") + perfIncrementULongLongCounterValue = doGetProcAddress(libadvapi32, "PerfIncrementULongLongCounterValue") + perfQueryInstance = doGetProcAddress(libadvapi32, "PerfQueryInstance") + perfSetCounterRefValue = doGetProcAddress(libadvapi32, "PerfSetCounterRefValue") + perfSetULongCounterValue = doGetProcAddress(libadvapi32, "PerfSetULongCounterValue") + perfSetULongLongCounterValue = doGetProcAddress(libadvapi32, "PerfSetULongLongCounterValue") + perfStopProvider = doGetProcAddress(libadvapi32, "PerfStopProvider") + privilegeCheck = doGetProcAddress(libadvapi32, "PrivilegeCheck") + privilegedServiceAuditAlarm = doGetProcAddress(libadvapi32, "PrivilegedServiceAuditAlarmW") + querySecurityAccessMask = doGetProcAddress(libadvapi32, "QuerySecurityAccessMask") + queryServiceConfig2 = doGetProcAddress(libadvapi32, "QueryServiceConfig2W") + queryServiceObjectSecurity = doGetProcAddress(libadvapi32, "QueryServiceObjectSecurity") + queryServiceStatus = doGetProcAddress(libadvapi32, "QueryServiceStatus") + readEventLog = doGetProcAddress(libadvapi32, "ReadEventLogW") + regCloseKey = doGetProcAddress(libadvapi32, "RegCloseKey") + regConnectRegistryEx = doGetProcAddress(libadvapi32, "RegConnectRegistryExW") + regConnectRegistry = doGetProcAddress(libadvapi32, "RegConnectRegistryW") + regCopyTree = doGetProcAddress(libadvapi32, "RegCopyTreeW") + regCreateKeyEx = doGetProcAddress(libadvapi32, "RegCreateKeyExW") + regCreateKeyTransacted = doGetProcAddress(libadvapi32, "RegCreateKeyTransactedW") + regCreateKey = doGetProcAddress(libadvapi32, "RegCreateKeyW") + regDeleteKeyEx = doGetProcAddress(libadvapi32, "RegDeleteKeyExW") + regDeleteKeyTransacted = doGetProcAddress(libadvapi32, "RegDeleteKeyTransactedW") + regDeleteKeyValue = doGetProcAddress(libadvapi32, "RegDeleteKeyValueW") + regDeleteKey = doGetProcAddress(libadvapi32, "RegDeleteKeyW") + regDeleteTree = doGetProcAddress(libadvapi32, "RegDeleteTreeW") + regDeleteValue = doGetProcAddress(libadvapi32, "RegDeleteValueW") + regDisablePredefinedCache = doGetProcAddress(libadvapi32, "RegDisablePredefinedCache") + regDisablePredefinedCacheEx = doGetProcAddress(libadvapi32, "RegDisablePredefinedCacheEx") + regDisableReflectionKey = doGetProcAddress(libadvapi32, "RegDisableReflectionKey") + regEnableReflectionKey = doGetProcAddress(libadvapi32, "RegEnableReflectionKey") + regEnumKey = doGetProcAddress(libadvapi32, "RegEnumKeyW") + regEnumValue = doGetProcAddress(libadvapi32, "RegEnumValueW") + regFlushKey = doGetProcAddress(libadvapi32, "RegFlushKey") + regGetKeySecurity = doGetProcAddress(libadvapi32, "RegGetKeySecurity") + regGetValue = doGetProcAddress(libadvapi32, "RegGetValueW") + regLoadAppKey = doGetProcAddress(libadvapi32, "RegLoadAppKeyW") + regLoadKey = doGetProcAddress(libadvapi32, "RegLoadKeyW") + regLoadMUIString = doGetProcAddress(libadvapi32, "RegLoadMUIStringW") + regNotifyChangeKeyValue = doGetProcAddress(libadvapi32, "RegNotifyChangeKeyValue") + regOpenCurrentUser = doGetProcAddress(libadvapi32, "RegOpenCurrentUser") + regOpenKeyEx = doGetProcAddress(libadvapi32, "RegOpenKeyExW") + regOpenKeyTransacted = doGetProcAddress(libadvapi32, "RegOpenKeyTransactedW") + regOpenKey = doGetProcAddress(libadvapi32, "RegOpenKeyW") + regOpenUserClassesRoot = doGetProcAddress(libadvapi32, "RegOpenUserClassesRoot") + regOverridePredefKey = doGetProcAddress(libadvapi32, "RegOverridePredefKey") + regQueryReflectionKey = doGetProcAddress(libadvapi32, "RegQueryReflectionKey") + regQueryValueEx = doGetProcAddress(libadvapi32, "RegQueryValueExW") + regQueryValue = doGetProcAddress(libadvapi32, "RegQueryValueW") + regReplaceKey = doGetProcAddress(libadvapi32, "RegReplaceKeyW") + regRestoreKey = doGetProcAddress(libadvapi32, "RegRestoreKeyW") + regSaveKeyEx = doGetProcAddress(libadvapi32, "RegSaveKeyExW") + regSaveKey = doGetProcAddress(libadvapi32, "RegSaveKeyW") + regSetKeySecurity = doGetProcAddress(libadvapi32, "RegSetKeySecurity") + regSetKeyValue = doGetProcAddress(libadvapi32, "RegSetKeyValueW") + regSetValueEx = doGetProcAddress(libadvapi32, "RegSetValueExW") + regSetValue = doGetProcAddress(libadvapi32, "RegSetValueW") + regUnLoadKey = doGetProcAddress(libadvapi32, "RegUnLoadKeyW") + registerEventSource = doGetProcAddress(libadvapi32, "RegisterEventSourceW") + registerServiceCtrlHandlerEx = doGetProcAddress(libadvapi32, "RegisterServiceCtrlHandlerExW") + reportEvent = doGetProcAddress(libadvapi32, "ReportEventW") + revertToSelf = doGetProcAddress(libadvapi32, "RevertToSelf") + saferCloseLevel = doGetProcAddress(libadvapi32, "SaferCloseLevel") + saferComputeTokenFromLevel = doGetProcAddress(libadvapi32, "SaferComputeTokenFromLevel") + saferCreateLevel = doGetProcAddress(libadvapi32, "SaferCreateLevel") + saferRecordEventLogEntry = doGetProcAddress(libadvapi32, "SaferRecordEventLogEntry") + saferiIsExecutableFileType = doGetProcAddress(libadvapi32, "SaferiIsExecutableFileType") + setFileSecurity = doGetProcAddress(libadvapi32, "SetFileSecurityW") + setKernelObjectSecurity = doGetProcAddress(libadvapi32, "SetKernelObjectSecurity") + setNamedSecurityInfo = doGetProcAddress(libadvapi32, "SetNamedSecurityInfoW") + setPrivateObjectSecurity = doGetProcAddress(libadvapi32, "SetPrivateObjectSecurity") + setPrivateObjectSecurityEx = doGetProcAddress(libadvapi32, "SetPrivateObjectSecurityEx") + setSecurityAccessMask = doGetProcAddress(libadvapi32, "SetSecurityAccessMask") + setSecurityDescriptorControl = doGetProcAddress(libadvapi32, "SetSecurityDescriptorControl") + setSecurityDescriptorDacl = doGetProcAddress(libadvapi32, "SetSecurityDescriptorDacl") + setSecurityDescriptorGroup = doGetProcAddress(libadvapi32, "SetSecurityDescriptorGroup") + setSecurityDescriptorOwner = doGetProcAddress(libadvapi32, "SetSecurityDescriptorOwner") + setSecurityDescriptorRMControl = doGetProcAddress(libadvapi32, "SetSecurityDescriptorRMControl") + setSecurityDescriptorSacl = doGetProcAddress(libadvapi32, "SetSecurityDescriptorSacl") + setSecurityInfo = doGetProcAddress(libadvapi32, "SetSecurityInfo") + setServiceBits = doGetProcAddress(libadvapi32, "SetServiceBits") + setServiceObjectSecurity = doGetProcAddress(libadvapi32, "SetServiceObjectSecurity") + setServiceStatus = doGetProcAddress(libadvapi32, "SetServiceStatus") + setThreadToken = doGetProcAddress(libadvapi32, "SetThreadToken") + setUserFileEncryptionKey = doGetProcAddress(libadvapi32, "SetUserFileEncryptionKey") + startService = doGetProcAddress(libadvapi32, "StartServiceW") + uninstallApplication = doGetProcAddress(libadvapi32, "UninstallApplication") + unlockServiceDatabase = doGetProcAddress(libadvapi32, "UnlockServiceDatabase") + wow64Win32ApiEntry = doGetProcAddress(libadvapi32, "Wow64Win32ApiEntry") + eventActivityIdControl = doGetProcAddress(libadvapi32, "EventActivityIdControl") + lsaNtStatusToWinError = doGetProcAddress(libadvapi32, "LsaNtStatusToWinError") + systemFunction001 = doGetProcAddress(libadvapi32, "SystemFunction001") + systemFunction002 = doGetProcAddress(libadvapi32, "SystemFunction002") + systemFunction003 = doGetProcAddress(libadvapi32, "SystemFunction003") + systemFunction006 = doGetProcAddress(libadvapi32, "SystemFunction006") + systemFunction008 = doGetProcAddress(libadvapi32, "SystemFunction008") + systemFunction009 = doGetProcAddress(libadvapi32, "SystemFunction009") + systemFunction010 = doGetProcAddress(libadvapi32, "SystemFunction010") + systemFunction012 = doGetProcAddress(libadvapi32, "SystemFunction012") + systemFunction013 = doGetProcAddress(libadvapi32, "SystemFunction013") + systemFunction024 = doGetProcAddress(libadvapi32, "SystemFunction024") + systemFunction025 = doGetProcAddress(libadvapi32, "SystemFunction025") + systemFunction030 = doGetProcAddress(libadvapi32, "SystemFunction030") + systemFunction035 = doGetProcAddress(libadvapi32, "SystemFunction035") + systemFunction036 = doGetProcAddress(libadvapi32, "SystemFunction036") + systemFunction040 = doGetProcAddress(libadvapi32, "SystemFunction040") + systemFunction041 = doGetProcAddress(libadvapi32, "SystemFunction041") +} + +func AbortSystemShutdown(lpMachineName LPWSTR) bool { + ret1 := syscall3(abortSystemShutdown, 1, + uintptr(unsafe.Pointer(lpMachineName)), + 0, + 0) + return ret1 != 0 +} + +func AccessCheck(pSecurityDescriptor PSECURITY_DESCRIPTOR, clientToken HANDLE, desiredAccess DWORD, genericMapping *GENERIC_MAPPING, privilegeSet *PRIVILEGE_SET, privilegeSetLength *uint32, grantedAccess *uint32, accessStatus *BOOL) bool { + ret1 := syscall9(accessCheck, 8, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(clientToken), + uintptr(desiredAccess), + uintptr(unsafe.Pointer(genericMapping)), + uintptr(unsafe.Pointer(privilegeSet)), + uintptr(unsafe.Pointer(privilegeSetLength)), + uintptr(unsafe.Pointer(grantedAccess)), + uintptr(unsafe.Pointer(accessStatus)), + 0) + return ret1 != 0 +} + +func AccessCheckAndAuditAlarm(subsystemName string, handleId LPVOID, objectTypeName LPWSTR, objectName LPWSTR, securityDescriptor PSECURITY_DESCRIPTOR, desiredAccess DWORD, genericMapping *GENERIC_MAPPING, objectCreation bool, grantedAccess *uint32, accessStatus *BOOL, pfGenerateOnClose *BOOL) bool { + subsystemNameStr := unicode16FromString(subsystemName) + ret1 := syscall12(accessCheckAndAuditAlarm, 11, + uintptr(unsafe.Pointer(&subsystemNameStr[0])), + uintptr(unsafe.Pointer(handleId)), + uintptr(unsafe.Pointer(objectTypeName)), + uintptr(unsafe.Pointer(objectName)), + uintptr(unsafe.Pointer(securityDescriptor)), + uintptr(desiredAccess), + uintptr(unsafe.Pointer(genericMapping)), + getUintptrFromBool(objectCreation), + uintptr(unsafe.Pointer(grantedAccess)), + uintptr(unsafe.Pointer(accessStatus)), + uintptr(unsafe.Pointer(pfGenerateOnClose)), + 0) + return ret1 != 0 +} + +func AccessCheckByType(pSecurityDescriptor PSECURITY_DESCRIPTOR, principalSelfSid PSID, clientToken HANDLE, desiredAccess DWORD, objectTypeList *OBJECT_TYPE_LIST, objectTypeListLength DWORD, genericMapping *GENERIC_MAPPING, privilegeSet *PRIVILEGE_SET, privilegeSetLength *uint32, grantedAccess *uint32, accessStatus *BOOL) bool { + ret1 := syscall12(accessCheckByType, 11, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(principalSelfSid), + uintptr(clientToken), + uintptr(desiredAccess), + uintptr(unsafe.Pointer(objectTypeList)), + uintptr(objectTypeListLength), + uintptr(unsafe.Pointer(genericMapping)), + uintptr(unsafe.Pointer(privilegeSet)), + uintptr(unsafe.Pointer(privilegeSetLength)), + uintptr(unsafe.Pointer(grantedAccess)), + uintptr(unsafe.Pointer(accessStatus)), + 0) + return ret1 != 0 +} + +// TODO: Too many syscall arguments: 18 +// func AccessCheckByTypeAndAuditAlarm(subsystemName string, handleId LPVOID, objectTypeName string, objectName string, securityDescriptor PSECURITY_DESCRIPTOR, principalSelfSid PSID, desiredAccess DWORD, auditType AUDIT_EVENT_TYPE, flags DWORD, objectTypeList *OBJECT_TYPE_LIST, objectTypeListLength DWORD, genericMapping *GENERIC_MAPPING, objectCreation bool, grantedAccess *uint32, accessStatus *BOOL, pfGenerateOnClose *BOOL) bool + +func AccessCheckByTypeResultList(pSecurityDescriptor PSECURITY_DESCRIPTOR, principalSelfSid PSID, clientToken HANDLE, desiredAccess DWORD, objectTypeList *OBJECT_TYPE_LIST, objectTypeListLength DWORD, genericMapping *GENERIC_MAPPING, privilegeSet *PRIVILEGE_SET, privilegeSetLength *uint32, grantedAccessList *uint32, accessStatusList *uint32) bool { + ret1 := syscall12(accessCheckByTypeResultList, 11, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(principalSelfSid), + uintptr(clientToken), + uintptr(desiredAccess), + uintptr(unsafe.Pointer(objectTypeList)), + uintptr(objectTypeListLength), + uintptr(unsafe.Pointer(genericMapping)), + uintptr(unsafe.Pointer(privilegeSet)), + uintptr(unsafe.Pointer(privilegeSetLength)), + uintptr(unsafe.Pointer(grantedAccessList)), + uintptr(unsafe.Pointer(accessStatusList)), + 0) + return ret1 != 0 +} + +// TODO: Too many syscall arguments: 18 +// func AccessCheckByTypeResultListAndAuditAlarmByHandle(subsystemName string, handleId LPVOID, clientToken HANDLE, objectTypeName string, objectName string, securityDescriptor PSECURITY_DESCRIPTOR, principalSelfSid PSID, desiredAccess DWORD, auditType AUDIT_EVENT_TYPE, flags DWORD, objectTypeList *OBJECT_TYPE_LIST, objectTypeListLength DWORD, genericMapping *GENERIC_MAPPING, objectCreation bool, grantedAccessList *uint32, accessStatusList *uint32, pfGenerateOnClose *BOOL) bool + +// TODO: Too many syscall arguments: 18 +// func AccessCheckByTypeResultListAndAuditAlarm(subsystemName string, handleId LPVOID, objectTypeName string, objectName string, securityDescriptor PSECURITY_DESCRIPTOR, principalSelfSid PSID, desiredAccess DWORD, auditType AUDIT_EVENT_TYPE, flags DWORD, objectTypeList *OBJECT_TYPE_LIST, objectTypeListLength DWORD, genericMapping *GENERIC_MAPPING, objectCreation bool, grantedAccessList *uint32, accessStatusList *uint32, pfGenerateOnClose *BOOL) bool + +func AddAccessAllowedAce(pAcl *ACL, dwAceRevision DWORD, accessMask DWORD, pSid PSID) bool { + ret1 := syscall6(addAccessAllowedAce, 4, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceRevision), + uintptr(accessMask), + uintptr(pSid), + 0, + 0) + return ret1 != 0 +} + +func AddAccessAllowedAceEx(pAcl *ACL, dwAceRevision DWORD, aceFlags DWORD, accessMask DWORD, pSid PSID) bool { + ret1 := syscall6(addAccessAllowedAceEx, 5, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceRevision), + uintptr(aceFlags), + uintptr(accessMask), + uintptr(pSid), + 0) + return ret1 != 0 +} + +func AddAccessAllowedObjectAce(pAcl *ACL, dwAceRevision DWORD, aceFlags DWORD, accessMask DWORD, objectTypeGuid *GUID, inheritedObjectTypeGuid *GUID, pSid PSID) bool { + ret1 := syscall9(addAccessAllowedObjectAce, 7, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceRevision), + uintptr(aceFlags), + uintptr(accessMask), + uintptr(unsafe.Pointer(objectTypeGuid)), + uintptr(unsafe.Pointer(inheritedObjectTypeGuid)), + uintptr(pSid), + 0, + 0) + return ret1 != 0 +} + +func AddAccessDeniedAce(pAcl *ACL, dwAceRevision DWORD, accessMask DWORD, pSid PSID) bool { + ret1 := syscall6(addAccessDeniedAce, 4, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceRevision), + uintptr(accessMask), + uintptr(pSid), + 0, + 0) + return ret1 != 0 +} + +func AddAccessDeniedAceEx(pAcl *ACL, dwAceRevision DWORD, aceFlags DWORD, accessMask DWORD, pSid PSID) bool { + ret1 := syscall6(addAccessDeniedAceEx, 5, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceRevision), + uintptr(aceFlags), + uintptr(accessMask), + uintptr(pSid), + 0) + return ret1 != 0 +} + +func AddAccessDeniedObjectAce(pAcl *ACL, dwAceRevision DWORD, aceFlags DWORD, accessMask DWORD, objectTypeGuid *GUID, inheritedObjectTypeGuid *GUID, pSid PSID) bool { + ret1 := syscall9(addAccessDeniedObjectAce, 7, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceRevision), + uintptr(aceFlags), + uintptr(accessMask), + uintptr(unsafe.Pointer(objectTypeGuid)), + uintptr(unsafe.Pointer(inheritedObjectTypeGuid)), + uintptr(pSid), + 0, + 0) + return ret1 != 0 +} + +func AddAce(pAcl *ACL, dwAceRevision DWORD, dwStartingAceIndex DWORD, pAceList LPVOID, nAceListLength DWORD) bool { + ret1 := syscall6(addAce, 5, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceRevision), + uintptr(dwStartingAceIndex), + uintptr(unsafe.Pointer(pAceList)), + uintptr(nAceListLength), + 0) + return ret1 != 0 +} + +func AddAuditAccessAce(pAcl *ACL, dwAceRevision DWORD, dwAccessMask DWORD, pSid PSID, bAuditSuccess bool, bAuditFailure bool) bool { + ret1 := syscall6(addAuditAccessAce, 6, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceRevision), + uintptr(dwAccessMask), + uintptr(pSid), + getUintptrFromBool(bAuditSuccess), + getUintptrFromBool(bAuditFailure)) + return ret1 != 0 +} + +func AddAuditAccessAceEx(pAcl *ACL, dwAceRevision DWORD, aceFlags DWORD, dwAccessMask DWORD, pSid PSID, bAuditSuccess bool, bAuditFailure bool) bool { + ret1 := syscall9(addAuditAccessAceEx, 7, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceRevision), + uintptr(aceFlags), + uintptr(dwAccessMask), + uintptr(pSid), + getUintptrFromBool(bAuditSuccess), + getUintptrFromBool(bAuditFailure), + 0, + 0) + return ret1 != 0 +} + +func AddAuditAccessObjectAce(pAcl *ACL, dwAceRevision DWORD, aceFlags DWORD, accessMask DWORD, objectTypeGuid *GUID, inheritedObjectTypeGuid *GUID, pSid PSID, bAuditSuccess bool, bAuditFailure bool) bool { + ret1 := syscall9(addAuditAccessObjectAce, 9, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceRevision), + uintptr(aceFlags), + uintptr(accessMask), + uintptr(unsafe.Pointer(objectTypeGuid)), + uintptr(unsafe.Pointer(inheritedObjectTypeGuid)), + uintptr(pSid), + getUintptrFromBool(bAuditSuccess), + getUintptrFromBool(bAuditFailure)) + return ret1 != 0 +} + +func AddConditionalAce(pAcl *ACL, dwAceRevision DWORD, aceFlags DWORD, aceType UCHAR, accessMask DWORD, pSid PSID, conditionStr PWCHAR, returnLength *uint32) bool { + ret1 := syscall9(addConditionalAce, 8, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceRevision), + uintptr(aceFlags), + uintptr(aceType), + uintptr(accessMask), + uintptr(pSid), + uintptr(unsafe.Pointer(conditionStr)), + uintptr(unsafe.Pointer(returnLength)), + 0) + return ret1 != 0 +} + +func AddMandatoryAce(pAcl *ACL, dwAceRevision DWORD, aceFlags DWORD, mandatoryPolicy DWORD, pLabelSid PSID) bool { + ret1 := syscall6(addMandatoryAce, 5, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceRevision), + uintptr(aceFlags), + uintptr(mandatoryPolicy), + uintptr(pLabelSid), + 0) + return ret1 != 0 +} + +func AddUsersToEncryptedFile(lpFileName string, pUsers *ENCRYPTION_CERTIFICATE_LIST) DWORD { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(addUsersToEncryptedFile, 2, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(unsafe.Pointer(pUsers)), + 0) + return DWORD(ret1) +} + +func AdjustTokenGroups(tokenHandle HANDLE, resetToDefault bool, newState *TOKEN_GROUPS, bufferLength DWORD, previousState *TOKEN_GROUPS, returnLength *DWORD) bool { + ret1 := syscall6(adjustTokenGroups, 6, + uintptr(tokenHandle), + getUintptrFromBool(resetToDefault), + uintptr(unsafe.Pointer(newState)), + uintptr(bufferLength), + uintptr(unsafe.Pointer(previousState)), + uintptr(unsafe.Pointer(returnLength))) + return ret1 != 0 +} + +func AdjustTokenPrivileges(tokenHandle HANDLE, disableAllPrivileges bool, newState *TOKEN_PRIVILEGES, bufferLength DWORD, previousState *TOKEN_PRIVILEGES, returnLength *DWORD) bool { + ret1 := syscall6(adjustTokenPrivileges, 6, + uintptr(tokenHandle), + getUintptrFromBool(disableAllPrivileges), + uintptr(unsafe.Pointer(newState)), + uintptr(bufferLength), + uintptr(unsafe.Pointer(previousState)), + uintptr(unsafe.Pointer(returnLength))) + return ret1 != 0 +} + +func AllocateAndInitializeSid(pIdentifierAuthority *SID_IDENTIFIER_AUTHORITY, nSubAuthorityCount BYTE, nSubAuthority0 DWORD, nSubAuthority1 DWORD, nSubAuthority2 DWORD, nSubAuthority3 DWORD, nSubAuthority4 DWORD, nSubAuthority5 DWORD, nSubAuthority6 DWORD, nSubAuthority7 DWORD, pSid *PSID) bool { + ret1 := syscall12(allocateAndInitializeSid, 11, + uintptr(unsafe.Pointer(pIdentifierAuthority)), + uintptr(nSubAuthorityCount), + uintptr(nSubAuthority0), + uintptr(nSubAuthority1), + uintptr(nSubAuthority2), + uintptr(nSubAuthority3), + uintptr(nSubAuthority4), + uintptr(nSubAuthority5), + uintptr(nSubAuthority6), + uintptr(nSubAuthority7), + uintptr(unsafe.Pointer(pSid)), + 0) + return ret1 != 0 +} + +func AllocateLocallyUniqueId(luid *LUID) bool { + ret1 := syscall3(allocateLocallyUniqueId, 1, + uintptr(unsafe.Pointer(luid)), + 0, + 0) + return ret1 != 0 +} + +func AreAllAccessesGranted(grantedAccess DWORD, desiredAccess DWORD) bool { + ret1 := syscall3(areAllAccessesGranted, 2, + uintptr(grantedAccess), + uintptr(desiredAccess), + 0) + return ret1 != 0 +} + +func AreAnyAccessesGranted(grantedAccess DWORD, desiredAccess DWORD) bool { + ret1 := syscall3(areAnyAccessesGranted, 2, + uintptr(grantedAccess), + uintptr(desiredAccess), + 0) + return ret1 != 0 +} + +func AuditComputeEffectivePolicyBySid(pSid /*const*/ PSID, pSubCategoryGuids /*const*/ *GUID, policyCount ULONG, ppAuditPolicy *PAUDIT_POLICY_INFORMATION) BOOLEAN { + ret1 := syscall6(auditComputeEffectivePolicyBySid, 4, + uintptr(pSid), + uintptr(unsafe.Pointer(pSubCategoryGuids)), + uintptr(policyCount), + uintptr(unsafe.Pointer(ppAuditPolicy)), + 0, + 0) + return BOOLEAN(ret1) +} + +func AuditComputeEffectivePolicyByToken(hTokenHandle HANDLE, pSubCategoryGuids /*const*/ *GUID, policyCount ULONG, ppAuditPolicy *PAUDIT_POLICY_INFORMATION) BOOLEAN { + ret1 := syscall6(auditComputeEffectivePolicyByToken, 4, + uintptr(hTokenHandle), + uintptr(unsafe.Pointer(pSubCategoryGuids)), + uintptr(policyCount), + uintptr(unsafe.Pointer(ppAuditPolicy)), + 0, + 0) + return BOOLEAN(ret1) +} + +func AuditEnumerateCategories(ppAuditCategoriesArray uintptr, pCountReturned *uint32) BOOLEAN { + ret1 := syscall3(auditEnumerateCategories, 2, + ppAuditCategoriesArray, + uintptr(unsafe.Pointer(pCountReturned)), + 0) + return BOOLEAN(ret1) +} + +func AuditEnumeratePerUserPolicy(ppAuditSidArray *PPOLICY_AUDIT_SID_ARRAY) BOOLEAN { + ret1 := syscall3(auditEnumeratePerUserPolicy, 1, + uintptr(unsafe.Pointer(ppAuditSidArray)), + 0, + 0) + return BOOLEAN(ret1) +} + +func AuditEnumerateSubCategories(pAuditCategoryGuid /*const*/ *GUID, bRetrieveAllSubCategories BOOLEAN, ppAuditSubCategoriesArray uintptr, pCountReturned *uint32) BOOLEAN { + ret1 := syscall6(auditEnumerateSubCategories, 4, + uintptr(unsafe.Pointer(pAuditCategoryGuid)), + uintptr(bRetrieveAllSubCategories), + ppAuditSubCategoriesArray, + uintptr(unsafe.Pointer(pCountReturned)), + 0, + 0) + return BOOLEAN(ret1) +} + +func AuditFree(buffer uintptr) { + syscall3(auditFree, 1, + buffer, + 0, + 0) +} + +func AuditLookupCategoryGuidFromCategoryId(auditCategoryId POLICY_AUDIT_EVENT_TYPE, pAuditCategoryGuid *GUID) BOOLEAN { + ret1 := syscall3(auditLookupCategoryGuidFromCategoryId, 2, + uintptr(auditCategoryId), + uintptr(unsafe.Pointer(pAuditCategoryGuid)), + 0) + return BOOLEAN(ret1) +} + +func AuditLookupCategoryIdFromCategoryGuid(pAuditCategoryGuid /*const*/ *GUID, pAuditCategoryId PPOLICY_AUDIT_EVENT_TYPE) BOOLEAN { + ret1 := syscall3(auditLookupCategoryIdFromCategoryGuid, 2, + uintptr(unsafe.Pointer(pAuditCategoryGuid)), + uintptr(unsafe.Pointer(pAuditCategoryId)), + 0) + return BOOLEAN(ret1) +} + +func AuditLookupCategoryName(pAuditCategoryGuid /*const*/ *GUID, ppszCategoryName *LPWSTR) BOOLEAN { + ret1 := syscall3(auditLookupCategoryName, 2, + uintptr(unsafe.Pointer(pAuditCategoryGuid)), + uintptr(unsafe.Pointer(ppszCategoryName)), + 0) + return BOOLEAN(ret1) +} + +func AuditLookupSubCategoryName(pAuditSubCategoryGuid /*const*/ *GUID, ppszSubCategoryName *LPWSTR) BOOLEAN { + ret1 := syscall3(auditLookupSubCategoryName, 2, + uintptr(unsafe.Pointer(pAuditSubCategoryGuid)), + uintptr(unsafe.Pointer(ppszSubCategoryName)), + 0) + return BOOLEAN(ret1) +} + +func AuditQueryPerUserPolicy(pSid /*const*/ PSID, pSubCategoryGuids /*const*/ *GUID, policyCount ULONG, ppAuditPolicy *PAUDIT_POLICY_INFORMATION) BOOLEAN { + ret1 := syscall6(auditQueryPerUserPolicy, 4, + uintptr(pSid), + uintptr(unsafe.Pointer(pSubCategoryGuids)), + uintptr(policyCount), + uintptr(unsafe.Pointer(ppAuditPolicy)), + 0, + 0) + return BOOLEAN(ret1) +} + +func AuditQuerySecurity(securityInformation SECURITY_INFORMATION, ppSecurityDescriptor *PSECURITY_DESCRIPTOR) BOOLEAN { + ret1 := syscall3(auditQuerySecurity, 2, + uintptr(securityInformation), + uintptr(unsafe.Pointer(ppSecurityDescriptor)), + 0) + return BOOLEAN(ret1) +} + +func AuditQuerySystemPolicy(pSubCategoryGuids /*const*/ *GUID, policyCount ULONG, ppAuditPolicy *PAUDIT_POLICY_INFORMATION) BOOLEAN { + ret1 := syscall3(auditQuerySystemPolicy, 3, + uintptr(unsafe.Pointer(pSubCategoryGuids)), + uintptr(policyCount), + uintptr(unsafe.Pointer(ppAuditPolicy))) + return BOOLEAN(ret1) +} + +func AuditSetPerUserPolicy(pSid /*const*/ PSID, pAuditPolicy /*const*/ PAUDIT_POLICY_INFORMATION, policyCount ULONG) BOOLEAN { + ret1 := syscall3(auditSetPerUserPolicy, 3, + uintptr(pSid), + uintptr(unsafe.Pointer(pAuditPolicy)), + uintptr(policyCount)) + return BOOLEAN(ret1) +} + +func AuditSetSecurity(securityInformation SECURITY_INFORMATION, pSecurityDescriptor PSECURITY_DESCRIPTOR) BOOLEAN { + ret1 := syscall3(auditSetSecurity, 2, + uintptr(securityInformation), + uintptr(unsafe.Pointer(pSecurityDescriptor)), + 0) + return BOOLEAN(ret1) +} + +func AuditSetSystemPolicy(pAuditPolicy /*const*/ PAUDIT_POLICY_INFORMATION, policyCount ULONG) BOOLEAN { + ret1 := syscall3(auditSetSystemPolicy, 2, + uintptr(unsafe.Pointer(pAuditPolicy)), + uintptr(policyCount), + 0) + return BOOLEAN(ret1) +} + +func BackupEventLog(hEventLog HANDLE, lpBackupFileName string) bool { + lpBackupFileNameStr := unicode16FromString(lpBackupFileName) + ret1 := syscall3(backupEventLog, 2, + uintptr(hEventLog), + uintptr(unsafe.Pointer(&lpBackupFileNameStr[0])), + 0) + return ret1 != 0 +} + +func BuildExplicitAccessWithName(pExplicitAccess *EXPLICIT_ACCESS, pTrusteeName LPWSTR, accessPermissions DWORD, accessMode ACCESS_MODE, inheritance DWORD) { + syscall6(buildExplicitAccessWithName, 5, + uintptr(unsafe.Pointer(pExplicitAccess)), + uintptr(unsafe.Pointer(pTrusteeName)), + uintptr(accessPermissions), + uintptr(accessMode), + uintptr(inheritance), + 0) +} + +func BuildImpersonateExplicitAccessWithName(pExplicitAccess *EXPLICIT_ACCESS, pTrusteeName LPWSTR, pTrustee *TRUSTEE, accessPermissions DWORD, accessMode ACCESS_MODE, inheritance DWORD) { + syscall6(buildImpersonateExplicitAccessWithName, 6, + uintptr(unsafe.Pointer(pExplicitAccess)), + uintptr(unsafe.Pointer(pTrusteeName)), + uintptr(unsafe.Pointer(pTrustee)), + uintptr(accessPermissions), + uintptr(accessMode), + uintptr(inheritance)) +} + +func BuildImpersonateTrustee(pTrustee *TRUSTEE, pImpersonateTrustee *TRUSTEE) { + syscall3(buildImpersonateTrustee, 2, + uintptr(unsafe.Pointer(pTrustee)), + uintptr(unsafe.Pointer(pImpersonateTrustee)), + 0) +} + +func BuildSecurityDescriptor(pOwner *TRUSTEE, pGroup *TRUSTEE, cCountOfAccessEntries ULONG, pListOfAccessEntries *EXPLICIT_ACCESS, cCountOfAuditEntries ULONG, pListOfAuditEntries *EXPLICIT_ACCESS, pOldSD PSECURITY_DESCRIPTOR, pSizeNewSD *uint32, pNewSD *PSECURITY_DESCRIPTOR) DWORD { + ret1 := syscall9(buildSecurityDescriptor, 9, + uintptr(unsafe.Pointer(pOwner)), + uintptr(unsafe.Pointer(pGroup)), + uintptr(cCountOfAccessEntries), + uintptr(unsafe.Pointer(pListOfAccessEntries)), + uintptr(cCountOfAuditEntries), + uintptr(unsafe.Pointer(pListOfAuditEntries)), + uintptr(unsafe.Pointer(pOldSD)), + uintptr(unsafe.Pointer(pSizeNewSD)), + uintptr(unsafe.Pointer(pNewSD))) + return DWORD(ret1) +} + +func BuildTrusteeWithName(pTrustee *TRUSTEE, pName LPWSTR) { + syscall3(buildTrusteeWithName, 2, + uintptr(unsafe.Pointer(pTrustee)), + uintptr(unsafe.Pointer(pName)), + 0) +} + +func BuildTrusteeWithObjectsAndName(pTrustee *TRUSTEE, pObjName *OBJECTS_AND_NAME, objectType SE_OBJECT_TYPE, objectTypeName LPWSTR, inheritedObjectTypeName LPWSTR, name LPWSTR) { + syscall6(buildTrusteeWithObjectsAndName, 6, + uintptr(unsafe.Pointer(pTrustee)), + uintptr(unsafe.Pointer(pObjName)), + uintptr(objectType), + uintptr(unsafe.Pointer(objectTypeName)), + uintptr(unsafe.Pointer(inheritedObjectTypeName)), + uintptr(unsafe.Pointer(name))) +} + +func BuildTrusteeWithObjectsAndSid(pTrustee *TRUSTEE, pObjSid *OBJECTS_AND_SID, pObjectGuid *GUID, pInheritedObjectGuid *GUID, pSid PSID) { + syscall6(buildTrusteeWithObjectsAndSid, 5, + uintptr(unsafe.Pointer(pTrustee)), + uintptr(unsafe.Pointer(pObjSid)), + uintptr(unsafe.Pointer(pObjectGuid)), + uintptr(unsafe.Pointer(pInheritedObjectGuid)), + uintptr(pSid), + 0) +} + +func BuildTrusteeWithSid(pTrustee *TRUSTEE, pSid PSID) { + syscall3(buildTrusteeWithSid, 2, + uintptr(unsafe.Pointer(pTrustee)), + uintptr(pSid), + 0) +} + +func ChangeServiceConfig2(hService SC_HANDLE, dwInfoLevel DWORD, lpInfo LPVOID) bool { + ret1 := syscall3(changeServiceConfig2, 3, + uintptr(hService), + uintptr(dwInfoLevel), + uintptr(unsafe.Pointer(lpInfo))) + return ret1 != 0 +} + +func ChangeServiceConfig(hService SC_HANDLE, dwServiceType DWORD, dwStartType DWORD, dwErrorControl DWORD, lpBinaryPathName string, lpLoadOrderGroup string, lpdwTagId *uint32, lpDependencies string, lpServiceStartName string, lpPassword string, lpDisplayName string) bool { + lpBinaryPathNameStr := unicode16FromString(lpBinaryPathName) + lpLoadOrderGroupStr := unicode16FromString(lpLoadOrderGroup) + lpDependenciesStr := unicode16FromString(lpDependencies) + lpServiceStartNameStr := unicode16FromString(lpServiceStartName) + lpPasswordStr := unicode16FromString(lpPassword) + lpDisplayNameStr := unicode16FromString(lpDisplayName) + ret1 := syscall12(changeServiceConfig, 11, + uintptr(hService), + uintptr(dwServiceType), + uintptr(dwStartType), + uintptr(dwErrorControl), + uintptr(unsafe.Pointer(&lpBinaryPathNameStr[0])), + uintptr(unsafe.Pointer(&lpLoadOrderGroupStr[0])), + uintptr(unsafe.Pointer(lpdwTagId)), + uintptr(unsafe.Pointer(&lpDependenciesStr[0])), + uintptr(unsafe.Pointer(&lpServiceStartNameStr[0])), + uintptr(unsafe.Pointer(&lpPasswordStr[0])), + uintptr(unsafe.Pointer(&lpDisplayNameStr[0])), + 0) + return ret1 != 0 +} + +func CheckTokenMembership(tokenHandle HANDLE, sidToCheck PSID, isMember *BOOL) bool { + ret1 := syscall3(checkTokenMembership, 3, + uintptr(tokenHandle), + uintptr(sidToCheck), + uintptr(unsafe.Pointer(isMember))) + return ret1 != 0 +} + +func ClearEventLog(hEventLog HANDLE, lpBackupFileName string) bool { + lpBackupFileNameStr := unicode16FromString(lpBackupFileName) + ret1 := syscall3(clearEventLog, 2, + uintptr(hEventLog), + uintptr(unsafe.Pointer(&lpBackupFileNameStr[0])), + 0) + return ret1 != 0 +} + +func CloseEncryptedFileRaw(pvContext uintptr) { + syscall3(closeEncryptedFileRaw, 1, + pvContext, + 0, + 0) +} + +func CloseEventLog(hEventLog HANDLE) bool { + ret1 := syscall3(closeEventLog, 1, + uintptr(hEventLog), + 0, + 0) + return ret1 != 0 +} + +func CloseServiceHandle(hSCObject SC_HANDLE) bool { + ret1 := syscall3(closeServiceHandle, 1, + uintptr(hSCObject), + 0, + 0) + return ret1 != 0 +} + +func CloseThreadWaitChainSession(wctHandle HWCT) { + syscall3(closeThreadWaitChainSession, 1, + uintptr(wctHandle), + 0, + 0) +} + +func CommandLineFromMsiDescriptor(descriptor *WCHAR, commandLine *WCHAR, commandLineLength *uint32) DWORD { + ret1 := syscall3(commandLineFromMsiDescriptor, 3, + uintptr(unsafe.Pointer(descriptor)), + uintptr(unsafe.Pointer(commandLine)), + uintptr(unsafe.Pointer(commandLineLength))) + return DWORD(ret1) +} + +func ControlService(hService SC_HANDLE, dwControl DWORD, lpServiceStatus *SERVICE_STATUS) bool { + ret1 := syscall3(controlService, 3, + uintptr(hService), + uintptr(dwControl), + uintptr(unsafe.Pointer(lpServiceStatus))) + return ret1 != 0 +} + +func ControlServiceEx(hService SC_HANDLE, dwControl DWORD, dwInfoLevel DWORD, pControlParams uintptr) bool { + ret1 := syscall6(controlServiceEx, 4, + uintptr(hService), + uintptr(dwControl), + uintptr(dwInfoLevel), + pControlParams, + 0, + 0) + return ret1 != 0 +} + +func ConvertSecurityDescriptorToStringSecurityDescriptor(securityDescriptor PSECURITY_DESCRIPTOR, requestedStringSDRevision DWORD, securityInformation SECURITY_INFORMATION, stringSecurityDescriptor *LPWSTR, stringSecurityDescriptorLen *uint32) bool { + ret1 := syscall6(convertSecurityDescriptorToStringSecurityDescriptor, 5, + uintptr(unsafe.Pointer(securityDescriptor)), + uintptr(requestedStringSDRevision), + uintptr(securityInformation), + uintptr(unsafe.Pointer(stringSecurityDescriptor)), + uintptr(unsafe.Pointer(stringSecurityDescriptorLen)), + 0) + return ret1 != 0 +} + +func ConvertSidToStringSid(sid PSID, stringSid *LPWSTR) bool { + ret1 := syscall3(convertSidToStringSid, 2, + uintptr(sid), + uintptr(unsafe.Pointer(stringSid)), + 0) + return ret1 != 0 +} + +func ConvertStringSecurityDescriptorToSecurityDescriptor(stringSecurityDescriptor string, stringSDRevision DWORD, securityDescriptor *PSECURITY_DESCRIPTOR, securityDescriptorSize *uint32) bool { + stringSecurityDescriptorStr := unicode16FromString(stringSecurityDescriptor) + ret1 := syscall6(convertStringSecurityDescriptorToSecurityDescriptor, 4, + uintptr(unsafe.Pointer(&stringSecurityDescriptorStr[0])), + uintptr(stringSDRevision), + uintptr(unsafe.Pointer(securityDescriptor)), + uintptr(unsafe.Pointer(securityDescriptorSize)), + 0, + 0) + return ret1 != 0 +} + +func ConvertStringSidToSid(stringSid string, sid *PSID) bool { + stringSidStr := unicode16FromString(stringSid) + ret1 := syscall3(convertStringSidToSid, 2, + uintptr(unsafe.Pointer(&stringSidStr[0])), + uintptr(unsafe.Pointer(sid)), + 0) + return ret1 != 0 +} + +func ConvertToAutoInheritPrivateObjectSecurity(parentDescriptor PSECURITY_DESCRIPTOR, currentSecurityDescriptor PSECURITY_DESCRIPTOR, newSecurityDescriptor *PSECURITY_DESCRIPTOR, objectType *GUID, isDirectoryObject BOOLEAN, genericMapping *GENERIC_MAPPING) bool { + ret1 := syscall6(convertToAutoInheritPrivateObjectSecurity, 6, + uintptr(unsafe.Pointer(parentDescriptor)), + uintptr(unsafe.Pointer(currentSecurityDescriptor)), + uintptr(unsafe.Pointer(newSecurityDescriptor)), + uintptr(unsafe.Pointer(objectType)), + uintptr(isDirectoryObject), + uintptr(unsafe.Pointer(genericMapping))) + return ret1 != 0 +} + +func CopySid(nDestinationSidLength DWORD, pDestinationSid PSID, pSourceSid PSID) bool { + ret1 := syscall3(copySid, 3, + uintptr(nDestinationSidLength), + uintptr(pDestinationSid), + uintptr(pSourceSid)) + return ret1 != 0 +} + +func CreatePrivateObjectSecurity(parentDescriptor PSECURITY_DESCRIPTOR, creatorDescriptor PSECURITY_DESCRIPTOR, newDescriptor *PSECURITY_DESCRIPTOR, isDirectoryObject bool, token HANDLE, genericMapping *GENERIC_MAPPING) bool { + ret1 := syscall6(createPrivateObjectSecurity, 6, + uintptr(unsafe.Pointer(parentDescriptor)), + uintptr(unsafe.Pointer(creatorDescriptor)), + uintptr(unsafe.Pointer(newDescriptor)), + getUintptrFromBool(isDirectoryObject), + uintptr(token), + uintptr(unsafe.Pointer(genericMapping))) + return ret1 != 0 +} + +func CreatePrivateObjectSecurityEx(parentDescriptor PSECURITY_DESCRIPTOR, creatorDescriptor PSECURITY_DESCRIPTOR, newDescriptor *PSECURITY_DESCRIPTOR, objectType *GUID, isContainerObject bool, autoInheritFlags ULONG, token HANDLE, genericMapping *GENERIC_MAPPING) bool { + ret1 := syscall9(createPrivateObjectSecurityEx, 8, + uintptr(unsafe.Pointer(parentDescriptor)), + uintptr(unsafe.Pointer(creatorDescriptor)), + uintptr(unsafe.Pointer(newDescriptor)), + uintptr(unsafe.Pointer(objectType)), + getUintptrFromBool(isContainerObject), + uintptr(autoInheritFlags), + uintptr(token), + uintptr(unsafe.Pointer(genericMapping)), + 0) + return ret1 != 0 +} + +func CreatePrivateObjectSecurityWithMultipleInheritance(parentDescriptor PSECURITY_DESCRIPTOR, creatorDescriptor PSECURITY_DESCRIPTOR, newDescriptor *PSECURITY_DESCRIPTOR, objectTypes uintptr, guidCount ULONG, isContainerObject bool, autoInheritFlags ULONG, token HANDLE, genericMapping *GENERIC_MAPPING) bool { + ret1 := syscall9(createPrivateObjectSecurityWithMultipleInheritance, 9, + uintptr(unsafe.Pointer(parentDescriptor)), + uintptr(unsafe.Pointer(creatorDescriptor)), + uintptr(unsafe.Pointer(newDescriptor)), + objectTypes, + uintptr(guidCount), + getUintptrFromBool(isContainerObject), + uintptr(autoInheritFlags), + uintptr(token), + uintptr(unsafe.Pointer(genericMapping))) + return ret1 != 0 +} + +func CreateProcessAsUser(hToken HANDLE, lpApplicationName string, lpCommandLine LPWSTR, lpProcessAttributes *SECURITY_ATTRIBUTES, lpThreadAttributes *SECURITY_ATTRIBUTES, bInheritHandles bool, dwCreationFlags DWORD, lpEnvironment LPVOID, lpCurrentDirectory string, lpStartupInfo *STARTUPINFO, lpProcessInformation *PROCESS_INFORMATION) bool { + lpApplicationNameStr := unicode16FromString(lpApplicationName) + lpCurrentDirectoryStr := unicode16FromString(lpCurrentDirectory) + ret1 := syscall12(createProcessAsUser, 11, + uintptr(hToken), + uintptr(unsafe.Pointer(&lpApplicationNameStr[0])), + uintptr(unsafe.Pointer(lpCommandLine)), + uintptr(unsafe.Pointer(lpProcessAttributes)), + uintptr(unsafe.Pointer(lpThreadAttributes)), + getUintptrFromBool(bInheritHandles), + uintptr(dwCreationFlags), + uintptr(unsafe.Pointer(lpEnvironment)), + uintptr(unsafe.Pointer(&lpCurrentDirectoryStr[0])), + uintptr(unsafe.Pointer(lpStartupInfo)), + uintptr(unsafe.Pointer(lpProcessInformation)), + 0) + return ret1 != 0 +} + +func CreateProcessWithLogonW(lpUsername string, lpDomain string, lpPassword string, dwLogonFlags DWORD, lpApplicationName string, lpCommandLine LPWSTR, dwCreationFlags DWORD, lpEnvironment LPVOID, lpCurrentDirectory string, lpStartupInfo *STARTUPINFO, lpProcessInformation *PROCESS_INFORMATION) bool { + lpUsernameStr := unicode16FromString(lpUsername) + lpDomainStr := unicode16FromString(lpDomain) + lpPasswordStr := unicode16FromString(lpPassword) + lpApplicationNameStr := unicode16FromString(lpApplicationName) + lpCurrentDirectoryStr := unicode16FromString(lpCurrentDirectory) + ret1 := syscall12(createProcessWithLogonW, 11, + uintptr(unsafe.Pointer(&lpUsernameStr[0])), + uintptr(unsafe.Pointer(&lpDomainStr[0])), + uintptr(unsafe.Pointer(&lpPasswordStr[0])), + uintptr(dwLogonFlags), + uintptr(unsafe.Pointer(&lpApplicationNameStr[0])), + uintptr(unsafe.Pointer(lpCommandLine)), + uintptr(dwCreationFlags), + uintptr(unsafe.Pointer(lpEnvironment)), + uintptr(unsafe.Pointer(&lpCurrentDirectoryStr[0])), + uintptr(unsafe.Pointer(lpStartupInfo)), + uintptr(unsafe.Pointer(lpProcessInformation)), + 0) + return ret1 != 0 +} + +func CreateProcessWithTokenW(hToken HANDLE, dwLogonFlags DWORD, lpApplicationName string, lpCommandLine LPWSTR, dwCreationFlags DWORD, lpEnvironment LPVOID, lpCurrentDirectory string, lpStartupInfo *STARTUPINFO, lpProcessInformation *PROCESS_INFORMATION) bool { + lpApplicationNameStr := unicode16FromString(lpApplicationName) + lpCurrentDirectoryStr := unicode16FromString(lpCurrentDirectory) + ret1 := syscall9(createProcessWithTokenW, 9, + uintptr(hToken), + uintptr(dwLogonFlags), + uintptr(unsafe.Pointer(&lpApplicationNameStr[0])), + uintptr(unsafe.Pointer(lpCommandLine)), + uintptr(dwCreationFlags), + uintptr(unsafe.Pointer(lpEnvironment)), + uintptr(unsafe.Pointer(&lpCurrentDirectoryStr[0])), + uintptr(unsafe.Pointer(lpStartupInfo)), + uintptr(unsafe.Pointer(lpProcessInformation))) + return ret1 != 0 +} + +// TODO: Unknown type(s): PLUID_AND_ATTRIBUTES, PSID_AND_ATTRIBUTES +// func CreateRestrictedToken(existingTokenHandle HANDLE, flags DWORD, disableSidCount DWORD, sidsToDisable PSID_AND_ATTRIBUTES, deletePrivilegeCount DWORD, privilegesToDelete PLUID_AND_ATTRIBUTES, restrictedSidCount DWORD, sidsToRestrict PSID_AND_ATTRIBUTES, newTokenHandle *HANDLE) bool + +func CreateService(hSCManager SC_HANDLE, lpServiceName string, lpDisplayName string, dwDesiredAccess DWORD, dwServiceType DWORD, dwStartType DWORD, dwErrorControl DWORD, lpBinaryPathName string, lpLoadOrderGroup string, lpdwTagId *uint32, lpDependencies string, lpServiceStartName string, lpPassword string) SC_HANDLE { + lpServiceNameStr := unicode16FromString(lpServiceName) + lpDisplayNameStr := unicode16FromString(lpDisplayName) + lpBinaryPathNameStr := unicode16FromString(lpBinaryPathName) + lpLoadOrderGroupStr := unicode16FromString(lpLoadOrderGroup) + lpDependenciesStr := unicode16FromString(lpDependencies) + lpServiceStartNameStr := unicode16FromString(lpServiceStartName) + lpPasswordStr := unicode16FromString(lpPassword) + ret1 := syscall15(createService, 13, + uintptr(hSCManager), + uintptr(unsafe.Pointer(&lpServiceNameStr[0])), + uintptr(unsafe.Pointer(&lpDisplayNameStr[0])), + uintptr(dwDesiredAccess), + uintptr(dwServiceType), + uintptr(dwStartType), + uintptr(dwErrorControl), + uintptr(unsafe.Pointer(&lpBinaryPathNameStr[0])), + uintptr(unsafe.Pointer(&lpLoadOrderGroupStr[0])), + uintptr(unsafe.Pointer(lpdwTagId)), + uintptr(unsafe.Pointer(&lpDependenciesStr[0])), + uintptr(unsafe.Pointer(&lpServiceStartNameStr[0])), + uintptr(unsafe.Pointer(&lpPasswordStr[0])), + 0, + 0) + return SC_HANDLE(ret1) +} + +// TODO: Unknown type(s): WELL_KNOWN_SID_TYPE +// func CreateWellKnownSid(wellKnownSidType WELL_KNOWN_SID_TYPE, domainSid PSID, pSid PSID, cbSid *uint32) bool + +func CredDelete(targetName string, aType DWORD, flags DWORD) bool { + targetNameStr := unicode16FromString(targetName) + ret1 := syscall3(credDelete, 3, + uintptr(unsafe.Pointer(&targetNameStr[0])), + uintptr(aType), + uintptr(flags)) + return ret1 != 0 +} + +func CredEnumerate(filter string, flags DWORD, count *uint32, credential uintptr) bool { + filterStr := unicode16FromString(filter) + ret1 := syscall6(credEnumerate, 4, + uintptr(unsafe.Pointer(&filterStr[0])), + uintptr(flags), + uintptr(unsafe.Pointer(count)), + credential, + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCREDENTIALW * +// func CredFindBestCredential(targetName string, aType DWORD, flags DWORD, credential PCREDENTIALW *) bool + +func CredFree(buffer uintptr) { + syscall3(credFree, 1, + buffer, + 0, + 0) +} + +func CredGetSessionTypes(maximumPersistCount DWORD, maximumPersist *uint32) bool { + ret1 := syscall3(credGetSessionTypes, 2, + uintptr(maximumPersistCount), + uintptr(unsafe.Pointer(maximumPersist)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCREDENTIAL_TARGET_INFORMATIONW * +// func CredGetTargetInfo(targetName string, flags DWORD, targetInfo PCREDENTIAL_TARGET_INFORMATIONW *) bool + +func CredIsMarshaledCredential(marshaledCredential string) bool { + marshaledCredentialStr := unicode16FromString(marshaledCredential) + ret1 := syscall3(credIsMarshaledCredential, 1, + uintptr(unsafe.Pointer(&marshaledCredentialStr[0])), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): CRED_PROTECTION_TYPE * +// func CredIsProtected(pszProtectedCredentials LPWSTR, pProtectionType CRED_PROTECTION_TYPE *) bool + +// TODO: Unknown type(s): CRED_MARSHAL_TYPE +// func CredMarshalCredential(credType CRED_MARSHAL_TYPE, credential uintptr, marshaledCredential *LPWSTR) bool + +// TODO: Unknown type(s): CRED_PROTECTION_TYPE * +// func CredProtect(fAsSelf bool, pszCredentials LPWSTR, cchCredentials DWORD, pszProtectedCredentials LPWSTR, pcchMaxChars *uint32, protectionType CRED_PROTECTION_TYPE *) bool + +// TODO: Unknown type(s): PCREDENTIAL_TARGET_INFORMATIONW +// func CredReadDomainCredentials(targetInfo PCREDENTIAL_TARGET_INFORMATIONW, flags DWORD, count *uint32, credential uintptr) bool + +// TODO: Unknown type(s): PCREDENTIALW * +// func CredRead(targetName string, aType DWORD, flags DWORD, credential PCREDENTIALW *) bool + +func CredRename(oldTargetName string, newTargetName string, aType DWORD, flags DWORD) bool { + oldTargetNameStr := unicode16FromString(oldTargetName) + newTargetNameStr := unicode16FromString(newTargetName) + ret1 := syscall6(credRename, 4, + uintptr(unsafe.Pointer(&oldTargetNameStr[0])), + uintptr(unsafe.Pointer(&newTargetNameStr[0])), + uintptr(aType), + uintptr(flags), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCRED_MARSHAL_TYPE +// func CredUnmarshalCredential(marshaledCredential string, credType PCRED_MARSHAL_TYPE, credential *PVOID) bool + +func CredUnprotect(fAsSelf bool, pszProtectedCredentials LPWSTR, cchCredentials DWORD, pszCredentials LPWSTR, pcchMaxChars *uint32) bool { + ret1 := syscall6(credUnprotect, 5, + getUintptrFromBool(fAsSelf), + uintptr(unsafe.Pointer(pszProtectedCredentials)), + uintptr(cchCredentials), + uintptr(unsafe.Pointer(pszCredentials)), + uintptr(unsafe.Pointer(pcchMaxChars)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCREDENTIAL_TARGET_INFORMATIONW +// func CredWriteDomainCredentials(targetInfo PCREDENTIAL_TARGET_INFORMATIONW, credential *CREDENTIAL, flags DWORD) bool + +func CredWrite(credential *CREDENTIAL, flags DWORD) bool { + ret1 := syscall3(credWrite, 2, + uintptr(unsafe.Pointer(credential)), + uintptr(flags), + 0) + return ret1 != 0 +} + +func CryptAcquireContext(phProv *HCRYPTPROV, szContainer string, szProvider string, dwProvType DWORD, dwFlags DWORD) bool { + szContainerStr := unicode16FromString(szContainer) + szProviderStr := unicode16FromString(szProvider) + ret1 := syscall6(cryptAcquireContext, 5, + uintptr(unsafe.Pointer(phProv)), + uintptr(unsafe.Pointer(&szContainerStr[0])), + uintptr(unsafe.Pointer(&szProviderStr[0])), + uintptr(dwProvType), + uintptr(dwFlags), + 0) + return ret1 != 0 +} + +func CryptContextAddRef(hProv HCRYPTPROV, pdwReserved *uint32, dwFlags DWORD) bool { + ret1 := syscall3(cryptContextAddRef, 3, + uintptr(hProv), + uintptr(unsafe.Pointer(pdwReserved)), + uintptr(dwFlags)) + return ret1 != 0 +} + +func CryptCreateHash(hProv HCRYPTPROV, algid ALG_ID, hKey HCRYPTKEY, dwFlags DWORD, phHash *HCRYPTHASH) bool { + ret1 := syscall6(cryptCreateHash, 5, + uintptr(hProv), + uintptr(algid), + uintptr(hKey), + uintptr(dwFlags), + uintptr(unsafe.Pointer(phHash)), + 0) + return ret1 != 0 +} + +func CryptDecrypt(hKey HCRYPTKEY, hHash HCRYPTHASH, final bool, dwFlags DWORD, pbData *byte, pdwDataLen *uint32) bool { + ret1 := syscall6(cryptDecrypt, 6, + uintptr(hKey), + uintptr(hHash), + getUintptrFromBool(final), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbData)), + uintptr(unsafe.Pointer(pdwDataLen))) + return ret1 != 0 +} + +func CryptDeriveKey(hProv HCRYPTPROV, algid ALG_ID, hBaseData HCRYPTHASH, dwFlags DWORD, phKey *HCRYPTKEY) bool { + ret1 := syscall6(cryptDeriveKey, 5, + uintptr(hProv), + uintptr(algid), + uintptr(hBaseData), + uintptr(dwFlags), + uintptr(unsafe.Pointer(phKey)), + 0) + return ret1 != 0 +} + +func CryptDestroyHash(hHash HCRYPTHASH) bool { + ret1 := syscall3(cryptDestroyHash, 1, + uintptr(hHash), + 0, + 0) + return ret1 != 0 +} + +func CryptDestroyKey(hKey HCRYPTKEY) bool { + ret1 := syscall3(cryptDestroyKey, 1, + uintptr(hKey), + 0, + 0) + return ret1 != 0 +} + +func CryptDuplicateHash(hHash HCRYPTHASH, pdwReserved *uint32, dwFlags DWORD, phHash *HCRYPTHASH) bool { + ret1 := syscall6(cryptDuplicateHash, 4, + uintptr(hHash), + uintptr(unsafe.Pointer(pdwReserved)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(phHash)), + 0, + 0) + return ret1 != 0 +} + +func CryptDuplicateKey(hKey HCRYPTKEY, pdwReserved *uint32, dwFlags DWORD, phKey *HCRYPTKEY) bool { + ret1 := syscall6(cryptDuplicateKey, 4, + uintptr(hKey), + uintptr(unsafe.Pointer(pdwReserved)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(phKey)), + 0, + 0) + return ret1 != 0 +} + +func CryptEncrypt(hKey HCRYPTKEY, hHash HCRYPTHASH, final bool, dwFlags DWORD, pbData *byte, pdwDataLen *uint32, dwBufLen DWORD) bool { + ret1 := syscall9(cryptEncrypt, 7, + uintptr(hKey), + uintptr(hHash), + getUintptrFromBool(final), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbData)), + uintptr(unsafe.Pointer(pdwDataLen)), + uintptr(dwBufLen), + 0, + 0) + return ret1 != 0 +} + +func CryptEnumProviderTypes(dwIndex DWORD, pdwReserved *uint32, dwFlags DWORD, pdwProvType *uint32, szTypeName LPWSTR, pcbTypeName *uint32) bool { + ret1 := syscall6(cryptEnumProviderTypes, 6, + uintptr(dwIndex), + uintptr(unsafe.Pointer(pdwReserved)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pdwProvType)), + uintptr(unsafe.Pointer(szTypeName)), + uintptr(unsafe.Pointer(pcbTypeName))) + return ret1 != 0 +} + +func CryptEnumProviders(dwIndex DWORD, pdwReserved *uint32, dwFlags DWORD, pdwProvType *uint32, szProvName LPWSTR, pcbProvName *uint32) bool { + ret1 := syscall6(cryptEnumProviders, 6, + uintptr(dwIndex), + uintptr(unsafe.Pointer(pdwReserved)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pdwProvType)), + uintptr(unsafe.Pointer(szProvName)), + uintptr(unsafe.Pointer(pcbProvName))) + return ret1 != 0 +} + +func CryptExportKey(hKey HCRYPTKEY, hExpKey HCRYPTKEY, dwBlobType DWORD, dwFlags DWORD, pbData *byte, pdwDataLen *uint32) bool { + ret1 := syscall6(cryptExportKey, 6, + uintptr(hKey), + uintptr(hExpKey), + uintptr(dwBlobType), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbData)), + uintptr(unsafe.Pointer(pdwDataLen))) + return ret1 != 0 +} + +func CryptGenKey(hProv HCRYPTPROV, algid ALG_ID, dwFlags DWORD, phKey *HCRYPTKEY) bool { + ret1 := syscall6(cryptGenKey, 4, + uintptr(hProv), + uintptr(algid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(phKey)), + 0, + 0) + return ret1 != 0 +} + +func CryptGenRandom(hProv HCRYPTPROV, dwLen DWORD, pbBuffer *byte) bool { + ret1 := syscall3(cryptGenRandom, 3, + uintptr(hProv), + uintptr(dwLen), + uintptr(unsafe.Pointer(pbBuffer))) + return ret1 != 0 +} + +func CryptGetDefaultProvider(dwProvType DWORD, pdwReserved *uint32, dwFlags DWORD, pszProvName LPWSTR, pcbProvName *uint32) bool { + ret1 := syscall6(cryptGetDefaultProvider, 5, + uintptr(dwProvType), + uintptr(unsafe.Pointer(pdwReserved)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pszProvName)), + uintptr(unsafe.Pointer(pcbProvName)), + 0) + return ret1 != 0 +} + +func CryptGetHashParam(hHash HCRYPTHASH, dwParam DWORD, pbData *byte, pdwDataLen *uint32, dwFlags DWORD) bool { + ret1 := syscall6(cryptGetHashParam, 5, + uintptr(hHash), + uintptr(dwParam), + uintptr(unsafe.Pointer(pbData)), + uintptr(unsafe.Pointer(pdwDataLen)), + uintptr(dwFlags), + 0) + return ret1 != 0 +} + +func CryptGetKeyParam(hKey HCRYPTKEY, dwParam DWORD, pbData *byte, pdwDataLen *uint32, dwFlags DWORD) bool { + ret1 := syscall6(cryptGetKeyParam, 5, + uintptr(hKey), + uintptr(dwParam), + uintptr(unsafe.Pointer(pbData)), + uintptr(unsafe.Pointer(pdwDataLen)), + uintptr(dwFlags), + 0) + return ret1 != 0 +} + +func CryptGetProvParam(hProv HCRYPTPROV, dwParam DWORD, pbData *byte, pdwDataLen *uint32, dwFlags DWORD) bool { + ret1 := syscall6(cryptGetProvParam, 5, + uintptr(hProv), + uintptr(dwParam), + uintptr(unsafe.Pointer(pbData)), + uintptr(unsafe.Pointer(pdwDataLen)), + uintptr(dwFlags), + 0) + return ret1 != 0 +} + +func CryptGetUserKey(hProv HCRYPTPROV, dwKeySpec DWORD, phUserKey *HCRYPTKEY) bool { + ret1 := syscall3(cryptGetUserKey, 3, + uintptr(hProv), + uintptr(dwKeySpec), + uintptr(unsafe.Pointer(phUserKey))) + return ret1 != 0 +} + +func CryptHashData(hHash HCRYPTHASH, pbData /*const*/ *byte, dwDataLen DWORD, dwFlags DWORD) bool { + ret1 := syscall6(cryptHashData, 4, + uintptr(hHash), + uintptr(unsafe.Pointer(pbData)), + uintptr(dwDataLen), + uintptr(dwFlags), + 0, + 0) + return ret1 != 0 +} + +func CryptHashSessionKey(hHash HCRYPTHASH, hKey HCRYPTKEY, dwFlags DWORD) bool { + ret1 := syscall3(cryptHashSessionKey, 3, + uintptr(hHash), + uintptr(hKey), + uintptr(dwFlags)) + return ret1 != 0 +} + +func CryptImportKey(hProv HCRYPTPROV, pbData /*const*/ *byte, dwDataLen DWORD, hPubKey HCRYPTKEY, dwFlags DWORD, phKey *HCRYPTKEY) bool { + ret1 := syscall6(cryptImportKey, 6, + uintptr(hProv), + uintptr(unsafe.Pointer(pbData)), + uintptr(dwDataLen), + uintptr(hPubKey), + uintptr(dwFlags), + uintptr(unsafe.Pointer(phKey))) + return ret1 != 0 +} + +func CryptReleaseContext(hProv HCRYPTPROV, dwFlags DWORD) bool { + ret1 := syscall3(cryptReleaseContext, 2, + uintptr(hProv), + uintptr(dwFlags), + 0) + return ret1 != 0 +} + +func CryptSetHashParam(hHash HCRYPTHASH, dwParam DWORD, pbData /*const*/ *byte, dwFlags DWORD) bool { + ret1 := syscall6(cryptSetHashParam, 4, + uintptr(hHash), + uintptr(dwParam), + uintptr(unsafe.Pointer(pbData)), + uintptr(dwFlags), + 0, + 0) + return ret1 != 0 +} + +func CryptSetKeyParam(hKey HCRYPTKEY, dwParam DWORD, pbData /*const*/ *byte, dwFlags DWORD) bool { + ret1 := syscall6(cryptSetKeyParam, 4, + uintptr(hKey), + uintptr(dwParam), + uintptr(unsafe.Pointer(pbData)), + uintptr(dwFlags), + 0, + 0) + return ret1 != 0 +} + +func CryptSetProvParam(hProv HCRYPTPROV, dwParam DWORD, pbData /*const*/ *byte, dwFlags DWORD) bool { + ret1 := syscall6(cryptSetProvParam, 4, + uintptr(hProv), + uintptr(dwParam), + uintptr(unsafe.Pointer(pbData)), + uintptr(dwFlags), + 0, + 0) + return ret1 != 0 +} + +func CryptSetProviderEx(pszProvName string, dwProvType DWORD, pdwReserved *uint32, dwFlags DWORD) bool { + pszProvNameStr := unicode16FromString(pszProvName) + ret1 := syscall6(cryptSetProviderEx, 4, + uintptr(unsafe.Pointer(&pszProvNameStr[0])), + uintptr(dwProvType), + uintptr(unsafe.Pointer(pdwReserved)), + uintptr(dwFlags), + 0, + 0) + return ret1 != 0 +} + +func CryptSetProvider(pszProvName string, dwProvType DWORD) bool { + pszProvNameStr := unicode16FromString(pszProvName) + ret1 := syscall3(cryptSetProvider, 2, + uintptr(unsafe.Pointer(&pszProvNameStr[0])), + uintptr(dwProvType), + 0) + return ret1 != 0 +} + +func CryptSignHash(hHash HCRYPTHASH, dwKeySpec DWORD, szDescription string, dwFlags DWORD, pbSignature *byte, pdwSigLen *uint32) bool { + szDescriptionStr := unicode16FromString(szDescription) + ret1 := syscall6(cryptSignHash, 6, + uintptr(hHash), + uintptr(dwKeySpec), + uintptr(unsafe.Pointer(&szDescriptionStr[0])), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbSignature)), + uintptr(unsafe.Pointer(pdwSigLen))) + return ret1 != 0 +} + +func CryptVerifySignature(hHash HCRYPTHASH, pbSignature /*const*/ *byte, dwSigLen DWORD, hPubKey HCRYPTKEY, szDescription string, dwFlags DWORD) bool { + szDescriptionStr := unicode16FromString(szDescription) + ret1 := syscall6(cryptVerifySignature, 6, + uintptr(hHash), + uintptr(unsafe.Pointer(pbSignature)), + uintptr(dwSigLen), + uintptr(hPubKey), + uintptr(unsafe.Pointer(&szDescriptionStr[0])), + uintptr(dwFlags)) + return ret1 != 0 +} + +func DecryptFile(lpFileName string, dwReserved DWORD) bool { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(decryptFile, 2, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(dwReserved), + 0) + return ret1 != 0 +} + +func DeleteAce(pAcl *ACL, dwAceIndex DWORD) bool { + ret1 := syscall3(deleteAce, 2, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceIndex), + 0) + return ret1 != 0 +} + +func DeleteService(hService SC_HANDLE) bool { + ret1 := syscall3(deleteService, 1, + uintptr(hService), + 0, + 0) + return ret1 != 0 +} + +func DeregisterEventSource(hEventLog HANDLE) bool { + ret1 := syscall3(deregisterEventSource, 1, + uintptr(hEventLog), + 0, + 0) + return ret1 != 0 +} + +func DestroyPrivateObjectSecurity(objectDescriptor *PSECURITY_DESCRIPTOR) bool { + ret1 := syscall3(destroyPrivateObjectSecurity, 1, + uintptr(unsafe.Pointer(objectDescriptor)), + 0, + 0) + return ret1 != 0 +} + +func DuplicateEncryptionInfoFile(srcFileName string, dstFileName string, dwCreationDistribution DWORD, dwAttributes DWORD, lpSecurityAttributes /*const*/ *SECURITY_ATTRIBUTES) DWORD { + srcFileNameStr := unicode16FromString(srcFileName) + dstFileNameStr := unicode16FromString(dstFileName) + ret1 := syscall6(duplicateEncryptionInfoFile, 5, + uintptr(unsafe.Pointer(&srcFileNameStr[0])), + uintptr(unsafe.Pointer(&dstFileNameStr[0])), + uintptr(dwCreationDistribution), + uintptr(dwAttributes), + uintptr(unsafe.Pointer(lpSecurityAttributes)), + 0) + return DWORD(ret1) +} + +func DuplicateToken(existingTokenHandle HANDLE, impersonationLevel SECURITY_IMPERSONATION_LEVEL, duplicateTokenHandle *HANDLE) bool { + ret1 := syscall3(duplicateToken, 3, + uintptr(existingTokenHandle), + uintptr(impersonationLevel), + uintptr(unsafe.Pointer(duplicateTokenHandle))) + return ret1 != 0 +} + +type TOKEN_TYPE uint32 + +const ( + TokenPrimary = iota + 1 + TokenImpersonation +) + +// TODO: Unknown type(s): TOKEN_TYPE +func DuplicateTokenEx(hExistingToken HANDLE, + dwDesiredAccess DWORD, + lpTokenAttributes *SECURITY_ATTRIBUTES, + impersonationLevel SECURITY_IMPERSONATION_LEVEL, + tokenType TOKEN_TYPE, + phNewToken *HANDLE) DWORD { + ret1 := syscall6(duplicateToken, 6, + uintptr(hExistingToken), + uintptr(dwDesiredAccess), + uintptr(unsafe.Pointer(lpTokenAttributes)), + uintptr(impersonationLevel), + uintptr(tokenType), + uintptr(unsafe.Pointer(phNewToken))) + return DWORD(ret1) +} + +func EncryptFile(lpFileName string) bool { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(encryptFile, 1, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + 0, + 0) + return ret1 != 0 +} + +func EncryptionDisable(dirPath string, disable bool) bool { + dirPathStr := unicode16FromString(dirPath) + ret1 := syscall3(encryptionDisable, 2, + uintptr(unsafe.Pointer(&dirPathStr[0])), + getUintptrFromBool(disable), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPENUM_SERVICE_STATUSW +// func EnumDependentServices(hService SC_HANDLE, dwServiceState DWORD, lpServices LPENUM_SERVICE_STATUSW, cbBufSize DWORD, pcbBytesNeeded *uint32, lpServicesReturned *uint32) bool + +// TODO: Unknown type(s): SC_ENUM_TYPE +// func EnumServicesStatusEx(hSCManager SC_HANDLE, infoLevel SC_ENUM_TYPE, dwServiceType DWORD, dwServiceState DWORD, lpServices *byte, cbBufSize DWORD, pcbBytesNeeded *uint32, lpServicesReturned *uint32, lpResumeHandle *uint32, pszGroupName string) bool + +// TODO: Unknown type(s): LPENUM_SERVICE_STATUSW +// func EnumServicesStatus(hSCManager SC_HANDLE, dwServiceType DWORD, dwServiceState DWORD, lpServices LPENUM_SERVICE_STATUSW, cbBufSize DWORD, pcbBytesNeeded *uint32, lpServicesReturned *uint32, lpResumeHandle *uint32) bool + +func EqualDomainSid(pSid1 PSID, pSid2 PSID, pfEqual *BOOL) bool { + ret1 := syscall3(equalDomainSid, 3, + uintptr(pSid1), + uintptr(pSid2), + uintptr(unsafe.Pointer(pfEqual))) + return ret1 != 0 +} + +func EqualPrefixSid(pSid1 PSID, pSid2 PSID) bool { + ret1 := syscall3(equalPrefixSid, 2, + uintptr(pSid1), + uintptr(pSid2), + 0) + return ret1 != 0 +} + +func EqualSid(pSid1 PSID, pSid2 PSID) bool { + ret1 := syscall3(equalSid, 2, + uintptr(pSid1), + uintptr(pSid2), + 0) + return ret1 != 0 +} + +func FileEncryptionStatus(lpFileName string, lpStatus *uint32) bool { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(fileEncryptionStatus, 2, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(unsafe.Pointer(lpStatus)), + 0) + return ret1 != 0 +} + +func FindFirstFreeAce(pAcl *ACL, pAce *LPVOID) bool { + ret1 := syscall3(findFirstFreeAce, 2, + uintptr(unsafe.Pointer(pAcl)), + uintptr(unsafe.Pointer(pAce)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PENCRYPTION_CERTIFICATE_HASH_LIST +// func FreeEncryptionCertificateHashList(pHashes PENCRYPTION_CERTIFICATE_HASH_LIST) + +// TODO: Unknown type(s): PFN_OBJECT_MGR_FUNCTS, PINHERITED_FROMW +// func FreeInheritedFromArray(pInheritArray PINHERITED_FROMW, aceCnt USHORT, pfnArray PFN_OBJECT_MGR_FUNCTS) DWORD + +func FreeSid(pSid PSID) uintptr { + ret1 := syscall3(freeSid, 1, + uintptr(pSid), + 0, + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func GetAce(pAcl *ACL, dwAceIndex DWORD, pAce *LPVOID) bool { + ret1 := syscall3(getAce, 3, + uintptr(unsafe.Pointer(pAcl)), + uintptr(dwAceIndex), + uintptr(unsafe.Pointer(pAce))) + return ret1 != 0 +} + +// TODO: Unknown type(s): ACL_INFORMATION_CLASS +// func GetAclInformation(pAcl *ACL, pAclInformation LPVOID, nAclInformationLength DWORD, dwAclInformationClass ACL_INFORMATION_CLASS) bool + +// TODO: Unknown type(s): PACCESS_MASK +// func GetAuditedPermissionsFromAcl(pacl *ACL, pTrustee *TRUSTEE, pSuccessfulAuditedRights PACCESS_MASK, pFailedAuditRights PACCESS_MASK) DWORD + +// TODO: Unknown type(s): LPHW_PROFILE_INFOW +// func GetCurrentHwProfile(lpHwProfileInfo LPHW_PROFILE_INFOW) bool + +// TODO: Unknown type(s): PACCESS_MASK +// func GetEffectiveRightsFromAcl(pacl *ACL, pTrustee *TRUSTEE, pAccessRights PACCESS_MASK) DWORD + +func GetEventLogInformation(hEventLog HANDLE, dwInfoLevel DWORD, lpBuffer LPVOID, cbBufSize DWORD, pcbBytesNeeded *uint32) bool { + ret1 := syscall6(getEventLogInformation, 5, + uintptr(hEventLog), + uintptr(dwInfoLevel), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(cbBufSize), + uintptr(unsafe.Pointer(pcbBytesNeeded)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PEXPLICIT_ACCESS_W * +// func GetExplicitEntriesFromAcl(pacl *ACL, pcCountOfExplicitEntries *uint32, pListOfExplicitEntries PEXPLICIT_ACCESS_W *) DWORD + +func GetFileSecurity(lpFileName string, requestedInformation SECURITY_INFORMATION, pSecurityDescriptor PSECURITY_DESCRIPTOR, nLength DWORD, lpnLengthNeeded *uint32) bool { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall6(getFileSecurity, 5, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(requestedInformation), + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(nLength), + uintptr(unsafe.Pointer(lpnLengthNeeded)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PFN_OBJECT_MGR_FUNCTS, PINHERITED_FROMW +// func GetInheritanceSource(pObjectName LPWSTR, objectType SE_OBJECT_TYPE, securityInfo SECURITY_INFORMATION, container bool, pObjectClassGuids uintptr, guidCount DWORD, pAcl *ACL, pfnArray PFN_OBJECT_MGR_FUNCTS, pGenericMapping *GENERIC_MAPPING, pInheritArray PINHERITED_FROMW) DWORD + +func GetKernelObjectSecurity(handle HANDLE, requestedInformation SECURITY_INFORMATION, pSecurityDescriptor PSECURITY_DESCRIPTOR, nLength DWORD, lpnLengthNeeded *uint32) bool { + ret1 := syscall6(getKernelObjectSecurity, 5, + uintptr(handle), + uintptr(requestedInformation), + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(nLength), + uintptr(unsafe.Pointer(lpnLengthNeeded)), + 0) + return ret1 != 0 +} + +func GetLengthSid(pSid PSID) DWORD { + ret1 := syscall3(getLengthSid, 1, + uintptr(pSid), + 0, + 0) + return DWORD(ret1) +} + +func GetLocalManagedApplicationData(productCode *WCHAR, displayName *LPWSTR, supportUrl *LPWSTR) { + syscall3(getLocalManagedApplicationData, 3, + uintptr(unsafe.Pointer(productCode)), + uintptr(unsafe.Pointer(displayName)), + uintptr(unsafe.Pointer(supportUrl))) +} + +// TODO: Unknown type(s): PLOCALMANAGEDAPPLICATION * +// func GetLocalManagedApplications(bUserApps bool, pdwApps *uint32, prgLocalApps PLOCALMANAGEDAPPLICATION *) DWORD + +// TODO: Unknown type(s): APPCATEGORYINFOLIST * +// func GetManagedApplicationCategories(dwReserved DWORD, pAppCategory APPCATEGORYINFOLIST *) DWORD + +// TODO: Unknown type(s): PMANAGEDAPPLICATION * +// func GetManagedApplications(pCategory *GUID, dwQueryFlags DWORD, dwInfoLevel DWORD, pdwApps *uint32, prgManagedApps PMANAGEDAPPLICATION *) DWORD + +func GetMultipleTrusteeOperation(pTrustee *TRUSTEE) MULTIPLE_TRUSTEE_OPERATION { + ret1 := syscall3(getMultipleTrusteeOperation, 1, + uintptr(unsafe.Pointer(pTrustee)), + 0, + 0) + return MULTIPLE_TRUSTEE_OPERATION(ret1) +} + +func GetMultipleTrustee(pTrustee *TRUSTEE) *TRUSTEE { + ret1 := syscall3(getMultipleTrustee, 1, + uintptr(unsafe.Pointer(pTrustee)), + 0, + 0) + return (*TRUSTEE)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): PACL * +// func GetNamedSecurityInfo(pObjectName string, objectType SE_OBJECT_TYPE, securityInfo SECURITY_INFORMATION, ppsidOwner *PSID, ppsidGroup *PSID, ppDacl PACL *, ppSacl PACL *, ppSecurityDescriptor *PSECURITY_DESCRIPTOR) DWORD + +func GetNumberOfEventLogRecords(hEventLog HANDLE, numberOfRecords *DWORD) bool { + ret1 := syscall3(getNumberOfEventLogRecords, 2, + uintptr(hEventLog), + uintptr(unsafe.Pointer(numberOfRecords)), + 0) + return ret1 != 0 +} + +func GetOldestEventLogRecord(hEventLog HANDLE, oldestRecord *DWORD) bool { + ret1 := syscall3(getOldestEventLogRecord, 2, + uintptr(hEventLog), + uintptr(unsafe.Pointer(oldestRecord)), + 0) + return ret1 != 0 +} + +func GetPrivateObjectSecurity(objectDescriptor PSECURITY_DESCRIPTOR, securityInformation SECURITY_INFORMATION, resultantDescriptor PSECURITY_DESCRIPTOR, descriptorLength DWORD, returnLength *DWORD) bool { + ret1 := syscall6(getPrivateObjectSecurity, 5, + uintptr(unsafe.Pointer(objectDescriptor)), + uintptr(securityInformation), + uintptr(unsafe.Pointer(resultantDescriptor)), + uintptr(descriptorLength), + uintptr(unsafe.Pointer(returnLength)), + 0) + return ret1 != 0 +} + +func GetSecurityDescriptorControl(pSecurityDescriptor PSECURITY_DESCRIPTOR, pControl *SECURITY_DESCRIPTOR_CONTROL, lpdwRevision *uint32) bool { + ret1 := syscall3(getSecurityDescriptorControl, 3, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(unsafe.Pointer(pControl)), + uintptr(unsafe.Pointer(lpdwRevision))) + return ret1 != 0 +} + +// TODO: Unknown type(s): PACL * +// func GetSecurityDescriptorDacl(pSecurityDescriptor PSECURITY_DESCRIPTOR, lpbDaclPresent *BOOL, pDacl PACL *, lpbDaclDefaulted *BOOL) bool + +func GetSecurityDescriptorGroup(pSecurityDescriptor PSECURITY_DESCRIPTOR, pGroup *PSID, lpbGroupDefaulted *BOOL) bool { + ret1 := syscall3(getSecurityDescriptorGroup, 3, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(unsafe.Pointer(pGroup)), + uintptr(unsafe.Pointer(lpbGroupDefaulted))) + return ret1 != 0 +} + +func GetSecurityDescriptorLength(pSecurityDescriptor PSECURITY_DESCRIPTOR) DWORD { + ret1 := syscall3(getSecurityDescriptorLength, 1, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + 0, + 0) + return DWORD(ret1) +} + +func GetSecurityDescriptorOwner(pSecurityDescriptor PSECURITY_DESCRIPTOR, pOwner *PSID, lpbOwnerDefaulted *BOOL) bool { + ret1 := syscall3(getSecurityDescriptorOwner, 3, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(unsafe.Pointer(pOwner)), + uintptr(unsafe.Pointer(lpbOwnerDefaulted))) + return ret1 != 0 +} + +func GetSecurityDescriptorRMControl(securityDescriptor PSECURITY_DESCRIPTOR, rMControl PUCHAR) DWORD { + ret1 := syscall3(getSecurityDescriptorRMControl, 2, + uintptr(unsafe.Pointer(securityDescriptor)), + uintptr(unsafe.Pointer(rMControl)), + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PACL * +// func GetSecurityDescriptorSacl(pSecurityDescriptor PSECURITY_DESCRIPTOR, lpbSaclPresent *BOOL, pSacl PACL *, lpbSaclDefaulted *BOOL) bool + +// TODO: Unknown type(s): PACL * +// func GetSecurityInfo(handle HANDLE, objectType SE_OBJECT_TYPE, securityInfo SECURITY_INFORMATION, ppsidOwner *PSID, ppsidGroup *PSID, ppDacl PACL *, ppSacl PACL *, ppSecurityDescriptor *PSECURITY_DESCRIPTOR) DWORD + +func GetServiceDisplayName(hSCManager SC_HANDLE, lpServiceName string, lpDisplayName LPWSTR, lpcchBuffer *uint32) bool { + lpServiceNameStr := unicode16FromString(lpServiceName) + ret1 := syscall6(getServiceDisplayName, 4, + uintptr(hSCManager), + uintptr(unsafe.Pointer(&lpServiceNameStr[0])), + uintptr(unsafe.Pointer(lpDisplayName)), + uintptr(unsafe.Pointer(lpcchBuffer)), + 0, + 0) + return ret1 != 0 +} + +func GetServiceKeyName(hSCManager SC_HANDLE, lpDisplayName string, lpServiceName LPWSTR, lpcchBuffer *uint32) bool { + lpDisplayNameStr := unicode16FromString(lpDisplayName) + ret1 := syscall6(getServiceKeyName, 4, + uintptr(hSCManager), + uintptr(unsafe.Pointer(&lpDisplayNameStr[0])), + uintptr(unsafe.Pointer(lpServiceName)), + uintptr(unsafe.Pointer(lpcchBuffer)), + 0, + 0) + return ret1 != 0 +} + +func GetSidIdentifierAuthority(pSid PSID) *SID_IDENTIFIER_AUTHORITY { + ret1 := syscall3(getSidIdentifierAuthority, 1, + uintptr(pSid), + 0, + 0) + return (*SID_IDENTIFIER_AUTHORITY)(unsafe.Pointer(ret1)) +} + +func GetSidLengthRequired(nSubAuthorityCount UCHAR) DWORD { + ret1 := syscall3(getSidLengthRequired, 1, + uintptr(nSubAuthorityCount), + 0, + 0) + return DWORD(ret1) +} + +func GetSidSubAuthority(pSid PSID, nSubAuthority DWORD) *DWORD { + ret1 := syscall3(getSidSubAuthority, 2, + uintptr(pSid), + uintptr(nSubAuthority), + 0) + return (*DWORD)(unsafe.Pointer(ret1)) +} + +func GetSidSubAuthorityCount(pSid PSID) PUCHAR { + ret1 := syscall3(getSidSubAuthorityCount, 1, + uintptr(pSid), + 0, + 0) + return (PUCHAR)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): PWAITCHAIN_NODE_INFO +// func GetThreadWaitChain(wctHandle HWCT, context *uint32, flags DWORD, threadId DWORD, nodeCount *uint32, nodeInfoArray PWAITCHAIN_NODE_INFO, isCycle *BOOL) bool + +// TODO: Unknown type(s): TOKEN_INFORMATION_CLASS +// func GetTokenInformation(tokenHandle HANDLE, tokenInformationClass TOKEN_INFORMATION_CLASS, tokenInformation LPVOID, tokenInformationLength DWORD, returnLength *DWORD) bool + +func GetTrusteeForm(pTrustee *TRUSTEE) TRUSTEE_FORM { + ret1 := syscall3(getTrusteeForm, 1, + uintptr(unsafe.Pointer(pTrustee)), + 0, + 0) + return TRUSTEE_FORM(ret1) +} + +func GetTrusteeName(pTrustee *TRUSTEE) LPWSTR { + ret1 := syscall3(getTrusteeName, 1, + uintptr(unsafe.Pointer(pTrustee)), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func GetTrusteeType(pTrustee *TRUSTEE) TRUSTEE_TYPE { + ret1 := syscall3(getTrusteeType, 1, + uintptr(unsafe.Pointer(pTrustee)), + 0, + 0) + return TRUSTEE_TYPE(ret1) +} + +func GetUserName(lpBuffer LPWSTR, pcbBuffer *uint32) bool { + ret1 := syscall3(getUserName, 2, + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(unsafe.Pointer(pcbBuffer)), + 0) + return ret1 != 0 +} + +func GetWindowsAccountDomainSid(pSid PSID, pDomainSid PSID, cbDomainSid *uint32) bool { + ret1 := syscall3(getWindowsAccountDomainSid, 3, + uintptr(pSid), + uintptr(pDomainSid), + uintptr(unsafe.Pointer(cbDomainSid))) + return ret1 != 0 +} + +func ImpersonateAnonymousToken(threadHandle HANDLE) bool { + ret1 := syscall3(impersonateAnonymousToken, 1, + uintptr(threadHandle), + 0, + 0) + return ret1 != 0 +} + +func ImpersonateLoggedOnUser(hToken HANDLE) bool { + ret1 := syscall3(impersonateLoggedOnUser, 1, + uintptr(hToken), + 0, + 0) + return ret1 != 0 +} + +func ImpersonateNamedPipeClient(hNamedPipe HANDLE) bool { + ret1 := syscall3(impersonateNamedPipeClient, 1, + uintptr(hNamedPipe), + 0, + 0) + return ret1 != 0 +} + +func ImpersonateSelf(impersonationLevel SECURITY_IMPERSONATION_LEVEL) bool { + ret1 := syscall3(impersonateSelf, 1, + uintptr(impersonationLevel), + 0, + 0) + return ret1 != 0 +} + +func InitializeAcl(pAcl *ACL, nAclLength DWORD, dwAclRevision DWORD) bool { + ret1 := syscall3(initializeAcl, 3, + uintptr(unsafe.Pointer(pAcl)), + uintptr(nAclLength), + uintptr(dwAclRevision)) + return ret1 != 0 +} + +func InitializeSecurityDescriptor(pSecurityDescriptor PSECURITY_DESCRIPTOR, dwRevision DWORD) bool { + ret1 := syscall3(initializeSecurityDescriptor, 2, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(dwRevision), + 0) + return ret1 != 0 +} + +func InitializeSid(sid PSID, pIdentifierAuthority *SID_IDENTIFIER_AUTHORITY, nSubAuthorityCount BYTE) bool { + ret1 := syscall3(initializeSid, 3, + uintptr(sid), + uintptr(unsafe.Pointer(pIdentifierAuthority)), + uintptr(nSubAuthorityCount)) + return ret1 != 0 +} + +func InitiateShutdown(lpMachineName LPWSTR, lpMessage LPWSTR, dwGracePeriod DWORD, dwShutdownFlags DWORD, dwReason DWORD) DWORD { + ret1 := syscall6(initiateShutdown, 5, + uintptr(unsafe.Pointer(lpMachineName)), + uintptr(unsafe.Pointer(lpMessage)), + uintptr(dwGracePeriod), + uintptr(dwShutdownFlags), + uintptr(dwReason), + 0) + return DWORD(ret1) +} + +func InitiateSystemShutdownEx(lpMachineName LPWSTR, lpMessage LPWSTR, dwTimeout DWORD, bForceAppsClosed bool, bRebootAfterShutdown bool, dwReason DWORD) bool { + ret1 := syscall6(initiateSystemShutdownEx, 6, + uintptr(unsafe.Pointer(lpMachineName)), + uintptr(unsafe.Pointer(lpMessage)), + uintptr(dwTimeout), + getUintptrFromBool(bForceAppsClosed), + getUintptrFromBool(bRebootAfterShutdown), + uintptr(dwReason)) + return ret1 != 0 +} + +func InitiateSystemShutdown(lpMachineName LPWSTR, lpMessage LPWSTR, dwTimeout DWORD, bForceAppsClosed bool, bRebootAfterShutdown bool) bool { + ret1 := syscall6(initiateSystemShutdown, 5, + uintptr(unsafe.Pointer(lpMachineName)), + uintptr(unsafe.Pointer(lpMessage)), + uintptr(dwTimeout), + getUintptrFromBool(bForceAppsClosed), + getUintptrFromBool(bRebootAfterShutdown), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PINSTALLDATA +// func InstallApplication(pInstallInfo PINSTALLDATA) DWORD + +func IsTextUnicode(lpv /*const*/ uintptr, iSize int32, lpiResult *int32) bool { + ret1 := syscall3(isTextUnicode, 3, + lpv, + uintptr(iSize), + uintptr(unsafe.Pointer(lpiResult))) + return ret1 != 0 +} + +func IsTokenRestricted(tokenHandle HANDLE) bool { + ret1 := syscall3(isTokenRestricted, 1, + uintptr(tokenHandle), + 0, + 0) + return ret1 != 0 +} + +func IsTokenUntrusted(tokenHandle HANDLE) bool { + ret1 := syscall3(isTokenUntrusted, 1, + uintptr(tokenHandle), + 0, + 0) + return ret1 != 0 +} + +func IsValidAcl(pAcl *ACL) bool { + ret1 := syscall3(isValidAcl, 1, + uintptr(unsafe.Pointer(pAcl)), + 0, + 0) + return ret1 != 0 +} + +func IsValidSecurityDescriptor(pSecurityDescriptor PSECURITY_DESCRIPTOR) bool { + ret1 := syscall3(isValidSecurityDescriptor, 1, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + 0, + 0) + return ret1 != 0 +} + +func IsValidSid(pSid PSID) bool { + ret1 := syscall3(isValidSid, 1, + uintptr(pSid), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): WELL_KNOWN_SID_TYPE +// func IsWellKnownSid(pSid PSID, wellKnownSidType WELL_KNOWN_SID_TYPE) bool + +func LockServiceDatabase(hSCManager SC_HANDLE) SC_LOCK { + ret1 := syscall3(lockServiceDatabase, 1, + uintptr(hSCManager), + 0, + 0) + return SC_LOCK(ret1) +} + +// TODO: Unknown type(s): PQUOTA_LIMITS +// func LogonUserEx(lpszUsername string, lpszDomain string, lpszPassword string, dwLogonType DWORD, dwLogonProvider DWORD, phToken *HANDLE, ppLogonSid *PSID, ppProfileBuffer *PVOID, pdwProfileLength *uint32, pQuotaLimits PQUOTA_LIMITS) bool + +func LogonUser(lpszUsername string, lpszDomain string, lpszPassword string, dwLogonType DWORD, dwLogonProvider DWORD, phToken *HANDLE) bool { + lpszUsernameStr := unicode16FromString(lpszUsername) + lpszDomainStr := unicode16FromString(lpszDomain) + lpszPasswordStr := unicode16FromString(lpszPassword) + ret1 := syscall6(logonUser, 6, + uintptr(unsafe.Pointer(&lpszUsernameStr[0])), + uintptr(unsafe.Pointer(&lpszDomainStr[0])), + uintptr(unsafe.Pointer(&lpszPasswordStr[0])), + uintptr(dwLogonType), + uintptr(dwLogonProvider), + uintptr(unsafe.Pointer(phToken))) + return ret1 != 0 +} + +// TODO: Unknown type(s): PSID_NAME_USE +// func LookupAccountName(lpSystemName string, lpAccountName string, sid PSID, cbSid *uint32, referencedDomainName LPWSTR, cchReferencedDomainName *uint32, peUse PSID_NAME_USE) bool + +// TODO: Unknown type(s): PSID_NAME_USE +// func LookupAccountSid(lpSystemName string, sid PSID, name LPWSTR, cchName *uint32, referencedDomainName LPWSTR, cchReferencedDomainName *uint32, peUse PSID_NAME_USE) bool + +func LookupPrivilegeDisplayName(lpSystemName string, lpName string, lpDisplayName LPWSTR, cchDisplayName *uint32, lpLanguageId *uint32) bool { + lpSystemNameStr := unicode16FromString(lpSystemName) + lpNameStr := unicode16FromString(lpName) + ret1 := syscall6(lookupPrivilegeDisplayName, 5, + uintptr(unsafe.Pointer(&lpSystemNameStr[0])), + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(unsafe.Pointer(lpDisplayName)), + uintptr(unsafe.Pointer(cchDisplayName)), + uintptr(unsafe.Pointer(lpLanguageId)), + 0) + return ret1 != 0 +} + +func LookupPrivilegeName(lpSystemName string, lpLuid *LUID, lpName LPWSTR, cchName *uint32) bool { + lpSystemNameStr := unicode16FromString(lpSystemName) + ret1 := syscall6(lookupPrivilegeName, 4, + uintptr(unsafe.Pointer(&lpSystemNameStr[0])), + uintptr(unsafe.Pointer(lpLuid)), + uintptr(unsafe.Pointer(lpName)), + uintptr(unsafe.Pointer(cchName)), + 0, + 0) + return ret1 != 0 +} + +func LookupPrivilegeValue(lpSystemName string, lpName string, lpLuid *LUID) bool { + lpSystemNameStr := unicode16FromString(lpSystemName) + lpNameStr := unicode16FromString(lpName) + ret1 := syscall3(lookupPrivilegeValue, 3, + uintptr(unsafe.Pointer(&lpSystemNameStr[0])), + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(unsafe.Pointer(lpLuid))) + return ret1 != 0 +} + +// TODO: Unknown type(s): PEXPLICIT_ACCESS_W *, PTRUSTEE_W * +// func LookupSecurityDescriptorParts(ppOwner PTRUSTEE_W *, ppGroup PTRUSTEE_W *, pcCountOfAccessEntries *uint32, ppListOfAccessEntries PEXPLICIT_ACCESS_W *, pcCountOfAuditEntries *uint32, ppListOfAuditEntries PEXPLICIT_ACCESS_W *, pSD PSECURITY_DESCRIPTOR) DWORD + +// TODO: Unknown type(s): PLM_OWF_PASSWORD, PNT_OWF_PASSWORD +// func MSChapSrvChangePassword(serverName LPWSTR, userName LPWSTR, lmOldPresent BOOLEAN, lmOldOwfPassword PLM_OWF_PASSWORD, lmNewOwfPassword PLM_OWF_PASSWORD, ntOldOwfPassword PNT_OWF_PASSWORD, ntNewOwfPassword PNT_OWF_PASSWORD) DWORD + +// TODO: Unknown type(s): PENCRYPTED_LM_OWF_PASSWORD, PENCRYPTED_NT_OWF_PASSWORD, PSAMPR_ENCRYPTED_USER_PASSWORD +// func MSChapSrvChangePassword2(serverName LPWSTR, userName LPWSTR, newPasswordEncryptedWithOldNt PSAMPR_ENCRYPTED_USER_PASSWORD, oldNtOwfPasswordEncryptedWithNewNt PENCRYPTED_NT_OWF_PASSWORD, lmPresent BOOLEAN, newPasswordEncryptedWithOldLm PSAMPR_ENCRYPTED_USER_PASSWORD, oldLmOwfPasswordEncryptedWithNewLmOrNt PENCRYPTED_LM_OWF_PASSWORD) DWORD + +func MakeAbsoluteSD(pSelfRelativeSecurityDescriptor PSECURITY_DESCRIPTOR, pAbsoluteSecurityDescriptor PSECURITY_DESCRIPTOR, lpdwAbsoluteSecurityDescriptorSize *uint32, pDacl *ACL, lpdwDaclSize *uint32, pSacl *ACL, lpdwSaclSize *uint32, pOwner PSID, lpdwOwnerSize *uint32, pPrimaryGroup PSID, lpdwPrimaryGroupSize *uint32) bool { + ret1 := syscall12(makeAbsoluteSD, 11, + uintptr(unsafe.Pointer(pSelfRelativeSecurityDescriptor)), + uintptr(unsafe.Pointer(pAbsoluteSecurityDescriptor)), + uintptr(unsafe.Pointer(lpdwAbsoluteSecurityDescriptorSize)), + uintptr(unsafe.Pointer(pDacl)), + uintptr(unsafe.Pointer(lpdwDaclSize)), + uintptr(unsafe.Pointer(pSacl)), + uintptr(unsafe.Pointer(lpdwSaclSize)), + uintptr(pOwner), + uintptr(unsafe.Pointer(lpdwOwnerSize)), + uintptr(pPrimaryGroup), + uintptr(unsafe.Pointer(lpdwPrimaryGroupSize)), + 0) + return ret1 != 0 +} + +func MakeSelfRelativeSD(pAbsoluteSecurityDescriptor PSECURITY_DESCRIPTOR, pSelfRelativeSecurityDescriptor PSECURITY_DESCRIPTOR, lpdwBufferLength *uint32) bool { + ret1 := syscall3(makeSelfRelativeSD, 3, + uintptr(unsafe.Pointer(pAbsoluteSecurityDescriptor)), + uintptr(unsafe.Pointer(pSelfRelativeSecurityDescriptor)), + uintptr(unsafe.Pointer(lpdwBufferLength))) + return ret1 != 0 +} + +func MapGenericMask(accessMask *DWORD, genericMapping *GENERIC_MAPPING) { + syscall3(mapGenericMask, 2, + uintptr(unsafe.Pointer(accessMask)), + uintptr(unsafe.Pointer(genericMapping)), + 0) +} + +func NotifyBootConfigStatus(bootAcceptable bool) bool { + ret1 := syscall3(notifyBootConfigStatus, 1, + getUintptrFromBool(bootAcceptable), + 0, + 0) + return ret1 != 0 +} + +func NotifyChangeEventLog(hEventLog HANDLE, hEvent HANDLE) bool { + ret1 := syscall3(notifyChangeEventLog, 2, + uintptr(hEventLog), + uintptr(hEvent), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PSERVICE_NOTIFYW +// func NotifyServiceStatusChange(hService SC_HANDLE, dwNotifyMask DWORD, pNotifyBuffer PSERVICE_NOTIFYW) DWORD + +func ObjectCloseAuditAlarm(subsystemName string, handleId LPVOID, generateOnClose bool) bool { + subsystemNameStr := unicode16FromString(subsystemName) + ret1 := syscall3(objectCloseAuditAlarm, 3, + uintptr(unsafe.Pointer(&subsystemNameStr[0])), + uintptr(unsafe.Pointer(handleId)), + getUintptrFromBool(generateOnClose)) + return ret1 != 0 +} + +func ObjectDeleteAuditAlarm(subsystemName string, handleId LPVOID, generateOnClose bool) bool { + subsystemNameStr := unicode16FromString(subsystemName) + ret1 := syscall3(objectDeleteAuditAlarm, 3, + uintptr(unsafe.Pointer(&subsystemNameStr[0])), + uintptr(unsafe.Pointer(handleId)), + getUintptrFromBool(generateOnClose)) + return ret1 != 0 +} + +func ObjectOpenAuditAlarm(subsystemName string, handleId LPVOID, objectTypeName LPWSTR, objectName LPWSTR, pSecurityDescriptor PSECURITY_DESCRIPTOR, clientToken HANDLE, desiredAccess DWORD, grantedAccess DWORD, privileges *PRIVILEGE_SET, objectCreation bool, accessGranted bool, generateOnClose *BOOL) bool { + subsystemNameStr := unicode16FromString(subsystemName) + ret1 := syscall12(objectOpenAuditAlarm, 12, + uintptr(unsafe.Pointer(&subsystemNameStr[0])), + uintptr(unsafe.Pointer(handleId)), + uintptr(unsafe.Pointer(objectTypeName)), + uintptr(unsafe.Pointer(objectName)), + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(clientToken), + uintptr(desiredAccess), + uintptr(grantedAccess), + uintptr(unsafe.Pointer(privileges)), + getUintptrFromBool(objectCreation), + getUintptrFromBool(accessGranted), + uintptr(unsafe.Pointer(generateOnClose))) + return ret1 != 0 +} + +func ObjectPrivilegeAuditAlarm(subsystemName string, handleId LPVOID, clientToken HANDLE, desiredAccess DWORD, privileges *PRIVILEGE_SET, accessGranted bool) bool { + subsystemNameStr := unicode16FromString(subsystemName) + ret1 := syscall6(objectPrivilegeAuditAlarm, 6, + uintptr(unsafe.Pointer(&subsystemNameStr[0])), + uintptr(unsafe.Pointer(handleId)), + uintptr(clientToken), + uintptr(desiredAccess), + uintptr(unsafe.Pointer(privileges)), + getUintptrFromBool(accessGranted)) + return ret1 != 0 +} + +func OpenBackupEventLog(lpUNCServerName string, lpFileName string) HANDLE { + lpUNCServerNameStr := unicode16FromString(lpUNCServerName) + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(openBackupEventLog, 2, + uintptr(unsafe.Pointer(&lpUNCServerNameStr[0])), + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + 0) + return HANDLE(ret1) +} + +func OpenEncryptedFileRaw(lpFileName string, ulFlags ULONG, pvContext *PVOID) DWORD { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(openEncryptedFileRaw, 3, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(ulFlags), + uintptr(unsafe.Pointer(pvContext))) + return DWORD(ret1) +} + +func OpenEventLog(lpUNCServerName string, lpSourceName string) HANDLE { + lpUNCServerNameStr := unicode16FromString(lpUNCServerName) + lpSourceNameStr := unicode16FromString(lpSourceName) + ret1 := syscall3(openEventLog, 2, + uintptr(unsafe.Pointer(&lpUNCServerNameStr[0])), + uintptr(unsafe.Pointer(&lpSourceNameStr[0])), + 0) + return HANDLE(ret1) +} + +func OpenProcessToken(processHandle HANDLE, desiredAccess DWORD, tokenHandle *HANDLE) bool { + ret1 := syscall3(openProcessToken, 3, + uintptr(processHandle), + uintptr(desiredAccess), + uintptr(unsafe.Pointer(tokenHandle))) + return ret1 != 0 +} + +func OpenSCManager(lpMachineName string, lpDatabaseName string, dwDesiredAccess DWORD) SC_HANDLE { + lpMachineNameStr := unicode16FromString(lpMachineName) + lpDatabaseNameStr := unicode16FromString(lpDatabaseName) + ret1 := syscall3(openSCManager, 3, + uintptr(unsafe.Pointer(&lpMachineNameStr[0])), + uintptr(unsafe.Pointer(&lpDatabaseNameStr[0])), + uintptr(dwDesiredAccess)) + return SC_HANDLE(ret1) +} + +func OpenService(hSCManager SC_HANDLE, lpServiceName string, dwDesiredAccess DWORD) SC_HANDLE { + lpServiceNameStr := unicode16FromString(lpServiceName) + ret1 := syscall3(openService, 3, + uintptr(hSCManager), + uintptr(unsafe.Pointer(&lpServiceNameStr[0])), + uintptr(dwDesiredAccess)) + return SC_HANDLE(ret1) +} + +func OpenThreadToken(threadHandle HANDLE, desiredAccess DWORD, openAsSelf bool, tokenHandle *HANDLE) bool { + ret1 := syscall6(openThreadToken, 4, + uintptr(threadHandle), + uintptr(desiredAccess), + getUintptrFromBool(openAsSelf), + uintptr(unsafe.Pointer(tokenHandle)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PWAITCHAINCALLBACK +// func OpenThreadWaitChainSession(flags DWORD, callback PWAITCHAINCALLBACK) HWCT + +func PerfCreateInstance(hProvider HANDLE, counterSetGuid /*const*/ *GUID, szInstanceName string, dwInstance ULONG) *PERF_COUNTERSET_INSTANCE { + szInstanceNameStr := unicode16FromString(szInstanceName) + ret1 := syscall6(perfCreateInstance, 4, + uintptr(hProvider), + uintptr(unsafe.Pointer(counterSetGuid)), + uintptr(unsafe.Pointer(&szInstanceNameStr[0])), + uintptr(dwInstance), + 0, + 0) + return (*PERF_COUNTERSET_INSTANCE)(unsafe.Pointer(ret1)) +} + +func PerfDecrementULongCounterValue(hProvider HANDLE, pInstance *PERF_COUNTERSET_INSTANCE, counterId ULONG, lValue ULONG) ULONG { + ret1 := syscall6(perfDecrementULongCounterValue, 4, + uintptr(hProvider), + uintptr(unsafe.Pointer(pInstance)), + uintptr(counterId), + uintptr(lValue), + 0, + 0) + return ULONG(ret1) +} + +func PerfDecrementULongLongCounterValue(hProvider HANDLE, pInstance *PERF_COUNTERSET_INSTANCE, counterId ULONG, llValue ULONGLONG) ULONG { + ret1 := syscall6(perfDecrementULongLongCounterValue, 4, + uintptr(hProvider), + uintptr(unsafe.Pointer(pInstance)), + uintptr(counterId), + uintptr(llValue), + 0, + 0) + return ULONG(ret1) +} + +func PerfDeleteInstance(hProvider HANDLE, instanceBlock *PERF_COUNTERSET_INSTANCE) ULONG { + ret1 := syscall3(perfDeleteInstance, 2, + uintptr(hProvider), + uintptr(unsafe.Pointer(instanceBlock)), + 0) + return ULONG(ret1) +} + +func PerfIncrementULongCounterValue(hProvider HANDLE, pInstance *PERF_COUNTERSET_INSTANCE, counterId ULONG, lValue ULONG) ULONG { + ret1 := syscall6(perfIncrementULongCounterValue, 4, + uintptr(hProvider), + uintptr(unsafe.Pointer(pInstance)), + uintptr(counterId), + uintptr(lValue), + 0, + 0) + return ULONG(ret1) +} + +func PerfIncrementULongLongCounterValue(hProvider HANDLE, pInstance *PERF_COUNTERSET_INSTANCE, counterId ULONG, llValue ULONGLONG) ULONG { + ret1 := syscall6(perfIncrementULongLongCounterValue, 4, + uintptr(hProvider), + uintptr(unsafe.Pointer(pInstance)), + uintptr(counterId), + uintptr(llValue), + 0, + 0) + return ULONG(ret1) +} + +func PerfQueryInstance(hProvider HANDLE, counterSetGuid /*const*/ *GUID, szInstance string, dwInstance ULONG) *PERF_COUNTERSET_INSTANCE { + szInstanceStr := unicode16FromString(szInstance) + ret1 := syscall6(perfQueryInstance, 4, + uintptr(hProvider), + uintptr(unsafe.Pointer(counterSetGuid)), + uintptr(unsafe.Pointer(&szInstanceStr[0])), + uintptr(dwInstance), + 0, + 0) + return (*PERF_COUNTERSET_INSTANCE)(unsafe.Pointer(ret1)) +} + +func PerfSetCounterRefValue(hProvider HANDLE, pInstance *PERF_COUNTERSET_INSTANCE, counterId ULONG, lpAddr uintptr) ULONG { + ret1 := syscall6(perfSetCounterRefValue, 4, + uintptr(hProvider), + uintptr(unsafe.Pointer(pInstance)), + uintptr(counterId), + lpAddr, + 0, + 0) + return ULONG(ret1) +} + +// TODO: Unknown type(s): PPERF_COUNTERSET_INFO +// func PerfSetCounterSetInfo(hProvider HANDLE, pTemplate PPERF_COUNTERSET_INFO, dwTemplateSize ULONG) ULONG + +func PerfSetULongCounterValue(hProvider HANDLE, pInstance *PERF_COUNTERSET_INSTANCE, counterId ULONG, lValue ULONG) ULONG { + ret1 := syscall6(perfSetULongCounterValue, 4, + uintptr(hProvider), + uintptr(unsafe.Pointer(pInstance)), + uintptr(counterId), + uintptr(lValue), + 0, + 0) + return ULONG(ret1) +} + +func PerfSetULongLongCounterValue(hProvider HANDLE, pInstance *PERF_COUNTERSET_INSTANCE, counterId ULONG, llValue ULONGLONG) ULONG { + ret1 := syscall6(perfSetULongLongCounterValue, 4, + uintptr(hProvider), + uintptr(unsafe.Pointer(pInstance)), + uintptr(counterId), + uintptr(llValue), + 0, + 0) + return ULONG(ret1) +} + +// TODO: Unknown type(s): PERFLIBREQUEST +// func PerfStartProvider(providerGuid *GUID, controlCallback PERFLIBREQUEST, phProvider *HANDLE) ULONG + +// TODO: Unknown type(s): PPERF_PROVIDER_CONTEXT +// func PerfStartProviderEx(providerGuid *GUID, providerContext PPERF_PROVIDER_CONTEXT, phProvider *HANDLE) ULONG + +func PerfStopProvider(hProvider HANDLE) ULONG { + ret1 := syscall3(perfStopProvider, 1, + uintptr(hProvider), + 0, + 0) + return ULONG(ret1) +} + +func PrivilegeCheck(clientToken HANDLE, requiredPrivileges *PRIVILEGE_SET, pfResult *BOOL) bool { + ret1 := syscall3(privilegeCheck, 3, + uintptr(clientToken), + uintptr(unsafe.Pointer(requiredPrivileges)), + uintptr(unsafe.Pointer(pfResult))) + return ret1 != 0 +} + +func PrivilegedServiceAuditAlarm(subsystemName string, serviceName string, clientToken HANDLE, privileges *PRIVILEGE_SET, accessGranted bool) bool { + subsystemNameStr := unicode16FromString(subsystemName) + serviceNameStr := unicode16FromString(serviceName) + ret1 := syscall6(privilegedServiceAuditAlarm, 5, + uintptr(unsafe.Pointer(&subsystemNameStr[0])), + uintptr(unsafe.Pointer(&serviceNameStr[0])), + uintptr(clientToken), + uintptr(unsafe.Pointer(privileges)), + getUintptrFromBool(accessGranted), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PENCRYPTION_CERTIFICATE_HASH_LIST * +// func QueryRecoveryAgentsOnEncryptedFile(lpFileName string, pRecoveryAgents PENCRYPTION_CERTIFICATE_HASH_LIST *) DWORD + +func QuerySecurityAccessMask(securityInformation SECURITY_INFORMATION, desiredAccess *uint32) { + syscall3(querySecurityAccessMask, 2, + uintptr(securityInformation), + uintptr(unsafe.Pointer(desiredAccess)), + 0) +} + +func QueryServiceConfig2(hService SC_HANDLE, dwInfoLevel DWORD, lpBuffer *byte, cbBufSize DWORD, pcbBytesNeeded *uint32) bool { + ret1 := syscall6(queryServiceConfig2, 5, + uintptr(hService), + uintptr(dwInfoLevel), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(cbBufSize), + uintptr(unsafe.Pointer(pcbBytesNeeded)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPQUERY_SERVICE_CONFIGW +// func QueryServiceConfig(hService SC_HANDLE, lpServiceConfig LPQUERY_SERVICE_CONFIGW, cbBufSize DWORD, pcbBytesNeeded *uint32) bool + +// TODO: Unknown type(s): LPQUERY_SERVICE_LOCK_STATUSW +// func QueryServiceLockStatus(hSCManager SC_HANDLE, lpLockStatus LPQUERY_SERVICE_LOCK_STATUSW, cbBufSize DWORD, pcbBytesNeeded *uint32) bool + +func QueryServiceObjectSecurity(hService SC_HANDLE, dwSecurityInformation SECURITY_INFORMATION, lpSecurityDescriptor PSECURITY_DESCRIPTOR, cbBufSize DWORD, pcbBytesNeeded *uint32) bool { + ret1 := syscall6(queryServiceObjectSecurity, 5, + uintptr(hService), + uintptr(dwSecurityInformation), + uintptr(unsafe.Pointer(lpSecurityDescriptor)), + uintptr(cbBufSize), + uintptr(unsafe.Pointer(pcbBytesNeeded)), + 0) + return ret1 != 0 +} + +func QueryServiceStatus(hService SC_HANDLE, lpServiceStatus *SERVICE_STATUS) bool { + ret1 := syscall3(queryServiceStatus, 2, + uintptr(hService), + uintptr(unsafe.Pointer(lpServiceStatus)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): SC_STATUS_TYPE +// func QueryServiceStatusEx(hService SC_HANDLE, infoLevel SC_STATUS_TYPE, lpBuffer *byte, cbBufSize DWORD, pcbBytesNeeded *uint32) bool + +// TODO: Unknown type(s): PENCRYPTION_CERTIFICATE_HASH_LIST * +// func QueryUsersOnEncryptedFile(lpFileName string, pUsers PENCRYPTION_CERTIFICATE_HASH_LIST *) DWORD + +// TODO: Unknown type(s): PFE_EXPORT_FUNC +// func ReadEncryptedFileRaw(pfExportCallback PFE_EXPORT_FUNC, pvCallbackContext uintptr, pvContext uintptr) DWORD + +func ReadEventLog(hEventLog HANDLE, dwReadFlags DWORD, dwRecordOffset DWORD, lpBuffer LPVOID, nNumberOfBytesToRead DWORD, pnBytesRead *uint32, pnMinNumberOfBytesNeeded *uint32) bool { + ret1 := syscall9(readEventLog, 7, + uintptr(hEventLog), + uintptr(dwReadFlags), + uintptr(dwRecordOffset), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(nNumberOfBytesToRead), + uintptr(unsafe.Pointer(pnBytesRead)), + uintptr(unsafe.Pointer(pnMinNumberOfBytesNeeded)), + 0, + 0) + return ret1 != 0 +} + +func RegCloseKey(hKey HKEY) LONG { + ret1 := syscall3(regCloseKey, 1, + uintptr(hKey), + 0, + 0) + return LONG(ret1) +} + +func RegConnectRegistryEx(lpMachineName string, hKey HKEY, flags ULONG, phkResult *HKEY) LONG { + lpMachineNameStr := unicode16FromString(lpMachineName) + ret1 := syscall6(regConnectRegistryEx, 4, + uintptr(unsafe.Pointer(&lpMachineNameStr[0])), + uintptr(hKey), + uintptr(flags), + uintptr(unsafe.Pointer(phkResult)), + 0, + 0) + return LONG(ret1) +} + +func RegConnectRegistry(lpMachineName string, hKey HKEY, phkResult *HKEY) LONG { + lpMachineNameStr := unicode16FromString(lpMachineName) + ret1 := syscall3(regConnectRegistry, 3, + uintptr(unsafe.Pointer(&lpMachineNameStr[0])), + uintptr(hKey), + uintptr(unsafe.Pointer(phkResult))) + return LONG(ret1) +} + +func RegCopyTree(hKeySrc HKEY, lpSubKey string, hKeyDest HKEY) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + ret1 := syscall3(regCopyTree, 3, + uintptr(hKeySrc), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(hKeyDest)) + return LONG(ret1) +} + +func RegCreateKeyEx(hKey HKEY, lpSubKey string, reserved DWORD, lpClass LPWSTR, dwOptions DWORD, samDesired REGSAM, lpSecurityAttributes *SECURITY_ATTRIBUTES, phkResult *HKEY, lpdwDisposition *uint32) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + ret1 := syscall9(regCreateKeyEx, 9, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(reserved), + uintptr(unsafe.Pointer(lpClass)), + uintptr(dwOptions), + uintptr(samDesired), + uintptr(unsafe.Pointer(lpSecurityAttributes)), + uintptr(unsafe.Pointer(phkResult)), + uintptr(unsafe.Pointer(lpdwDisposition))) + return LONG(ret1) +} + +func RegCreateKeyTransacted(hKey HKEY, lpSubKey string, reserved DWORD, lpClass LPWSTR, dwOptions DWORD, samDesired REGSAM, lpSecurityAttributes /*const*/ *SECURITY_ATTRIBUTES, phkResult *HKEY, lpdwDisposition *uint32, hTransaction HANDLE, pExtendedParemeter uintptr) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + ret1 := syscall12(regCreateKeyTransacted, 11, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(reserved), + uintptr(unsafe.Pointer(lpClass)), + uintptr(dwOptions), + uintptr(samDesired), + uintptr(unsafe.Pointer(lpSecurityAttributes)), + uintptr(unsafe.Pointer(phkResult)), + uintptr(unsafe.Pointer(lpdwDisposition)), + uintptr(hTransaction), + pExtendedParemeter, + 0) + return LONG(ret1) +} + +func RegCreateKey(hKey HKEY, lpSubKey string, phkResult *HKEY) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + ret1 := syscall3(regCreateKey, 3, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(unsafe.Pointer(phkResult))) + return LONG(ret1) +} + +func RegDeleteKeyEx(hKey HKEY, lpSubKey string, samDesired REGSAM, reserved DWORD) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + ret1 := syscall6(regDeleteKeyEx, 4, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(samDesired), + uintptr(reserved), + 0, + 0) + return LONG(ret1) +} + +func RegDeleteKeyTransacted(hKey HKEY, lpSubKey string, samDesired REGSAM, reserved DWORD, hTransaction HANDLE, pExtendedParameter uintptr) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + ret1 := syscall6(regDeleteKeyTransacted, 6, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(samDesired), + uintptr(reserved), + uintptr(hTransaction), + pExtendedParameter) + return LONG(ret1) +} + +func RegDeleteKeyValue(hKey HKEY, lpSubKey string, lpValueName string) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + lpValueNameStr := unicode16FromString(lpValueName) + ret1 := syscall3(regDeleteKeyValue, 3, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(unsafe.Pointer(&lpValueNameStr[0]))) + return LONG(ret1) +} + +func RegDeleteKey(hKey HKEY, lpSubKey string) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + ret1 := syscall3(regDeleteKey, 2, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + 0) + return LONG(ret1) +} + +func RegDeleteTree(hKey HKEY, lpSubKey string) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + ret1 := syscall3(regDeleteTree, 2, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + 0) + return LONG(ret1) +} + +func RegDeleteValue(hKey HKEY, lpValueName string) LONG { + lpValueNameStr := unicode16FromString(lpValueName) + ret1 := syscall3(regDeleteValue, 2, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpValueNameStr[0])), + 0) + return LONG(ret1) +} + +func RegDisablePredefinedCache() LONG { + ret1 := syscall3(regDisablePredefinedCache, 0, + 0, + 0, + 0) + return LONG(ret1) +} + +func RegDisablePredefinedCacheEx() LONG { + ret1 := syscall3(regDisablePredefinedCacheEx, 0, + 0, + 0, + 0) + return LONG(ret1) +} + +func RegDisableReflectionKey(hBase HKEY) LONG { + ret1 := syscall3(regDisableReflectionKey, 1, + uintptr(hBase), + 0, + 0) + return LONG(ret1) +} + +func RegEnableReflectionKey(hBase HKEY) LONG { + ret1 := syscall3(regEnableReflectionKey, 1, + uintptr(hBase), + 0, + 0) + return LONG(ret1) +} + +// TODO: Unknown type(s): PFILETIME +// func RegEnumKeyEx(hKey HKEY, dwIndex DWORD, lpName LPWSTR, lpcchName *uint32, lpReserved *uint32, lpClass LPWSTR, lpcchClass *uint32, lpftLastWriteTime PFILETIME) LONG + +func RegEnumKey(hKey HKEY, dwIndex DWORD, lpName LPWSTR, cchName DWORD) LONG { + ret1 := syscall6(regEnumKey, 4, + uintptr(hKey), + uintptr(dwIndex), + uintptr(unsafe.Pointer(lpName)), + uintptr(cchName), + 0, + 0) + return LONG(ret1) +} + +func RegEnumValue(hKey HKEY, dwIndex DWORD, lpValueName LPWSTR, lpcchValueName *uint32, lpReserved *uint32, lpType *uint32, lpData *byte, lpcbData *uint32) LONG { + ret1 := syscall9(regEnumValue, 8, + uintptr(hKey), + uintptr(dwIndex), + uintptr(unsafe.Pointer(lpValueName)), + uintptr(unsafe.Pointer(lpcchValueName)), + uintptr(unsafe.Pointer(lpReserved)), + uintptr(unsafe.Pointer(lpType)), + uintptr(unsafe.Pointer(lpData)), + uintptr(unsafe.Pointer(lpcbData)), + 0) + return LONG(ret1) +} + +func RegFlushKey(hKey HKEY) LONG { + ret1 := syscall3(regFlushKey, 1, + uintptr(hKey), + 0, + 0) + return LONG(ret1) +} + +func RegGetKeySecurity(hKey HKEY, securityInformation SECURITY_INFORMATION, pSecurityDescriptor PSECURITY_DESCRIPTOR, lpcbSecurityDescriptor *uint32) LONG { + ret1 := syscall6(regGetKeySecurity, 4, + uintptr(hKey), + uintptr(securityInformation), + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(unsafe.Pointer(lpcbSecurityDescriptor)), + 0, + 0) + return LONG(ret1) +} + +func RegGetValue(hkey HKEY, lpSubKey string, lpValue string, dwFlags DWORD, pdwType *uint32, pvData uintptr, pcbData *uint32) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + lpValueStr := unicode16FromString(lpValue) + ret1 := syscall9(regGetValue, 7, + uintptr(hkey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(unsafe.Pointer(&lpValueStr[0])), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pdwType)), + pvData, + uintptr(unsafe.Pointer(pcbData)), + 0, + 0) + return LONG(ret1) +} + +func RegLoadAppKey(lpFile string, phkResult *HKEY, samDesired REGSAM, dwOptions DWORD, reserved DWORD) LONG { + lpFileStr := unicode16FromString(lpFile) + ret1 := syscall6(regLoadAppKey, 5, + uintptr(unsafe.Pointer(&lpFileStr[0])), + uintptr(unsafe.Pointer(phkResult)), + uintptr(samDesired), + uintptr(dwOptions), + uintptr(reserved), + 0) + return LONG(ret1) +} + +func RegLoadKey(hKey HKEY, lpSubKey string, lpFile string) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + lpFileStr := unicode16FromString(lpFile) + ret1 := syscall3(regLoadKey, 3, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(unsafe.Pointer(&lpFileStr[0]))) + return LONG(ret1) +} + +func RegLoadMUIString(hKey HKEY, pszValue string, pszOutBuf LPWSTR, cbOutBuf DWORD, pcbData *uint32, flags DWORD, pszDirectory string) LONG { + pszValueStr := unicode16FromString(pszValue) + pszDirectoryStr := unicode16FromString(pszDirectory) + ret1 := syscall9(regLoadMUIString, 7, + uintptr(hKey), + uintptr(unsafe.Pointer(&pszValueStr[0])), + uintptr(unsafe.Pointer(pszOutBuf)), + uintptr(cbOutBuf), + uintptr(unsafe.Pointer(pcbData)), + uintptr(flags), + uintptr(unsafe.Pointer(&pszDirectoryStr[0])), + 0, + 0) + return LONG(ret1) +} + +func RegNotifyChangeKeyValue(hKey HKEY, bWatchSubtree bool, dwNotifyFilter DWORD, hEvent HANDLE, fAsynchronous bool) LONG { + ret1 := syscall6(regNotifyChangeKeyValue, 5, + uintptr(hKey), + getUintptrFromBool(bWatchSubtree), + uintptr(dwNotifyFilter), + uintptr(hEvent), + getUintptrFromBool(fAsynchronous), + 0) + return LONG(ret1) +} + +func RegOpenCurrentUser(samDesired REGSAM, phkResult *HKEY) LONG { + ret1 := syscall3(regOpenCurrentUser, 2, + uintptr(samDesired), + uintptr(unsafe.Pointer(phkResult)), + 0) + return LONG(ret1) +} + +func RegOpenKeyEx(hKey HKEY, lpSubKey string, ulOptions DWORD, samDesired REGSAM, phkResult *HKEY) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + ret1 := syscall6(regOpenKeyEx, 5, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(ulOptions), + uintptr(samDesired), + uintptr(unsafe.Pointer(phkResult)), + 0) + return LONG(ret1) +} + +func RegOpenKeyTransacted(hKey HKEY, lpSubKey string, ulOptions DWORD, samDesired REGSAM, phkResult *HKEY, hTransaction HANDLE, pExtendedParameter uintptr) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + ret1 := syscall9(regOpenKeyTransacted, 7, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(ulOptions), + uintptr(samDesired), + uintptr(unsafe.Pointer(phkResult)), + uintptr(hTransaction), + pExtendedParameter, + 0, + 0) + return LONG(ret1) +} + +func RegOpenKey(hKey HKEY, lpSubKey string, phkResult *HKEY) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + ret1 := syscall3(regOpenKey, 3, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(unsafe.Pointer(phkResult))) + return LONG(ret1) +} + +func RegOpenUserClassesRoot(hToken HANDLE, dwOptions DWORD, samDesired REGSAM, phkResult *HKEY) LONG { + ret1 := syscall6(regOpenUserClassesRoot, 4, + uintptr(hToken), + uintptr(dwOptions), + uintptr(samDesired), + uintptr(unsafe.Pointer(phkResult)), + 0, + 0) + return LONG(ret1) +} + +func RegOverridePredefKey(hKey HKEY, hNewHKey HKEY) LONG { + ret1 := syscall3(regOverridePredefKey, 2, + uintptr(hKey), + uintptr(hNewHKey), + 0) + return LONG(ret1) +} + +// TODO: Unknown type(s): PFILETIME +// func RegQueryInfoKey(hKey HKEY, lpClass LPWSTR, lpcchClass *uint32, lpReserved *uint32, lpcSubKeys *uint32, lpcbMaxSubKeyLen *uint32, lpcbMaxClassLen *uint32, lpcValues *uint32, lpcbMaxValueNameLen *uint32, lpcbMaxValueLen *uint32, lpcbSecurityDescriptor *uint32, lpftLastWriteTime PFILETIME) LONG + +// TODO: Unknown type(s): PVALENTW +// func RegQueryMultipleValues(hKey HKEY, val_list PVALENTW, num_vals DWORD, lpValueBuf LPWSTR, ldwTotsize *uint32) LONG + +func RegQueryReflectionKey(hBase HKEY, bIsReflectionDisabled *BOOL) LONG { + ret1 := syscall3(regQueryReflectionKey, 2, + uintptr(hBase), + uintptr(unsafe.Pointer(bIsReflectionDisabled)), + 0) + return LONG(ret1) +} + +func RegQueryValueEx(hKey HKEY, lpValueName string, lpReserved *uint32, lpType *uint32, lpData *byte, lpcbData *uint32) LONG { + lpValueNameStr := unicode16FromString(lpValueName) + ret1 := syscall6(regQueryValueEx, 6, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpValueNameStr[0])), + uintptr(unsafe.Pointer(lpReserved)), + uintptr(unsafe.Pointer(lpType)), + uintptr(unsafe.Pointer(lpData)), + uintptr(unsafe.Pointer(lpcbData))) + return LONG(ret1) +} + +func RegQueryValue(hKey HKEY, lpSubKey string, lpData LPWSTR, lpcbData *int32) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + ret1 := syscall6(regQueryValue, 4, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(unsafe.Pointer(lpData)), + uintptr(unsafe.Pointer(lpcbData)), + 0, + 0) + return LONG(ret1) +} + +func RegReplaceKey(hKey HKEY, lpSubKey string, lpNewFile string, lpOldFile string) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + lpNewFileStr := unicode16FromString(lpNewFile) + lpOldFileStr := unicode16FromString(lpOldFile) + ret1 := syscall6(regReplaceKey, 4, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(unsafe.Pointer(&lpNewFileStr[0])), + uintptr(unsafe.Pointer(&lpOldFileStr[0])), + 0, + 0) + return LONG(ret1) +} + +func RegRestoreKey(hKey HKEY, lpFile string, dwFlags DWORD) LONG { + lpFileStr := unicode16FromString(lpFile) + ret1 := syscall3(regRestoreKey, 3, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpFileStr[0])), + uintptr(dwFlags)) + return LONG(ret1) +} + +func RegSaveKeyEx(hKey HKEY, lpFile string, lpSecurityAttributes *SECURITY_ATTRIBUTES, flags DWORD) LONG { + lpFileStr := unicode16FromString(lpFile) + ret1 := syscall6(regSaveKeyEx, 4, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpFileStr[0])), + uintptr(unsafe.Pointer(lpSecurityAttributes)), + uintptr(flags), + 0, + 0) + return LONG(ret1) +} + +func RegSaveKey(hKey HKEY, lpFile string, lpSecurityAttributes *SECURITY_ATTRIBUTES) LONG { + lpFileStr := unicode16FromString(lpFile) + ret1 := syscall3(regSaveKey, 3, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpFileStr[0])), + uintptr(unsafe.Pointer(lpSecurityAttributes))) + return LONG(ret1) +} + +func RegSetKeySecurity(hKey HKEY, securityInformation SECURITY_INFORMATION, pSecurityDescriptor PSECURITY_DESCRIPTOR) LONG { + ret1 := syscall3(regSetKeySecurity, 3, + uintptr(hKey), + uintptr(securityInformation), + uintptr(unsafe.Pointer(pSecurityDescriptor))) + return LONG(ret1) +} + +func RegSetKeyValue(hKey HKEY, lpSubKey /*const*/ LPCSTR, lpValueName /*const*/ LPCSTR, dwType DWORD, lpData /*const*/ uintptr, cbData DWORD) LONG { + ret1 := syscall6(regSetKeyValue, 6, + uintptr(hKey), + uintptr(unsafe.Pointer(lpSubKey)), + uintptr(unsafe.Pointer(lpValueName)), + uintptr(dwType), + lpData, + uintptr(cbData)) + return LONG(ret1) +} + +func RegSetValueEx(hKey HKEY, lpValueName string, reserved DWORD, dwType DWORD, lpData /*const*/ *byte, cbData DWORD) LONG { + lpValueNameStr := unicode16FromString(lpValueName) + ret1 := syscall6(regSetValueEx, 6, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpValueNameStr[0])), + uintptr(reserved), + uintptr(dwType), + uintptr(unsafe.Pointer(lpData)), + uintptr(cbData)) + return LONG(ret1) +} + +func RegSetValue(hKey HKEY, lpSubKey string, dwType DWORD, lpData string, cbData DWORD) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + lpDataStr := unicode16FromString(lpData) + ret1 := syscall6(regSetValue, 5, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + uintptr(dwType), + uintptr(unsafe.Pointer(&lpDataStr[0])), + uintptr(cbData), + 0) + return LONG(ret1) +} + +func RegUnLoadKey(hKey HKEY, lpSubKey string) LONG { + lpSubKeyStr := unicode16FromString(lpSubKey) + ret1 := syscall3(regUnLoadKey, 2, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpSubKeyStr[0])), + 0) + return LONG(ret1) +} + +func RegisterEventSource(lpUNCServerName string, lpSourceName string) HANDLE { + lpUNCServerNameStr := unicode16FromString(lpUNCServerName) + lpSourceNameStr := unicode16FromString(lpSourceName) + ret1 := syscall3(registerEventSource, 2, + uintptr(unsafe.Pointer(&lpUNCServerNameStr[0])), + uintptr(unsafe.Pointer(&lpSourceNameStr[0])), + 0) + return HANDLE(ret1) +} + +func RegisterServiceCtrlHandlerEx(lpServiceName string, lpHandlerProc HANDLER_FUNCTION_EX, lpContext LPVOID) SERVICE_STATUS_HANDLE { + lpServiceNameStr := unicode16FromString(lpServiceName) + lpHandlerProcCallback := syscall.NewCallback(func(dwControlRawArg uint32, dwEventTypeRawArg uint32, lpEventDataRawArg uintptr, lpContextRawArg uintptr) uintptr { + ret := lpHandlerProc(dwControlRawArg, dwEventTypeRawArg, lpEventDataRawArg, lpContextRawArg) + return uintptr(ret) + }) + ret1 := syscall3(registerServiceCtrlHandlerEx, 3, + uintptr(unsafe.Pointer(&lpServiceNameStr[0])), + lpHandlerProcCallback, + uintptr(unsafe.Pointer(lpContext))) + return SERVICE_STATUS_HANDLE(ret1) +} + +// TODO: Unknown type(s): LPHANDLER_FUNCTION +// func RegisterServiceCtrlHandler(lpServiceName string, lpHandlerProc LPHANDLER_FUNCTION) SERVICE_STATUS_HANDLE + +// TODO: Unknown type(s): PCOGETACTIVATIONSTATE, PCOGETCALLSTATE +// func RegisterWaitChainCOMCallback(callStateCallback PCOGETCALLSTATE, activationStateCallback PCOGETACTIVATIONSTATE) + +// TODO: Unknown type(s): PENCRYPTION_CERTIFICATE_HASH_LIST +// func RemoveUsersFromEncryptedFile(lpFileName string, pHashes PENCRYPTION_CERTIFICATE_HASH_LIST) DWORD + +func ReportEvent(hEventLog HANDLE, wType WORD, wCategory WORD, dwEventID DWORD, lpUserSid PSID, wNumStrings WORD, dwDataSize DWORD, lpStrings *LPCWSTR, lpRawData LPVOID) bool { + ret1 := syscall9(reportEvent, 9, + uintptr(hEventLog), + uintptr(wType), + uintptr(wCategory), + uintptr(dwEventID), + uintptr(lpUserSid), + uintptr(wNumStrings), + uintptr(dwDataSize), + uintptr(unsafe.Pointer(lpStrings)), + uintptr(unsafe.Pointer(lpRawData))) + return ret1 != 0 +} + +func RevertToSelf() bool { + ret1 := syscall3(revertToSelf, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func SaferCloseLevel(hLevelHandle SAFER_LEVEL_HANDLE) bool { + ret1 := syscall3(saferCloseLevel, 1, + uintptr(hLevelHandle), + 0, + 0) + return ret1 != 0 +} + +func SaferComputeTokenFromLevel(levelHandle SAFER_LEVEL_HANDLE, inAccessToken HANDLE, outAccessToken *HANDLE, dwFlags DWORD, lpReserved LPVOID) bool { + ret1 := syscall6(saferComputeTokenFromLevel, 5, + uintptr(levelHandle), + uintptr(inAccessToken), + uintptr(unsafe.Pointer(outAccessToken)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpReserved)), + 0) + return ret1 != 0 +} + +func SaferCreateLevel(dwScopeId DWORD, dwLevelId DWORD, openFlags DWORD, pLevelHandle *SAFER_LEVEL_HANDLE, lpReserved LPVOID) bool { + ret1 := syscall6(saferCreateLevel, 5, + uintptr(dwScopeId), + uintptr(dwLevelId), + uintptr(openFlags), + uintptr(unsafe.Pointer(pLevelHandle)), + uintptr(unsafe.Pointer(lpReserved)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): SAFER_OBJECT_INFO_CLASS +// func SaferGetLevelInformation(levelHandle SAFER_LEVEL_HANDLE, dwInfoType SAFER_OBJECT_INFO_CLASS, lpQueryBuffer LPVOID, dwInBufferSize DWORD, lpdwOutBufferSize *uint32) bool + +// TODO: Unknown type(s): SAFER_POLICY_INFO_CLASS +// func SaferGetPolicyInformation(dwScopeId DWORD, saferPolicyInfoClass SAFER_POLICY_INFO_CLASS, infoBufferSize DWORD, infoBuffer uintptr, infoBufferRetSize *DWORD, lpReserved LPVOID) bool + +// TODO: Unknown type(s): PSAFER_CODE_PROPERTIES +// func SaferIdentifyLevel(dwNumProperties DWORD, pCodeProperties PSAFER_CODE_PROPERTIES, pLevelHandle *SAFER_LEVEL_HANDLE, lpReserved LPVOID) bool + +func SaferRecordEventLogEntry(hLevel SAFER_LEVEL_HANDLE, szTargetPath string, lpReserved LPVOID) bool { + szTargetPathStr := unicode16FromString(szTargetPath) + ret1 := syscall3(saferRecordEventLogEntry, 3, + uintptr(hLevel), + uintptr(unsafe.Pointer(&szTargetPathStr[0])), + uintptr(unsafe.Pointer(lpReserved))) + return ret1 != 0 +} + +// TODO: Unknown type(s): SAFER_OBJECT_INFO_CLASS +// func SaferSetLevelInformation(levelHandle SAFER_LEVEL_HANDLE, dwInfoType SAFER_OBJECT_INFO_CLASS, lpQueryBuffer LPVOID, dwInBufferSize DWORD) bool + +// TODO: Unknown type(s): SAFER_POLICY_INFO_CLASS +// func SaferSetPolicyInformation(dwScopeId DWORD, saferPolicyInfoClass SAFER_POLICY_INFO_CLASS, infoBufferSize DWORD, infoBuffer uintptr, lpReserved LPVOID) bool + +func SaferiIsExecutableFileType(szFullPathname string, bFromShellExecute BOOLEAN) bool { + szFullPathnameStr := unicode16FromString(szFullPathname) + ret1 := syscall3(saferiIsExecutableFileType, 2, + uintptr(unsafe.Pointer(&szFullPathnameStr[0])), + uintptr(bFromShellExecute), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): ACL_INFORMATION_CLASS +// func SetAclInformation(pAcl *ACL, pAclInformation LPVOID, nAclInformationLength DWORD, dwAclInformationClass ACL_INFORMATION_CLASS) bool + +// TODO: Unknown type(s): PACL * +// func SetEntriesInAcl(cCountOfExplicitEntries ULONG, pListOfExplicitEntries *EXPLICIT_ACCESS, oldAcl *ACL, newAcl PACL *) DWORD + +func SetFileSecurity(lpFileName string, securityInformation SECURITY_INFORMATION, pSecurityDescriptor PSECURITY_DESCRIPTOR) bool { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(setFileSecurity, 3, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(securityInformation), + uintptr(unsafe.Pointer(pSecurityDescriptor))) + return ret1 != 0 +} + +func SetKernelObjectSecurity(handle HANDLE, securityInformation SECURITY_INFORMATION, securityDescriptor PSECURITY_DESCRIPTOR) bool { + ret1 := syscall3(setKernelObjectSecurity, 3, + uintptr(handle), + uintptr(securityInformation), + uintptr(unsafe.Pointer(securityDescriptor))) + return ret1 != 0 +} + +func SetNamedSecurityInfo(pObjectName LPWSTR, objectType SE_OBJECT_TYPE, securityInfo SECURITY_INFORMATION, psidOwner PSID, psidGroup PSID, pDacl *ACL, pSacl *ACL) DWORD { + ret1 := syscall9(setNamedSecurityInfo, 7, + uintptr(unsafe.Pointer(pObjectName)), + uintptr(objectType), + uintptr(securityInfo), + uintptr(psidOwner), + uintptr(psidGroup), + uintptr(unsafe.Pointer(pDacl)), + uintptr(unsafe.Pointer(pSacl)), + 0, + 0) + return DWORD(ret1) +} + +func SetPrivateObjectSecurity(securityInformation SECURITY_INFORMATION, modificationDescriptor PSECURITY_DESCRIPTOR, objectsSecurityDescriptor *PSECURITY_DESCRIPTOR, genericMapping *GENERIC_MAPPING, token HANDLE) bool { + ret1 := syscall6(setPrivateObjectSecurity, 5, + uintptr(securityInformation), + uintptr(unsafe.Pointer(modificationDescriptor)), + uintptr(unsafe.Pointer(objectsSecurityDescriptor)), + uintptr(unsafe.Pointer(genericMapping)), + uintptr(token), + 0) + return ret1 != 0 +} + +func SetPrivateObjectSecurityEx(securityInformation SECURITY_INFORMATION, modificationDescriptor PSECURITY_DESCRIPTOR, objectsSecurityDescriptor *PSECURITY_DESCRIPTOR, autoInheritFlags ULONG, genericMapping *GENERIC_MAPPING, token HANDLE) bool { + ret1 := syscall6(setPrivateObjectSecurityEx, 6, + uintptr(securityInformation), + uintptr(unsafe.Pointer(modificationDescriptor)), + uintptr(unsafe.Pointer(objectsSecurityDescriptor)), + uintptr(autoInheritFlags), + uintptr(unsafe.Pointer(genericMapping)), + uintptr(token)) + return ret1 != 0 +} + +func SetSecurityAccessMask(securityInformation SECURITY_INFORMATION, desiredAccess *uint32) { + syscall3(setSecurityAccessMask, 2, + uintptr(securityInformation), + uintptr(unsafe.Pointer(desiredAccess)), + 0) +} + +func SetSecurityDescriptorControl(pSecurityDescriptor PSECURITY_DESCRIPTOR, controlBitsOfInterest SECURITY_DESCRIPTOR_CONTROL, controlBitsToSet SECURITY_DESCRIPTOR_CONTROL) bool { + ret1 := syscall3(setSecurityDescriptorControl, 3, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(controlBitsOfInterest), + uintptr(controlBitsToSet)) + return ret1 != 0 +} + +func SetSecurityDescriptorDacl(pSecurityDescriptor PSECURITY_DESCRIPTOR, bDaclPresent bool, pDacl *ACL, bDaclDefaulted bool) bool { + ret1 := syscall6(setSecurityDescriptorDacl, 4, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + getUintptrFromBool(bDaclPresent), + uintptr(unsafe.Pointer(pDacl)), + getUintptrFromBool(bDaclDefaulted), + 0, + 0) + return ret1 != 0 +} + +func SetSecurityDescriptorGroup(pSecurityDescriptor PSECURITY_DESCRIPTOR, pGroup PSID, bGroupDefaulted bool) bool { + ret1 := syscall3(setSecurityDescriptorGroup, 3, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(pGroup), + getUintptrFromBool(bGroupDefaulted)) + return ret1 != 0 +} + +func SetSecurityDescriptorOwner(pSecurityDescriptor PSECURITY_DESCRIPTOR, pOwner PSID, bOwnerDefaulted bool) bool { + ret1 := syscall3(setSecurityDescriptorOwner, 3, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + uintptr(pOwner), + getUintptrFromBool(bOwnerDefaulted)) + return ret1 != 0 +} + +func SetSecurityDescriptorRMControl(securityDescriptor PSECURITY_DESCRIPTOR, rMControl PUCHAR) DWORD { + ret1 := syscall3(setSecurityDescriptorRMControl, 2, + uintptr(unsafe.Pointer(securityDescriptor)), + uintptr(unsafe.Pointer(rMControl)), + 0) + return DWORD(ret1) +} + +func SetSecurityDescriptorSacl(pSecurityDescriptor PSECURITY_DESCRIPTOR, bSaclPresent bool, pSacl *ACL, bSaclDefaulted bool) bool { + ret1 := syscall6(setSecurityDescriptorSacl, 4, + uintptr(unsafe.Pointer(pSecurityDescriptor)), + getUintptrFromBool(bSaclPresent), + uintptr(unsafe.Pointer(pSacl)), + getUintptrFromBool(bSaclDefaulted), + 0, + 0) + return ret1 != 0 +} + +func SetSecurityInfo(handle HANDLE, objectType SE_OBJECT_TYPE, securityInfo SECURITY_INFORMATION, psidOwner PSID, psidGroup PSID, pDacl *ACL, pSacl *ACL) DWORD { + ret1 := syscall9(setSecurityInfo, 7, + uintptr(handle), + uintptr(objectType), + uintptr(securityInfo), + uintptr(psidOwner), + uintptr(psidGroup), + uintptr(unsafe.Pointer(pDacl)), + uintptr(unsafe.Pointer(pSacl)), + 0, + 0) + return DWORD(ret1) +} + +func SetServiceBits(hServiceStatus SERVICE_STATUS_HANDLE, dwServiceBits DWORD, bSetBitsOn bool, bUpdateImmediately bool) bool { + ret1 := syscall6(setServiceBits, 4, + uintptr(hServiceStatus), + uintptr(dwServiceBits), + getUintptrFromBool(bSetBitsOn), + getUintptrFromBool(bUpdateImmediately), + 0, + 0) + return ret1 != 0 +} + +func SetServiceObjectSecurity(hService SC_HANDLE, dwSecurityInformation SECURITY_INFORMATION, lpSecurityDescriptor PSECURITY_DESCRIPTOR) bool { + ret1 := syscall3(setServiceObjectSecurity, 3, + uintptr(hService), + uintptr(dwSecurityInformation), + uintptr(unsafe.Pointer(lpSecurityDescriptor))) + return ret1 != 0 +} + +func SetServiceStatus(hServiceStatus SERVICE_STATUS_HANDLE, lpServiceStatus *SERVICE_STATUS) bool { + ret1 := syscall3(setServiceStatus, 2, + uintptr(hServiceStatus), + uintptr(unsafe.Pointer(lpServiceStatus)), + 0) + return ret1 != 0 +} + +func SetThreadToken(thread *HANDLE, token HANDLE) bool { + ret1 := syscall3(setThreadToken, 2, + uintptr(unsafe.Pointer(thread)), + uintptr(token), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): TOKEN_INFORMATION_CLASS +// func SetTokenInformation(tokenHandle HANDLE, tokenInformationClass TOKEN_INFORMATION_CLASS, tokenInformation LPVOID, tokenInformationLength DWORD) bool + +func SetUserFileEncryptionKey(pEncryptionCertificate PENCRYPTION_CERTIFICATE) DWORD { + ret1 := syscall3(setUserFileEncryptionKey, 1, + uintptr(unsafe.Pointer(pEncryptionCertificate)), + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): CONST SERVICE_TABLE_ENTRYW * +// func StartServiceCtrlDispatcher(lpServiceStartTable /*const*/ CONST SERVICE_TABLE_ENTRYW *) bool + +func StartService(hService SC_HANDLE, dwNumServiceArgs DWORD, lpServiceArgVectors *LPCWSTR) bool { + ret1 := syscall3(startService, 3, + uintptr(hService), + uintptr(dwNumServiceArgs), + uintptr(unsafe.Pointer(lpServiceArgVectors))) + return ret1 != 0 +} + +// TODO: Unknown type(s): FN_PROGRESS, PROG_INVOKE_SETTING +// func TreeResetNamedSecurityInfo(pObjectName LPWSTR, objectType SE_OBJECT_TYPE, securityInfo SECURITY_INFORMATION, pOwner PSID, pGroup PSID, pDacl *ACL, pSacl *ACL, keepExplicit bool, fnProgress FN_PROGRESS, progressInvokeSetting PROG_INVOKE_SETTING, args uintptr) DWORD + +// TODO: Unknown type(s): FN_PROGRESS, PROG_INVOKE_SETTING +// func TreeSetNamedSecurityInfo(pObjectName LPWSTR, objectType SE_OBJECT_TYPE, securityInfo SECURITY_INFORMATION, pOwner PSID, pGroup PSID, pDacl *ACL, pSacl *ACL, dwAction DWORD, fnProgress FN_PROGRESS, progressInvokeSetting PROG_INVOKE_SETTING, args uintptr) DWORD + +func UninstallApplication(productCode *WCHAR, dwStatus DWORD) DWORD { + ret1 := syscall3(uninstallApplication, 2, + uintptr(unsafe.Pointer(productCode)), + uintptr(dwStatus), + 0) + return DWORD(ret1) +} + +func UnlockServiceDatabase(scLock SC_LOCK) bool { + ret1 := syscall3(unlockServiceDatabase, 1, + uintptr(scLock), + 0, + 0) + return ret1 != 0 +} + +func Wow64Win32ApiEntry(dwFuncNumber DWORD, dwFlag DWORD, dwRes DWORD) LONG { + ret1 := syscall3(wow64Win32ApiEntry, 3, + uintptr(dwFuncNumber), + uintptr(dwFlag), + uintptr(dwRes)) + return LONG(ret1) +} + +// TODO: Unknown type(s): PFE_IMPORT_FUNC +// func WriteEncryptedFileRaw(pfImportCallback PFE_IMPORT_FUNC, pvCallbackContext uintptr, pvContext uintptr) DWORD + +// TODO: Unknown type(s): PSHA_CTX +// func A_SHAFinal(context PSHA_CTX, result *uint32) + +// TODO: Unknown type(s): PSHA_CTX +// func A_SHAInit(context PSHA_CTX) + +// TODO: Unknown type(s): PSHA_CTX +// func A_SHAUpdate(context PSHA_CTX, buffer /*const*/ *byte, bufferSize UINT) + +// TODO: Unknown type(s): TRACEHANDLE +// func CloseTrace(handle TRACEHANDLE) ULONG + +// TODO: Unknown type(s): PEVENT_TRACE_PROPERTIES, TRACEHANDLE +// func ControlTrace(hSession TRACEHANDLE, sessionName string, properties PEVENT_TRACE_PROPERTIES, control ULONG) ULONG + +// TODO: Unknown type(s): TRACEHANDLE +// func EnableTrace(enable ULONG, flag ULONG, level ULONG, guid /*const*/ *GUID, hSession TRACEHANDLE) ULONG + +// TODO: Unknown type(s): PEVENT_FILTER_DESCRIPTOR, TRACEHANDLE +// func EnableTraceEx(provider /*const*/ *GUID, source /*const*/ *GUID, hSession TRACEHANDLE, enable ULONG, level UCHAR, anykeyword ULONGLONG, allkeyword ULONGLONG, enableprop ULONG, filterdesc PEVENT_FILTER_DESCRIPTOR) ULONG + +// TODO: Unknown type(s): PENABLE_TRACE_PARAMETERS, TRACEHANDLE +// func EnableTraceEx2(handle TRACEHANDLE, provider /*const*/ *GUID, control ULONG, level UCHAR, match_any ULONGLONG, match_all ULONGLONG, timeout ULONG, params PENABLE_TRACE_PARAMETERS) ULONG + +// TODO: Unknown type(s): PTRACE_GUID_PROPERTIES * +// func EnumerateTraceGuids(propertiesarray PTRACE_GUID_PROPERTIES *, arraycount ULONG, guidcount *uint32) ULONG + +func EventActivityIdControl(code ULONG, guid *GUID) ULONG { + ret1 := syscall3(eventActivityIdControl, 2, + uintptr(code), + uintptr(unsafe.Pointer(guid)), + 0) + return ULONG(ret1) +} + +// TODO: Unknown type(s): PCEVENT_DESCRIPTOR, REGHANDLE +// func EventEnabled(handle REGHANDLE, descriptor PCEVENT_DESCRIPTOR) BOOLEAN + +// TODO: Unknown type(s): REGHANDLE +// func EventProviderEnabled(handle REGHANDLE, level UCHAR, keyword ULONGLONG) BOOLEAN + +// TODO: Unknown type(s): PCEVENT_DESCRIPTOR, PEVENT_DATA_DESCRIPTOR, REGHANDLE +// func EventWrite(handle REGHANDLE, descriptor PCEVENT_DESCRIPTOR, count ULONG, data PEVENT_DATA_DESCRIPTOR) ULONG + +// TODO: Unknown type(s): PCEVENT_DESCRIPTOR, PEVENT_DATA_DESCRIPTOR, REGHANDLE +// func EventWriteTransfer(handle REGHANDLE, descriptor PCEVENT_DESCRIPTOR, activity /*const*/ *GUID, related /*const*/ *GUID, count ULONG, data PEVENT_DATA_DESCRIPTOR) ULONG + +// TODO: Unknown type(s): PEVENT_TRACE_PROPERTIES, TRACEHANDLE +// func FlushTrace(hSession TRACEHANDLE, sessionName string, properties PEVENT_TRACE_PROPERTIES) ULONG + +// TODO: Unknown type(s): PACTRL_ACCESSW *, PACTRL_AUDITW * +// func GetNamedSecurityInfoEx(object string, aType SE_OBJECT_TYPE, info SECURITY_INFORMATION, provider string, property string, access_list PACTRL_ACCESSW *, audit_list PACTRL_AUDITW *, owner *LPWSTR, group *LPWSTR) DWORD + +// TODO: Unknown type(s): PACTRL_ACCESSW *, PACTRL_AUDITW * +// func GetSecurityInfoEx(hObject HANDLE, objectType SE_OBJECT_TYPE, securityInfo SECURITY_INFORMATION, lpProvider string, lpProperty string, ppAccessList PACTRL_ACCESSW *, ppAuditList PACTRL_AUDITW *, lppOwner *LPWSTR, lppGroup *LPWSTR) DWORD + +// TODO: Unknown type(s): TRACEHANDLE +// func GetTraceEnableFlags(handle TRACEHANDLE) ULONG + +// TODO: Unknown type(s): TRACEHANDLE +// func GetTraceEnableLevel(handle TRACEHANDLE) UCHAR + +// TODO: Unknown type(s): TRACEHANDLE +// func GetTraceLoggerHandle(buf uintptr) TRACEHANDLE + +// TODO: Unknown type(s): LSA_HANDLE, PLSA_UNICODE_STRING +// func LsaAddAccountRights(policy LSA_HANDLE, sid PSID, rights PLSA_UNICODE_STRING, count ULONG) NTSTATUS + +// TODO: Unknown type(s): IN LSA_HANDLE +// func LsaClose(objectHandle IN LSA_HANDLE) NTSTATUS + +// TODO: Unknown type(s): LSA_HANDLE, PLSA_HANDLE, PTRUSTED_DOMAIN_AUTH_INFORMATION, PTRUSTED_DOMAIN_INFORMATION_EX +// func LsaCreateTrustedDomainEx(policy LSA_HANDLE, domain_info PTRUSTED_DOMAIN_INFORMATION_EX, auth_info PTRUSTED_DOMAIN_AUTH_INFORMATION, access ACCESS_MASK, domain PLSA_HANDLE) NTSTATUS + +// TODO: Unknown type(s): LSA_HANDLE +// func LsaDeleteTrustedDomain(policy LSA_HANDLE, sid PSID) NTSTATUS + +// TODO: Unknown type(s): LSA_HANDLE, PLSA_UNICODE_STRING * +// func LsaEnumerateAccountRights(policy LSA_HANDLE, sid PSID, rights PLSA_UNICODE_STRING *, count *uint32) NTSTATUS + +// TODO: Unknown type(s): LSA_HANDLE, PLSA_UNICODE_STRING +// func LsaEnumerateAccountsWithUserRight(policy LSA_HANDLE, rights PLSA_UNICODE_STRING, buffer *PVOID, count *uint32) NTSTATUS + +// TODO: Unknown type(s): IN LSA_HANDLE, IN PLSA_ENUMERATION_HANDLE, IN ULONG, OUT PULONG, OUT PVOID * +// func LsaEnumerateTrustedDomains(policyHandle IN LSA_HANDLE, enumerationContext IN PLSA_ENUMERATION_HANDLE, buffer OUT PVOID *, preferredMaximumLength IN ULONG, countReturned OUT PULONG) NTSTATUS + +// TODO: Unknown type(s): LSA_HANDLE, PLSA_ENUMERATION_HANDLE +// func LsaEnumerateTrustedDomainsEx(policy LSA_HANDLE, context PLSA_ENUMERATION_HANDLE, buffer *PVOID, length ULONG, count *uint32) NTSTATUS + +// TODO: Unknown type(s): IN PVOID +// func LsaFreeMemory(buffer IN PVOID) NTSTATUS + +// TODO: Unknown type(s): IN LSA_HANDLE, IN PLSA_UNICODE_STRING, IN ULONG, OUT PLSA_REFERENCED_DOMAIN_LIST *, OUT PLSA_TRANSLATED_SID * +// func LsaLookupNames(policyHandle IN LSA_HANDLE, count IN ULONG, names IN PLSA_UNICODE_STRING, referencedDomains OUT PLSA_REFERENCED_DOMAIN_LIST *, sids OUT PLSA_TRANSLATED_SID *) NTSTATUS + +// TODO: Unknown type(s): LSA_HANDLE, PLSA_REFERENCED_DOMAIN_LIST *, PLSA_TRANSLATED_SID2 *, PLSA_UNICODE_STRING +// func LsaLookupNames2(policy LSA_HANDLE, flags ULONG, count ULONG, names PLSA_UNICODE_STRING, domains PLSA_REFERENCED_DOMAIN_LIST *, sids PLSA_TRANSLATED_SID2 *) NTSTATUS + +// TODO: Unknown type(s): LSA_HANDLE, LSA_REFERENCED_DOMAIN_LIST * *, LSA_TRANSLATED_NAME * * +// func LsaLookupSids(policyHandle LSA_HANDLE, count ULONG, sids *PSID, referencedDomains LSA_REFERENCED_DOMAIN_LIST * *, names LSA_TRANSLATED_NAME * *) NTSTATUS + +func LsaNtStatusToWinError(status NTSTATUS) ULONG { + ret1 := syscall3(lsaNtStatusToWinError, 1, + uintptr(status), + 0, + 0) + return ULONG(ret1) +} + +// TODO: Unknown type(s): IN ACCESS_MASK, IN OUT PLSA_HANDLE, IN PLSA_OBJECT_ATTRIBUTES, IN PLSA_UNICODE_STRING +// func LsaOpenPolicy(systemName IN PLSA_UNICODE_STRING, objectAttributes IN PLSA_OBJECT_ATTRIBUTES, desiredAccess IN ACCESS_MASK, policyHandle IN OUT PLSA_HANDLE) NTSTATUS + +// TODO: Unknown type(s): LSA_HANDLE, PLSA_HANDLE, PLSA_UNICODE_STRING +// func LsaOpenTrustedDomainByName(policy LSA_HANDLE, name PLSA_UNICODE_STRING, access ACCESS_MASK, handle PLSA_HANDLE) NTSTATUS + +// TODO: Unknown type(s): IN LSA_HANDLE, IN POLICY_INFORMATION_CLASS, OUT PVOID * +// func LsaQueryInformationPolicy(policyHandle IN LSA_HANDLE, informationClass IN POLICY_INFORMATION_CLASS, buffer OUT PVOID *) NTSTATUS + +// TODO: Unknown type(s): LSA_HANDLE, TRUSTED_INFORMATION_CLASS +// func LsaQueryTrustedDomainInfo(policy LSA_HANDLE, sid PSID, class TRUSTED_INFORMATION_CLASS, buffer *PVOID) NTSTATUS + +// TODO: Unknown type(s): LSA_HANDLE, PLSA_UNICODE_STRING, TRUSTED_INFORMATION_CLASS +// func LsaQueryTrustedDomainInfoByName(policy LSA_HANDLE, name PLSA_UNICODE_STRING, class TRUSTED_INFORMATION_CLASS, buffer *PVOID) NTSTATUS + +// TODO: Unknown type(s): LSA_HANDLE, PLSA_UNICODE_STRING +// func LsaRemoveAccountRights(policy LSA_HANDLE, sid PSID, all BOOLEAN, rights PLSA_UNICODE_STRING, count ULONG) NTSTATUS + +// TODO: Unknown type(s): IN LSA_HANDLE, IN PLSA_UNICODE_STRING, OUT PLSA_UNICODE_STRING * +// func LsaRetrievePrivateData(policyHandle IN LSA_HANDLE, keyName IN PLSA_UNICODE_STRING, privateData OUT PLSA_UNICODE_STRING *) NTSTATUS + +// TODO: Unknown type(s): IN LSA_HANDLE, IN POLICY_INFORMATION_CLASS, IN PVOID +// func LsaSetInformationPolicy(policyHandle IN LSA_HANDLE, informationClass IN POLICY_INFORMATION_CLASS, buffer IN PVOID) NTSTATUS + +// TODO: Unknown type(s): IN LSA_HANDLE, IN PLSA_UNICODE_STRING +// func LsaSetSecret(secretHandle IN LSA_HANDLE, encryptedCurrentValue IN PLSA_UNICODE_STRING, encryptedOldValue IN PLSA_UNICODE_STRING) NTSTATUS + +// TODO: Unknown type(s): LSA_HANDLE, PLSA_UNICODE_STRING, TRUSTED_INFORMATION_CLASS +// func LsaSetTrustedDomainInfoByName(policy LSA_HANDLE, name PLSA_UNICODE_STRING, class TRUSTED_INFORMATION_CLASS, buffer uintptr) NTSTATUS + +// TODO: Unknown type(s): LSA_HANDLE, TRUSTED_INFORMATION_CLASS +// func LsaSetTrustedDomainInformation(policy LSA_HANDLE, sid PSID, class TRUSTED_INFORMATION_CLASS, buffer uintptr) NTSTATUS + +// TODO: Unknown type(s): IN LSA_HANDLE, IN PLSA_UNICODE_STRING +// func LsaStorePrivateData(policyHandle IN LSA_HANDLE, keyName IN PLSA_UNICODE_STRING, privateData IN PLSA_UNICODE_STRING) NTSTATUS + +// TODO: Unknown type(s): MD4_CTX * +// func MD4Final(ctx MD4_CTX *) + +// TODO: Unknown type(s): MD4_CTX * +// func MD4Init(ctx MD4_CTX *) + +// TODO: Unknown type(s): MD4_CTX * +// func MD4Update(ctx MD4_CTX *, buf /*const*/ *byte, aLen uint32) + +// TODO: Unknown type(s): MD5_CTX * +// func MD5Final(ctx MD5_CTX *) + +// TODO: Unknown type(s): MD5_CTX * +// func MD5Init(ctx MD5_CTX *) + +// TODO: Unknown type(s): PEVENT_TRACE_LOGFILEW, TRACEHANDLE +// func OpenTrace(logfile PEVENT_TRACE_LOGFILEW) TRACEHANDLE + +// TODO: Unknown type(s): PTRACEHANDLE +// func ProcessTrace(handleArray PTRACEHANDLE, handleCount ULONG, startTime *FILETIME, endTime *FILETIME) ULONG + +// TODO: Unknown type(s): PEVENT_TRACE_PROPERTIES * +// func QueryAllTraces(parray PEVENT_TRACE_PROPERTIES *, arraycount ULONG, psessioncount *uint32) ULONG + +// TODO: Unknown type(s): PEVENT_TRACE_PROPERTIES, TRACEHANDLE +// func QueryTrace(handle TRACEHANDLE, sessionname string, properties PEVENT_TRACE_PROPERTIES) ULONG + +// TODO: Unknown type(s): PEVENT_TRACE_PROPERTIES, PTRACEHANDLE +// func StartTrace(pSessionHandle PTRACEHANDLE, sessionName string, properties PEVENT_TRACE_PROPERTIES) ULONG + +// TODO: Unknown type(s): PEVENT_TRACE_PROPERTIES, TRACEHANDLE +// func StopTrace(session TRACEHANDLE, session_name string, properties PEVENT_TRACE_PROPERTIES) ULONG + +func SystemFunction001(data /*const*/ *byte, key /*const*/ *byte, output *byte) NTSTATUS { + ret1 := syscall3(systemFunction001, 3, + uintptr(unsafe.Pointer(data)), + uintptr(unsafe.Pointer(key)), + uintptr(unsafe.Pointer(output))) + return NTSTATUS(ret1) +} + +func SystemFunction002(data /*const*/ *byte, key /*const*/ *byte, output *byte) NTSTATUS { + ret1 := syscall3(systemFunction002, 3, + uintptr(unsafe.Pointer(data)), + uintptr(unsafe.Pointer(key)), + uintptr(unsafe.Pointer(output))) + return NTSTATUS(ret1) +} + +func SystemFunction003(key /*const*/ *byte, output *byte) NTSTATUS { + ret1 := syscall3(systemFunction003, 2, + uintptr(unsafe.Pointer(key)), + uintptr(unsafe.Pointer(output)), + 0) + return NTSTATUS(ret1) +} + +// TODO: Unknown type(s): const struct ustring *, struct ustring * +// func SystemFunction004(in /*const*/ const struct ustring *, key /*const*/ const struct ustring *, out struct ustring *) NTSTATUS + +// TODO: Unknown type(s): const struct ustring *, struct ustring * +// func SystemFunction005(in /*const*/ const struct ustring *, key /*const*/ const struct ustring *, out struct ustring *) NTSTATUS + +func SystemFunction006(password /*const*/ LPCSTR, hash LPSTR) NTSTATUS { + ret1 := syscall3(systemFunction006, 2, + uintptr(unsafe.Pointer(password)), + uintptr(unsafe.Pointer(hash)), + 0) + return NTSTATUS(ret1) +} + +// TODO: Unknown type(s): const UNICODE_STRING * +// func SystemFunction007(string /*const*/ const UNICODE_STRING *, hash *byte) NTSTATUS + +func SystemFunction008(challenge /*const*/ *byte, hash /*const*/ *byte, response *byte) NTSTATUS { + ret1 := syscall3(systemFunction008, 3, + uintptr(unsafe.Pointer(challenge)), + uintptr(unsafe.Pointer(hash)), + uintptr(unsafe.Pointer(response))) + return NTSTATUS(ret1) +} + +func SystemFunction009(challenge /*const*/ *byte, hash /*const*/ *byte, response *byte) NTSTATUS { + ret1 := syscall3(systemFunction009, 3, + uintptr(unsafe.Pointer(challenge)), + uintptr(unsafe.Pointer(hash)), + uintptr(unsafe.Pointer(response))) + return NTSTATUS(ret1) +} + +func SystemFunction010(unknown LPVOID, data /*const*/ *byte, hash *byte) NTSTATUS { + ret1 := syscall3(systemFunction010, 3, + uintptr(unsafe.Pointer(unknown)), + uintptr(unsafe.Pointer(data)), + uintptr(unsafe.Pointer(hash))) + return NTSTATUS(ret1) +} + +func SystemFunction012(in /*const*/ *byte, key /*const*/ *byte, out *byte) NTSTATUS { + ret1 := syscall3(systemFunction012, 3, + uintptr(unsafe.Pointer(in)), + uintptr(unsafe.Pointer(key)), + uintptr(unsafe.Pointer(out))) + return NTSTATUS(ret1) +} + +func SystemFunction013(in /*const*/ *byte, key /*const*/ *byte, out *byte) NTSTATUS { + ret1 := syscall3(systemFunction013, 3, + uintptr(unsafe.Pointer(in)), + uintptr(unsafe.Pointer(key)), + uintptr(unsafe.Pointer(out))) + return NTSTATUS(ret1) +} + +func SystemFunction024(in /*const*/ *byte, key /*const*/ *byte, out *byte) NTSTATUS { + ret1 := syscall3(systemFunction024, 3, + uintptr(unsafe.Pointer(in)), + uintptr(unsafe.Pointer(key)), + uintptr(unsafe.Pointer(out))) + return NTSTATUS(ret1) +} + +func SystemFunction025(in /*const*/ *byte, key /*const*/ *byte, out *byte) NTSTATUS { + ret1 := syscall3(systemFunction025, 3, + uintptr(unsafe.Pointer(in)), + uintptr(unsafe.Pointer(key)), + uintptr(unsafe.Pointer(out))) + return NTSTATUS(ret1) +} + +func SystemFunction030(b1 /*const*/ uintptr, b2 /*const*/ uintptr) bool { + ret1 := syscall3(systemFunction030, 2, + b1, + b2, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): const struct ustring *, struct ustring * +// func SystemFunction032(data struct ustring *, key /*const*/ const struct ustring *) NTSTATUS + +func SystemFunction035(lpszDllFilePath /*const*/ LPCSTR) bool { + ret1 := syscall3(systemFunction035, 1, + uintptr(unsafe.Pointer(lpszDllFilePath)), + 0, + 0) + return ret1 != 0 +} + +func SystemFunction036(pbBuffer uintptr, dwLen ULONG) BOOLEAN { + ret1 := syscall3(systemFunction036, 2, + pbBuffer, + uintptr(dwLen), + 0) + return BOOLEAN(ret1) +} + +func SystemFunction040(memory uintptr, length ULONG, flags ULONG) NTSTATUS { + ret1 := syscall3(systemFunction040, 3, + memory, + uintptr(length), + uintptr(flags)) + return NTSTATUS(ret1) +} + +func SystemFunction041(memory uintptr, length ULONG, flags ULONG) NTSTATUS { + ret1 := syscall3(systemFunction041, 3, + memory, + uintptr(length), + uintptr(flags)) + return NTSTATUS(ret1) +} + +// TODO: Unknown type(s): PEVENT_TRACE_HEADER, TRACEHANDLE +// func TraceEvent(sessionHandle TRACEHANDLE, eventTrace PEVENT_TRACE_HEADER) ULONG + +// TODO: Unknown type(s): TRACEHANDLE +// func UnregisterTraceGuids(registrationHandle TRACEHANDLE) ULONG + +// TODO: Unknown type(s): WMIHANDLE * +// func WmiOpenBlock(guid *GUID, access ULONG, handle WMIHANDLE *) ULONG diff --git a/grdp/win/comctl32.go b/grdp/win/comctl32.go new file mode 100644 index 0000000..9fdefb6 --- /dev/null +++ b/grdp/win/comctl32.go @@ -0,0 +1,1138 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "syscall" + "unsafe" +) + +var ( + // Library + libcomctl32 uintptr + + // Functions + createMappedBitmap uintptr + createPropertySheetPage uintptr + createStatusWindow uintptr + createToolbarEx uintptr + createUpDownControl uintptr + dPA_Create uintptr + dPA_DeleteAllPtrs uintptr + dPA_DeletePtr uintptr + dPA_Destroy uintptr + dPA_DestroyCallback uintptr + dPA_EnumCallback uintptr + dPA_GetPtr uintptr + dPA_InsertPtr uintptr + dPA_Search uintptr + dPA_SetPtr uintptr + dPA_Sort uintptr + dSA_Create uintptr + dSA_DeleteAllItems uintptr + dSA_Destroy uintptr + dSA_DestroyCallback uintptr + dSA_GetItemPtr uintptr + dSA_InsertItem uintptr + defSubclassProc uintptr + destroyPropertySheetPage uintptr + drawInsert uintptr + drawStatusText uintptr + flatSB_EnableScrollBar uintptr + flatSB_GetScrollInfo uintptr + flatSB_GetScrollPos uintptr + flatSB_GetScrollProp uintptr + flatSB_GetScrollPropPtr uintptr + flatSB_GetScrollRange uintptr + flatSB_SetScrollInfo uintptr + flatSB_SetScrollPos uintptr + flatSB_SetScrollProp uintptr + flatSB_SetScrollRange uintptr + flatSB_ShowScrollBar uintptr + getEffectiveClientRect uintptr + getMUILanguage uintptr + imageList_Add uintptr + imageList_AddMasked uintptr + imageList_BeginDrag uintptr + imageList_Copy uintptr + imageList_Create uintptr + imageList_Destroy uintptr + imageList_DragEnter uintptr + imageList_DragLeave uintptr + imageList_DragMove uintptr + imageList_DragShowNolock uintptr + imageList_Draw uintptr + imageList_DrawEx uintptr + imageList_DrawIndirect uintptr + imageList_Duplicate uintptr + imageList_EndDrag uintptr + imageList_GetBkColor uintptr + imageList_GetDragImage uintptr + imageList_GetIcon uintptr + imageList_GetIconSize uintptr + imageList_GetImageCount uintptr + imageList_GetImageInfo uintptr + imageList_LoadImage uintptr + imageList_Merge uintptr + imageList_Read uintptr + imageList_Remove uintptr + imageList_Replace uintptr + imageList_ReplaceIcon uintptr + imageList_SetBkColor uintptr + imageList_SetDragCursorImage uintptr + imageList_SetIconSize uintptr + imageList_SetImageCount uintptr + imageList_SetOverlayImage uintptr + imageList_Write uintptr + initCommonControls uintptr + initCommonControlsEx uintptr + initMUILanguage uintptr + initializeFlatSB uintptr + lBItemFromPt uintptr + makeDragList uintptr + menuHelp uintptr + propertySheet uintptr + removeWindowSubclass uintptr + setWindowSubclass uintptr + showHideMenuCtl uintptr + str_SetPtrW uintptr + taskDialog uintptr + taskDialogIndirect uintptr + uninitializeFlatSB uintptr + addMRUStringW uintptr + createMRUListW uintptr + createToolbar uintptr + enumMRUListW uintptr + freeMRUList uintptr + imageList_AddIcon uintptr + imageList_GetFlags uintptr + imageList_GetImageRect uintptr + imageList_SetFilter uintptr + imageList_SetFlags uintptr +) + +func init() { + // Library + libcomctl32 = doLoadLibrary("comctl32.dll") + + // Functions + createMappedBitmap = doGetProcAddress(libcomctl32, "CreateMappedBitmap") + createPropertySheetPage = doGetProcAddress(libcomctl32, "CreatePropertySheetPageW") + createStatusWindow = doGetProcAddress(libcomctl32, "CreateStatusWindowW") + createToolbarEx = doGetProcAddress(libcomctl32, "CreateToolbarEx") + createUpDownControl = doGetProcAddress(libcomctl32, "CreateUpDownControl") + dPA_Create = doGetProcAddress(libcomctl32, "DPA_Create") + dPA_DeleteAllPtrs = doGetProcAddress(libcomctl32, "DPA_DeleteAllPtrs") + dPA_DeletePtr = doGetProcAddress(libcomctl32, "DPA_DeletePtr") + dPA_Destroy = doGetProcAddress(libcomctl32, "DPA_Destroy") + dPA_DestroyCallback = doGetProcAddress(libcomctl32, "DPA_DestroyCallback") + dPA_EnumCallback = doGetProcAddress(libcomctl32, "DPA_EnumCallback") + dPA_GetPtr = doGetProcAddress(libcomctl32, "DPA_GetPtr") + dPA_InsertPtr = doGetProcAddress(libcomctl32, "DPA_InsertPtr") + dPA_Search = doGetProcAddress(libcomctl32, "DPA_Search") + dPA_SetPtr = doGetProcAddress(libcomctl32, "DPA_SetPtr") + dPA_Sort = doGetProcAddress(libcomctl32, "DPA_Sort") + dSA_Create = doGetProcAddress(libcomctl32, "DSA_Create") + dSA_DeleteAllItems = doGetProcAddress(libcomctl32, "DSA_DeleteAllItems") + dSA_Destroy = doGetProcAddress(libcomctl32, "DSA_Destroy") + dSA_DestroyCallback = doGetProcAddress(libcomctl32, "DSA_DestroyCallback") + dSA_GetItemPtr = doGetProcAddress(libcomctl32, "DSA_GetItemPtr") + dSA_InsertItem = doGetProcAddress(libcomctl32, "DSA_InsertItem") + defSubclassProc = doGetProcAddress(libcomctl32, "DefSubclassProc") + destroyPropertySheetPage = doGetProcAddress(libcomctl32, "DestroyPropertySheetPage") + drawInsert = doGetProcAddress(libcomctl32, "DrawInsert") + drawStatusText = doGetProcAddress(libcomctl32, "DrawStatusTextW") + flatSB_EnableScrollBar = doGetProcAddress(libcomctl32, "FlatSB_EnableScrollBar") + flatSB_GetScrollInfo = doGetProcAddress(libcomctl32, "FlatSB_GetScrollInfo") + flatSB_GetScrollPos = doGetProcAddress(libcomctl32, "FlatSB_GetScrollPos") + flatSB_GetScrollProp = doGetProcAddress(libcomctl32, "FlatSB_GetScrollProp") + flatSB_GetScrollPropPtr = doGetProcAddress(libcomctl32, "FlatSB_GetScrollPropPtr") + flatSB_GetScrollRange = doGetProcAddress(libcomctl32, "FlatSB_GetScrollRange") + flatSB_SetScrollInfo = doGetProcAddress(libcomctl32, "FlatSB_SetScrollInfo") + flatSB_SetScrollPos = doGetProcAddress(libcomctl32, "FlatSB_SetScrollPos") + flatSB_SetScrollProp = doGetProcAddress(libcomctl32, "FlatSB_SetScrollProp") + flatSB_SetScrollRange = doGetProcAddress(libcomctl32, "FlatSB_SetScrollRange") + flatSB_ShowScrollBar = doGetProcAddress(libcomctl32, "FlatSB_ShowScrollBar") + getEffectiveClientRect = doGetProcAddress(libcomctl32, "GetEffectiveClientRect") + getMUILanguage = doGetProcAddress(libcomctl32, "GetMUILanguage") + imageList_Add = doGetProcAddress(libcomctl32, "ImageList_Add") + imageList_AddMasked = doGetProcAddress(libcomctl32, "ImageList_AddMasked") + imageList_BeginDrag = doGetProcAddress(libcomctl32, "ImageList_BeginDrag") + imageList_Copy = doGetProcAddress(libcomctl32, "ImageList_Copy") + imageList_Create = doGetProcAddress(libcomctl32, "ImageList_Create") + imageList_Destroy = doGetProcAddress(libcomctl32, "ImageList_Destroy") + imageList_DragEnter = doGetProcAddress(libcomctl32, "ImageList_DragEnter") + imageList_DragLeave = doGetProcAddress(libcomctl32, "ImageList_DragLeave") + imageList_DragMove = doGetProcAddress(libcomctl32, "ImageList_DragMove") + imageList_DragShowNolock = doGetProcAddress(libcomctl32, "ImageList_DragShowNolock") + imageList_Draw = doGetProcAddress(libcomctl32, "ImageList_Draw") + imageList_DrawEx = doGetProcAddress(libcomctl32, "ImageList_DrawEx") + imageList_DrawIndirect = doGetProcAddress(libcomctl32, "ImageList_DrawIndirect") + imageList_Duplicate = doGetProcAddress(libcomctl32, "ImageList_Duplicate") + imageList_EndDrag = doGetProcAddress(libcomctl32, "ImageList_EndDrag") + imageList_GetBkColor = doGetProcAddress(libcomctl32, "ImageList_GetBkColor") + imageList_GetDragImage = doGetProcAddress(libcomctl32, "ImageList_GetDragImage") + imageList_GetIcon = doGetProcAddress(libcomctl32, "ImageList_GetIcon") + imageList_GetIconSize = doGetProcAddress(libcomctl32, "ImageList_GetIconSize") + imageList_GetImageCount = doGetProcAddress(libcomctl32, "ImageList_GetImageCount") + imageList_GetImageInfo = doGetProcAddress(libcomctl32, "ImageList_GetImageInfo") + imageList_LoadImage = doGetProcAddress(libcomctl32, "ImageList_LoadImageW") + imageList_Merge = doGetProcAddress(libcomctl32, "ImageList_Merge") + imageList_Read = doGetProcAddress(libcomctl32, "ImageList_Read") + imageList_Remove = doGetProcAddress(libcomctl32, "ImageList_Remove") + imageList_Replace = doGetProcAddress(libcomctl32, "ImageList_Replace") + imageList_ReplaceIcon = doGetProcAddress(libcomctl32, "ImageList_ReplaceIcon") + imageList_SetBkColor = doGetProcAddress(libcomctl32, "ImageList_SetBkColor") + imageList_SetDragCursorImage = doGetProcAddress(libcomctl32, "ImageList_SetDragCursorImage") + imageList_SetIconSize = doGetProcAddress(libcomctl32, "ImageList_SetIconSize") + imageList_SetImageCount = doGetProcAddress(libcomctl32, "ImageList_SetImageCount") + imageList_SetOverlayImage = doGetProcAddress(libcomctl32, "ImageList_SetOverlayImage") + imageList_Write = doGetProcAddress(libcomctl32, "ImageList_Write") + initCommonControls = doGetProcAddress(libcomctl32, "InitCommonControls") + initCommonControlsEx = doGetProcAddress(libcomctl32, "InitCommonControlsEx") + initMUILanguage = doGetProcAddress(libcomctl32, "InitMUILanguage") + initializeFlatSB = doGetProcAddress(libcomctl32, "InitializeFlatSB") + lBItemFromPt = doGetProcAddress(libcomctl32, "LBItemFromPt") + makeDragList = doGetProcAddress(libcomctl32, "MakeDragList") + menuHelp = doGetProcAddress(libcomctl32, "MenuHelp") + propertySheet = doGetProcAddress(libcomctl32, "PropertySheetW") + removeWindowSubclass = doGetProcAddress(libcomctl32, "RemoveWindowSubclass") + setWindowSubclass = doGetProcAddress(libcomctl32, "SetWindowSubclass") + showHideMenuCtl = doGetProcAddress(libcomctl32, "ShowHideMenuCtl") + str_SetPtrW = doGetProcAddress(libcomctl32, "Str_SetPtrW") + taskDialog = doGetProcAddress(libcomctl32, "TaskDialog") + taskDialogIndirect = doGetProcAddress(libcomctl32, "TaskDialogIndirect") + uninitializeFlatSB = doGetProcAddress(libcomctl32, "UninitializeFlatSB") + addMRUStringW = doGetProcAddress(libcomctl32, "AddMRUStringW") + createMRUListW = doGetProcAddress(libcomctl32, "CreateMRUListW") + createToolbar = doGetProcAddress(libcomctl32, "CreateToolbar") + enumMRUListW = doGetProcAddress(libcomctl32, "EnumMRUListW") + freeMRUList = doGetProcAddress(libcomctl32, "FreeMRUList") + imageList_AddIcon = doGetProcAddress(libcomctl32, "ImageList_AddIcon") + imageList_GetFlags = doGetProcAddress(libcomctl32, "ImageList_GetFlags") + imageList_GetImageRect = doGetProcAddress(libcomctl32, "ImageList_GetImageRect") + imageList_SetFilter = doGetProcAddress(libcomctl32, "ImageList_SetFilter") + imageList_SetFlags = doGetProcAddress(libcomctl32, "ImageList_SetFlags") +} + +func CreateMappedBitmap(hInstance HINSTANCE, idBitmap INT_PTR, wFlags UINT, lpColorMap *COLORMAP, iNumMaps int32) HBITMAP { + ret1 := syscall6(createMappedBitmap, 5, + uintptr(hInstance), + uintptr(unsafe.Pointer(idBitmap)), + uintptr(wFlags), + uintptr(unsafe.Pointer(lpColorMap)), + uintptr(iNumMaps), + 0) + return HBITMAP(ret1) +} + +func CreatePropertySheetPage(constPropSheetPagePointer /*const*/ *PROPSHEETPAGE) HPROPSHEETPAGE { + ret1 := syscall3(createPropertySheetPage, 1, + uintptr(unsafe.Pointer(constPropSheetPagePointer)), + 0, + 0) + return HPROPSHEETPAGE(ret1) +} + +func CreateStatusWindow(style LONG, lpszText string, hwndParent HWND, wID UINT) HWND { + lpszTextStr := unicode16FromString(lpszText) + ret1 := syscall6(createStatusWindow, 4, + uintptr(style), + uintptr(unsafe.Pointer(&lpszTextStr[0])), + uintptr(hwndParent), + uintptr(wID), + 0, + 0) + return HWND(ret1) +} + +func CreateToolbarEx(hwnd HWND, ws DWORD, wID UINT, nBitmaps int32, hBMInst HINSTANCE, wBMID *uint32, lpButtons /*const*/ *TBBUTTON, iNumButtons int32, dxButton int32, dyButton int32, dxBitmap int32, dyBitmap int32, uStructSize UINT) HWND { + ret1 := syscall15(createToolbarEx, 13, + uintptr(hwnd), + uintptr(ws), + uintptr(wID), + uintptr(nBitmaps), + uintptr(hBMInst), + uintptr(unsafe.Pointer(wBMID)), + uintptr(unsafe.Pointer(lpButtons)), + uintptr(iNumButtons), + uintptr(dxButton), + uintptr(dyButton), + uintptr(dxBitmap), + uintptr(dyBitmap), + uintptr(uStructSize), + 0, + 0) + return HWND(ret1) +} + +func CreateUpDownControl(dwStyle DWORD, x int32, y int32, cx int32, cy int32, hParent HWND, nID int32, hInst HINSTANCE, hBuddy HWND, nUpper int32, nLower int32, nPos int32) HWND { + ret1 := syscall12(createUpDownControl, 12, + uintptr(dwStyle), + uintptr(x), + uintptr(y), + uintptr(cx), + uintptr(cy), + uintptr(hParent), + uintptr(nID), + uintptr(hInst), + uintptr(hBuddy), + uintptr(nUpper), + uintptr(nLower), + uintptr(nPos)) + return HWND(ret1) +} + +func DPA_Create(cItemGrow int32) HDPA { + ret1 := syscall3(dPA_Create, 1, + uintptr(cItemGrow), + 0, + 0) + return HDPA(ret1) +} + +func DPA_DeleteAllPtrs(hdpa HDPA) bool { + ret1 := syscall3(dPA_DeleteAllPtrs, 1, + uintptr(hdpa), + 0, + 0) + return ret1 != 0 +} + +func DPA_DeletePtr(hdpa HDPA, i int32) uintptr { + ret1 := syscall3(dPA_DeletePtr, 2, + uintptr(hdpa), + uintptr(i), + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func DPA_Destroy(hdpa HDPA) bool { + ret1 := syscall3(dPA_Destroy, 1, + uintptr(hdpa), + 0, + 0) + return ret1 != 0 +} + +func DPA_DestroyCallback(hdpa HDPA, pfnCB DAENUMCALLBACK, pData uintptr) { + pfnCBCallback := syscall.NewCallback(func(pRawArg uintptr, pDataRawArg uintptr) uintptr { + ret := pfnCB(pRawArg, pDataRawArg) + return uintptr(ret) + }) + syscall3(dPA_DestroyCallback, 3, + uintptr(hdpa), + pfnCBCallback, + pData) +} + +func DPA_EnumCallback(hdpa HDPA, pfnCB DAENUMCALLBACK, pData uintptr) { + pfnCBCallback := syscall.NewCallback(func(pRawArg uintptr, pDataRawArg uintptr) uintptr { + ret := pfnCB(pRawArg, pDataRawArg) + return uintptr(ret) + }) + syscall3(dPA_EnumCallback, 3, + uintptr(hdpa), + pfnCBCallback, + pData) +} + +func DPA_GetPtr(hdpa HDPA, i INT_PTR) uintptr { + ret1 := syscall3(dPA_GetPtr, 2, + uintptr(hdpa), + uintptr(unsafe.Pointer(i)), + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func DPA_InsertPtr(hdpa HDPA, i int32, p uintptr) int32 { + ret1 := syscall3(dPA_InsertPtr, 3, + uintptr(hdpa), + uintptr(i), + p) + return int32(ret1) +} + +func DPA_Search(hdpa HDPA, pFind uintptr, iStart int32, pfnCompare DACOMPARE, lParam LPARAM, options UINT) int32 { + pfnCompareCallback := syscall.NewCallback(func(p1RawArg uintptr, p2RawArg uintptr, lParamRawArg LPARAM) uintptr { + ret := pfnCompare(p1RawArg, p2RawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall6(dPA_Search, 6, + uintptr(hdpa), + pFind, + uintptr(iStart), + pfnCompareCallback, + uintptr(lParam), + uintptr(options)) + return int32(ret1) +} + +func DPA_SetPtr(hdpa HDPA, i int32, p uintptr) bool { + ret1 := syscall3(dPA_SetPtr, 3, + uintptr(hdpa), + uintptr(i), + p) + return ret1 != 0 +} + +func DPA_Sort(hdpa HDPA, pfnCompare DACOMPARE, lParam LPARAM) bool { + pfnCompareCallback := syscall.NewCallback(func(p1RawArg uintptr, p2RawArg uintptr, lParamRawArg LPARAM) uintptr { + ret := pfnCompare(p1RawArg, p2RawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall3(dPA_Sort, 3, + uintptr(hdpa), + pfnCompareCallback, + uintptr(lParam)) + return ret1 != 0 +} + +func DSA_Create(cbItem int32, cItemGrow int32) HDSA { + ret1 := syscall3(dSA_Create, 2, + uintptr(cbItem), + uintptr(cItemGrow), + 0) + return HDSA(ret1) +} + +func DSA_DeleteAllItems(hdsa HDSA) bool { + ret1 := syscall3(dSA_DeleteAllItems, 1, + uintptr(hdsa), + 0, + 0) + return ret1 != 0 +} + +func DSA_Destroy(hdsa HDSA) bool { + ret1 := syscall3(dSA_Destroy, 1, + uintptr(hdsa), + 0, + 0) + return ret1 != 0 +} + +func DSA_DestroyCallback(hdsa HDSA, pfnCB DAENUMCALLBACK, pData uintptr) { + pfnCBCallback := syscall.NewCallback(func(pRawArg uintptr, pDataRawArg uintptr) uintptr { + ret := pfnCB(pRawArg, pDataRawArg) + return uintptr(ret) + }) + syscall3(dSA_DestroyCallback, 3, + uintptr(hdsa), + pfnCBCallback, + pData) +} + +func DSA_GetItemPtr(hdsa HDSA, i int32) uintptr { + ret1 := syscall3(dSA_GetItemPtr, 2, + uintptr(hdsa), + uintptr(i), + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func DSA_InsertItem(hdsa HDSA, i int32, pitem /*const*/ uintptr) int32 { + ret1 := syscall3(dSA_InsertItem, 3, + uintptr(hdsa), + uintptr(i), + pitem) + return int32(ret1) +} + +func DefSubclassProc(hWnd HWND, uMsg UINT, wParam WPARAM, lParam LPARAM) LRESULT { + ret1 := syscall6(defSubclassProc, 4, + uintptr(hWnd), + uintptr(uMsg), + uintptr(wParam), + uintptr(lParam), + 0, + 0) + return LRESULT(ret1) +} + +func DestroyPropertySheetPage(unnamed0 HPROPSHEETPAGE) bool { + ret1 := syscall3(destroyPropertySheetPage, 1, + uintptr(unnamed0), + 0, + 0) + return ret1 != 0 +} + +func DrawInsert(handParent HWND, hLB HWND, nItem int32) { + syscall3(drawInsert, 3, + uintptr(handParent), + uintptr(hLB), + uintptr(nItem)) +} + +func DrawStatusText(hDC HDC, lprc /*const*/ *RECT, pszText string, uFlags UINT) { + pszTextStr := unicode16FromString(pszText) + syscall6(drawStatusText, 4, + uintptr(hDC), + uintptr(unsafe.Pointer(lprc)), + uintptr(unsafe.Pointer(&pszTextStr[0])), + uintptr(uFlags), + 0, + 0) +} + +func FlatSB_EnableScrollBar(unnamed0 HWND, unnamed1 int32, unnamed2 UINT) bool { + ret1 := syscall3(flatSB_EnableScrollBar, 3, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2)) + return ret1 != 0 +} + +func FlatSB_GetScrollInfo(unnamed0 HWND, code int32, unnamed2 *SCROLLINFO) bool { + ret1 := syscall3(flatSB_GetScrollInfo, 3, + uintptr(unnamed0), + uintptr(code), + uintptr(unsafe.Pointer(unnamed2))) + return ret1 != 0 +} + +func FlatSB_GetScrollPos(unnamed0 HWND, code int32) int32 { + ret1 := syscall3(flatSB_GetScrollPos, 2, + uintptr(unnamed0), + uintptr(code), + 0) + return int32(ret1) +} + +func FlatSB_GetScrollProp(unnamed0 HWND, propIndex int32, unnamed2 *int32) bool { + ret1 := syscall3(flatSB_GetScrollProp, 3, + uintptr(unnamed0), + uintptr(propIndex), + uintptr(unsafe.Pointer(unnamed2))) + return ret1 != 0 +} + +func FlatSB_GetScrollPropPtr(unnamed0 HWND, propIndex int32, unnamed2 PINT_PTR) bool { + ret1 := syscall3(flatSB_GetScrollPropPtr, 3, + uintptr(unnamed0), + uintptr(propIndex), + uintptr(unsafe.Pointer(unnamed2))) + return ret1 != 0 +} + +func FlatSB_GetScrollRange(unnamed0 HWND, code int32, unnamed2 *int32, unnamed3 *int32) bool { + ret1 := syscall6(flatSB_GetScrollRange, 4, + uintptr(unnamed0), + uintptr(code), + uintptr(unsafe.Pointer(unnamed2)), + uintptr(unsafe.Pointer(unnamed3)), + 0, + 0) + return ret1 != 0 +} + +func FlatSB_SetScrollInfo(unnamed0 HWND, code int32, unnamed2 *SCROLLINFO, fRedraw bool) int32 { + ret1 := syscall6(flatSB_SetScrollInfo, 4, + uintptr(unnamed0), + uintptr(code), + uintptr(unsafe.Pointer(unnamed2)), + getUintptrFromBool(fRedraw), + 0, + 0) + return int32(ret1) +} + +func FlatSB_SetScrollPos(unnamed0 HWND, code int32, pos int32, fRedraw bool) int32 { + ret1 := syscall6(flatSB_SetScrollPos, 4, + uintptr(unnamed0), + uintptr(code), + uintptr(pos), + getUintptrFromBool(fRedraw), + 0, + 0) + return int32(ret1) +} + +func FlatSB_SetScrollProp(unnamed0 HWND, index UINT, newValue INT_PTR, unnamed3 bool) bool { + ret1 := syscall6(flatSB_SetScrollProp, 4, + uintptr(unnamed0), + uintptr(index), + uintptr(unsafe.Pointer(newValue)), + getUintptrFromBool(unnamed3), + 0, + 0) + return ret1 != 0 +} + +func FlatSB_SetScrollRange(unnamed0 HWND, code int32, min int32, max int32, fRedraw bool) int32 { + ret1 := syscall6(flatSB_SetScrollRange, 5, + uintptr(unnamed0), + uintptr(code), + uintptr(min), + uintptr(max), + getUintptrFromBool(fRedraw), + 0) + return int32(ret1) +} + +func FlatSB_ShowScrollBar(unnamed0 HWND, code int32, unnamed2 bool) bool { + ret1 := syscall3(flatSB_ShowScrollBar, 3, + uintptr(unnamed0), + uintptr(code), + getUintptrFromBool(unnamed2)) + return ret1 != 0 +} + +func GetEffectiveClientRect(hWnd HWND, lprc *RECT, lpInfo /*const*/ *int32) { + syscall3(getEffectiveClientRect, 3, + uintptr(hWnd), + uintptr(unsafe.Pointer(lprc)), + uintptr(unsafe.Pointer(lpInfo))) +} + +func GetMUILanguage() LANGID { + ret1 := syscall3(getMUILanguage, 0, + 0, + 0, + 0) + return LANGID(ret1) +} + +func ImageList_Add(himl HIMAGELIST, hbmImage HBITMAP, hbmMask HBITMAP) int32 { + ret1 := syscall3(imageList_Add, 3, + uintptr(himl), + uintptr(hbmImage), + uintptr(hbmMask)) + return int32(ret1) +} + +func ImageList_AddMasked(himl HIMAGELIST, hbmImage HBITMAP, crMask COLORREF) int32 { + ret1 := syscall3(imageList_AddMasked, 3, + uintptr(himl), + uintptr(hbmImage), + uintptr(crMask)) + return int32(ret1) +} + +func ImageList_BeginDrag(himlTrack HIMAGELIST, iTrack int32, dxHotspot int32, dyHotspot int32) bool { + ret1 := syscall6(imageList_BeginDrag, 4, + uintptr(himlTrack), + uintptr(iTrack), + uintptr(dxHotspot), + uintptr(dyHotspot), + 0, + 0) + return ret1 != 0 +} + +func ImageList_Copy(himlDst HIMAGELIST, iDst int32, himlSrc HIMAGELIST, iSrc int32, uFlags UINT) bool { + ret1 := syscall6(imageList_Copy, 5, + uintptr(himlDst), + uintptr(iDst), + uintptr(himlSrc), + uintptr(iSrc), + uintptr(uFlags), + 0) + return ret1 != 0 +} + +func ImageList_Create(cx int32, cy int32, flags UINT, cInitial int32, cGrow int32) HIMAGELIST { + ret1 := syscall6(imageList_Create, 5, + uintptr(cx), + uintptr(cy), + uintptr(flags), + uintptr(cInitial), + uintptr(cGrow), + 0) + return HIMAGELIST(ret1) +} + +func ImageList_Destroy(himl HIMAGELIST) bool { + ret1 := syscall3(imageList_Destroy, 1, + uintptr(himl), + 0, + 0) + return ret1 != 0 +} + +func ImageList_DragEnter(hwndLock HWND, x int32, y int32) bool { + ret1 := syscall3(imageList_DragEnter, 3, + uintptr(hwndLock), + uintptr(x), + uintptr(y)) + return ret1 != 0 +} + +func ImageList_DragLeave(hwndLock HWND) bool { + ret1 := syscall3(imageList_DragLeave, 1, + uintptr(hwndLock), + 0, + 0) + return ret1 != 0 +} + +func ImageList_DragMove(x int32, y int32) bool { + ret1 := syscall3(imageList_DragMove, 2, + uintptr(x), + uintptr(y), + 0) + return ret1 != 0 +} + +func ImageList_DragShowNolock(fShow bool) bool { + ret1 := syscall3(imageList_DragShowNolock, 1, + getUintptrFromBool(fShow), + 0, + 0) + return ret1 != 0 +} + +func ImageList_Draw(himl HIMAGELIST, i int32, hdcDst HDC, x int32, y int32, fStyle UINT) bool { + ret1 := syscall6(imageList_Draw, 6, + uintptr(himl), + uintptr(i), + uintptr(hdcDst), + uintptr(x), + uintptr(y), + uintptr(fStyle)) + return ret1 != 0 +} + +func ImageList_DrawEx(himl HIMAGELIST, i int32, hdcDst HDC, x int32, y int32, dx int32, dy int32, rgbBk COLORREF, rgbFg COLORREF, fStyle UINT) bool { + ret1 := syscall12(imageList_DrawEx, 10, + uintptr(himl), + uintptr(i), + uintptr(hdcDst), + uintptr(x), + uintptr(y), + uintptr(dx), + uintptr(dy), + uintptr(rgbBk), + uintptr(rgbFg), + uintptr(fStyle), + 0, + 0) + return ret1 != 0 +} + +func ImageList_DrawIndirect(pimldp *IMAGELISTDRAWPARAMS) bool { + ret1 := syscall3(imageList_DrawIndirect, 1, + uintptr(unsafe.Pointer(pimldp)), + 0, + 0) + return ret1 != 0 +} + +func ImageList_Duplicate(himl HIMAGELIST) HIMAGELIST { + ret1 := syscall3(imageList_Duplicate, 1, + uintptr(himl), + 0, + 0) + return HIMAGELIST(ret1) +} + +func ImageList_EndDrag() { + syscall3(imageList_EndDrag, 0, + 0, + 0, + 0) +} + +func ImageList_GetBkColor(himl HIMAGELIST) COLORREF { + ret1 := syscall3(imageList_GetBkColor, 1, + uintptr(himl), + 0, + 0) + return COLORREF(ret1) +} + +func ImageList_GetDragImage(ppt *POINT, pptHotspot *POINT) HIMAGELIST { + ret1 := syscall3(imageList_GetDragImage, 2, + uintptr(unsafe.Pointer(ppt)), + uintptr(unsafe.Pointer(pptHotspot)), + 0) + return HIMAGELIST(ret1) +} + +func ImageList_GetIcon(himl HIMAGELIST, i int32, flags UINT) HICON { + ret1 := syscall3(imageList_GetIcon, 3, + uintptr(himl), + uintptr(i), + uintptr(flags)) + return HICON(ret1) +} + +func ImageList_GetIconSize(himl HIMAGELIST, cx *int, cy *int) bool { + ret1 := syscall3(imageList_GetIconSize, 3, + uintptr(himl), + uintptr(unsafe.Pointer(cx)), + uintptr(unsafe.Pointer(cy))) + return ret1 != 0 +} + +func ImageList_GetImageCount(himl HIMAGELIST) int32 { + ret1 := syscall3(imageList_GetImageCount, 1, + uintptr(himl), + 0, + 0) + return int32(ret1) +} + +func ImageList_GetImageInfo(himl HIMAGELIST, i int32, pImageInfo *IMAGEINFO) bool { + ret1 := syscall3(imageList_GetImageInfo, 3, + uintptr(himl), + uintptr(i), + uintptr(unsafe.Pointer(pImageInfo))) + return ret1 != 0 +} + +func ImageList_LoadImage(hi HINSTANCE, lpbmp string, cx int32, cGrow int32, crMask COLORREF, uType UINT, uFlags UINT) HIMAGELIST { + lpbmpStr := unicode16FromString(lpbmp) + ret1 := syscall9(imageList_LoadImage, 7, + uintptr(hi), + uintptr(unsafe.Pointer(&lpbmpStr[0])), + uintptr(cx), + uintptr(cGrow), + uintptr(crMask), + uintptr(uType), + uintptr(uFlags), + 0, + 0) + return HIMAGELIST(ret1) +} + +func ImageList_Merge(himl1 HIMAGELIST, i1 int32, himl2 HIMAGELIST, i2 int32, dx int32, dy int32) HIMAGELIST { + ret1 := syscall6(imageList_Merge, 6, + uintptr(himl1), + uintptr(i1), + uintptr(himl2), + uintptr(i2), + uintptr(dx), + uintptr(dy)) + return HIMAGELIST(ret1) +} + +func ImageList_Read(pstm LPSTREAM) HIMAGELIST { + ret1 := syscall3(imageList_Read, 1, + uintptr(unsafe.Pointer(pstm)), + 0, + 0) + return HIMAGELIST(ret1) +} + +func ImageList_Remove(himl HIMAGELIST, i int32) bool { + ret1 := syscall3(imageList_Remove, 2, + uintptr(himl), + uintptr(i), + 0) + return ret1 != 0 +} + +func ImageList_Replace(himl HIMAGELIST, i int32, hbmImage HBITMAP, hbmMask HBITMAP) bool { + ret1 := syscall6(imageList_Replace, 4, + uintptr(himl), + uintptr(i), + uintptr(hbmImage), + uintptr(hbmMask), + 0, + 0) + return ret1 != 0 +} + +func ImageList_ReplaceIcon(himl HIMAGELIST, i int32, hicon HICON) int32 { + ret1 := syscall3(imageList_ReplaceIcon, 3, + uintptr(himl), + uintptr(i), + uintptr(hicon)) + return int32(ret1) +} + +func ImageList_SetBkColor(himl HIMAGELIST, clrBk COLORREF) COLORREF { + ret1 := syscall3(imageList_SetBkColor, 2, + uintptr(himl), + uintptr(clrBk), + 0) + return COLORREF(ret1) +} + +func ImageList_SetDragCursorImage(himlDrag HIMAGELIST, iDrag int32, dxHotspot int32, dyHotspot int32) bool { + ret1 := syscall6(imageList_SetDragCursorImage, 4, + uintptr(himlDrag), + uintptr(iDrag), + uintptr(dxHotspot), + uintptr(dyHotspot), + 0, + 0) + return ret1 != 0 +} + +func ImageList_SetIconSize(himl HIMAGELIST, cx int32, cy int32) bool { + ret1 := syscall3(imageList_SetIconSize, 3, + uintptr(himl), + uintptr(cx), + uintptr(cy)) + return ret1 != 0 +} + +func ImageList_SetImageCount(himl HIMAGELIST, uNewCount UINT) bool { + ret1 := syscall3(imageList_SetImageCount, 2, + uintptr(himl), + uintptr(uNewCount), + 0) + return ret1 != 0 +} + +func ImageList_SetOverlayImage(himl HIMAGELIST, iImage int32, iOverlay int32) bool { + ret1 := syscall3(imageList_SetOverlayImage, 3, + uintptr(himl), + uintptr(iImage), + uintptr(iOverlay)) + return ret1 != 0 +} + +func ImageList_Write(himl HIMAGELIST, pstm LPSTREAM) bool { + ret1 := syscall3(imageList_Write, 2, + uintptr(himl), + uintptr(unsafe.Pointer(pstm)), + 0) + return ret1 != 0 +} + +func InitCommonControls() { + syscall3(initCommonControls, 0, + 0, + 0, + 0) +} + +func InitCommonControlsEx(unnamed0 /*const*/ *INITCOMMONCONTROLSEX) bool { + ret1 := syscall3(initCommonControlsEx, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return ret1 != 0 +} + +func InitMUILanguage(uiLang LANGID) { + syscall3(initMUILanguage, 1, + uintptr(uiLang), + 0, + 0) +} + +func InitializeFlatSB(unnamed0 HWND) bool { + ret1 := syscall3(initializeFlatSB, 1, + uintptr(unnamed0), + 0, + 0) + return ret1 != 0 +} + +func LBItemFromPt(hLB HWND, pt POINT, bAutoScroll bool) int32 { + ret1 := syscall6(lBItemFromPt, 4, + uintptr(hLB), + uintptr(pt.X), + uintptr(pt.Y), + getUintptrFromBool(bAutoScroll), + 0, + 0) + return int32(ret1) +} + +func MakeDragList(hLB HWND) bool { + ret1 := syscall3(makeDragList, 1, + uintptr(hLB), + 0, + 0) + return ret1 != 0 +} + +func MenuHelp(uMsg UINT, wParam WPARAM, lParam LPARAM, hMainMenu HMENU, hInst HINSTANCE, hwndStatus HWND, lpwIDs *UINT) { + syscall9(menuHelp, 7, + uintptr(uMsg), + uintptr(wParam), + uintptr(lParam), + uintptr(hMainMenu), + uintptr(hInst), + uintptr(hwndStatus), + uintptr(unsafe.Pointer(lpwIDs)), + 0, + 0) +} + +func PropertySheet(unnamed0 /*const*/ *PROPSHEETHEADER) INT_PTR { + ret1 := syscall3(propertySheet, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return (INT_PTR)(unsafe.Pointer(ret1)) +} + +func RemoveWindowSubclass(hWnd HWND, pfnSubclass SUBCLASSPROC, uIdSubclass *uint32) bool { + pfnSubclassCallback := syscall.NewCallback(func(hWndRawArg HWND, uMsgRawArg UINT, wParamRawArg WPARAM, lParamRawArg LPARAM, uIdSubclassRawArg UINT_PTR, dwRefDataRawArg DWORD_PTR) uintptr { + ret := pfnSubclass(hWndRawArg, uMsgRawArg, wParamRawArg, lParamRawArg, uIdSubclassRawArg, dwRefDataRawArg) + return uintptr(ret) + }) + ret1 := syscall3(removeWindowSubclass, 3, + uintptr(hWnd), + pfnSubclassCallback, + uintptr(unsafe.Pointer(uIdSubclass))) + return ret1 != 0 +} + +func SetWindowSubclass(hWnd HWND, pfnSubclass SUBCLASSPROC, uIdSubclass *uint32, dwRefData *uint32) bool { + pfnSubclassCallback := syscall.NewCallback(func(hWndRawArg HWND, uMsgRawArg UINT, wParamRawArg WPARAM, lParamRawArg LPARAM, uIdSubclassRawArg UINT_PTR, dwRefDataRawArg DWORD_PTR) uintptr { + ret := pfnSubclass(hWndRawArg, uMsgRawArg, wParamRawArg, lParamRawArg, uIdSubclassRawArg, dwRefDataRawArg) + return uintptr(ret) + }) + ret1 := syscall6(setWindowSubclass, 4, + uintptr(hWnd), + pfnSubclassCallback, + uintptr(unsafe.Pointer(uIdSubclass)), + uintptr(unsafe.Pointer(dwRefData)), + 0, + 0) + return ret1 != 0 +} + +func ShowHideMenuCtl(hWnd HWND, uFlags *uint32, lpInfo *int32) bool { + ret1 := syscall3(showHideMenuCtl, 3, + uintptr(hWnd), + uintptr(unsafe.Pointer(uFlags)), + uintptr(unsafe.Pointer(lpInfo))) + return ret1 != 0 +} + +func Str_SetPtrW(ppsz *LPWSTR, psz string) bool { + pszStr := unicode16FromString(psz) + ret1 := syscall3(str_SetPtrW, 2, + uintptr(unsafe.Pointer(ppsz)), + uintptr(unsafe.Pointer(&pszStr[0])), + 0) + return ret1 != 0 +} + +func TaskDialog(hwndOwner HWND, hInstance HINSTANCE, pszWindowTitle string, pszMainInstruction string, pszContent string, dwCommonButtons TASKDIALOG_COMMON_BUTTON_FLAGS, pszIcon string, pnButton *int) HRESULT { + pszWindowTitleStr := unicode16FromString(pszWindowTitle) + pszMainInstructionStr := unicode16FromString(pszMainInstruction) + pszContentStr := unicode16FromString(pszContent) + pszIconStr := unicode16FromString(pszIcon) + ret1 := syscall9(taskDialog, 8, + uintptr(hwndOwner), + uintptr(hInstance), + uintptr(unsafe.Pointer(&pszWindowTitleStr[0])), + uintptr(unsafe.Pointer(&pszMainInstructionStr[0])), + uintptr(unsafe.Pointer(&pszContentStr[0])), + uintptr(dwCommonButtons), + uintptr(unsafe.Pointer(&pszIconStr[0])), + uintptr(unsafe.Pointer(pnButton)), + 0) + return HRESULT(ret1) +} + +func TaskDialogIndirect(pTaskConfig /*const*/ *TASKDIALOGCONFIG, pnButton *int, pnRadioButton *int, pfVerificationFlagChecked *BOOL) HRESULT { + ret1 := syscall6(taskDialogIndirect, 4, + uintptr(unsafe.Pointer(pTaskConfig)), + uintptr(unsafe.Pointer(pnButton)), + uintptr(unsafe.Pointer(pnRadioButton)), + uintptr(unsafe.Pointer(pfVerificationFlagChecked)), + 0, + 0) + return HRESULT(ret1) +} + +func UninitializeFlatSB(unnamed0 HWND) HRESULT { + ret1 := syscall3(uninitializeFlatSB, 1, + uintptr(unnamed0), + 0, + 0) + return HRESULT(ret1) +} + +func AddMRUStringW(hList HANDLE, lpszString string) INT { + lpszStringStr := unicode16FromString(lpszString) + ret1 := syscall3(addMRUStringW, 2, + uintptr(hList), + uintptr(unsafe.Pointer(&lpszStringStr[0])), + 0) + return INT(ret1) +} + +func CreateMRUListW(infoW /*const*/ *MRUINFO) HANDLE { + ret1 := syscall3(createMRUListW, 1, + uintptr(unsafe.Pointer(infoW)), + 0, + 0) + return HANDLE(ret1) +} + +func CreateToolbar(hwnd HWND, style DWORD, wID UINT, nBitmaps INT, hBMInst HINSTANCE, wBMID UINT, lpButtons /*const*/ *TBBUTTON, iNumButtons INT) HWND { + ret1 := syscall9(createToolbar, 8, + uintptr(hwnd), + uintptr(style), + uintptr(wID), + uintptr(nBitmaps), + uintptr(hBMInst), + uintptr(wBMID), + uintptr(unsafe.Pointer(lpButtons)), + uintptr(iNumButtons), + 0) + return HWND(ret1) +} + +func EnumMRUListW(hList HANDLE, nItemPos INT, lpBuffer LPVOID, nBufferSize DWORD) INT { + ret1 := syscall6(enumMRUListW, 4, + uintptr(hList), + uintptr(nItemPos), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(nBufferSize), + 0, + 0) + return INT(ret1) +} + +func FreeMRUList(hMRUList HANDLE) { + syscall3(freeMRUList, 1, + uintptr(hMRUList), + 0, + 0) +} + +func ImageList_AddIcon(himl HIMAGELIST, hIcon HICON) INT { + ret1 := syscall3(imageList_AddIcon, 2, + uintptr(himl), + uintptr(hIcon), + 0) + return INT(ret1) +} + +func ImageList_GetFlags(himl HIMAGELIST) DWORD { + ret1 := syscall3(imageList_GetFlags, 1, + uintptr(himl), + 0, + 0) + return DWORD(ret1) +} + +func ImageList_GetImageRect(himl HIMAGELIST, i INT, lpRect *RECT) bool { + ret1 := syscall3(imageList_GetImageRect, 3, + uintptr(himl), + uintptr(i), + uintptr(unsafe.Pointer(lpRect))) + return ret1 != 0 +} + +func ImageList_SetFilter(himl HIMAGELIST, i INT, dwFilter DWORD) bool { + ret1 := syscall3(imageList_SetFilter, 3, + uintptr(himl), + uintptr(i), + uintptr(dwFilter)) + return ret1 != 0 +} + +func ImageList_SetFlags(himl HIMAGELIST, flags DWORD) DWORD { + ret1 := syscall3(imageList_SetFlags, 2, + uintptr(himl), + uintptr(flags), + 0) + return DWORD(ret1) +} diff --git a/grdp/win/comdlg32.go b/grdp/win/comdlg32.go new file mode 100644 index 0000000..67e4e76 --- /dev/null +++ b/grdp/win/comdlg32.go @@ -0,0 +1,135 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "unsafe" +) + +var ( + // Library + libcomdlg32 uintptr + + // Functions + chooseColor uintptr + chooseFont uintptr + commDlgExtendedError uintptr + findText uintptr + getFileTitle uintptr + getOpenFileName uintptr + getSaveFileName uintptr + pageSetupDlg uintptr + printDlgEx uintptr + printDlg uintptr + replaceText uintptr +) + +func init() { + // Library + libcomdlg32 = doLoadLibrary("comdlg32.dll") + + // Functions + chooseColor = doGetProcAddress(libcomdlg32, "ChooseColorW") + chooseFont = doGetProcAddress(libcomdlg32, "ChooseFontW") + commDlgExtendedError = doGetProcAddress(libcomdlg32, "CommDlgExtendedError") + findText = doGetProcAddress(libcomdlg32, "FindTextW") + getFileTitle = doGetProcAddress(libcomdlg32, "GetFileTitleW") + getOpenFileName = doGetProcAddress(libcomdlg32, "GetOpenFileNameW") + getSaveFileName = doGetProcAddress(libcomdlg32, "GetSaveFileNameW") + pageSetupDlg = doGetProcAddress(libcomdlg32, "PageSetupDlgW") + printDlgEx = doGetProcAddress(libcomdlg32, "PrintDlgExW") + printDlg = doGetProcAddress(libcomdlg32, "PrintDlgW") + replaceText = doGetProcAddress(libcomdlg32, "ReplaceTextW") +} + +func ChooseColor(unnamed0 *CHOOSECOLOR) bool { + ret1 := syscall3(chooseColor, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return ret1 != 0 +} + +func ChooseFont(unnamed0 LPCHOOSEFONT) bool { + ret1 := syscall3(chooseFont, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return ret1 != 0 +} + +func CommDlgExtendedError() DWORD { + ret1 := syscall3(commDlgExtendedError, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func FindText(unnamed0 LPFINDREPLACE) HWND { + ret1 := syscall3(findText, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return HWND(ret1) +} + +func GetFileTitle(unnamed0 string, unnamed1 LPWSTR, unnamed2 WORD) int16 { + unnamed0Str := unicode16FromString(unnamed0) + ret1 := syscall3(getFileTitle, 3, + uintptr(unsafe.Pointer(&unnamed0Str[0])), + uintptr(unsafe.Pointer(unnamed1)), + uintptr(unnamed2)) + return int16(ret1) +} + +func GetOpenFileName(unnamed0 LPOPENFILENAME) bool { + ret1 := syscall3(getOpenFileName, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return ret1 != 0 +} + +func GetSaveFileName(unnamed0 LPOPENFILENAME) bool { + ret1 := syscall3(getSaveFileName, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return ret1 != 0 +} + +func PageSetupDlg(unnamed0 LPPAGESETUPDLG) bool { + ret1 := syscall3(pageSetupDlg, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return ret1 != 0 +} + +func PrintDlgEx(unnamed0 LPPRINTDLGEX) HRESULT { + ret1 := syscall3(printDlgEx, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return HRESULT(ret1) +} + +func PrintDlg(unnamed0 LPPRINTDLG) bool { + ret1 := syscall3(printDlg, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return ret1 != 0 +} + +func ReplaceText(unnamed0 LPFINDREPLACE) HWND { + ret1 := syscall3(replaceText, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return HWND(ret1) +} diff --git a/grdp/win/const.go b/grdp/win/const.go new file mode 100644 index 0000000..db050af --- /dev/null +++ b/grdp/win/const.go @@ -0,0 +1,1437 @@ +package win + +type BOOL int32 + +const ( + TRUE BOOL = 1 + FALSE BOOL = 0 +) + +const ( + CCHDEVICENAME = 32 + CCHFORMNAME = 32 +) + +type SECURITY_IMPERSONATION_LEVEL int32 + +const ( + SecurityAnonymous SECURITY_IMPERSONATION_LEVEL = iota + SecurityIdentification + SecurityImpersonation + SecurityDelegation +) + +const ( + CCHILDREN_TITLEBAR = 5 + CCHILDREN_SCROLLBAR = 5 +) + +type SE_OBJECT_TYPE int32 + +const ( + SE_UNKNOWN_OBJECT_TYPE SE_OBJECT_TYPE = iota + SE_FILE_OBJECT + SE_SERVICE + SE_PRINTER + SE_REGISTRY_KEY + SE_LMSHARE + SE_KERNEL_OBJECT + SE_WINDOW_OBJECT + SE_DS_OBJECT + SE_DS_OBJECT_ALL + SE_PROVIDER_DEFINED_OBJECT + SE_WMIGUID_OBJECT + SE_REGISTRY_WOW64_32KEY +) + +type PROPERTYORIGIN int32 + +const ( + PO_STATE PROPERTYORIGIN = iota + PO_PART + PO_CLASS + PO_GLOBAL + PO_NOTFOUND +) + +type THEMESIZE int32 + +const ( + TS_MIN THEMESIZE = iota + TS_TRUE + TS_DRAW +) + +const ANYSIZE_ARRAY = 1 + +type AUDIT_EVENT_TYPE int32 + +const ( + AuditEventObjectAccess AUDIT_EVENT_TYPE = iota + AuditEventDirectoryServiceAccess +) + +type POLICY_AUDIT_EVENT_TYPE int32 + +const ( + AuditCategorySystem POLICY_AUDIT_EVENT_TYPE = iota + AuditCategoryLogon + AuditCategoryObjectAccess + AuditCategoryPrivilegeUse + AuditCategoryDetailedTracking + AuditCategoryPolicyChange + AuditCategoryAccountManagement + AuditCategoryDirectoryServiceAccess + AuditCategoryAccountLogon +) + +type ACCESS_MODE int32 + +const ( + NOT_USED_ACCESS ACCESS_MODE = iota + GRANT_ACCESS + SET_ACCESS + DENY_ACCESS + REVOKE_ACCESS + SET_AUDIT_SUCCESS + SET_AUDIT_FAILURE +) + +type MULTIPLE_TRUSTEE_OPERATION int32 + +const ( + NO_MULTIPLE_TRUSTEE MULTIPLE_TRUSTEE_OPERATION = iota + TRUSTEE_IS_IMPERSONATE +) + +type TRUSTEE_FORM int32 + +const ( + TRUSTEE_IS_SID TRUSTEE_FORM = iota + TRUSTEE_IS_NAME + TRUSTEE_BAD_FORM + TRUSTEE_IS_OBJECTS_AND_SID + TRUSTEE_IS_OBJECTS_AND_NAME +) + +type TRUSTEE_TYPE int32 + +const ( + TRUSTEE_IS_UNKNOWN TRUSTEE_TYPE = iota + TRUSTEE_IS_USER + TRUSTEE_IS_GROUP + TRUSTEE_IS_DOMAIN + TRUSTEE_IS_ALIAS + TRUSTEE_IS_WELL_KNOWN_GROUP + TRUSTEE_IS_DELETED + TRUSTEE_IS_INVALID + TRUSTEE_IS_COMPUTER +) + +const MAXPNAMELEN = 32 + +type XLAT_SIDE int32 + +const ( + XLAT_SERVER XLAT_SIDE = iota + XLAT_CLIENT +) + +type IDL_CS_CONVERT int32 + +const ( + IDL_CS_NO_CONVERT IDL_CS_CONVERT = iota + IDL_CS_IN_PLACE_CONVERT + IDL_CS_NEW_BUFFER_CONVERT +) + +type VARENUM int32 + +const ( + VT_EMPTY VARENUM = 0 + VT_NULL = 1 + VT_I2 = 2 + VT_I4 = 3 + VT_R4 = 4 + VT_R8 = 5 + VT_CY = 6 + VT_DATE = 7 + VT_BSTR = 8 + VT_DISPATCH = 9 + VT_ERROR = 10 + VT_BOOL = 11 + VT_VARIANT = 12 + VT_UNKNOWN = 13 + VT_DECIMAL = 14 + VT_I1 = 16 + VT_UI1 = 17 + VT_UI2 = 18 + VT_UI4 = 19 + VT_I8 = 20 + VT_UI8 = 21 + VT_INT = 22 + VT_UINT = 23 + VT_VOID = 24 + VT_HRESULT = 25 + VT_PTR = 26 + VT_SAFEARRAY = 27 + VT_CARRAY = 28 + VT_USERDEFINED = 29 + VT_LPSTR = 30 + VT_LPWSTR = 31 + VT_RECORD = 36 + VT_INT_PTR = 37 + VT_UINT_PTR = 38 + VT_FILETIME = 64 + VT_BLOB = 65 + VT_STREAM = 66 + VT_STORAGE = 67 + VT_STREAMED_OBJECT = 68 + VT_STORED_OBJECT = 69 + VT_BLOB_OBJECT = 70 + VT_CF = 71 + VT_CLSID = 72 + VT_VERSIONED_STREAM = 73 + VT_BSTR_BLOB = 0xfff + VT_VECTOR = 0x1000 + VT_ARRAY = 0x2000 + VT_BYREF = 0x4000 + VT_RESERVED = 0x8000 + VT_ILLEGAL = 0xffff + VT_ILLEGALMASKED = 0xfff + VT_TYPEMASK = 0xfff +) + +type GpStatus int32 + +const ( + Ok GpStatus = 0 + GenericError = 1 + InvalidParameter = 2 + OutOfMemory = 3 + ObjectBusy = 4 + InsufficientBuffer = 5 + NotImplemented = 6 + Win32Error = 7 + WrongState = 8 + Aborted = 9 + FileNotFound = 10 + ValueOverflow = 11 + AccessDenied = 12 + UnknownImageFormat = 13 + FontFamilyNotFound = 14 + FontStyleNotFound = 15 + NotTrueTypeFont = 16 + UnsupportedGdiplusVersion = 17 + GdiplusNotInitialized = 18 + PropertyNotFound = 19 + PropertyNotSupported = 20 + ProfileNotFound = 21 +) + +type BP_ANIMATIONSTYLE int32 + +const ( + BPAS_NONE BP_ANIMATIONSTYLE = iota + BPAS_LINEAR + BPAS_CUBIC + BPAS_SINE +) + +type BP_BUFFERFORMAT int32 + +const ( + BPBF_COMPATIBLEBITMAP BP_BUFFERFORMAT = iota + BPBF_DIB + BPBF_TOPDOWNDIB + BPBF_TOPDOWNMONODIB +) + +const MAX_INTLIST_COUNT = 402 + +type PERCEIVED int32 + +const ( + PERCEIVED_TYPE_FIRST PERCEIVED = -3 + PERCEIVED_TYPE_CUSTOM = -3 + PERCEIVED_TYPE_UNSPECIFIED = -2 + PERCEIVED_TYPE_FOLDER = -1 + PERCEIVED_TYPE_UNKNOWN = 0 + PERCEIVED_TYPE_TEXT = 1 + PERCEIVED_TYPE_IMAGE = 2 + PERCEIVED_TYPE_AUDIO = 3 + PERCEIVED_TYPE_VIDEO = 4 + PERCEIVED_TYPE_COMPRESSED = 5 + PERCEIVED_TYPE_DOCUMENT = 6 + PERCEIVED_TYPE_SYSTEM = 7 + PERCEIVED_TYPE_APPLICATION = 8 + PERCEIVED_TYPE_GAMEMEDIA = 9 + PERCEIVED_TYPE_CONTACTS = 10 + PERCEIVED_TYPE_LAST = 10 +) + +type DWORD uint32 + +type ASSOCF DWORD + +const ( + ASSOCF_NONE ASSOCF = 0x00000000 + ASSOCF_INIT_NOREMAPCLSID = 0x00000001 + ASSOCF_INIT_BYEXENAME = 0x00000002 + ASSOCF_OPEN_BYEXENAME = 0x00000002 + ASSOCF_INIT_DEFAULTTOSTAR = 0x00000004 + ASSOCF_INIT_DEFAULTTOFOLDER = 0x00000008 + ASSOCF_NOUSERSETTINGS = 0x00000010 + ASSOCF_NOTRUNCATE = 0x00000020 + ASSOCF_VERIFY = 0x00000040 + ASSOCF_REMAPRUNDLL = 0x00000080 + ASSOCF_NOFIXUPS = 0x00000100 + ASSOCF_IGNOREBASECLASS = 0x00000200 + ASSOCF_INIT_IGNOREUNKNOWN = 0x00000400 + ASSOCF_INIT_FIXED_PROGID = 0x00000800 + ASSOCF_IS_PROTOCOL = 0x00001000 + ASSOCF_INIT_FOR_FILE = 0x00002000 +) + +type ASSOCKEY int32 + +const ( + ASSOCKEY_SHELLEXECCLASS ASSOCKEY = iota + 1 + ASSOCKEY_APP + ASSOCKEY_CLASS + ASSOCKEY_BASECLASS + ASSOCKEY_MAX +) + +type ASSOCSTR int32 + +const ( + ASSOCSTR_COMMAND ASSOCSTR = iota + 1 + ASSOCSTR_EXECUTABLE + ASSOCSTR_FRIENDLYDOCNAME + ASSOCSTR_FRIENDLYAPPNAME + ASSOCSTR_NOOPEN + ASSOCSTR_SHELLNEWVALUE + ASSOCSTR_DDECOMMAND + ASSOCSTR_DDEIFEXEC + ASSOCSTR_DDEAPPLICATION + ASSOCSTR_DDETOPIC + ASSOCSTR_INFOTIP + ASSOCSTR_QUICKTIP + ASSOCSTR_TILEINFO + ASSOCSTR_CONTENTTYPE + ASSOCSTR_DEFAULTICON + ASSOCSTR_SHELLEXTENSION + ASSOCSTR_DROPTARGET + ASSOCSTR_DELEGATEEXECUTE + ASSOCSTR_SUPPORTED_URI_PROTOCOLS + ASSOCSTR_MAX +) + +type SHREGDEL_FLAGS int32 + +const ( + SHREGDEL_DEFAULT SHREGDEL_FLAGS = 0x00000000 + SHREGDEL_HKCU = 0x00000001 + SHREGDEL_HKLM = 0x00000010 + SHREGDEL_BOTH = 0x00000011 +) + +type SHREGENUM_FLAGS int32 + +const ( + SHREGENUM_DEFAULT SHREGENUM_FLAGS = 0x00000000 + SHREGENUM_HKCU = 0x00000001 + SHREGENUM_HKLM = 0x00000010 + SHREGENUM_BOTH = 0x00000011 +) + +type URLIS int32 + +const ( + URLIS_URL URLIS = iota + URLIS_OPAQUE + URLIS_NOHISTORY + URLIS_FILEURL + URLIS_APPLIABLE + URLIS_DIRECTORY + URLIS_HASQUERY +) + +type TASKDIALOG_COMMON_BUTTON_FLAGS int32 + +const ( + TDCBF_OK_BUTTON TASKDIALOG_COMMON_BUTTON_FLAGS = 0x0001 + TDCBF_YES_BUTTON = 0x0002 + TDCBF_NO_BUTTON = 0x0004 + TDCBF_CANCEL_BUTTON = 0x0008 + TDCBF_RETRY_BUTTON = 0x0010 + TDCBF_CLOSE_BUTTON = 0x0020 +) + +type TASKDIALOG_FLAGS int32 + +const ( + TDF_ENABLE_HYPERLINKS TASKDIALOG_FLAGS = 0x0001 + TDF_USE_HICON_MAIN = 0x0002 + TDF_USE_HICON_FOOTER = 0x0004 + TDF_ALLOW_DIALOG_CANCELLATION = 0x0008 + TDF_USE_COMMAND_LINKS = 0x0010 + TDF_USE_COMMAND_LINKS_NO_ICON = 0x0020 + TDF_EXPAND_FOOTER_AREA = 0x0040 + TDF_EXPANDED_BY_DEFAULT = 0x0080 + TDF_VERIFICATION_FLAG_CHECKED = 0x0100 + TDF_SHOW_PROGRESS_BAR = 0x0200 + TDF_SHOW_MARQUEE_PROGRESS_BAR = 0x0400 + TDF_CALLBACK_TIMER = 0x0800 + TDF_POSITION_RELATIVE_TO_WINDOW = 0x1000 + TDF_RTL_LAYOUT = 0x2000 + TDF_NO_DEFAULT_RADIO_BUTTON = 0x4000 + TDF_CAN_BE_MINIMIZED = 0x8000 + TDF_NO_SET_FOREGROUND = 0x00010000 + TDF_SIZE_TO_CONTENT = 0x01000000 +) + +const MAX_PATH = 260 + +const LF_FACESIZE = 32 +const LF_FULLFACESIZE = 64 + +const MM_MAX_NUMAXES = 16 + +type CALLCONV int32 + +const ( + CC_FASTCALL CALLCONV = 0 + CC_CDECL = 1 + CC_MSCPASCAL = CC_CDECL + 1 + CC_PASCAL = CC_MSCPASCAL + CC_MACPASCAL = CC_PASCAL + 1 + CC_STDCALL = CC_MACPASCAL + 1 + CC_FPFASTCALL = CC_STDCALL + 1 + CC_SYSCALL = CC_FPFASTCALL + 1 + CC_MPWCDECL = CC_SYSCALL + 1 + CC_MPWPASCAL = CC_MPWCDECL + 1 + CC_MAX = CC_MPWPASCAL + 1 +) + +type SYSKIND int32 + +const ( + SYS_WIN16 SYSKIND = 0 + SYS_WIN32 = SYS_WIN16 + 1 + SYS_MAC = SYS_WIN32 + 1 + SYS_WIN64 = SYS_MAC + 1 +) + +type REGKIND int32 + +const ( + REGKIND_DEFAULT REGKIND = iota + REGKIND_REGISTER + REGKIND_NONE +) + +const IMEMENUITEM_STRING_SIZE = 80 + +const STYLE_DESCRIPTION_SIZE = 32 + +const MAX_PROTOCOL_CHAIN = 7 + +const WSAPROTOCOL_LEN = 255 + +type ADDRESS_FAMILY int16 + +const ( + AF_UNSPEC ADDRESS_FAMILY = 0 + AF_UNIX = 1 + AF_INET = 2 + AF_IMPLINK = 3 + AF_PUP = 4 + AF_CHAOS = 5 + AF_NS = 6 + AF_IPX = AF_NS + AF_ISO = 7 + AF_OSI = AF_ISO + AF_ECMA = 8 + AF_DATAKIT = 9 + AF_CCITT = 10 + AF_SNA = 11 + AF_DECnet = 12 + AF_DLI = 13 + AF_LAT = 14 + AF_HYLINK = 15 + AF_APPLETALK = 16 + AF_NETBIOS = 17 + AF_VOICEVIEW = 18 + AF_FIREFOX = 19 + AF_UNKNOWN1 = 20 + AF_BAN = 21 + AF_ATM = 22 + AF_INET6 = 23 + AF_CLUSTER = 24 + AF_12844 = 25 + AF_IRDA = 26 + AF_NETDES = 28 + AF_TCNPROCESS = 29 + AF_TCNMESSAGE = 30 + AF_ICLFXBM = 31 + AF_BTH = 32 + AF_LINK = 33 + AF_MAX = 34 +) + +type SERVICETYPE uint32 + +const ( + SERVICETYPE_NOTRAFFIC SERVICETYPE = 0x00000000 + SERVICETYPE_BESTEFFORT = 0x00000001 + SERVICETYPE_CONTROLLEDLOAD = 0x00000002 + SERVICETYPE_GUARANTEED = 0x00000003 + SERVICETYPE_NETWORK_UNAVAILABLE = 0x00000004 + SERVICETYPE_GENERAL_INFORMATION = 0x00000005 + SERVICETYPE_NOCHANGE = 0x00000006 + SERVICETYPE_NONCONFORMING = 0x00000009 + SERVICETYPE_NETWORK_CONTROL = 0x0000000A + SERVICETYPE_QUALITATIVE = 0x0000000D +) + +const FD_MAX_EVENTS = 10 + +type WSAECOMPARATOR int32 + +const ( + COMP_EQUAL WSAECOMPARATOR = iota + COMP_NOTLESS +) + +type WSACOMPLETIONTYPE int32 + +const ( + NSP_NOTIFY_IMMEDIATELY WSACOMPLETIONTYPE = iota + NSP_NOTIFY_HWND + NSP_NOTIFY_EVENT + NSP_NOTIFY_PORT + NSP_NOTIFY_APC +) + +type WSAESETSERVICEOP int32 + +const ( + RNRSERVICE_REGISTER WSAESETSERVICEOP = iota + RNRSERVICE_DEREGISTER + RNRSERVICE_DELETE +) + +const WSADESCRIPTION_LEN = 256 +const WSASYS_STATUS_LEN = 128 + +type MIB_IPFORWARD_TYPE int32 + +const ( + MIB_IPROUTE_TYPE_OTHER MIB_IPFORWARD_TYPE = 1 + MIB_IPROUTE_TYPE_INVALID = 2 + MIB_IPROUTE_TYPE_DIRECT = 3 + MIB_IPROUTE_TYPE_INDIRECT = 4 +) + +type NL_ROUTE_PROTOCOL int32 + +const ( + RouteProtocolOther NL_ROUTE_PROTOCOL = 1 + RouteProtocolLocal = 2 + RouteProtocolNetMgmt = 3 + RouteProtocolIcmp = 4 + RouteProtocolEgp = 5 + RouteProtocolGgp = 6 + RouteProtocolHello = 7 + RouteProtocolRip = 8 + RouteProtocolIsIs = 9 + RouteProtocolEsIs = 10 + RouteProtocolCisco = 11 + RouteProtocolBbn = 12 + RouteProtocolOspf = 13 + RouteProtocolBgp = 14 + RouteProtocolIdpr = 15 + RouteProtocolEigrp = 16 + RouteProtocolDvmrp = 17 + RouteProtocolRpl = 18 + RouteProtocolDhcp = 19 + + MIB_IPPROTO_OTHER = 1 + MIB_IPPROTO_LOCAL = 2 + MIB_IPPROTO_NETMGMT = 3 + MIB_IPPROTO_ICMP = 4 + MIB_IPPROTO_EGP = 5 + MIB_IPPROTO_GGP = 6 + MIB_IPPROTO_HELLO = 7 + MIB_IPPROTO_RIP = 8 + MIB_IPPROTO_IS_IS = 9 + MIB_IPPROTO_ES_IS = 10 + MIB_IPPROTO_CISCO = 11 + MIB_IPPROTO_BBN = 12 + MIB_IPPROTO_OSPF = 13 + MIB_IPPROTO_BGP = 14 + MIB_IPPROTO_IDPR = 15 + MIB_IPPROTO_EIGRP = 16 + MIB_IPPROTO_DVMRP = 17 + MIB_IPPROTO_RPL = 18 + MIB_IPPROTO_DHCP = 19 + MIB_IPPROTO_NT_AUTOSTATIC = 10002 + MIB_IPPROTO_NT_STATIC = 10006 + MIB_IPPROTO_NT_STATIC_NON_DOD = 10007 + + PROTO_IP_OTHER = 1 + PROTO_IP_LOCAL = 2 + PROTO_IP_NETMGMT = 3 + PROTO_IP_ICMP = 4 + PROTO_IP_EGP = 5 + PROTO_IP_GGP = 6 + PROTO_IP_HELLO = 7 + PROTO_IP_RIP = 8 + PROTO_IP_IS_IS = 9 + PROTO_IP_ES_IS = 10 + PROTO_IP_CISCO = 11 + PROTO_IP_BBN = 12 + PROTO_IP_OSPF = 13 + PROTO_IP_BGP = 14 + PROTO_IP_IDPR = 15 + PROTO_IP_EIGRP = 16 + PROTO_IP_DVMRP = 17 + PROTO_IP_RPL = 18 + PROTO_IP_DHCP = 19 + PROTO_IP_NT_AUTOSTATIC = 10002 + PROTO_IP_NT_STATIC = 10006 + PROTO_IP_NT_STATIC_NON_DOD = 10007 +) + +const MAXLEN_PHYSADDR = 8 +const MAXLEN_IFDESCR = 256 +const MAX_INTERFACE_NAME_LEN = 256 + +type MIB_IPNET_TYPE int32 + +const ( + MIB_IPNET_TYPE_OTHER MIB_IPNET_TYPE = 1 + MIB_IPNET_TYPE_INVALID = 2 + MIB_IPNET_TYPE_DYNAMIC = 3 + MIB_IPNET_TYPE_STATIC = 4 +) + +type MIB_TCP_STATE int32 + +const ( + MIB_TCP_STATE_CLOSED MIB_TCP_STATE = 1 + MIB_TCP_STATE_LISTEN = 2 + MIB_TCP_STATE_SYN_SENT = 3 + MIB_TCP_STATE_SYN_RCVD = 4 + MIB_TCP_STATE_ESTAB = 5 + MIB_TCP_STATE_FIN_WAIT1 = 6 + MIB_TCP_STATE_FIN_WAIT2 = 7 + MIB_TCP_STATE_CLOSE_WAIT = 8 + MIB_TCP_STATE_CLOSING = 9 + MIB_TCP_STATE_LAST_ACK = 10 + MIB_TCP_STATE_TIME_WAIT = 11 + MIB_TCP_STATE_DELETE_TCB = 12 +) + +type MIB_IPSTATS_FORWARDING int32 + +const ( + MIB_IP_FORWARDING MIB_IPSTATS_FORWARDING = 1 + MIB_IP_NOT_FORWARDING = 2 +) + +type NL_PREFIX_ORIGIN int32 + +const ( + IpPrefixOriginOther NL_PREFIX_ORIGIN = iota + IpPrefixOriginManual + IpPrefixOriginWellKnown + IpPrefixOriginDhcp + IpPrefixOriginRouterAdvertisement + IpPrefixOriginUnchanged = 1 << 4 +) + +type NL_SUFFIX_ORIGIN int32 + +const ( + NlsoOther NL_SUFFIX_ORIGIN = iota + NlsoManual + NlsoWellKnown + NlsoDhcp + NlsoLinkLayerAddress + NlsoRandom +) +const ( + IpSuffixOriginOther NL_SUFFIX_ORIGIN = iota + IpSuffixOriginManual + IpSuffixOriginWellKnown + IpSuffixOriginDhcp + IpSuffixOriginLinkLayerAddress + IpSuffixOriginRandom + IpSuffixOriginUnchanged = 1 << 4 +) + +type NL_DAD_STATE int32 + +const ( + NldsInvalid NL_DAD_STATE = iota + NldsTentative + NldsDuplicate + NldsDeprecated + NldsPreferred +) +const ( + IpDadStateInvalid NL_DAD_STATE = iota + IpDadStateTentative + IpDadStateDuplicate + IpDadStateDeprecated + IpDadStatePreferred +) + +const MAX_ADAPTER_NAME_LENGTH = 256 +const MAX_ADAPTER_DESCRIPTION_LENGTH = 128 +const MAX_ADAPTER_ADDRESS_LENGTH = 8 + +type TCP_TABLE_CLASS int32 + +const ( + TCP_TABLE_BASIC_LISTENER TCP_TABLE_CLASS = iota + TCP_TABLE_BASIC_CONNECTIONS + TCP_TABLE_BASIC_ALL + TCP_TABLE_OWNER_PID_LISTENER + TCP_TABLE_OWNER_PID_CONNECTIONS + TCP_TABLE_OWNER_PID_ALL + TCP_TABLE_OWNER_MODULE_LISTENER + TCP_TABLE_OWNER_MODULE_CONNECTIONS + TCP_TABLE_OWNER_MODULE_ALL +) + +type UDP_TABLE_CLASS int32 + +const ( + UDP_TABLE_BASIC UDP_TABLE_CLASS = iota + UDP_TABLE_OWNER_PID + UDP_TABLE_OWNER_MODULE +) + +type INTERNAL_IF_OPER_STATUS int32 + +const ( + IF_OPER_STATUS_NON_OPERATIONAL INTERNAL_IF_OPER_STATUS = 0 + IF_OPER_STATUS_UNREACHABLE = 1 + IF_OPER_STATUS_DISCONNECTED = 2 + IF_OPER_STATUS_CONNECTING = 3 + IF_OPER_STATUS_CONNECTED = 4 + IF_OPER_STATUS_OPERATIONAL = 5 +) + +type IF_OPER_STATUS int32 + +const ( + IfOperStatusUp IF_OPER_STATUS = iota + 1 + IfOperStatusDown + IfOperStatusTesting + IfOperStatusUnknown + IfOperStatusDormant + IfOperStatusNotPresent + IfOperStatusLowerLayerDown +) + +const MAX_DHCPV6_DUID_LENGTH = 130 + +type NET_IF_COMPARTMENT_ID uint32 + +const ( + NET_IF_COMPARTMENT_ID_UNSPECIFIED NET_IF_COMPARTMENT_ID = 0 + NET_IF_COMPARTMENT_ID_PRIMARY = 1 + NET_IF_COMPARTMENT_ID_ALL = 0xffffffff +) + +type NET_IF_CONNECTION_TYPE int32 + +const ( + NET_IF_CONNECTION_DEDICATED NET_IF_CONNECTION_TYPE = iota + 1 + NET_IF_CONNECTION_PASSIVE + NET_IF_CONNECTION_DEMAND + NET_IF_CONNECTION_MAXIMUM +) + +type TUNNEL_TYPE int32 + +const ( + TUNNEL_TYPE_NONE TUNNEL_TYPE = 0 + TUNNEL_TYPE_OTHER = 1 + TUNNEL_TYPE_DIRECT = 2 + TUNNEL_TYPE_6TO4 = 11 + TUNNEL_TYPE_ISATAP = 13 + TUNNEL_TYPE_TEREDO = 14 + TUNNEL_TYPE_IPHTTPS = 15 +) + +const MAX_DNS_SUFFIX_STRING_LENGTH = 256 + +const ANY_SIZE = 100 + +const MAX_ADAPTER_NAME = 128 + +const MAX_HOSTNAME_LEN = 128 +const MAX_DOMAIN_NAME_LEN = 128 +const MAX_SCOPE_ID_LEN = 256 + +type TCPIP_OWNER_MODULE_INFO_CLASS int32 + +const ( + TCPIP_OWNER_MODULE_INFO_BASIC TCPIP_OWNER_MODULE_INFO_CLASS = iota +) + +const TCPIP_OWNING_MODULE_SIZE = 16 +const MAX_DEFAULTCHAR = 2 +const MAX_LEADBYTES = 12 + +const ( + FOREGROUND_BLUE = 0x0001 + FOREGROUND_GREEN = 0x0002 + FOREGROUND_RED = 0x0004 + FOREGROUND_INTENSITY = 0x0008 + BACKGROUND_BLUE = 0x0010 + BACKGROUND_GREEN = 0x0020 + BACKGROUND_RED = 0x0040 + BACKGROUND_INTENSITY = 0x0080 + COMMON_LVB_LEADING_BYTE = 0x0100 + COMMON_LVB_TRAILING_BYTE = 0x0200 + COMMON_LVB_GRID_HORIZONTAL = 0x0400 + COMMON_LVB_GRID_LVERTICAL = 0x0800 + COMMON_LVB_GRID_RVERTICAL = 0x1000 + COMMON_LVB_REVERSE_VIDEO = 0x4000 + COMMON_LVB_UNDERSCORE = 0x8000 +) + +type TCP_ESTATS_TYPE int32 + +const ( + TcpConnectionEstatsSynOpts TCP_ESTATS_TYPE = iota + TcpConnectionEstatsData + TcpConnectionEstatsSndCong + TcpConnectionEstatsPath + TcpConnectionEstatsSendBuff + TcpConnectionEstatsRec + TcpConnectionEstatsObsRec + TcpConnectionEstatsBandwidth + TcpConnectionEstatsFineRtt + TcpConnectionEstatsMaximum +) + +type TCP_CONNECTION_OFFLOAD_STATE int32 + +const ( + TcpConnectionOffloadStateInHost TCP_CONNECTION_OFFLOAD_STATE = iota + TcpConnectionOffloadStateOffloading + TcpConnectionOffloadStateOffloaded + TcpConnectionOffloadStateUploading + TcpConnectionOffloadStateMax +) + +type TCP_RTO_ALGORITHM int32 + +const ( + TcpRtoAlgorithmOther TCP_RTO_ALGORITHM = iota + TcpRtoAlgorithmConstant + TcpRtoAlgorithmRsre + TcpRtoAlgorithmVanj + + MIB_TCP_RTO_OTHER = 1 + MIB_TCP_RTO_CONSTANT = 2 + MIB_TCP_RTO_RSRE = 3 + MIB_TCP_RTO_VANJ = 4 +) + +type NET_ADDRESS_FORMAT int32 + +const ( + NET_ADDRESS_FORMAT_UNSPECIFIED NET_ADDRESS_FORMAT = iota + NET_ADDRESS_DNS_NAME + NET_ADDRESS_IPV4 + NET_ADDRESS_IPV6 +) + +const DNS_MAX_NAME_BUFFER_LENGTH = 256 + +type NDIS_MEDIUM int32 + +const ( + NdisMedium802_3 NDIS_MEDIUM = iota + NdisMedium802_5 + NdisMediumFddi + NdisMediumWan + NdisMediumLocalTalk + NdisMediumDix + NdisMediumArcnetRaw + NdisMediumArcnet878_2 + NdisMediumAtm + NdisMediumWirelessWan + NdisMediumIrda + NdisMediumBpc + NdisMediumCoWan + NdisMedium1394 + NdisMediumInfiniBand + NdisMediumTunnel + NdisMediumNative802_11 + NdisMediumLoopback + NdisMediumWiMAX + NdisMediumIP + NdisMediumMax +) + +type NDIS_PHYSICAL_MEDIUM int32 + +const ( + NdisPhysicalMediumUnspecified NDIS_PHYSICAL_MEDIUM = iota + NdisPhysicalMediumWirelessLan + NdisPhysicalMediumCableModem + NdisPhysicalMediumPhoneLine + NdisPhysicalMediumPowerLine + NdisPhysicalMediumDSL + NdisPhysicalMediumFibreChannel + NdisPhysicalMedium1394 + NdisPhysicalMediumWirelessWan + NdisPhysicalMediumNative802_11 + NdisPhysicalMediumBluetooth + NdisPhysicalMediumInfiniband + NdisPhysicalMediumWiMax + NdisPhysicalMediumUWB + NdisPhysicalMedium802_3 + NdisPhysicalMedium802_5 + NdisPhysicalMediumIrda + NdisPhysicalMediumWiredWAN + NdisPhysicalMediumWiredCoWan + NdisPhysicalMediumOther + NdisPhysicalMediumMax +) + +type NET_IF_ACCESS_TYPE int32 + +const ( + NET_IF_ACCESS_LOOPBACK NET_IF_ACCESS_TYPE = 1 + NET_IF_ACCESS_BROADCAST = 2 + NET_IF_ACCESS_POINT_TO_POINT = 3 + NET_IF_ACCESS_POINT_TO_MULTI_POINT = 4 + NET_IF_ACCESS_MAXIMUM = 5 +) + +type NET_IF_ADMIN_STATUS int32 + +const ( + NET_IF_ADMIN_STATUS_UP NET_IF_ADMIN_STATUS = 1 + NET_IF_ADMIN_STATUS_DOWN = 2 + NET_IF_ADMIN_STATUS_TESTING = 3 +) + +type NET_IF_DIRECTION_TYPE int32 + +const ( + NET_IF_DIRECTION_SENDRECEIVE NET_IF_DIRECTION_TYPE = iota + NET_IF_DIRECTION_SENDONLY + NET_IF_DIRECTION_RECEIVEONLY + NET_IF_DIRECTION_MAXIMUM +) + +type NET_IF_MEDIA_CONNECT_STATE int32 + +const ( + MediaConnectStateUnknown NET_IF_MEDIA_CONNECT_STATE = iota + MediaConnectStateConnected + MediaConnectStateDisconnected +) + +const IF_MAX_STRING_SIZE = 256 +const IF_MAX_PHYS_ADDRESS_LENGTH = 32 + +type PFADDRESSTYPE int32 + +const ( + PF_IPV4 PFADDRESSTYPE = iota + PF_IPV6 +) + +type PFFORWARD_ACTION int32 + +const ( + PF_ACTION_FORWARD PFFORWARD_ACTION = iota + PF_ACTION_DROP +) + +const MAX_JOYSTICKOEMVXDNAME = 260 + +const MIXER_SHORT_NAME_CHARS = 16 +const MIXER_LONG_NAME_CHARS = 64 + +const NUM_POINTS = 3 + +type ASSOC_FILTER int32 + +const ( + ASSOC_FILTER_NONE ASSOC_FILTER = 0 + ASSOC_FILTER_RECOMMENDED ASSOC_FILTER = 0x1 +) + +type FOLDERVIEWMODE int32 + +const ( + FVM_AUTO FOLDERVIEWMODE = -1 + FVM_FIRST = 1 + FVM_ICON = 1 + FVM_SMALLICON = 2 + FVM_LIST = 3 + FVM_DETAILS = 4 + FVM_THUMBNAIL = 5 + FVM_TILE = 6 + FVM_THUMBSTRIP = 7 + FVM_CONTENT = 8 + FVM_LAST = 8 +) + +type FILEOP_FLAGS uint16 + +const ( + FOF_MULTIDESTFILES FILEOP_FLAGS = 0x0001 + FOF_CONFIRMMOUSE = 0x0002 + FOF_SILENT = 0x0004 + FOF_RENAMEONCOLLISION = 0x0008 + FOF_NOCONFIRMATION = 0x0010 + FOF_WANTMAPPINGHANDLE = 0x0020 + FOF_ALLOWUNDO = 0x0040 + FOF_FILESONLY = 0x0080 + FOF_SIMPLEPROGRESS = 0x0100 + FOF_NOCONFIRMMKDIR = 0x0200 + FOF_NOERRORUI = 0x0400 + FOF_NOCOPYSECURITYATTRIBS = 0x0800 + FOF_NORECURSION = 0x1000 + FOF_NO_CONNECTED_ELEMENTS = 0x2000 + FOF_WANTNUKEWARNING = 0x4000 + FOF_NORECURSEREPARSE = 0x8000 + FOF_NO_UI = (FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_NOCONFIRMMKDIR) +) + +type DATAOBJ_GET_ITEM_FLAGS int32 + +const ( + DOGIF_DEFAULT DATAOBJ_GET_ITEM_FLAGS = 0 + DOGIF_TRAVERSE_LINK = 0x1 + DOGIF_NO_HDROP = 0x2 + DOGIF_NO_URL = 0x4 + DOGIF_ONLY_IF_ONE = 0x8 +) + +type KNOWN_FOLDER_FLAG int32 + +const ( + KF_FLAG_DEFAULT KNOWN_FOLDER_FLAG = 0x00000000 + KF_FLAG_NO_APPCONTAINER_REDIRECTION = 0x00010000 + KF_FLAG_CREATE = 0x00008000 + KF_FLAG_DONT_VERIFY = 0x00004000 + KF_FLAG_DONT_UNEXPAND = 0x00002000 + KF_FLAG_NO_ALIAS = 0x00001000 + KF_FLAG_INIT = 0x00000800 + KF_FLAG_DEFAULT_PATH = 0x00000400 + KF_FLAG_NOT_PARENT_RELATIVE = 0x00000200 + KF_FLAG_SIMPLE_IDLIST = 0x00000100 + KF_FLAG_ALIAS_ONLY = 0x80000000 +) + +type SIGDN int32 + +const ( + SIGDN_NORMALDISPLAY SIGDN = 0 + SIGDN_PARENTRELATIVEPARSING = 0x80018001 + SIGDN_DESKTOPABSOLUTEPARSING = 0x80028000 + SIGDN_PARENTRELATIVEEDITING = 0x80031001 + SIGDN_DESKTOPABSOLUTEEDITING = 0x8004c000 + SIGDN_FILESYSPATH = 0x80058000 + SIGDN_URL = 0x80068000 + SIGDN_PARENTRELATIVEFORADDRESSBAR = 0x8007c001 + SIGDN_PARENTRELATIVE = 0x80080001 + SIGDN_PARENTRELATIVEFORUI = 0x80094001 +) + +type GETPROPERTYSTOREFLAGS int32 + +const ( + GPS_DEFAULT GETPROPERTYSTOREFLAGS = 0 + GPS_HANDLERPROPERTIESONLY = 0x1 + GPS_READWRITE = 0x2 + GPS_TEMPORARY = 0x4 + GPS_FASTPROPERTIESONLY = 0x8 + GPS_OPENSLOWITEM = 0x10 + GPS_DELAYCREATION = 0x20 + GPS_BESTEFFORT = 0x40 + GPS_NO_OPLOCK = 0x80 + GPS_PREFERQUERYPROPERTIES = 0x100 + GPS_EXTRINSICPROPERTIES = 0x200 + GPS_EXTRINSICPROPERTIESONLY = 0x400 + GPS_MASK_VALID = 0x7ff +) + +type SHSTOCKICONID int32 + +const ( + SIID_DOCNOASSOC SHSTOCKICONID = 0 + SIID_DOCASSOC = 1 + SIID_APPLICATION = 2 + SIID_FOLDER = 3 + SIID_FOLDEROPEN = 4 + SIID_DRIVE525 = 5 + SIID_DRIVE35 = 6 + SIID_DRIVEREMOVE = 7 + SIID_DRIVEFIXED = 8 + SIID_DRIVENET = 9 + SIID_DRIVENETDISABLED = 10 + SIID_DRIVECD = 11 + SIID_DRIVERAM = 12 + SIID_WORLD = 13 + SIID_SERVER = 15 + SIID_PRINTER = 16 + SIID_MYNETWORK = 17 + SIID_FIND = 22 + SIID_HELP = 23 + SIID_SHARE = 28 + SIID_LINK = 29 + SIID_SLOWFILE = 30 + SIID_RECYCLER = 31 + SIID_RECYCLERFULL = 32 + SIID_MEDIACDAUDIO = 40 + SIID_LOCK = 47 + SIID_AUTOLIST = 49 + SIID_PRINTERNET = 50 + SIID_SERVERSHARE = 51 + SIID_PRINTERFAX = 52 + SIID_PRINTERFAXNET = 53 + SIID_PRINTERFILE = 54 + SIID_STACK = 55 + SIID_MEDIASVCD = 56 + SIID_STUFFEDFOLDER = 57 + SIID_DRIVEUNKNOWN = 58 + SIID_DRIVEDVD = 59 + SIID_MEDIADVD = 60 + SIID_MEDIADVDRAM = 61 + SIID_MEDIADVDRW = 62 + SIID_MEDIADVDR = 63 + SIID_MEDIADVDROM = 64 + SIID_MEDIACDAUDIOPLUS = 65 + SIID_MEDIACDRW = 66 + SIID_MEDIACDR = 67 + SIID_MEDIACDBURN = 68 + SIID_MEDIABLANKCD = 69 + SIID_MEDIACDROM = 70 + SIID_AUDIOFILES = 71 + SIID_IMAGEFILES = 72 + SIID_VIDEOFILES = 73 + SIID_MIXEDFILES = 74 + SIID_FOLDERBACK = 75 + SIID_FOLDERFRONT = 76 + SIID_SHIELD = 77 + SIID_WARNING = 78 + SIID_INFO = 79 + SIID_ERROR = 80 + SIID_KEY = 81 + SIID_SOFTWARE = 82 + SIID_RENAME = 83 + SIID_DELETE = 84 + SIID_MEDIAAUDIODVD = 85 + SIID_MEDIAMOVIEDVD = 86 + SIID_MEDIAENHANCEDCD = 87 + SIID_MEDIAENHANCEDDVD = 88 + SIID_MEDIAHDDVD = 89 + SIID_MEDIABLURAY = 90 + SIID_MEDIAVCD = 91 + SIID_MEDIADVDPLUSR = 92 + SIID_MEDIADVDPLUSRW = 93 + SIID_DESKTOPPC = 94 + SIID_MOBILEPC = 95 + SIID_USERS = 96 + SIID_MEDIASMARTMEDIA = 97 + SIID_MEDIACOMPACTFLASH = 98 + SIID_DEVICECELLPHONE = 99 + SIID_DEVICECAMERA = 100 + SIID_DEVICEVIDEOCAMERA = 101 + SIID_DEVICEAUDIOPLAYER = 102 + SIID_NETWORKCONNECT = 103 + SIID_INTERNET = 104 + SIID_ZIPFILE = 105 + SIID_SETTINGS = 106 + SIID_DRIVEHDDVD = 132 + SIID_DRIVEBD = 133 + SIID_MEDIAHDDVDROM = 134 + SIID_MEDIAHDDVDR = 135 + SIID_MEDIAHDDVDRAM = 136 + SIID_MEDIABDROM = 137 + SIID_MEDIABDR = 138 + SIID_MEDIABDRE = 139 + SIID_CLUSTEREDDRIVE = 140 + SIID_MAX_ICONS = 175 +) + +const ( + DROPEFFECT_NONE = 0 + DROPEFFECT_COPY = 1 + DROPEFFECT_MOVE = 2 + DROPEFFECT_LINK = 4 + DROPEFFECT_SCROLL = 0x80000000 +) + +const ( + SHCIDS_ALLFIELDS = 0x80000000 + SHCIDS_CANONICALONLY = 0x10000000 + SHCIDS_BITMASK = 0xFFFF0000 + SHCIDS_COLUMNMASK = 0x0000FFFF + SFGAO_CANCOPY = DROPEFFECT_COPY + SFGAO_CANMOVE = DROPEFFECT_MOVE + SFGAO_CANLINK = DROPEFFECT_LINK + SFGAO_STORAGE = 0x00000008 + SFGAO_CANRENAME = 0x00000010 + SFGAO_CANDELETE = 0x00000020 + SFGAO_HASPROPSHEET = 0x00000040 + SFGAO_DROPTARGET = 0x00000100 + SFGAO_CAPABILITYMASK = 0x00000177 + SFGAO_SYSTEM = 0x00001000 + SFGAO_ENCRYPTED = 0x00002000 + SFGAO_ISSLOW = 0x00004000 + SFGAO_GHOSTED = 0x00008000 + SFGAO_LINK = 0x00010000 + SFGAO_SHARE = 0x00020000 + SFGAO_READONLY = 0x00040000 + SFGAO_HIDDEN = 0x00080000 + SFGAO_DISPLAYATTRMASK = 0x000FC000 + SFGAO_FILESYSANCESTOR = 0x10000000 + SFGAO_FOLDER = 0x20000000 + SFGAO_FILESYSTEM = 0x40000000 + SFGAO_HASSUBFOLDER = 0x80000000 + SFGAO_CONTENTSMASK = 0x80000000 + SFGAO_VALIDATE = 0x01000000 + SFGAO_REMOVABLE = 0x02000000 + SFGAO_COMPRESSED = 0x04000000 + SFGAO_BROWSABLE = 0x08000000 + SFGAO_NONENUMERATED = 0x00100000 + SFGAO_NEWCONTENT = 0x00200000 + SFGAO_CANMONIKER = 0x00400000 + SFGAO_HASSTORAGE = 0x00400000 + SFGAO_STREAM = 0x00400000 + SFGAO_STORAGEANCESTOR = 0x00800000 + SFGAO_STORAGECAPMASK = 0x70C50008 + SFGAO_PKEYSFGAOMASK = 0x81044000 +) + +type QUERY_USER_NOTIFICATION_STATE int32 + +const ( + QUNS_NOT_PRESENT QUERY_USER_NOTIFICATION_STATE = 1 + QUNS_BUSY = 2 + QUNS_RUNNING_D3D_FULL_SCREEN = 3 + QUNS_PRESENTATION_MODE = 4 + QUNS_ACCEPTS_NOTIFICATIONS = 5 + QUNS_QUIET_TIME = 6 + QUNS_APP = 7 +) + +type RESTRICTIONS int32 + +const ( + REST_NONE RESTRICTIONS = 0x00000000 + REST_NORUN = 0x00000001 + REST_NOCLOSE = 0x00000002 + REST_NOSAVESET = 0x00000004 + REST_NOFILEMENU = 0x00000008 + REST_NOSETFOLDERS = 0x00000010 + REST_NOSETTASKBAR = 0x00000020 + REST_NODESKTOP = 0x00000040 + REST_NOFIND = 0x00000080 + REST_NODRIVES = 0x00000100 + REST_NODRIVEAUTORUN = 0x00000200 + REST_NODRIVETYPEAUTORUN = 0x00000400 + REST_NONETHOOD = 0x00000800 + REST_STARTBANNER = 0x00001000 + REST_RESTRICTRUN = 0x00002000 + REST_NOPRINTERTABS = 0x00004000 + REST_NOPRINTERDELETE = 0x00008000 + REST_NOPRINTERADD = 0x00010000 + REST_NOSTARTMENUSUBFOLDERS = 0x00020000 + REST_MYDOCSONNET = 0x00040000 + REST_NOEXITTODOS = 0x00080000 + REST_ENFORCESHELLEXTSECURITY = 0x00100000 + REST_LINKRESOLVEIGNORELINKINFO = 0x00200000 + REST_NOCOMMONGROUPS = 0x00400000 + REST_SEPARATEDESKTOPPROCESS = 0x00800000 + REST_NOWEB = 0x01000000 + REST_NOTRAYCONTEXTMENU = 0x02000000 + REST_NOVIEWCONTEXTMENU = 0x04000000 + REST_NONETCONNECTDISCONNECT = 0x08000000 + REST_STARTMENULOGOFF = 0x10000000 + REST_NOSETTINGSASSIST = 0x20000000 + REST_NOINTERNETICON = 0x40000001 + REST_NORECENTDOCSHISTORY = 0x40000002 + REST_NORECENTDOCSMENU = 0x40000003 + REST_NOACTIVEDESKTOP = 0x40000004 + REST_NOACTIVEDESKTOPCHANGES = 0x40000005 + REST_NOFAVORITESMENU = 0x40000006 + REST_CLEARRECENTDOCSONEXIT = 0x40000007 + REST_CLASSICSHELL = 0x40000008 + REST_NOCUSTOMIZEWEBVIEW = 0x40000009 + REST_NOHTMLWALLPAPER = 0x40000010 + REST_NOCHANGINGWALLPAPER = 0x40000011 + REST_NODESKCOMP = 0x40000012 + REST_NOADDDESKCOMP = 0x40000013 + REST_NODELDESKCOMP = 0x40000014 + REST_NOCLOSEDESKCOMP = 0x40000015 + REST_NOCLOSE_DRAGDROPBAND = 0x40000016 + REST_NOMOVINGBAND = 0x40000017 + REST_NOEDITDESKCOMP = 0x40000018 + REST_NORESOLVESEARCH = 0x40000019 + REST_NORESOLVETRACK = 0x4000001A + REST_FORCECOPYACLWITHFILE = 0x4000001B + REST_NOFORGETSOFTWAREUPDATE = 0x4000001D + REST_NOSETACTIVEDESKTOP = 0x4000001E + REST_NOUPDATEWINDOWS = 0x4000001F + REST_NOCHANGESTARMENU = 0x40000020 + REST_NOFOLDEROPTIONS = 0x40000021 + REST_HASFINDCOMPUTERS = 0x40000022 + REST_INTELLIMENUS = 0x40000023 + REST_RUNDLGMEMCHECKBOX = 0x40000024 + REST_ARP_ShowPostSetup = 0x40000025 + REST_NOCSC = 0x40000026 + REST_NOCONTROLPANEL = 0x40000027 + REST_ENUMWORKGROUP = 0x40000028 + REST_ARP_NOARP = 0x40000029 + REST_ARP_NOREMOVEPAGE = 0x4000002A + REST_ARP_NOADDPAGE = 0x4000002B + REST_ARP_NOWINSETUPPAGE = 0x4000002C + REST_GREYMSIADS = 0x4000002D + REST_NOCHANGEMAPPEDDRIVELABEL = 0x4000002E + REST_NOCHANGEMAPPEDDRIVECOMMENT = 0x4000002F + REST_MaxRecentDocs = 0x40000030 + REST_NONETWORKCONNECTIONS = 0x40000031 + REST_FORCESTARTMENULOGOFF = 0x40000032 + REST_NOWEBVIEW = 0x40000033 + REST_NOCUSTOMIZETHISFOLDER = 0x40000034 + REST_NOENCRYPTION = 0x40000035 + REST_DONTSHOWSUPERHIDDEN = 0x40000037 + REST_NOSHELLSEARCHBUTTON = 0x40000038 + REST_NOHARDWARETAB = 0x40000039 + REST_NORUNASINSTALLPROMPT = 0x4000003A + REST_PROMPTRUNASINSTALLNETPATH = 0x4000003B + REST_NOMANAGEMYCOMPUTERVERB = 0x4000003C + REST_DISALLOWRUN = 0x4000003E + REST_NOWELCOMESCREEN = 0x4000003F + REST_RESTRICTCPL = 0x40000040 + REST_DISALLOWCPL = 0x40000041 + REST_NOSMBALLOONTIP = 0x40000042 + REST_NOSMHELP = 0x40000043 + REST_NOWINKEYS = 0x40000044 + REST_NOENCRYPTONMOVE = 0x40000045 + REST_NOLOCALMACHINERUN = 0x40000046 + REST_NOCURRENTUSERRUN = 0x40000047 + REST_NOLOCALMACHINERUNONCE = 0x40000048 + REST_NOCURRENTUSERRUNONCE = 0x40000049 + REST_FORCEACTIVEDESKTOPON = 0x4000004A + REST_NOVIEWONDRIVE = 0x4000004C + REST_NONETCRAWL = 0x4000004D + REST_NOSHAREDDOCUMENTS = 0x4000004E + REST_NOSMMYDOCS = 0x4000004F + REST_NOSMMYPICS = 0x40000050 + REST_ALLOWBITBUCKDRIVES = 0x40000051 + REST_NONLEGACYSHELLMODE = 0x40000052 + REST_NOCONTROLPANELBARRICADE = 0x40000053 + REST_NOSTARTPAGE = 0x40000054 + REST_NOAUTOTRAYNOTIFY = 0x40000055 + REST_NOTASKGROUPING = 0x40000056 + REST_NOCDBURNING = 0x40000057 + REST_MYCOMPNOPROP = 0x40000058 + REST_MYDOCSNOPROP = 0x40000059 + REST_NOSTARTPANEL = 0x4000005A + REST_NODISPLAYAPPEARANCEPAGE = 0x4000005B + REST_NOTHEMESTAB = 0x4000005C + REST_NOVISUALSTYLECHOICE = 0x4000005D + REST_NOSIZECHOICE = 0x4000005E + REST_NOCOLORCHOICE = 0x4000005F + REST_SETVISUALSTYLE = 0x40000060 + REST_STARTRUNNOHOMEPATH = 0x40000061 + REST_NOUSERNAMEINSTARTPANEL = 0x40000062 + REST_NOMYCOMPUTERICON = 0x40000063 + REST_NOSMNETWORKPLACES = 0x40000064 + REST_NOSMPINNEDLIST = 0x40000065 + REST_NOSMMYMUSIC = 0x40000066 + REST_NOSMEJECTPC = 0x40000067 + REST_NOSMMOREPROGRAMS = 0x40000068 + REST_NOSMMFUPROGRAMS = 0x40000069 + REST_NOTRAYITEMSDISPLAY = 0x4000006A + REST_NOTOOLBARSONTASKBAR = 0x4000006B + REST_NOSMCONFIGUREPROGRAMS = 0x4000006F + REST_HIDECLOCK = 0x40000070 + REST_NOLOWDISKSPACECHECKS = 0x40000071 + REST_NOENTIRENETWORK = 0x40000072 + REST_NODESKTOPCLEANUP = 0x40000073 + REST_BITBUCKNUKEONDELETE = 0x40000074 + REST_BITBUCKCONFIRMDELETE = 0x40000075 + REST_BITBUCKNOPROP = 0x40000076 + REST_NODISPBACKGROUND = 0x40000077 + REST_NODISPSCREENSAVEPG = 0x40000078 + REST_NODISPSETTINGSPG = 0x40000079 + REST_NODISPSCREENSAVEPREVIEW = 0x4000007A + REST_NODISPLAYCPL = 0x4000007B + REST_HIDERUNASVERB = 0x4000007C + REST_NOTHUMBNAILCACHE = 0x4000007D + REST_NOSTRCMPLOGICAL = 0x4000007E + REST_NOPUBLISHWIZARD = 0x4000007F + REST_NOONLINEPRINTSWIZARD = 0x40000080 + REST_NOWEBSERVICES = 0x40000081 + REST_ALLOWUNHASHEDWEBVIEW = 0x40000082 + REST_ALLOWLEGACYWEBVIEW = 0x40000083 + REST_REVERTWEBVIEWSECURITY = 0x40000084 + REST_INHERITCONSOLEHANDLES = 0x40000086 + REST_NOREMOTERECURSIVEEVENTS = 0x40000089 + REST_NOREMOTECHANGENOTIFY = 0x40000091 + REST_NOENUMENTIRENETWORK = 0x40000093 + REST_NOINTERNETOPENWITH = 0x40000095 + REST_DONTRETRYBADNETNAME = 0x4000009B + REST_ALLOWFILECLSIDJUNCTIONS = 0x4000009C + REST_NOUPNPINSTALL = 0x4000009D + REST_ARP_DONTGROUPPATCHES = 0x400000AC + REST_ARP_NOCHOOSEPROGRAMSPAGE = 0x400000AD + REST_NODISCONNECT = 0x41000001 + REST_NOSECURITY = 0x41000002 + REST_NOFILEASSOCIATE = 0x41000003 + REST_ALLOWCOMMENTTOGGLE = 0x41000004 +) + +type PROPVAR_CHANGE_FLAGS int32 + +const ( + PVCHF_DEFAULT PROPVAR_CHANGE_FLAGS = 0x00000000 + PVCHF_NOVALUEPROP = 0x00000001 + PVCHF_ALPHABOOL = 0x00000002 + PVCHF_NOUSEROVERRIDE = 0x00000004 + PVCHF_LOCALBOOL = 0x00000008 + PVCHF_NOHEXSTRING = 0x00000010 +) + +type APTTYPE int32 + +const ( + APTTYPE_CURRENT APTTYPE = -1 + APTTYPE_STA = 0 + APTTYPE_MTA = 1 + APTTYPE_NA = 2 + APTTYPE_MAINSTA = 3 +) + +type APTTYPEQUALIFIER int32 + +const ( + APTTYPEQUALIFIER_NONE APTTYPEQUALIFIER = 0 + APTTYPEQUALIFIER_IMPLICIT_MTA = 1 + APTTYPEQUALIFIER_NA_ON_MTA = 2 + APTTYPEQUALIFIER_NA_ON_STA = 3 + APTTYPEQUALIFIER_NA_ON_IMPLICIT_MTA = 4 + APTTYPEQUALIFIER_NA_ON_MAINSTA = 5 + APTTYPEQUALIFIER_APPLICATION_STA = 6 +) diff --git a/grdp/win/crypt32.go b/grdp/win/crypt32.go new file mode 100644 index 0000000..3842597 --- /dev/null +++ b/grdp/win/crypt32.go @@ -0,0 +1,1867 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "unsafe" +) + +var ( + // Library + libcrypt32 uintptr + + // Functions + certAddCRLContextToStore uintptr + certAddCRLLinkToStore uintptr + certAddCTLContextToStore uintptr + certAddCTLLinkToStore uintptr + certAddCertificateContextToStore uintptr + certAddCertificateLinkToStore uintptr + certAddEncodedCRLToStore uintptr + certAddEncodedCTLToStore uintptr + certAddEncodedCertificateToStore uintptr + certAddEncodedCertificateToSystemStore uintptr + certAddEnhancedKeyUsageIdentifier uintptr + certAddSerializedElementToStore uintptr + certAddStoreToCollection uintptr + certAlgIdToOID uintptr + certCloseStore uintptr + certCompareCertificate uintptr + certCompareCertificateName uintptr + certCompareIntegerBlob uintptr + certControlStore uintptr + certCreateCRLContext uintptr + certCreateCTLContext uintptr + certCreateCTLEntryFromCertificateContextProperties uintptr + certCreateCertificateContext uintptr + certDeleteCRLFromStore uintptr + certDeleteCTLFromStore uintptr + certDeleteCertificateFromStore uintptr + certDuplicateCRLContext uintptr + certDuplicateCTLContext uintptr + certDuplicateCertificateContext uintptr + certDuplicateStore uintptr + certEnumCRLContextProperties uintptr + certEnumCRLsInStore uintptr + certEnumCTLContextProperties uintptr + certEnumCTLsInStore uintptr + certEnumCertificateContextProperties uintptr + certEnumCertificatesInStore uintptr + certEnumSubjectInSortedCTL uintptr + certFindAttribute uintptr + certFindCRLInStore uintptr + certFindCTLInStore uintptr + certFindCertificateInCRL uintptr + certFindCertificateInStore uintptr + certFindExtension uintptr + certFindSubjectInCTL uintptr + certFindSubjectInSortedCTL uintptr + certFreeCRLContext uintptr + certFreeCTLContext uintptr + certFreeCertificateContext uintptr + certGetCRLContextProperty uintptr + certGetCRLFromStore uintptr + certGetCTLContextProperty uintptr + certGetCertificateContextProperty uintptr + certGetIntendedKeyUsage uintptr + certGetIssuerCertificateFromStore uintptr + certGetNameString uintptr + certGetStoreProperty uintptr + certGetSubjectCertificateFromStore uintptr + certGetValidUsages uintptr + certIsValidCRLForCertificate uintptr + certNameToStr uintptr + certOIDToAlgId uintptr + certRDNValueToStr uintptr + certRemoveEnhancedKeyUsageIdentifier uintptr + certRemoveStoreFromCollection uintptr + certSaveStore uintptr + certSerializeCRLStoreElement uintptr + certSerializeCTLStoreElement uintptr + certSerializeCertificateStoreElement uintptr + certSetCRLContextProperty uintptr + certSetCTLContextProperty uintptr + certSetCertificateContextPropertiesFromCTLEntry uintptr + certSetCertificateContextProperty uintptr + certSetStoreProperty uintptr + certStrToName uintptr + certUnregisterPhysicalStore uintptr + certUnregisterSystemStore uintptr + certVerifyCRLRevocation uintptr + certVerifyCRLTimeValidity uintptr + certVerifySubjectCertificateContext uintptr + certVerifyTimeValidity uintptr + certVerifyValidityNesting uintptr + cryptBinaryToString uintptr + cryptDecodeObject uintptr + cryptEncodeObject uintptr + cryptExportPKCS8 uintptr + cryptFindCertificateKeyProvInfo uintptr + cryptFindLocalizedName uintptr + cryptFormatObject uintptr + cryptGetKeyIdentifierProperty uintptr + cryptGetMessageSignerCount uintptr + cryptGetOIDFunctionValue uintptr + cryptMemAlloc uintptr + cryptMemFree uintptr + cryptMemRealloc uintptr + cryptMsgCalculateEncodedLength uintptr + cryptMsgClose uintptr + cryptMsgControl uintptr + cryptMsgDuplicate uintptr + cryptMsgGetAndVerifySigner uintptr + cryptMsgGetParam uintptr + cryptMsgUpdate uintptr + cryptProtectMemory uintptr + cryptQueryObject uintptr + cryptRegisterDefaultOIDFunction uintptr + cryptRegisterOIDFunction uintptr + cryptSIPRemoveProvider uintptr + cryptSIPRetrieveSubjectGuid uintptr + cryptSIPRetrieveSubjectGuidForCatalogFile uintptr + cryptSetKeyIdentifierProperty uintptr + cryptSetOIDFunctionValue uintptr + cryptStringToBinary uintptr + cryptUnprotectMemory uintptr + cryptUnregisterDefaultOIDFunction uintptr + cryptUnregisterOIDFunction uintptr + pFXExportCertStore uintptr + pFXExportCertStoreEx uintptr + pFXImportCertStore uintptr + pFXIsPFXBlob uintptr + pFXVerifyPassword uintptr + i_CertUpdateStore uintptr + i_CryptAllocTls uintptr + i_CryptDetachTls uintptr + i_CryptFindLruEntry uintptr + i_CryptFindLruEntryData uintptr + i_CryptFreeTls uintptr + i_CryptGetDefaultCryptProv uintptr + i_CryptGetOssGlobal uintptr + i_CryptGetTls uintptr + i_CryptInstallOssGlobal uintptr + i_CryptReadTrustedPublisherDWORDValueFromRegistry uintptr + i_CryptSetTls uintptr +) + +func init() { + // Library + libcrypt32 = doLoadLibrary("crypt32.dll") + + // Functions + certAddCRLContextToStore = doGetProcAddress(libcrypt32, "CertAddCRLContextToStore") + certAddCRLLinkToStore = doGetProcAddress(libcrypt32, "CertAddCRLLinkToStore") + certAddCTLContextToStore = doGetProcAddress(libcrypt32, "CertAddCTLContextToStore") + certAddCTLLinkToStore = doGetProcAddress(libcrypt32, "CertAddCTLLinkToStore") + certAddCertificateContextToStore = doGetProcAddress(libcrypt32, "CertAddCertificateContextToStore") + certAddCertificateLinkToStore = doGetProcAddress(libcrypt32, "CertAddCertificateLinkToStore") + certAddEncodedCRLToStore = doGetProcAddress(libcrypt32, "CertAddEncodedCRLToStore") + certAddEncodedCTLToStore = doGetProcAddress(libcrypt32, "CertAddEncodedCTLToStore") + certAddEncodedCertificateToStore = doGetProcAddress(libcrypt32, "CertAddEncodedCertificateToStore") + certAddEncodedCertificateToSystemStore = doGetProcAddress(libcrypt32, "CertAddEncodedCertificateToSystemStoreW") + certAddEnhancedKeyUsageIdentifier = doGetProcAddress(libcrypt32, "CertAddEnhancedKeyUsageIdentifier") + certAddSerializedElementToStore = doGetProcAddress(libcrypt32, "CertAddSerializedElementToStore") + certAddStoreToCollection = doGetProcAddress(libcrypt32, "CertAddStoreToCollection") + certAlgIdToOID = doGetProcAddress(libcrypt32, "CertAlgIdToOID") + certCloseStore = doGetProcAddress(libcrypt32, "CertCloseStore") + certCompareCertificate = doGetProcAddress(libcrypt32, "CertCompareCertificate") + certCompareCertificateName = doGetProcAddress(libcrypt32, "CertCompareCertificateName") + certCompareIntegerBlob = doGetProcAddress(libcrypt32, "CertCompareIntegerBlob") + certControlStore = doGetProcAddress(libcrypt32, "CertControlStore") + certCreateCRLContext = doGetProcAddress(libcrypt32, "CertCreateCRLContext") + certCreateCTLContext = doGetProcAddress(libcrypt32, "CertCreateCTLContext") + certCreateCTLEntryFromCertificateContextProperties = doGetProcAddress(libcrypt32, "CertCreateCTLEntryFromCertificateContextProperties") + certCreateCertificateContext = doGetProcAddress(libcrypt32, "CertCreateCertificateContext") + certDeleteCRLFromStore = doGetProcAddress(libcrypt32, "CertDeleteCRLFromStore") + certDeleteCTLFromStore = doGetProcAddress(libcrypt32, "CertDeleteCTLFromStore") + certDeleteCertificateFromStore = doGetProcAddress(libcrypt32, "CertDeleteCertificateFromStore") + certDuplicateCRLContext = doGetProcAddress(libcrypt32, "CertDuplicateCRLContext") + certDuplicateCTLContext = doGetProcAddress(libcrypt32, "CertDuplicateCTLContext") + certDuplicateCertificateContext = doGetProcAddress(libcrypt32, "CertDuplicateCertificateContext") + certDuplicateStore = doGetProcAddress(libcrypt32, "CertDuplicateStore") + certEnumCRLContextProperties = doGetProcAddress(libcrypt32, "CertEnumCRLContextProperties") + certEnumCRLsInStore = doGetProcAddress(libcrypt32, "CertEnumCRLsInStore") + certEnumCTLContextProperties = doGetProcAddress(libcrypt32, "CertEnumCTLContextProperties") + certEnumCTLsInStore = doGetProcAddress(libcrypt32, "CertEnumCTLsInStore") + certEnumCertificateContextProperties = doGetProcAddress(libcrypt32, "CertEnumCertificateContextProperties") + certEnumCertificatesInStore = doGetProcAddress(libcrypt32, "CertEnumCertificatesInStore") + certEnumSubjectInSortedCTL = doGetProcAddress(libcrypt32, "CertEnumSubjectInSortedCTL") + certFindAttribute = doGetProcAddress(libcrypt32, "CertFindAttribute") + certFindCRLInStore = doGetProcAddress(libcrypt32, "CertFindCRLInStore") + certFindCTLInStore = doGetProcAddress(libcrypt32, "CertFindCTLInStore") + certFindCertificateInCRL = doGetProcAddress(libcrypt32, "CertFindCertificateInCRL") + certFindCertificateInStore = doGetProcAddress(libcrypt32, "CertFindCertificateInStore") + certFindExtension = doGetProcAddress(libcrypt32, "CertFindExtension") + certFindSubjectInCTL = doGetProcAddress(libcrypt32, "CertFindSubjectInCTL") + certFindSubjectInSortedCTL = doGetProcAddress(libcrypt32, "CertFindSubjectInSortedCTL") + certFreeCRLContext = doGetProcAddress(libcrypt32, "CertFreeCRLContext") + certFreeCTLContext = doGetProcAddress(libcrypt32, "CertFreeCTLContext") + certFreeCertificateContext = doGetProcAddress(libcrypt32, "CertFreeCertificateContext") + certGetCRLContextProperty = doGetProcAddress(libcrypt32, "CertGetCRLContextProperty") + certGetCRLFromStore = doGetProcAddress(libcrypt32, "CertGetCRLFromStore") + certGetCTLContextProperty = doGetProcAddress(libcrypt32, "CertGetCTLContextProperty") + certGetCertificateContextProperty = doGetProcAddress(libcrypt32, "CertGetCertificateContextProperty") + certGetIntendedKeyUsage = doGetProcAddress(libcrypt32, "CertGetIntendedKeyUsage") + certGetIssuerCertificateFromStore = doGetProcAddress(libcrypt32, "CertGetIssuerCertificateFromStore") + certGetNameString = doGetProcAddress(libcrypt32, "CertGetNameStringW") + certGetStoreProperty = doGetProcAddress(libcrypt32, "CertGetStoreProperty") + certGetSubjectCertificateFromStore = doGetProcAddress(libcrypt32, "CertGetSubjectCertificateFromStore") + certGetValidUsages = doGetProcAddress(libcrypt32, "CertGetValidUsages") + certIsValidCRLForCertificate = doGetProcAddress(libcrypt32, "CertIsValidCRLForCertificate") + certNameToStr = doGetProcAddress(libcrypt32, "CertNameToStrW") + certOIDToAlgId = doGetProcAddress(libcrypt32, "CertOIDToAlgId") + certRDNValueToStr = doGetProcAddress(libcrypt32, "CertRDNValueToStrW") + certRemoveEnhancedKeyUsageIdentifier = doGetProcAddress(libcrypt32, "CertRemoveEnhancedKeyUsageIdentifier") + certRemoveStoreFromCollection = doGetProcAddress(libcrypt32, "CertRemoveStoreFromCollection") + certSaveStore = doGetProcAddress(libcrypt32, "CertSaveStore") + certSerializeCRLStoreElement = doGetProcAddress(libcrypt32, "CertSerializeCRLStoreElement") + certSerializeCTLStoreElement = doGetProcAddress(libcrypt32, "CertSerializeCTLStoreElement") + certSerializeCertificateStoreElement = doGetProcAddress(libcrypt32, "CertSerializeCertificateStoreElement") + certSetCRLContextProperty = doGetProcAddress(libcrypt32, "CertSetCRLContextProperty") + certSetCTLContextProperty = doGetProcAddress(libcrypt32, "CertSetCTLContextProperty") + certSetCertificateContextPropertiesFromCTLEntry = doGetProcAddress(libcrypt32, "CertSetCertificateContextPropertiesFromCTLEntry") + certSetCertificateContextProperty = doGetProcAddress(libcrypt32, "CertSetCertificateContextProperty") + certSetStoreProperty = doGetProcAddress(libcrypt32, "CertSetStoreProperty") + certStrToName = doGetProcAddress(libcrypt32, "CertStrToNameW") + certUnregisterPhysicalStore = doGetProcAddress(libcrypt32, "CertUnregisterPhysicalStore") + certUnregisterSystemStore = doGetProcAddress(libcrypt32, "CertUnregisterSystemStore") + certVerifyCRLRevocation = doGetProcAddress(libcrypt32, "CertVerifyCRLRevocation") + certVerifyCRLTimeValidity = doGetProcAddress(libcrypt32, "CertVerifyCRLTimeValidity") + certVerifySubjectCertificateContext = doGetProcAddress(libcrypt32, "CertVerifySubjectCertificateContext") + certVerifyTimeValidity = doGetProcAddress(libcrypt32, "CertVerifyTimeValidity") + certVerifyValidityNesting = doGetProcAddress(libcrypt32, "CertVerifyValidityNesting") + cryptBinaryToString = doGetProcAddress(libcrypt32, "CryptBinaryToStringW") + cryptDecodeObject = doGetProcAddress(libcrypt32, "CryptDecodeObject") + cryptEncodeObject = doGetProcAddress(libcrypt32, "CryptEncodeObject") + cryptExportPKCS8 = doGetProcAddress(libcrypt32, "CryptExportPKCS8") + cryptFindCertificateKeyProvInfo = doGetProcAddress(libcrypt32, "CryptFindCertificateKeyProvInfo") + cryptFindLocalizedName = doGetProcAddress(libcrypt32, "CryptFindLocalizedName") + cryptFormatObject = doGetProcAddress(libcrypt32, "CryptFormatObject") + cryptGetKeyIdentifierProperty = doGetProcAddress(libcrypt32, "CryptGetKeyIdentifierProperty") + cryptGetMessageSignerCount = doGetProcAddress(libcrypt32, "CryptGetMessageSignerCount") + cryptGetOIDFunctionValue = doGetProcAddress(libcrypt32, "CryptGetOIDFunctionValue") + cryptMemAlloc = doGetProcAddress(libcrypt32, "CryptMemAlloc") + cryptMemFree = doGetProcAddress(libcrypt32, "CryptMemFree") + cryptMemRealloc = doGetProcAddress(libcrypt32, "CryptMemRealloc") + cryptMsgCalculateEncodedLength = doGetProcAddress(libcrypt32, "CryptMsgCalculateEncodedLength") + cryptMsgClose = doGetProcAddress(libcrypt32, "CryptMsgClose") + cryptMsgControl = doGetProcAddress(libcrypt32, "CryptMsgControl") + cryptMsgDuplicate = doGetProcAddress(libcrypt32, "CryptMsgDuplicate") + cryptMsgGetAndVerifySigner = doGetProcAddress(libcrypt32, "CryptMsgGetAndVerifySigner") + cryptMsgGetParam = doGetProcAddress(libcrypt32, "CryptMsgGetParam") + cryptMsgUpdate = doGetProcAddress(libcrypt32, "CryptMsgUpdate") + cryptProtectMemory = doGetProcAddress(libcrypt32, "CryptProtectMemory") + cryptQueryObject = doGetProcAddress(libcrypt32, "CryptQueryObject") + cryptRegisterDefaultOIDFunction = doGetProcAddress(libcrypt32, "CryptRegisterDefaultOIDFunction") + cryptRegisterOIDFunction = doGetProcAddress(libcrypt32, "CryptRegisterOIDFunction") + cryptSIPRemoveProvider = doGetProcAddress(libcrypt32, "CryptSIPRemoveProvider") + cryptSIPRetrieveSubjectGuid = doGetProcAddress(libcrypt32, "CryptSIPRetrieveSubjectGuid") + cryptSIPRetrieveSubjectGuidForCatalogFile = doGetProcAddress(libcrypt32, "CryptSIPRetrieveSubjectGuidForCatalogFile") + cryptSetKeyIdentifierProperty = doGetProcAddress(libcrypt32, "CryptSetKeyIdentifierProperty") + cryptSetOIDFunctionValue = doGetProcAddress(libcrypt32, "CryptSetOIDFunctionValue") + cryptStringToBinary = doGetProcAddress(libcrypt32, "CryptStringToBinaryW") + cryptUnprotectMemory = doGetProcAddress(libcrypt32, "CryptUnprotectMemory") + cryptUnregisterDefaultOIDFunction = doGetProcAddress(libcrypt32, "CryptUnregisterDefaultOIDFunction") + cryptUnregisterOIDFunction = doGetProcAddress(libcrypt32, "CryptUnregisterOIDFunction") + pFXExportCertStore = doGetProcAddress(libcrypt32, "PFXExportCertStore") + pFXExportCertStoreEx = doGetProcAddress(libcrypt32, "PFXExportCertStoreEx") + pFXImportCertStore = doGetProcAddress(libcrypt32, "PFXImportCertStore") + pFXIsPFXBlob = doGetProcAddress(libcrypt32, "PFXIsPFXBlob") + pFXVerifyPassword = doGetProcAddress(libcrypt32, "PFXVerifyPassword") + i_CertUpdateStore = doGetProcAddress(libcrypt32, "I_CertUpdateStore") + i_CryptAllocTls = doGetProcAddress(libcrypt32, "I_CryptAllocTls") + i_CryptDetachTls = doGetProcAddress(libcrypt32, "I_CryptDetachTls") + i_CryptFindLruEntry = doGetProcAddress(libcrypt32, "I_CryptFindLruEntry") + i_CryptFindLruEntryData = doGetProcAddress(libcrypt32, "I_CryptFindLruEntryData") + i_CryptFreeTls = doGetProcAddress(libcrypt32, "I_CryptFreeTls") + i_CryptGetDefaultCryptProv = doGetProcAddress(libcrypt32, "I_CryptGetDefaultCryptProv") + i_CryptGetOssGlobal = doGetProcAddress(libcrypt32, "I_CryptGetOssGlobal") + i_CryptGetTls = doGetProcAddress(libcrypt32, "I_CryptGetTls") + i_CryptInstallOssGlobal = doGetProcAddress(libcrypt32, "I_CryptInstallOssGlobal") + i_CryptReadTrustedPublisherDWORDValueFromRegistry = doGetProcAddress(libcrypt32, "I_CryptReadTrustedPublisherDWORDValueFromRegistry") + i_CryptSetTls = doGetProcAddress(libcrypt32, "I_CryptSetTls") +} + +func CertAddCRLContextToStore(hCertStore HCERTSTORE, pCrlContext PCCRL_CONTEXT, dwAddDisposition DWORD, ppStoreContext *PCCRL_CONTEXT) bool { + ret1 := syscall6(certAddCRLContextToStore, 4, + uintptr(hCertStore), + uintptr(unsafe.Pointer(pCrlContext)), + uintptr(dwAddDisposition), + uintptr(unsafe.Pointer(ppStoreContext)), + 0, + 0) + return ret1 != 0 +} + +func CertAddCRLLinkToStore(hCertStore HCERTSTORE, pCrlContext PCCRL_CONTEXT, dwAddDisposition DWORD, ppStoreContext *PCCRL_CONTEXT) bool { + ret1 := syscall6(certAddCRLLinkToStore, 4, + uintptr(hCertStore), + uintptr(unsafe.Pointer(pCrlContext)), + uintptr(dwAddDisposition), + uintptr(unsafe.Pointer(ppStoreContext)), + 0, + 0) + return ret1 != 0 +} + +func CertAddCTLContextToStore(hCertStore HCERTSTORE, pCtlContext /*const*/ PCCTL_CONTEXT, dwAddDisposition DWORD, ppStoreContext *PCCTL_CONTEXT) bool { + ret1 := syscall6(certAddCTLContextToStore, 4, + uintptr(hCertStore), + uintptr(unsafe.Pointer(pCtlContext)), + uintptr(dwAddDisposition), + uintptr(unsafe.Pointer(ppStoreContext)), + 0, + 0) + return ret1 != 0 +} + +func CertAddCTLLinkToStore(hCertStore HCERTSTORE, pCtlContext /*const*/ PCCTL_CONTEXT, dwAddDisposition DWORD, ppStoreContext *PCCTL_CONTEXT) bool { + ret1 := syscall6(certAddCTLLinkToStore, 4, + uintptr(hCertStore), + uintptr(unsafe.Pointer(pCtlContext)), + uintptr(dwAddDisposition), + uintptr(unsafe.Pointer(ppStoreContext)), + 0, + 0) + return ret1 != 0 +} + +func CertAddCertificateContextToStore(hCertStore HCERTSTORE, pCertContext /*const*/ PCCERT_CONTEXT, dwAddDisposition DWORD, ppStoreContext *PCCERT_CONTEXT) bool { + ret1 := syscall6(certAddCertificateContextToStore, 4, + uintptr(hCertStore), + uintptr(unsafe.Pointer(pCertContext)), + uintptr(dwAddDisposition), + uintptr(unsafe.Pointer(ppStoreContext)), + 0, + 0) + return ret1 != 0 +} + +func CertAddCertificateLinkToStore(hCertStore HCERTSTORE, pCertContext /*const*/ PCCERT_CONTEXT, dwAddDisposition DWORD, ppStoreContext *PCCERT_CONTEXT) bool { + ret1 := syscall6(certAddCertificateLinkToStore, 4, + uintptr(hCertStore), + uintptr(unsafe.Pointer(pCertContext)), + uintptr(dwAddDisposition), + uintptr(unsafe.Pointer(ppStoreContext)), + 0, + 0) + return ret1 != 0 +} + +func CertAddEncodedCRLToStore(hCertStore HCERTSTORE, dwCertEncodingType DWORD, pbCrlEncoded /*const*/ *byte, cbCrlEncoded DWORD, dwAddDisposition DWORD, ppCrlContext *PCCRL_CONTEXT) bool { + ret1 := syscall6(certAddEncodedCRLToStore, 6, + uintptr(hCertStore), + uintptr(dwCertEncodingType), + uintptr(unsafe.Pointer(pbCrlEncoded)), + uintptr(cbCrlEncoded), + uintptr(dwAddDisposition), + uintptr(unsafe.Pointer(ppCrlContext))) + return ret1 != 0 +} + +func CertAddEncodedCTLToStore(hCertStore HCERTSTORE, dwMsgAndCertEncodingType DWORD, pbCtlEncoded /*const*/ *byte, cbCtlEncoded DWORD, dwAddDisposition DWORD, ppCtlContext *PCCTL_CONTEXT) bool { + ret1 := syscall6(certAddEncodedCTLToStore, 6, + uintptr(hCertStore), + uintptr(dwMsgAndCertEncodingType), + uintptr(unsafe.Pointer(pbCtlEncoded)), + uintptr(cbCtlEncoded), + uintptr(dwAddDisposition), + uintptr(unsafe.Pointer(ppCtlContext))) + return ret1 != 0 +} + +func CertAddEncodedCertificateToStore(hCertStore HCERTSTORE, dwCertEncodingType DWORD, pbCertEncoded /*const*/ *byte, cbCertEncoded DWORD, dwAddDisposition DWORD, ppCertContext *PCCERT_CONTEXT) bool { + ret1 := syscall6(certAddEncodedCertificateToStore, 6, + uintptr(hCertStore), + uintptr(dwCertEncodingType), + uintptr(unsafe.Pointer(pbCertEncoded)), + uintptr(cbCertEncoded), + uintptr(dwAddDisposition), + uintptr(unsafe.Pointer(ppCertContext))) + return ret1 != 0 +} + +func CertAddEncodedCertificateToSystemStore(szCertStoreName string, pbCertEncoded /*const*/ *byte, cbCertEncoded DWORD) bool { + szCertStoreNameStr := unicode16FromString(szCertStoreName) + ret1 := syscall3(certAddEncodedCertificateToSystemStore, 3, + uintptr(unsafe.Pointer(&szCertStoreNameStr[0])), + uintptr(unsafe.Pointer(pbCertEncoded)), + uintptr(cbCertEncoded)) + return ret1 != 0 +} + +func CertAddEnhancedKeyUsageIdentifier(pCertContext /*const*/ PCCERT_CONTEXT, pszUsageIdentifier /*const*/ LPCSTR) bool { + ret1 := syscall3(certAddEnhancedKeyUsageIdentifier, 2, + uintptr(unsafe.Pointer(pCertContext)), + uintptr(unsafe.Pointer(pszUsageIdentifier)), + 0) + return ret1 != 0 +} + +func CertAddSerializedElementToStore(hCertStore HCERTSTORE, pbElement /*const*/ *byte, cbElement DWORD, dwAddDisposition DWORD, dwFlags DWORD, dwContextTypeFlags DWORD, pdwContextType *uint32, ppvContext /*const*/ uintptr) bool { + ret1 := syscall9(certAddSerializedElementToStore, 8, + uintptr(hCertStore), + uintptr(unsafe.Pointer(pbElement)), + uintptr(cbElement), + uintptr(dwAddDisposition), + uintptr(dwFlags), + uintptr(dwContextTypeFlags), + uintptr(unsafe.Pointer(pdwContextType)), + ppvContext, + 0) + return ret1 != 0 +} + +func CertAddStoreToCollection(hCollectionStore HCERTSTORE, hSiblingStore HCERTSTORE, dwUpdateFlags DWORD, dwPriority DWORD) bool { + ret1 := syscall6(certAddStoreToCollection, 4, + uintptr(hCollectionStore), + uintptr(hSiblingStore), + uintptr(dwUpdateFlags), + uintptr(dwPriority), + 0, + 0) + return ret1 != 0 +} + +func CertAlgIdToOID(dwAlgId DWORD) LPCSTR { + ret1 := syscall3(certAlgIdToOID, 1, + uintptr(dwAlgId), + 0, + 0) + return (LPCSTR)(unsafe.Pointer(ret1)) +} + +func CertCloseStore(hCertStore HCERTSTORE, dwFlags DWORD) bool { + ret1 := syscall3(certCloseStore, 2, + uintptr(hCertStore), + uintptr(dwFlags), + 0) + return ret1 != 0 +} + +func CertCompareCertificate(dwCertEncodingType DWORD, pCertId1 PCERT_INFO, pCertId2 PCERT_INFO) bool { + ret1 := syscall3(certCompareCertificate, 3, + uintptr(dwCertEncodingType), + uintptr(unsafe.Pointer(pCertId1)), + uintptr(unsafe.Pointer(pCertId2))) + return ret1 != 0 +} + +func CertCompareCertificateName(dwCertEncodingType DWORD, pCertName1 PCERT_NAME_BLOB, pCertName2 PCERT_NAME_BLOB) bool { + ret1 := syscall3(certCompareCertificateName, 3, + uintptr(dwCertEncodingType), + uintptr(unsafe.Pointer(pCertName1)), + uintptr(unsafe.Pointer(pCertName2))) + return ret1 != 0 +} + +func CertCompareIntegerBlob(pInt1 PCRYPT_INTEGER_BLOB, pInt2 PCRYPT_INTEGER_BLOB) bool { + ret1 := syscall3(certCompareIntegerBlob, 2, + uintptr(unsafe.Pointer(pInt1)), + uintptr(unsafe.Pointer(pInt2)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCERT_PUBLIC_KEY_INFO +// func CertComparePublicKeyInfo(dwCertEncodingType DWORD, pPublicKey1 PCERT_PUBLIC_KEY_INFO, pPublicKey2 PCERT_PUBLIC_KEY_INFO) bool + +func CertControlStore(hCertStore HCERTSTORE, dwFlags DWORD, dwCtrlType DWORD, pvCtrlPara /*const*/ uintptr) bool { + ret1 := syscall6(certControlStore, 4, + uintptr(hCertStore), + uintptr(dwFlags), + uintptr(dwCtrlType), + pvCtrlPara, + 0, + 0) + return ret1 != 0 +} + +func CertCreateCRLContext(dwCertEncodingType DWORD, pbCrlEncoded /*const*/ *byte, cbCrlEncoded DWORD) PCCRL_CONTEXT { + ret1 := syscall3(certCreateCRLContext, 3, + uintptr(dwCertEncodingType), + uintptr(unsafe.Pointer(pbCrlEncoded)), + uintptr(cbCrlEncoded)) + return (PCCRL_CONTEXT)(unsafe.Pointer(ret1)) +} + +func CertCreateCTLContext(dwMsgAndCertEncodingType DWORD, pbCtlEncoded /*const*/ *byte, cbCtlEncoded DWORD) PCCTL_CONTEXT { + ret1 := syscall3(certCreateCTLContext, 3, + uintptr(dwMsgAndCertEncodingType), + uintptr(unsafe.Pointer(pbCtlEncoded)), + uintptr(cbCtlEncoded)) + return (PCCTL_CONTEXT)(unsafe.Pointer(ret1)) +} + +func CertCreateCTLEntryFromCertificateContextProperties(pCertContext /*const*/ PCCERT_CONTEXT, cOptAttr DWORD, rgOptAttr PCRYPT_ATTRIBUTE, dwFlags DWORD, pvReserved uintptr, pCtlEntry PCTL_ENTRY, pcbCtlEntry *uint32) bool { + ret1 := syscall9(certCreateCTLEntryFromCertificateContextProperties, 7, + uintptr(unsafe.Pointer(pCertContext)), + uintptr(cOptAttr), + uintptr(unsafe.Pointer(rgOptAttr)), + uintptr(dwFlags), + pvReserved, + uintptr(unsafe.Pointer(pCtlEntry)), + uintptr(unsafe.Pointer(pcbCtlEntry)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): HCERTCHAINENGINE *, PCERT_CHAIN_ENGINE_CONFIG +// func CertCreateCertificateChainEngine(pConfig PCERT_CHAIN_ENGINE_CONFIG, phChainEngine HCERTCHAINENGINE *) bool + +func CertCreateCertificateContext(dwCertEncodingType DWORD, pbCertEncoded /*const*/ *byte, cbCertEncoded DWORD) PCCERT_CONTEXT { + ret1 := syscall3(certCreateCertificateContext, 3, + uintptr(dwCertEncodingType), + uintptr(unsafe.Pointer(pbCertEncoded)), + uintptr(cbCertEncoded)) + return (PCCERT_CONTEXT)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, PCERT_EXTENSIONS, PCRYPT_ALGORITHM_IDENTIFIER, PCRYPT_KEY_PROV_INFO, PSYSTEMTIME +// func CertCreateSelfSignCertificate(hCryptProvOrNCryptKey HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, pSubjectIssuerBlob PCERT_NAME_BLOB, dwFlags DWORD, pKeyProvInfo PCRYPT_KEY_PROV_INFO, pSignatureAlgorithm PCRYPT_ALGORITHM_IDENTIFIER, pStartTime PSYSTEMTIME, pEndTime PSYSTEMTIME, pExtensions PCERT_EXTENSIONS) PCCERT_CONTEXT + +func CertDeleteCRLFromStore(pCrlContext PCCRL_CONTEXT) bool { + ret1 := syscall3(certDeleteCRLFromStore, 1, + uintptr(unsafe.Pointer(pCrlContext)), + 0, + 0) + return ret1 != 0 +} + +func CertDeleteCTLFromStore(pCtlContext /*const*/ PCCTL_CONTEXT) bool { + ret1 := syscall3(certDeleteCTLFromStore, 1, + uintptr(unsafe.Pointer(pCtlContext)), + 0, + 0) + return ret1 != 0 +} + +func CertDeleteCertificateFromStore(pCertContext /*const*/ PCCERT_CONTEXT) bool { + ret1 := syscall3(certDeleteCertificateFromStore, 1, + uintptr(unsafe.Pointer(pCertContext)), + 0, + 0) + return ret1 != 0 +} + +func CertDuplicateCRLContext(pCrlContext PCCRL_CONTEXT) PCCRL_CONTEXT { + ret1 := syscall3(certDuplicateCRLContext, 1, + uintptr(unsafe.Pointer(pCrlContext)), + 0, + 0) + return (PCCRL_CONTEXT)(unsafe.Pointer(ret1)) +} + +func CertDuplicateCTLContext(pCtlContext /*const*/ PCCTL_CONTEXT) PCCTL_CONTEXT { + ret1 := syscall3(certDuplicateCTLContext, 1, + uintptr(unsafe.Pointer(pCtlContext)), + 0, + 0) + return (PCCTL_CONTEXT)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): PCCERT_CHAIN_CONTEXT +// func CertDuplicateCertificateChain(pChainContext PCCERT_CHAIN_CONTEXT) PCCERT_CHAIN_CONTEXT + +func CertDuplicateCertificateContext(pCertContext /*const*/ PCCERT_CONTEXT) PCCERT_CONTEXT { + ret1 := syscall3(certDuplicateCertificateContext, 1, + uintptr(unsafe.Pointer(pCertContext)), + 0, + 0) + return (PCCERT_CONTEXT)(unsafe.Pointer(ret1)) +} + +func CertDuplicateStore(hCertStore HCERTSTORE) HCERTSTORE { + ret1 := syscall3(certDuplicateStore, 1, + uintptr(hCertStore), + 0, + 0) + return HCERTSTORE(ret1) +} + +func CertEnumCRLContextProperties(pCrlContext PCCRL_CONTEXT, dwPropId DWORD) DWORD { + ret1 := syscall3(certEnumCRLContextProperties, 2, + uintptr(unsafe.Pointer(pCrlContext)), + uintptr(dwPropId), + 0) + return DWORD(ret1) +} + +func CertEnumCRLsInStore(hCertStore HCERTSTORE, pPrevCrlContext PCCRL_CONTEXT) PCCRL_CONTEXT { + ret1 := syscall3(certEnumCRLsInStore, 2, + uintptr(hCertStore), + uintptr(unsafe.Pointer(pPrevCrlContext)), + 0) + return (PCCRL_CONTEXT)(unsafe.Pointer(ret1)) +} + +func CertEnumCTLContextProperties(pCtlContext /*const*/ PCCTL_CONTEXT, dwPropId DWORD) DWORD { + ret1 := syscall3(certEnumCTLContextProperties, 2, + uintptr(unsafe.Pointer(pCtlContext)), + uintptr(dwPropId), + 0) + return DWORD(ret1) +} + +func CertEnumCTLsInStore(hCertStore HCERTSTORE, pPrevCtlContext /*const*/ PCCTL_CONTEXT) PCCTL_CONTEXT { + ret1 := syscall3(certEnumCTLsInStore, 2, + uintptr(hCertStore), + uintptr(unsafe.Pointer(pPrevCtlContext)), + 0) + return (PCCTL_CONTEXT)(unsafe.Pointer(ret1)) +} + +func CertEnumCertificateContextProperties(pCertContext /*const*/ PCCERT_CONTEXT, dwPropId DWORD) DWORD { + ret1 := syscall3(certEnumCertificateContextProperties, 2, + uintptr(unsafe.Pointer(pCertContext)), + uintptr(dwPropId), + 0) + return DWORD(ret1) +} + +func CertEnumCertificatesInStore(hCertStore HCERTSTORE, pPrevCertContext /*const*/ PCCERT_CONTEXT) PCCERT_CONTEXT { + ret1 := syscall3(certEnumCertificatesInStore, 2, + uintptr(hCertStore), + uintptr(unsafe.Pointer(pPrevCertContext)), + 0) + return (PCCERT_CONTEXT)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): PFN_CERT_ENUM_PHYSICAL_STORE +// func CertEnumPhysicalStore(pvSystemStore /*const*/ uintptr, dwFlags DWORD, pvArg uintptr, pfnEnum PFN_CERT_ENUM_PHYSICAL_STORE) bool + +func CertEnumSubjectInSortedCTL(pCtlContext /*const*/ PCCTL_CONTEXT, ppvNextSubject uintptr, pSubjectIdentifier PCRYPT_DER_BLOB, pEncodedAttributes PCRYPT_DER_BLOB) bool { + ret1 := syscall6(certEnumSubjectInSortedCTL, 4, + uintptr(unsafe.Pointer(pCtlContext)), + ppvNextSubject, + uintptr(unsafe.Pointer(pSubjectIdentifier)), + uintptr(unsafe.Pointer(pEncodedAttributes)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PFN_CERT_ENUM_SYSTEM_STORE +// func CertEnumSystemStore(dwFlags DWORD, pvSystemStoreLocationPara uintptr, pvArg uintptr, pfnEnum PFN_CERT_ENUM_SYSTEM_STORE) bool + +// TODO: Unknown type(s): PFN_CERT_ENUM_SYSTEM_STORE_LOCATION +// func CertEnumSystemStoreLocation(dwFlags DWORD, pvArg uintptr, pfnEnum PFN_CERT_ENUM_SYSTEM_STORE_LOCATION) bool + +func CertFindAttribute(pszObjId /*const*/ LPCSTR, cAttr DWORD, rgAttr *CRYPT_ATTRIBUTE) PCRYPT_ATTRIBUTE { + ret1 := syscall3(certFindAttribute, 3, + uintptr(unsafe.Pointer(pszObjId)), + uintptr(cAttr), + uintptr(unsafe.Pointer(rgAttr))) + return (PCRYPT_ATTRIBUTE)(unsafe.Pointer(ret1)) +} + +func CertFindCRLInStore(hCertStore HCERTSTORE, dwCertEncodingType DWORD, dwFindFlags DWORD, dwFindType DWORD, pvFindPara /*const*/ uintptr, pPrevCrlContext PCCRL_CONTEXT) PCCRL_CONTEXT { + ret1 := syscall6(certFindCRLInStore, 6, + uintptr(hCertStore), + uintptr(dwCertEncodingType), + uintptr(dwFindFlags), + uintptr(dwFindType), + pvFindPara, + uintptr(unsafe.Pointer(pPrevCrlContext))) + return (PCCRL_CONTEXT)(unsafe.Pointer(ret1)) +} + +func CertFindCTLInStore(hCertStore HCERTSTORE, dwMsgAndCertEncodingType DWORD, dwFindFlags DWORD, dwFindType DWORD, pvFindPara /*const*/ uintptr, pPrevCtlContext /*const*/ PCCTL_CONTEXT) PCCTL_CONTEXT { + ret1 := syscall6(certFindCTLInStore, 6, + uintptr(hCertStore), + uintptr(dwMsgAndCertEncodingType), + uintptr(dwFindFlags), + uintptr(dwFindType), + pvFindPara, + uintptr(unsafe.Pointer(pPrevCtlContext))) + return (PCCTL_CONTEXT)(unsafe.Pointer(ret1)) +} + +func CertFindCertificateInCRL(pCert /*const*/ PCCERT_CONTEXT, pCrlContext PCCRL_CONTEXT, dwFlags DWORD, pvReserved uintptr, ppCrlEntry *PCRL_ENTRY) bool { + ret1 := syscall6(certFindCertificateInCRL, 5, + uintptr(unsafe.Pointer(pCert)), + uintptr(unsafe.Pointer(pCrlContext)), + uintptr(dwFlags), + pvReserved, + uintptr(unsafe.Pointer(ppCrlEntry)), + 0) + return ret1 != 0 +} + +func CertFindCertificateInStore(hCertStore HCERTSTORE, dwCertEncodingType DWORD, dwFindFlags DWORD, dwFindType DWORD, pvFindPara /*const*/ uintptr, pPrevCertContext /*const*/ PCCERT_CONTEXT) PCCERT_CONTEXT { + ret1 := syscall6(certFindCertificateInStore, 6, + uintptr(hCertStore), + uintptr(dwCertEncodingType), + uintptr(dwFindFlags), + uintptr(dwFindType), + pvFindPara, + uintptr(unsafe.Pointer(pPrevCertContext))) + return (PCCERT_CONTEXT)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): PCCERT_CHAIN_CONTEXT +// func CertFindChainInStore(hCertStore HCERTSTORE, dwCertEncodingType DWORD, dwFindFlags DWORD, dwFindType DWORD, pvFindPara /*const*/ uintptr, pPrevChainContext PCCERT_CHAIN_CONTEXT) PCCERT_CHAIN_CONTEXT + +func CertFindExtension(pszObjId /*const*/ LPCSTR, cExtensions DWORD, rgExtensions *CERT_EXTENSION) PCERT_EXTENSION { + ret1 := syscall3(certFindExtension, 3, + uintptr(unsafe.Pointer(pszObjId)), + uintptr(cExtensions), + uintptr(unsafe.Pointer(rgExtensions))) + return (PCERT_EXTENSION)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): PCERT_NAME_INFO, PCERT_RDN_ATTR +// func CertFindRDNAttr(pszObjId /*const*/ LPCSTR, pName PCERT_NAME_INFO) PCERT_RDN_ATTR + +func CertFindSubjectInCTL(dwEncodingType DWORD, dwSubjectType DWORD, pvSubject uintptr, pCtlContext /*const*/ PCCTL_CONTEXT, dwFlags DWORD) PCTL_ENTRY { + ret1 := syscall6(certFindSubjectInCTL, 5, + uintptr(dwEncodingType), + uintptr(dwSubjectType), + pvSubject, + uintptr(unsafe.Pointer(pCtlContext)), + uintptr(dwFlags), + 0) + return (PCTL_ENTRY)(unsafe.Pointer(ret1)) +} + +func CertFindSubjectInSortedCTL(pSubjectIdentifier PCRYPT_DATA_BLOB, pCtlContext /*const*/ PCCTL_CONTEXT, dwFlags DWORD, pvReserved uintptr, pEncodedAttributes PCRYPT_DER_BLOB) bool { + ret1 := syscall6(certFindSubjectInSortedCTL, 5, + uintptr(unsafe.Pointer(pSubjectIdentifier)), + uintptr(unsafe.Pointer(pCtlContext)), + uintptr(dwFlags), + pvReserved, + uintptr(unsafe.Pointer(pEncodedAttributes)), + 0) + return ret1 != 0 +} + +func CertFreeCRLContext(pCrlContext PCCRL_CONTEXT) bool { + ret1 := syscall3(certFreeCRLContext, 1, + uintptr(unsafe.Pointer(pCrlContext)), + 0, + 0) + return ret1 != 0 +} + +func CertFreeCTLContext(pCtlContext /*const*/ PCCTL_CONTEXT) bool { + ret1 := syscall3(certFreeCTLContext, 1, + uintptr(unsafe.Pointer(pCtlContext)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCCERT_CHAIN_CONTEXT +// func CertFreeCertificateChain(pChainContext PCCERT_CHAIN_CONTEXT) + +// TODO: Unknown type(s): HCERTCHAINENGINE +// func CertFreeCertificateChainEngine(hChainEngine HCERTCHAINENGINE) + +func CertFreeCertificateContext(pCertContext /*const*/ PCCERT_CONTEXT) bool { + ret1 := syscall3(certFreeCertificateContext, 1, + uintptr(unsafe.Pointer(pCertContext)), + 0, + 0) + return ret1 != 0 +} + +func CertGetCRLContextProperty(pCrlContext PCCRL_CONTEXT, dwPropId DWORD, pvData uintptr, pcbData *uint32) bool { + ret1 := syscall6(certGetCRLContextProperty, 4, + uintptr(unsafe.Pointer(pCrlContext)), + uintptr(dwPropId), + pvData, + uintptr(unsafe.Pointer(pcbData)), + 0, + 0) + return ret1 != 0 +} + +func CertGetCRLFromStore(hCertStore HCERTSTORE, pIssuerContext /*const*/ PCCERT_CONTEXT, pPrevCrlContext PCCRL_CONTEXT, pdwFlags *uint32) PCCRL_CONTEXT { + ret1 := syscall6(certGetCRLFromStore, 4, + uintptr(hCertStore), + uintptr(unsafe.Pointer(pIssuerContext)), + uintptr(unsafe.Pointer(pPrevCrlContext)), + uintptr(unsafe.Pointer(pdwFlags)), + 0, + 0) + return (PCCRL_CONTEXT)(unsafe.Pointer(ret1)) +} + +func CertGetCTLContextProperty(pCtlContext /*const*/ PCCTL_CONTEXT, dwPropId DWORD, pvData uintptr, pcbData *uint32) bool { + ret1 := syscall6(certGetCTLContextProperty, 4, + uintptr(unsafe.Pointer(pCtlContext)), + uintptr(dwPropId), + pvData, + uintptr(unsafe.Pointer(pcbData)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): HCERTCHAINENGINE, PCCERT_CHAIN_CONTEXT *, PCERT_CHAIN_PARA +// func CertGetCertificateChain(hChainEngine HCERTCHAINENGINE, pCertContext /*const*/ PCCERT_CONTEXT, pTime *FILETIME, hAdditionalStore HCERTSTORE, pChainPara PCERT_CHAIN_PARA, dwFlags DWORD, pvReserved LPVOID, ppChainContext PCCERT_CHAIN_CONTEXT *) bool + +func CertGetCertificateContextProperty(pCertContext /*const*/ PCCERT_CONTEXT, dwPropId DWORD, pvData uintptr, pcbData *uint32) bool { + ret1 := syscall6(certGetCertificateContextProperty, 4, + uintptr(unsafe.Pointer(pCertContext)), + uintptr(dwPropId), + pvData, + uintptr(unsafe.Pointer(pcbData)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCERT_ENHKEY_USAGE +// func CertGetEnhancedKeyUsage(pCertContext /*const*/ PCCERT_CONTEXT, dwFlags DWORD, pUsage PCERT_ENHKEY_USAGE, pcbUsage *uint32) bool + +func CertGetIntendedKeyUsage(dwCertEncodingType DWORD, pCertInfo PCERT_INFO, pbKeyUsage *byte, cbKeyUsage DWORD) bool { + ret1 := syscall6(certGetIntendedKeyUsage, 4, + uintptr(dwCertEncodingType), + uintptr(unsafe.Pointer(pCertInfo)), + uintptr(unsafe.Pointer(pbKeyUsage)), + uintptr(cbKeyUsage), + 0, + 0) + return ret1 != 0 +} + +func CertGetIssuerCertificateFromStore(hCertStore HCERTSTORE, pSubjectContext /*const*/ PCCERT_CONTEXT, pPrevIssuerContext /*const*/ PCCERT_CONTEXT, pdwFlags *uint32) PCCERT_CONTEXT { + ret1 := syscall6(certGetIssuerCertificateFromStore, 4, + uintptr(hCertStore), + uintptr(unsafe.Pointer(pSubjectContext)), + uintptr(unsafe.Pointer(pPrevIssuerContext)), + uintptr(unsafe.Pointer(pdwFlags)), + 0, + 0) + return (PCCERT_CONTEXT)(unsafe.Pointer(ret1)) +} + +func CertGetNameString(pCertContext /*const*/ PCCERT_CONTEXT, dwType DWORD, dwFlags DWORD, pvTypePara uintptr, pszNameString LPWSTR, cchNameString DWORD) DWORD { + ret1 := syscall6(certGetNameString, 6, + uintptr(unsafe.Pointer(pCertContext)), + uintptr(dwType), + uintptr(dwFlags), + pvTypePara, + uintptr(unsafe.Pointer(pszNameString)), + uintptr(cchNameString)) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PCERT_PUBLIC_KEY_INFO +// func CertGetPublicKeyLength(dwCertEncodingType DWORD, pPublicKey PCERT_PUBLIC_KEY_INFO) DWORD + +func CertGetStoreProperty(hCertStore HCERTSTORE, dwPropId DWORD, pvData uintptr, pcbData *uint32) bool { + ret1 := syscall6(certGetStoreProperty, 4, + uintptr(hCertStore), + uintptr(dwPropId), + pvData, + uintptr(unsafe.Pointer(pcbData)), + 0, + 0) + return ret1 != 0 +} + +func CertGetSubjectCertificateFromStore(hCertStore HCERTSTORE, dwCertEncodingType DWORD, pCertId PCERT_INFO) PCCERT_CONTEXT { + ret1 := syscall3(certGetSubjectCertificateFromStore, 3, + uintptr(hCertStore), + uintptr(dwCertEncodingType), + uintptr(unsafe.Pointer(pCertId))) + return (PCCERT_CONTEXT)(unsafe.Pointer(ret1)) +} + +func CertGetValidUsages(cCerts DWORD, rghCerts *PCCERT_CONTEXT, cNumOIDs *int, rghOIDs *LPSTR, pcbOIDs *uint32) bool { + ret1 := syscall6(certGetValidUsages, 5, + uintptr(cCerts), + uintptr(unsafe.Pointer(rghCerts)), + uintptr(unsafe.Pointer(cNumOIDs)), + uintptr(unsafe.Pointer(rghOIDs)), + uintptr(unsafe.Pointer(pcbOIDs)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCERT_RDN +// func CertIsRDNAttrsInCertificateName(dwCertEncodingType DWORD, dwFlags DWORD, pCertName PCERT_NAME_BLOB, pRDN PCERT_RDN) bool + +func CertIsValidCRLForCertificate(pCert /*const*/ PCCERT_CONTEXT, pCrl PCCRL_CONTEXT, dwFlags DWORD, pvReserved uintptr) bool { + ret1 := syscall6(certIsValidCRLForCertificate, 4, + uintptr(unsafe.Pointer(pCert)), + uintptr(unsafe.Pointer(pCrl)), + uintptr(dwFlags), + pvReserved, + 0, + 0) + return ret1 != 0 +} + +func CertNameToStr(dwCertEncodingType DWORD, pName PCERT_NAME_BLOB, dwStrType DWORD, psz LPWSTR, csz DWORD) DWORD { + ret1 := syscall6(certNameToStr, 5, + uintptr(dwCertEncodingType), + uintptr(unsafe.Pointer(pName)), + uintptr(dwStrType), + uintptr(unsafe.Pointer(psz)), + uintptr(csz), + 0) + return DWORD(ret1) +} + +func CertOIDToAlgId(pszObjId /*const*/ LPCSTR) DWORD { + ret1 := syscall3(certOIDToAlgId, 1, + uintptr(unsafe.Pointer(pszObjId)), + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): HCRYPTPROV_LEGACY +// func CertOpenStore(lpszStoreProvider /*const*/ LPCSTR, dwEncodingType DWORD, hCryptProv HCRYPTPROV_LEGACY, dwFlags DWORD, pvPara /*const*/ uintptr) HCERTSTORE + +// TODO: Unknown type(s): HCRYPTPROV_LEGACY +// func CertOpenSystemStore(hProv HCRYPTPROV_LEGACY, szSubsystemProtocol string) HCERTSTORE + +func CertRDNValueToStr(dwValueType DWORD, pValue PCERT_RDN_VALUE_BLOB, psz LPWSTR, csz DWORD) DWORD { + ret1 := syscall6(certRDNValueToStr, 4, + uintptr(dwValueType), + uintptr(unsafe.Pointer(pValue)), + uintptr(unsafe.Pointer(psz)), + uintptr(csz), + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PCERT_PHYSICAL_STORE_INFO +// func CertRegisterPhysicalStore(pvSystemStore /*const*/ uintptr, dwFlags DWORD, pwszStoreName string, pStoreInfo PCERT_PHYSICAL_STORE_INFO, pvReserved uintptr) bool + +// TODO: Unknown type(s): PCERT_SYSTEM_STORE_INFO +// func CertRegisterSystemStore(pvSystemStore /*const*/ uintptr, dwFlags DWORD, pStoreInfo PCERT_SYSTEM_STORE_INFO, pvReserved uintptr) bool + +func CertRemoveEnhancedKeyUsageIdentifier(pCertContext /*const*/ PCCERT_CONTEXT, pszUsageIdentifier /*const*/ LPCSTR) bool { + ret1 := syscall3(certRemoveEnhancedKeyUsageIdentifier, 2, + uintptr(unsafe.Pointer(pCertContext)), + uintptr(unsafe.Pointer(pszUsageIdentifier)), + 0) + return ret1 != 0 +} + +func CertRemoveStoreFromCollection(hCollectionStore HCERTSTORE, hSiblingStore HCERTSTORE) { + syscall3(certRemoveStoreFromCollection, 2, + uintptr(hCollectionStore), + uintptr(hSiblingStore), + 0) +} + +// TODO: Unknown type(s): HCERTCHAINENGINE +// func CertResyncCertificateChainEngine(hChainEngine HCERTCHAINENGINE) bool + +func CertSaveStore(hCertStore HCERTSTORE, dwEncodingType DWORD, dwSaveAs DWORD, dwSaveTo DWORD, pvSaveToPara uintptr, dwFlags DWORD) bool { + ret1 := syscall6(certSaveStore, 6, + uintptr(hCertStore), + uintptr(dwEncodingType), + uintptr(dwSaveAs), + uintptr(dwSaveTo), + pvSaveToPara, + uintptr(dwFlags)) + return ret1 != 0 +} + +func CertSerializeCRLStoreElement(pCrlContext PCCRL_CONTEXT, dwFlags DWORD, pbElement *byte, pcbElement *uint32) bool { + ret1 := syscall6(certSerializeCRLStoreElement, 4, + uintptr(unsafe.Pointer(pCrlContext)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbElement)), + uintptr(unsafe.Pointer(pcbElement)), + 0, + 0) + return ret1 != 0 +} + +func CertSerializeCTLStoreElement(pCtlContext /*const*/ PCCTL_CONTEXT, dwFlags DWORD, pbElement *byte, pcbElement *uint32) bool { + ret1 := syscall6(certSerializeCTLStoreElement, 4, + uintptr(unsafe.Pointer(pCtlContext)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbElement)), + uintptr(unsafe.Pointer(pcbElement)), + 0, + 0) + return ret1 != 0 +} + +func CertSerializeCertificateStoreElement(pCertContext /*const*/ PCCERT_CONTEXT, dwFlags DWORD, pbElement *byte, pcbElement *uint32) bool { + ret1 := syscall6(certSerializeCertificateStoreElement, 4, + uintptr(unsafe.Pointer(pCertContext)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbElement)), + uintptr(unsafe.Pointer(pcbElement)), + 0, + 0) + return ret1 != 0 +} + +func CertSetCRLContextProperty(pCrlContext PCCRL_CONTEXT, dwPropId DWORD, dwFlags DWORD, pvData /*const*/ uintptr) bool { + ret1 := syscall6(certSetCRLContextProperty, 4, + uintptr(unsafe.Pointer(pCrlContext)), + uintptr(dwPropId), + uintptr(dwFlags), + pvData, + 0, + 0) + return ret1 != 0 +} + +func CertSetCTLContextProperty(pCtlContext /*const*/ PCCTL_CONTEXT, dwPropId DWORD, dwFlags DWORD, pvData /*const*/ uintptr) bool { + ret1 := syscall6(certSetCTLContextProperty, 4, + uintptr(unsafe.Pointer(pCtlContext)), + uintptr(dwPropId), + uintptr(dwFlags), + pvData, + 0, + 0) + return ret1 != 0 +} + +func CertSetCertificateContextPropertiesFromCTLEntry(pCertContext /*const*/ PCCERT_CONTEXT, pCtlEntry PCTL_ENTRY, dwFlags DWORD) bool { + ret1 := syscall3(certSetCertificateContextPropertiesFromCTLEntry, 3, + uintptr(unsafe.Pointer(pCertContext)), + uintptr(unsafe.Pointer(pCtlEntry)), + uintptr(dwFlags)) + return ret1 != 0 +} + +func CertSetCertificateContextProperty(pCertContext /*const*/ PCCERT_CONTEXT, dwPropId DWORD, dwFlags DWORD, pvData /*const*/ uintptr) bool { + ret1 := syscall6(certSetCertificateContextProperty, 4, + uintptr(unsafe.Pointer(pCertContext)), + uintptr(dwPropId), + uintptr(dwFlags), + pvData, + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCERT_ENHKEY_USAGE +// func CertSetEnhancedKeyUsage(pCertContext /*const*/ PCCERT_CONTEXT, pUsage PCERT_ENHKEY_USAGE) bool + +func CertSetStoreProperty(hCertStore HCERTSTORE, dwPropId DWORD, dwFlags DWORD, pvData /*const*/ uintptr) bool { + ret1 := syscall6(certSetStoreProperty, 4, + uintptr(hCertStore), + uintptr(dwPropId), + uintptr(dwFlags), + pvData, + 0, + 0) + return ret1 != 0 +} + +func CertStrToName(dwCertEncodingType DWORD, pszX500 string, dwStrType DWORD, pvReserved uintptr, pbEncoded *byte, pcbEncoded *uint32, ppszError *LPCWSTR) bool { + pszX500Str := unicode16FromString(pszX500) + ret1 := syscall9(certStrToName, 7, + uintptr(dwCertEncodingType), + uintptr(unsafe.Pointer(&pszX500Str[0])), + uintptr(dwStrType), + pvReserved, + uintptr(unsafe.Pointer(pbEncoded)), + uintptr(unsafe.Pointer(pcbEncoded)), + uintptr(unsafe.Pointer(ppszError)), + 0, + 0) + return ret1 != 0 +} + +func CertUnregisterPhysicalStore(pvSystemStore /*const*/ uintptr, dwFlags DWORD, pwszStoreName string) bool { + pwszStoreNameStr := unicode16FromString(pwszStoreName) + ret1 := syscall3(certUnregisterPhysicalStore, 3, + pvSystemStore, + uintptr(dwFlags), + uintptr(unsafe.Pointer(&pwszStoreNameStr[0]))) + return ret1 != 0 +} + +func CertUnregisterSystemStore(pvSystemStore /*const*/ uintptr, dwFlags DWORD) bool { + ret1 := syscall3(certUnregisterSystemStore, 2, + pvSystemStore, + uintptr(dwFlags), + 0) + return ret1 != 0 +} + +func CertVerifyCRLRevocation(dwCertEncodingType DWORD, pCertId PCERT_INFO, cCrlInfo DWORD, rgpCrlInfo *PCRL_INFO) bool { + ret1 := syscall6(certVerifyCRLRevocation, 4, + uintptr(dwCertEncodingType), + uintptr(unsafe.Pointer(pCertId)), + uintptr(cCrlInfo), + uintptr(unsafe.Pointer(rgpCrlInfo)), + 0, + 0) + return ret1 != 0 +} + +func CertVerifyCRLTimeValidity(pTimeToVerify *FILETIME, pCrlInfo PCRL_INFO) LONG { + ret1 := syscall3(certVerifyCRLTimeValidity, 2, + uintptr(unsafe.Pointer(pTimeToVerify)), + uintptr(unsafe.Pointer(pCrlInfo)), + 0) + return LONG(ret1) +} + +// TODO: Unknown type(s): PCTL_USAGE, PCTL_VERIFY_USAGE_PARA, PCTL_VERIFY_USAGE_STATUS +// func CertVerifyCTLUsage(dwEncodingType DWORD, dwSubjectType DWORD, pvSubject uintptr, pSubjectUsage PCTL_USAGE, dwFlags DWORD, pVerifyUsagePara PCTL_VERIFY_USAGE_PARA, pVerifyUsageStatus PCTL_VERIFY_USAGE_STATUS) bool + +// TODO: Unknown type(s): PCCERT_CHAIN_CONTEXT, PCERT_CHAIN_POLICY_PARA, PCERT_CHAIN_POLICY_STATUS +// func CertVerifyCertificateChainPolicy(pszPolicyOID /*const*/ LPCSTR, pChainContext PCCERT_CHAIN_CONTEXT, pPolicyPara PCERT_CHAIN_POLICY_PARA, pPolicyStatus PCERT_CHAIN_POLICY_STATUS) bool + +// TODO: Unknown type(s): PCERT_REVOCATION_PARA, PCERT_REVOCATION_STATUS +// func CertVerifyRevocation(dwEncodingType DWORD, dwRevType DWORD, cContext DWORD, rgpvContext *PVOID, dwFlags DWORD, pRevPara PCERT_REVOCATION_PARA, pRevStatus PCERT_REVOCATION_STATUS) bool + +func CertVerifySubjectCertificateContext(pSubject /*const*/ PCCERT_CONTEXT, pIssuer /*const*/ PCCERT_CONTEXT, pdwFlags *uint32) bool { + ret1 := syscall3(certVerifySubjectCertificateContext, 3, + uintptr(unsafe.Pointer(pSubject)), + uintptr(unsafe.Pointer(pIssuer)), + uintptr(unsafe.Pointer(pdwFlags))) + return ret1 != 0 +} + +func CertVerifyTimeValidity(pTimeToVerify *FILETIME, pCertInfo PCERT_INFO) LONG { + ret1 := syscall3(certVerifyTimeValidity, 2, + uintptr(unsafe.Pointer(pTimeToVerify)), + uintptr(unsafe.Pointer(pCertInfo)), + 0) + return LONG(ret1) +} + +func CertVerifyValidityNesting(pSubjectInfo PCERT_INFO, pIssuerInfo PCERT_INFO) bool { + ret1 := syscall3(certVerifyValidityNesting, 2, + uintptr(unsafe.Pointer(pSubjectInfo)), + uintptr(unsafe.Pointer(pIssuerInfo)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): HCRYPTPROV_OR_NCRYPT_KEY_HANDLE * +// func CryptAcquireCertificatePrivateKey(pCert /*const*/ PCCERT_CONTEXT, dwFlags DWORD, pvParameters uintptr, phCryptProvOrNCryptKey HCRYPTPROV_OR_NCRYPT_KEY_HANDLE *, pdwKeySpec *uint32, pfCallerFreeProvOrNCryptKey *BOOL) bool + +func CryptBinaryToString(pbBinary /*const*/ *byte, cbBinary DWORD, dwFlags DWORD, pszString LPWSTR, pcchString *uint32) bool { + ret1 := syscall6(cryptBinaryToString, 5, + uintptr(unsafe.Pointer(pbBinary)), + uintptr(cbBinary), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pszString)), + uintptr(unsafe.Pointer(pcchString)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): HCRYPTASYNC +// func CryptCloseAsyncHandle(hAsync HCRYPTASYNC) bool + +// TODO: Unknown type(s): PHCRYPTASYNC +// func CryptCreateAsyncHandle(dwFlags DWORD, phAsync PHCRYPTASYNC) bool + +// TODO: Unknown type(s): const PUBLICKEYSTRUC * +// func CryptCreateKeyIdentifierFromCSP(dwCertEncodingType DWORD, pszPubKeyOID /*const*/ LPCSTR, pPubKeyStruc /*const*/ const PUBLICKEYSTRUC *, cbPubKeyStruc DWORD, dwFlags DWORD, pvReserved uintptr, pbHash *byte, pcbHash *uint32) bool + +// TODO: Unknown type(s): PCRYPT_DECRYPT_MESSAGE_PARA, PCRYPT_VERIFY_MESSAGE_PARA +// func CryptDecodeMessage(dwMsgTypeFlags DWORD, pDecryptPara PCRYPT_DECRYPT_MESSAGE_PARA, pVerifyPara PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex DWORD, pbEncodedBlob /*const*/ *byte, cbEncodedBlob DWORD, dwPrevInnerContentType DWORD, pdwMsgType *uint32, pdwInnerContentType *uint32, pbDecoded *byte, pcbDecoded *uint32, ppXchgCert *PCCERT_CONTEXT, ppSignerCert *PCCERT_CONTEXT) bool + +func CryptDecodeObject(dwCertEncodingType DWORD, lpszStructType /*const*/ LPCSTR, pbEncoded /*const*/ *byte, cbEncoded DWORD, dwFlags DWORD, pvStructInfo uintptr, pcbStructInfo *uint32) bool { + ret1 := syscall9(cryptDecodeObject, 7, + uintptr(dwCertEncodingType), + uintptr(unsafe.Pointer(lpszStructType)), + uintptr(unsafe.Pointer(pbEncoded)), + uintptr(cbEncoded), + uintptr(dwFlags), + pvStructInfo, + uintptr(unsafe.Pointer(pcbStructInfo)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCRYPT_DECODE_PARA +// func CryptDecodeObjectEx(dwCertEncodingType DWORD, lpszStructType /*const*/ LPCSTR, pbEncoded /*const*/ *byte, cbEncoded DWORD, dwFlags DWORD, pDecodePara PCRYPT_DECODE_PARA, pvStructInfo uintptr, pcbStructInfo *uint32) bool + +// TODO: Unknown type(s): PCRYPT_DECRYPT_MESSAGE_PARA, PCRYPT_VERIFY_MESSAGE_PARA +// func CryptDecryptAndVerifyMessageSignature(pDecryptPara PCRYPT_DECRYPT_MESSAGE_PARA, pVerifyPara PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex DWORD, pbEncryptedBlob /*const*/ *byte, cbEncryptedBlob DWORD, pbDecrypted *byte, pcbDecrypted *uint32, ppXchgCert *PCCERT_CONTEXT, ppSignerCert *PCCERT_CONTEXT) bool + +// TODO: Unknown type(s): PCRYPT_DECRYPT_MESSAGE_PARA +// func CryptDecryptMessage(pDecryptPara PCRYPT_DECRYPT_MESSAGE_PARA, pbEncryptedBlob /*const*/ *byte, cbEncryptedBlob DWORD, pbDecrypted *byte, pcbDecrypted *uint32, ppXchgCert *PCCERT_CONTEXT) bool + +func CryptEncodeObject(dwCertEncodingType DWORD, lpszStructType /*const*/ LPCSTR, pvStructInfo /*const*/ uintptr, pbEncoded *byte, pcbEncoded *uint32) bool { + ret1 := syscall6(cryptEncodeObject, 5, + uintptr(dwCertEncodingType), + uintptr(unsafe.Pointer(lpszStructType)), + pvStructInfo, + uintptr(unsafe.Pointer(pbEncoded)), + uintptr(unsafe.Pointer(pcbEncoded)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCRYPT_ENCODE_PARA +// func CryptEncodeObjectEx(dwCertEncodingType DWORD, lpszStructType /*const*/ LPCSTR, pvStructInfo /*const*/ uintptr, dwFlags DWORD, pEncodePara PCRYPT_ENCODE_PARA, pvEncoded uintptr, pcbEncoded *uint32) bool + +// TODO: Unknown type(s): PCRYPT_ENCRYPT_MESSAGE_PARA +// func CryptEncryptMessage(pEncryptPara PCRYPT_ENCRYPT_MESSAGE_PARA, cRecipientCert DWORD, rgpRecipientCert *PCCERT_CONTEXT, pbToBeEncrypted /*const*/ *byte, cbToBeEncrypted DWORD, pbEncryptedBlob *byte, pcbEncryptedBlob *uint32) bool + +// TODO: Unknown type(s): PFN_CRYPT_ENUM_KEYID_PROP +// func CryptEnumKeyIdentifierProperties(pKeyIdentifier /*const*/ *CRYPT_HASH_BLOB, dwPropId DWORD, dwFlags DWORD, pwszComputerName string, pvReserved uintptr, pvArg uintptr, pfnEnum PFN_CRYPT_ENUM_KEYID_PROP) bool + +// TODO: Unknown type(s): PFN_CRYPT_ENUM_OID_FUNC +// func CryptEnumOIDFunction(dwEncodingType DWORD, pszFuncName /*const*/ LPCSTR, pszOID /*const*/ LPCSTR, dwFlags DWORD, pvArg uintptr, pfnEnumOIDFunc PFN_CRYPT_ENUM_OID_FUNC) bool + +// TODO: Unknown type(s): PFN_CRYPT_ENUM_OID_INFO +// func CryptEnumOIDInfo(dwGroupId DWORD, dwFlags DWORD, pvArg uintptr, pfnEnumOIDInfo PFN_CRYPT_ENUM_OID_INFO) bool + +func CryptExportPKCS8(hCryptProv HCRYPTPROV, dwKeySpec DWORD, pszPrivateKeyObjId LPSTR, dwFlags DWORD, pvAuxInfo uintptr, pbPrivateKeyBlob *byte, pcbPrivateKeyBlob *uint32) bool { + ret1 := syscall9(cryptExportPKCS8, 7, + uintptr(hCryptProv), + uintptr(dwKeySpec), + uintptr(unsafe.Pointer(pszPrivateKeyObjId)), + uintptr(dwFlags), + pvAuxInfo, + uintptr(unsafe.Pointer(pbPrivateKeyBlob)), + uintptr(unsafe.Pointer(pcbPrivateKeyBlob)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, PCERT_PUBLIC_KEY_INFO +// func CryptExportPublicKeyInfo(hCryptProvOrNCryptKey HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec DWORD, dwCertEncodingType DWORD, pInfo PCERT_PUBLIC_KEY_INFO, pcbInfo *uint32) bool + +// TODO: Unknown type(s): HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, PCERT_PUBLIC_KEY_INFO +// func CryptExportPublicKeyInfoEx(hCryptProvOrNCryptKey HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec DWORD, dwCertEncodingType DWORD, pszPublicKeyObjId LPSTR, dwFlags DWORD, pvAuxInfo uintptr, pInfo PCERT_PUBLIC_KEY_INFO, pcbInfo *uint32) bool + +func CryptFindCertificateKeyProvInfo(pCert /*const*/ PCCERT_CONTEXT, dwFlags DWORD, pvReserved uintptr) bool { + ret1 := syscall3(cryptFindCertificateKeyProvInfo, 3, + uintptr(unsafe.Pointer(pCert)), + uintptr(dwFlags), + pvReserved) + return ret1 != 0 +} + +func CryptFindLocalizedName(pwszCryptName string) string { + pwszCryptNameStr := unicode16FromString(pwszCryptName) + ret1 := syscall3(cryptFindLocalizedName, 1, + uintptr(unsafe.Pointer(&pwszCryptNameStr[0])), + 0, + 0) + return stringFromUnicode16((*uint16)(unsafe.Pointer(ret1))) +} + +// TODO: Unknown type(s): PCCRYPT_OID_INFO +// func CryptFindOIDInfo(dwKeyType DWORD, pvKey uintptr, dwGroupId DWORD) PCCRYPT_OID_INFO + +func CryptFormatObject(dwCertEncodingType DWORD, dwFormatType DWORD, dwFormatStrType DWORD, pFormatStruct uintptr, lpszStructType /*const*/ LPCSTR, pbEncoded /*const*/ *byte, cbEncoded DWORD, pbFormat uintptr, pcbFormat *uint32) bool { + ret1 := syscall9(cryptFormatObject, 9, + uintptr(dwCertEncodingType), + uintptr(dwFormatType), + uintptr(dwFormatStrType), + pFormatStruct, + uintptr(unsafe.Pointer(lpszStructType)), + uintptr(unsafe.Pointer(pbEncoded)), + uintptr(cbEncoded), + pbFormat, + uintptr(unsafe.Pointer(pcbFormat))) + return ret1 != 0 +} + +// TODO: Unknown type(s): HCRYPTOIDFUNCADDR +// func CryptFreeOIDFunctionAddress(hFuncAddr HCRYPTOIDFUNCADDR, dwFlags DWORD) bool + +// TODO: Unknown type(s): HCRYPTASYNC, PFN_CRYPT_ASYNC_PARAM_FREE_FUNC * +// func CryptGetAsyncParam(hAsync HCRYPTASYNC, pszParamOid LPSTR, ppvParam *LPVOID, ppfnFree PFN_CRYPT_ASYNC_PARAM_FREE_FUNC *) bool + +// TODO: Unknown type(s): HCRYPTOIDFUNCSET +// func CryptGetDefaultOIDDllList(hFuncSet HCRYPTOIDFUNCSET, dwEncodingType DWORD, pwszDllList *WCHAR, pcchDllList *uint32) bool + +// TODO: Unknown type(s): HCRYPTOIDFUNCADDR *, HCRYPTOIDFUNCSET +// func CryptGetDefaultOIDFunctionAddress(hFuncSet HCRYPTOIDFUNCSET, dwEncodingType DWORD, pwszDll string, dwFlags DWORD, ppvFuncAddr uintptr, phFuncAddr HCRYPTOIDFUNCADDR *) bool + +func CryptGetKeyIdentifierProperty(pKeyIdentifier /*const*/ *CRYPT_HASH_BLOB, dwPropId DWORD, dwFlags DWORD, pwszComputerName string, pvReserved uintptr, pvData uintptr, pcbData *uint32) bool { + pwszComputerNameStr := unicode16FromString(pwszComputerName) + ret1 := syscall9(cryptGetKeyIdentifierProperty, 7, + uintptr(unsafe.Pointer(pKeyIdentifier)), + uintptr(dwPropId), + uintptr(dwFlags), + uintptr(unsafe.Pointer(&pwszComputerNameStr[0])), + pvReserved, + pvData, + uintptr(unsafe.Pointer(pcbData)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): HCRYPTPROV_LEGACY +// func CryptGetMessageCertificates(dwMsgAndCertEncodingType DWORD, hCryptProv HCRYPTPROV_LEGACY, dwFlags DWORD, pbSignedBlob /*const*/ *byte, cbSignedBlob DWORD) HCERTSTORE + +func CryptGetMessageSignerCount(dwMsgEncodingType DWORD, pbSignedBlob /*const*/ *byte, cbSignedBlob DWORD) LONG { + ret1 := syscall3(cryptGetMessageSignerCount, 3, + uintptr(dwMsgEncodingType), + uintptr(unsafe.Pointer(pbSignedBlob)), + uintptr(cbSignedBlob)) + return LONG(ret1) +} + +// TODO: Unknown type(s): HCRYPTOIDFUNCADDR *, HCRYPTOIDFUNCSET +// func CryptGetOIDFunctionAddress(hFuncSet HCRYPTOIDFUNCSET, dwEncodingType DWORD, pszOID /*const*/ LPCSTR, dwFlags DWORD, ppvFuncAddr uintptr, phFuncAddr HCRYPTOIDFUNCADDR *) bool + +func CryptGetOIDFunctionValue(dwEncodingType DWORD, pszFuncName /*const*/ LPCSTR, pszOID /*const*/ LPCSTR, pwszValueName string, pdwValueType *uint32, pbValueData *byte, pcbValueData *uint32) bool { + pwszValueNameStr := unicode16FromString(pwszValueName) + ret1 := syscall9(cryptGetOIDFunctionValue, 7, + uintptr(dwEncodingType), + uintptr(unsafe.Pointer(pszFuncName)), + uintptr(unsafe.Pointer(pszOID)), + uintptr(unsafe.Pointer(&pwszValueNameStr[0])), + uintptr(unsafe.Pointer(pdwValueType)), + uintptr(unsafe.Pointer(pbValueData)), + uintptr(unsafe.Pointer(pcbValueData)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): HCRYPTPROV_LEGACY +// func CryptHashCertificate(hCryptProv HCRYPTPROV_LEGACY, algid ALG_ID, dwFlags DWORD, pbEncoded /*const*/ *byte, cbEncoded DWORD, pbComputedHash *byte, pcbComputedHash *uint32) bool + +// TODO: Unknown type(s): PCRYPT_HASH_MESSAGE_PARA +// func CryptHashMessage(pHashPara PCRYPT_HASH_MESSAGE_PARA, fDetachedHash bool, cToBeHashed DWORD, rgpbToBeHashed /*const*/ **BYTE, rgcbToBeHashed *uint32, pbHashedBlob *byte, pcbHashedBlob *uint32, pbComputedHash *byte, pcbComputedHash *uint32) bool + +// TODO: Unknown type(s): HCRYPTPROV_LEGACY, PCERT_PUBLIC_KEY_INFO +// func CryptHashPublicKeyInfo(hCryptProv HCRYPTPROV_LEGACY, algid ALG_ID, dwFlags DWORD, dwCertEncodingType DWORD, pInfo PCERT_PUBLIC_KEY_INFO, pbComputedHash *byte, pcbComputedHash *uint32) bool + +// TODO: Unknown type(s): HCRYPTPROV_LEGACY +// func CryptHashToBeSigned(hCryptProv HCRYPTPROV_LEGACY, dwCertEncodingType DWORD, pbEncoded /*const*/ *byte, cbEncoded DWORD, pbComputedHash *byte, pcbComputedHash *uint32) bool + +// TODO: Unknown type(s): CRYPT_PKCS8_IMPORT_PARAMS +// func CryptImportPKCS8(sPrivateKeyAndParams CRYPT_PKCS8_IMPORT_PARAMS, dwFlags DWORD, phCryptProv *HCRYPTPROV, pvAuxInfo uintptr) bool + +// TODO: Unknown type(s): PCERT_PUBLIC_KEY_INFO +// func CryptImportPublicKeyInfo(hCryptProv HCRYPTPROV, dwCertEncodingType DWORD, pInfo PCERT_PUBLIC_KEY_INFO, phKey *HCRYPTKEY) bool + +// TODO: Unknown type(s): PCERT_PUBLIC_KEY_INFO +// func CryptImportPublicKeyInfoEx(hCryptProv HCRYPTPROV, dwCertEncodingType DWORD, pInfo PCERT_PUBLIC_KEY_INFO, aiKeyAlg ALG_ID, dwFlags DWORD, pvAuxInfo uintptr, phKey *HCRYPTKEY) bool + +// TODO: Unknown type(s): HCRYPTOIDFUNCSET +// func CryptInitOIDFunctionSet(pszFuncName /*const*/ LPCSTR, dwFlags DWORD) HCRYPTOIDFUNCSET + +// TODO: Unknown type(s): HCRYPTDEFAULTCONTEXT * +// func CryptInstallDefaultContext(hCryptProv HCRYPTPROV, dwDefaultType DWORD, pvDefaultPara /*const*/ uintptr, dwFlags DWORD, pvReserved uintptr, phDefaultContext HCRYPTDEFAULTCONTEXT *) bool + +// TODO: Unknown type(s): const CRYPT_OID_FUNC_ENTRY* +// func CryptInstallOIDFunctionAddress(hModule HMODULE, dwEncodingType DWORD, pszFuncName /*const*/ LPCSTR, cFuncEntry DWORD, rgFuncEntry /*const*/ const CRYPT_OID_FUNC_ENTRY*, dwFlags DWORD) bool + +func CryptMemAlloc(cbSize ULONG) LPVOID { + ret1 := syscall3(cryptMemAlloc, 1, + uintptr(cbSize), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func CryptMemFree(pv LPVOID) { + syscall3(cryptMemFree, 1, + uintptr(unsafe.Pointer(pv)), + 0, + 0) +} + +func CryptMemRealloc(pv LPVOID, cbSize ULONG) LPVOID { + ret1 := syscall3(cryptMemRealloc, 2, + uintptr(unsafe.Pointer(pv)), + uintptr(cbSize), + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func CryptMsgCalculateEncodedLength(dwMsgEncodingType DWORD, dwFlags DWORD, dwMsgType DWORD, pvMsgEncodeInfo /*const*/ uintptr, pszInnerContentObjID LPSTR, cbData DWORD) DWORD { + ret1 := syscall6(cryptMsgCalculateEncodedLength, 6, + uintptr(dwMsgEncodingType), + uintptr(dwFlags), + uintptr(dwMsgType), + pvMsgEncodeInfo, + uintptr(unsafe.Pointer(pszInnerContentObjID)), + uintptr(cbData)) + return DWORD(ret1) +} + +func CryptMsgClose(hCryptMsg HCRYPTMSG) bool { + ret1 := syscall3(cryptMsgClose, 1, + uintptr(unsafe.Pointer(hCryptMsg)), + 0, + 0) + return ret1 != 0 +} + +func CryptMsgControl(hCryptMsg HCRYPTMSG, dwFlags DWORD, dwCtrlType DWORD, pvCtrlPara /*const*/ uintptr) bool { + ret1 := syscall6(cryptMsgControl, 4, + uintptr(unsafe.Pointer(hCryptMsg)), + uintptr(dwFlags), + uintptr(dwCtrlType), + pvCtrlPara, + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCMSG_SIGNER_ENCODE_INFO +// func CryptMsgCountersign(hCryptMsg HCRYPTMSG, dwIndex DWORD, cCountersigners DWORD, rgCountersigners PCMSG_SIGNER_ENCODE_INFO) bool + +// TODO: Unknown type(s): PCMSG_SIGNER_ENCODE_INFO +// func CryptMsgCountersignEncoded(dwEncodingType DWORD, pbSignerInfo *byte, cbSignerInfo DWORD, cCountersigners DWORD, rgCountersigners PCMSG_SIGNER_ENCODE_INFO, pbCountersignature *byte, pcbCountersignature *DWORD) bool + +func CryptMsgDuplicate(hCryptMsg HCRYPTMSG) HCRYPTMSG { + ret1 := syscall3(cryptMsgDuplicate, 1, + uintptr(unsafe.Pointer(hCryptMsg)), + 0, + 0) + return (HCRYPTMSG)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): PCMSG_SIGNED_ENCODE_INFO +// func CryptMsgEncodeAndSignCTL(dwMsgEncodingType DWORD, pCtlInfo PCTL_INFO, pSignInfo PCMSG_SIGNED_ENCODE_INFO, dwFlags DWORD, pbEncoded *byte, pcbEncoded *uint32) bool + +func CryptMsgGetAndVerifySigner(hCryptMsg HCRYPTMSG, cSignerStore DWORD, rghSignerStore *HCERTSTORE, dwFlags DWORD, ppSigner *PCCERT_CONTEXT, pdwSignerIndex *uint32) bool { + ret1 := syscall6(cryptMsgGetAndVerifySigner, 6, + uintptr(unsafe.Pointer(hCryptMsg)), + uintptr(cSignerStore), + uintptr(unsafe.Pointer(rghSignerStore)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(ppSigner)), + uintptr(unsafe.Pointer(pdwSignerIndex))) + return ret1 != 0 +} + +func CryptMsgGetParam(hCryptMsg HCRYPTMSG, dwParamType DWORD, dwIndex DWORD, pvData uintptr, pcbData *uint32) bool { + ret1 := syscall6(cryptMsgGetParam, 5, + uintptr(unsafe.Pointer(hCryptMsg)), + uintptr(dwParamType), + uintptr(dwIndex), + pvData, + uintptr(unsafe.Pointer(pcbData)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): HCRYPTPROV_LEGACY, PCMSG_STREAM_INFO +// func CryptMsgOpenToDecode(dwMsgEncodingType DWORD, dwFlags DWORD, dwMsgType DWORD, hCryptProv HCRYPTPROV_LEGACY, pRecipientInfo PCERT_INFO, pStreamInfo PCMSG_STREAM_INFO) HCRYPTMSG + +// TODO: Unknown type(s): PCMSG_STREAM_INFO +// func CryptMsgOpenToEncode(dwMsgEncodingType DWORD, dwFlags DWORD, dwMsgType DWORD, pvMsgEncodeInfo /*const*/ uintptr, pszInnerContentObjID LPSTR, pStreamInfo PCMSG_STREAM_INFO) HCRYPTMSG + +// TODO: Unknown type(s): PCMSG_SIGNED_ENCODE_INFO +// func CryptMsgSignCTL(dwMsgEncodingType DWORD, pbCtlContent *byte, cbCtlContent DWORD, pSignInfo PCMSG_SIGNED_ENCODE_INFO, dwFlags DWORD, pbEncoded *byte, pcbEncoded *uint32) bool + +func CryptMsgUpdate(hCryptMsg HCRYPTMSG, pbData /*const*/ *byte, cbData DWORD, fFinal bool) bool { + ret1 := syscall6(cryptMsgUpdate, 4, + uintptr(unsafe.Pointer(hCryptMsg)), + uintptr(unsafe.Pointer(pbData)), + uintptr(cbData), + getUintptrFromBool(fFinal), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): HCRYPTPROV_LEGACY +// func CryptMsgVerifyCountersignatureEncoded(hCryptProv HCRYPTPROV_LEGACY, dwEncodingType DWORD, pbSignerInfo *byte, cbSignerInfo DWORD, pbSignerInfoCountersignature *byte, cbSignerInfoCountersignature DWORD, pciCountersigner PCERT_INFO) bool + +// TODO: Unknown type(s): HCRYPTPROV_LEGACY +// func CryptMsgVerifyCountersignatureEncodedEx(hCryptProv HCRYPTPROV_LEGACY, dwEncodingType DWORD, pbSignerInfo *byte, cbSignerInfo DWORD, pbSignerInfoCountersignature *byte, cbSignerInfoCountersignature DWORD, dwSignerType DWORD, pvSigner uintptr, dwFlags DWORD, pvExtra uintptr) bool + +// TODO: Unknown type(s): CRYPTPROTECT_PROMPTSTRUCT * +// func CryptProtectData(pDataIn *DATA_BLOB, szDataDescr string, pOptionalEntropy *DATA_BLOB, pvReserved uintptr, pPromptStruct CRYPTPROTECT_PROMPTSTRUCT *, dwFlags DWORD, pDataOut *DATA_BLOB) bool + +func CryptProtectMemory(pDataIn LPVOID, cbDataIn DWORD, dwFlags DWORD) bool { + ret1 := syscall3(cryptProtectMemory, 3, + uintptr(unsafe.Pointer(pDataIn)), + uintptr(cbDataIn), + uintptr(dwFlags)) + return ret1 != 0 +} + +func CryptQueryObject(dwObjectType DWORD, pvObject /*const*/ uintptr, dwExpectedContentTypeFlags DWORD, dwExpectedFormatTypeFlags DWORD, dwFlags DWORD, pdwMsgAndCertEncodingType *uint32, pdwContentType *uint32, pdwFormatType *uint32, phCertStore *HCERTSTORE, phMsg *HCRYPTMSG, ppvContext /*const*/ uintptr) bool { + ret1 := syscall12(cryptQueryObject, 11, + uintptr(dwObjectType), + pvObject, + uintptr(dwExpectedContentTypeFlags), + uintptr(dwExpectedFormatTypeFlags), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pdwMsgAndCertEncodingType)), + uintptr(unsafe.Pointer(pdwContentType)), + uintptr(unsafe.Pointer(pdwFormatType)), + uintptr(unsafe.Pointer(phCertStore)), + uintptr(unsafe.Pointer(phMsg)), + ppvContext, + 0) + return ret1 != 0 +} + +func CryptRegisterDefaultOIDFunction(dwEncodingType DWORD, pszFuncName /*const*/ LPCSTR, dwIndex DWORD, pwszDll string) bool { + pwszDllStr := unicode16FromString(pwszDll) + ret1 := syscall6(cryptRegisterDefaultOIDFunction, 4, + uintptr(dwEncodingType), + uintptr(unsafe.Pointer(pszFuncName)), + uintptr(dwIndex), + uintptr(unsafe.Pointer(&pwszDllStr[0])), + 0, + 0) + return ret1 != 0 +} + +func CryptRegisterOIDFunction(dwEncodingType DWORD, pszFuncName /*const*/ LPCSTR, pszOID /*const*/ LPCSTR, pwszDll string, pszOverrideFuncName /*const*/ LPCSTR) bool { + pwszDllStr := unicode16FromString(pwszDll) + ret1 := syscall6(cryptRegisterOIDFunction, 5, + uintptr(dwEncodingType), + uintptr(unsafe.Pointer(pszFuncName)), + uintptr(unsafe.Pointer(pszOID)), + uintptr(unsafe.Pointer(&pwszDllStr[0])), + uintptr(unsafe.Pointer(pszOverrideFuncName)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCCRYPT_OID_INFO +// func CryptRegisterOIDInfo(pInfo PCCRYPT_OID_INFO, dwFlags DWORD) bool + +// TODO: Unknown type(s): SIP_ADD_NEWPROVIDER * +// func CryptSIPAddProvider(psNewProv SIP_ADD_NEWPROVIDER *) bool + +// TODO: Unknown type(s): SIP_INDIRECT_DATA *, SIP_SUBJECTINFO * +// func CryptSIPCreateIndirectData(pSubjectInfo SIP_SUBJECTINFO *, pcbIndirectData *uint32, pIndirectData SIP_INDIRECT_DATA *) bool + +// TODO: Unknown type(s): SIP_SUBJECTINFO * +// func CryptSIPGetSignedDataMsg(pSubjectInfo SIP_SUBJECTINFO *, pdwEncodingType *uint32, dwIndex DWORD, pcbSignedDataMsg *uint32, pbSignedDataMsg *byte) bool + +// TODO: Unknown type(s): SIP_DISPATCH_INFO * +// func CryptSIPLoad(pgSubject /*const*/ *GUID, dwFlags DWORD, pSipDispatch SIP_DISPATCH_INFO *) bool + +// TODO: Unknown type(s): SIP_SUBJECTINFO * +// func CryptSIPPutSignedDataMsg(pSubjectInfo SIP_SUBJECTINFO *, dwEncodingType DWORD, pdwIndex *uint32, cbSignedDataMsg DWORD, pbSignedDataMsg *byte) bool + +func CryptSIPRemoveProvider(pgProv *GUID) bool { + ret1 := syscall3(cryptSIPRemoveProvider, 1, + uintptr(unsafe.Pointer(pgProv)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): SIP_SUBJECTINFO * +// func CryptSIPRemoveSignedDataMsg(pSubjectInfo SIP_SUBJECTINFO *, dwIndex DWORD) bool + +func CryptSIPRetrieveSubjectGuid(fileName string, hFileIn HANDLE, pgSubject *GUID) bool { + fileNameStr := unicode16FromString(fileName) + ret1 := syscall3(cryptSIPRetrieveSubjectGuid, 3, + uintptr(unsafe.Pointer(&fileNameStr[0])), + uintptr(hFileIn), + uintptr(unsafe.Pointer(pgSubject))) + return ret1 != 0 +} + +func CryptSIPRetrieveSubjectGuidForCatalogFile(fileName string, hFileIn HANDLE, pgSubject *GUID) bool { + fileNameStr := unicode16FromString(fileName) + ret1 := syscall3(cryptSIPRetrieveSubjectGuidForCatalogFile, 3, + uintptr(unsafe.Pointer(&fileNameStr[0])), + uintptr(hFileIn), + uintptr(unsafe.Pointer(pgSubject))) + return ret1 != 0 +} + +// TODO: Unknown type(s): SIP_INDIRECT_DATA *, SIP_SUBJECTINFO * +// func CryptSIPVerifyIndirectData(pSubjectInfo SIP_SUBJECTINFO *, pIndirectData SIP_INDIRECT_DATA *) bool + +// TODO: Unknown type(s): HCRYPTASYNC, PFN_CRYPT_ASYNC_PARAM_FREE_FUNC +// func CryptSetAsyncParam(hAsync HCRYPTASYNC, pszParamOid LPSTR, pvParam LPVOID, pfnFree PFN_CRYPT_ASYNC_PARAM_FREE_FUNC) bool + +func CryptSetKeyIdentifierProperty(pKeyIdentifier /*const*/ *CRYPT_HASH_BLOB, dwPropId DWORD, dwFlags DWORD, pwszComputerName string, pvReserved uintptr, pvData /*const*/ uintptr) bool { + pwszComputerNameStr := unicode16FromString(pwszComputerName) + ret1 := syscall6(cryptSetKeyIdentifierProperty, 6, + uintptr(unsafe.Pointer(pKeyIdentifier)), + uintptr(dwPropId), + uintptr(dwFlags), + uintptr(unsafe.Pointer(&pwszComputerNameStr[0])), + pvReserved, + pvData) + return ret1 != 0 +} + +func CryptSetOIDFunctionValue(dwEncodingType DWORD, pszFuncName /*const*/ LPCSTR, pszOID /*const*/ LPCSTR, pwszValueName string, dwValueType DWORD, pbValueData /*const*/ *byte, cbValueData DWORD) bool { + pwszValueNameStr := unicode16FromString(pwszValueName) + ret1 := syscall9(cryptSetOIDFunctionValue, 7, + uintptr(dwEncodingType), + uintptr(unsafe.Pointer(pszFuncName)), + uintptr(unsafe.Pointer(pszOID)), + uintptr(unsafe.Pointer(&pwszValueNameStr[0])), + uintptr(dwValueType), + uintptr(unsafe.Pointer(pbValueData)), + uintptr(cbValueData), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, PCRYPT_ALGORITHM_IDENTIFIER +// func CryptSignAndEncodeCertificate(hCryptProvOrNCryptKey HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec DWORD, dwCertEncodingType DWORD, lpszStructType /*const*/ LPCSTR, pvStructInfo /*const*/ uintptr, pSignatureAlgorithm PCRYPT_ALGORITHM_IDENTIFIER, pvHashAuxInfo /*const*/ uintptr, pbEncoded *byte, pcbEncoded *uint32) bool + +// TODO: Unknown type(s): PCRYPT_ENCRYPT_MESSAGE_PARA, PCRYPT_SIGN_MESSAGE_PARA +// func CryptSignAndEncryptMessage(pSignPara PCRYPT_SIGN_MESSAGE_PARA, pEncryptPara PCRYPT_ENCRYPT_MESSAGE_PARA, cRecipientCert DWORD, rgpRecipientCert *PCCERT_CONTEXT, pbToBeSignedAndEncrypted /*const*/ *byte, cbToBeSignedAndEncrypted DWORD, pbSignedAndEncryptedBlob *byte, pcbSignedAndEncryptedBlob *uint32) bool + +// TODO: Unknown type(s): HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, PCRYPT_ALGORITHM_IDENTIFIER +// func CryptSignCertificate(hCryptProvOrNCryptKey HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec DWORD, dwCertEncodingType DWORD, pbEncodedToBeSigned /*const*/ *byte, cbEncodedToBeSigned DWORD, pSignatureAlgorithm PCRYPT_ALGORITHM_IDENTIFIER, pvHashAuxInfo /*const*/ uintptr, pbSignature *byte, pcbSignature *uint32) bool + +// TODO: Unknown type(s): PCRYPT_SIGN_MESSAGE_PARA +// func CryptSignMessage(pSignPara PCRYPT_SIGN_MESSAGE_PARA, fDetachedSignature bool, cToBeSigned DWORD, rgpbToBeSigned /*const*/ **BYTE, rgcbToBeSigned *uint32, pbSignedBlob *byte, pcbSignedBlob *uint32) bool + +// TODO: Unknown type(s): PCRYPT_KEY_SIGN_MESSAGE_PARA +// func CryptSignMessageWithKey(pSignPara PCRYPT_KEY_SIGN_MESSAGE_PARA, pbToBeSigned /*const*/ *byte, cbToBeSigned DWORD, pbSignedBlob *byte, pcbSignedBlob *uint32) bool + +func CryptStringToBinary(pszString string, cchString DWORD, dwFlags DWORD, pbBinary *byte, pcbBinary *uint32, pdwSkip *uint32, pdwFlags *uint32) bool { + pszStringStr := unicode16FromString(pszString) + ret1 := syscall9(cryptStringToBinary, 7, + uintptr(unsafe.Pointer(&pszStringStr[0])), + uintptr(cchString), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbBinary)), + uintptr(unsafe.Pointer(pcbBinary)), + uintptr(unsafe.Pointer(pdwSkip)), + uintptr(unsafe.Pointer(pdwFlags)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): HCRYPTDEFAULTCONTEXT +// func CryptUninstallDefaultContext(hDefaultContext HCRYPTDEFAULTCONTEXT, dwFlags DWORD, pvReserved uintptr) bool + +// TODO: Unknown type(s): CRYPTPROTECT_PROMPTSTRUCT * +// func CryptUnprotectData(pDataIn *DATA_BLOB, ppszDataDescr *LPWSTR, pOptionalEntropy *DATA_BLOB, pvReserved uintptr, pPromptStruct CRYPTPROTECT_PROMPTSTRUCT *, dwFlags DWORD, pDataOut *DATA_BLOB) bool + +func CryptUnprotectMemory(pDataIn LPVOID, cbDataIn DWORD, dwFlags DWORD) bool { + ret1 := syscall3(cryptUnprotectMemory, 3, + uintptr(unsafe.Pointer(pDataIn)), + uintptr(cbDataIn), + uintptr(dwFlags)) + return ret1 != 0 +} + +func CryptUnregisterDefaultOIDFunction(dwEncodingType DWORD, pszFuncName /*const*/ LPCSTR, pwszDll string) bool { + pwszDllStr := unicode16FromString(pwszDll) + ret1 := syscall3(cryptUnregisterDefaultOIDFunction, 3, + uintptr(dwEncodingType), + uintptr(unsafe.Pointer(pszFuncName)), + uintptr(unsafe.Pointer(&pwszDllStr[0]))) + return ret1 != 0 +} + +func CryptUnregisterOIDFunction(dwEncodingType DWORD, pszFuncName /*const*/ LPCSTR, pszOID /*const*/ LPCSTR) bool { + ret1 := syscall3(cryptUnregisterOIDFunction, 3, + uintptr(dwEncodingType), + uintptr(unsafe.Pointer(pszFuncName)), + uintptr(unsafe.Pointer(pszOID))) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCCRYPT_OID_INFO +// func CryptUnregisterOIDInfo(pInfo PCCRYPT_OID_INFO) bool + +// TODO: Unknown type(s): HCRYPTPROV_LEGACY, PCERT_PUBLIC_KEY_INFO +// func CryptVerifyCertificateSignature(hCryptProv HCRYPTPROV_LEGACY, dwCertEncodingType DWORD, pbEncoded /*const*/ *byte, cbEncoded DWORD, pPublicKey PCERT_PUBLIC_KEY_INFO) bool + +// TODO: Unknown type(s): HCRYPTPROV_LEGACY +// func CryptVerifyCertificateSignatureEx(hCryptProv HCRYPTPROV_LEGACY, dwCertEncodingType DWORD, dwSubjectType DWORD, pvSubject uintptr, dwIssuerType DWORD, pvIssuer uintptr, dwFlags DWORD, pvExtra uintptr) bool + +// TODO: Unknown type(s): PCRYPT_HASH_MESSAGE_PARA +// func CryptVerifyDetachedMessageHash(pHashPara PCRYPT_HASH_MESSAGE_PARA, pbDetachedHashBlob *byte, cbDetachedHashBlob DWORD, cToBeHashed DWORD, rgpbToBeHashed /*const*/ **BYTE, rgcbToBeHashed *uint32, pbComputedHash *byte, pcbComputedHash *uint32) bool + +// TODO: Unknown type(s): PCRYPT_VERIFY_MESSAGE_PARA +// func CryptVerifyDetachedMessageSignature(pVerifyPara PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex DWORD, pbDetachedSignBlob /*const*/ *byte, cbDetachedSignBlob DWORD, cToBeSigned DWORD, rgpbToBeSigned /*const*/ **BYTE, rgcbToBeSigned *uint32, ppSignerCert *PCCERT_CONTEXT) bool + +// TODO: Unknown type(s): PCRYPT_HASH_MESSAGE_PARA +// func CryptVerifyMessageHash(pHashPara PCRYPT_HASH_MESSAGE_PARA, pbHashedBlob *byte, cbHashedBlob DWORD, pbToBeHashed *byte, pcbToBeHashed *uint32, pbComputedHash *byte, pcbComputedHash *uint32) bool + +// TODO: Unknown type(s): PCRYPT_VERIFY_MESSAGE_PARA +// func CryptVerifyMessageSignature(pVerifyPara PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex DWORD, pbSignedBlob /*const*/ *byte, cbSignedBlob DWORD, pbDecoded *byte, pcbDecoded *uint32, ppSignerCert *PCCERT_CONTEXT) bool + +// TODO: Unknown type(s): PCERT_PUBLIC_KEY_INFO, PCRYPT_KEY_VERIFY_MESSAGE_PARA +// func CryptVerifyMessageSignatureWithKey(pVerifyPara PCRYPT_KEY_VERIFY_MESSAGE_PARA, pPublicKeyInfo PCERT_PUBLIC_KEY_INFO, pbSignedBlob /*const*/ *byte, cbSignedBlob DWORD, pbDecoded *byte, pcbDecoded *uint32) bool + +// TODO: Unknown type(s): ASN1decoding_t, HCRYPTASN1MODULE +// func I_CryptGetAsn1Decoder(hAsn1Module HCRYPTASN1MODULE) ASN1decoding_t + +// TODO: Unknown type(s): ASN1encoding_t, HCRYPTASN1MODULE +// func I_CryptGetAsn1Encoder(hAsn1Module HCRYPTASN1MODULE) ASN1encoding_t + +// TODO: Unknown type(s): ASN1module_t, HCRYPTASN1MODULE +// func I_CryptInstallAsn1Module(pMod ASN1module_t, dwFlags DWORD, pvReserved uintptr) HCRYPTASN1MODULE + +// TODO: Unknown type(s): HCRYPTASN1MODULE +// func I_CryptUninstallAsn1Module(hAsn1Module HCRYPTASN1MODULE) bool + +func PFXExportCertStore(hStore HCERTSTORE, pPFX *CRYPT_DATA_BLOB, szPassword string, dwFlags DWORD) bool { + szPasswordStr := unicode16FromString(szPassword) + ret1 := syscall6(pFXExportCertStore, 4, + uintptr(hStore), + uintptr(unsafe.Pointer(pPFX)), + uintptr(unsafe.Pointer(&szPasswordStr[0])), + uintptr(dwFlags), + 0, + 0) + return ret1 != 0 +} + +func PFXExportCertStoreEx(hStore HCERTSTORE, pPFX *CRYPT_DATA_BLOB, szPassword string, pvPara uintptr, dwFlags DWORD) bool { + szPasswordStr := unicode16FromString(szPassword) + ret1 := syscall6(pFXExportCertStoreEx, 5, + uintptr(hStore), + uintptr(unsafe.Pointer(pPFX)), + uintptr(unsafe.Pointer(&szPasswordStr[0])), + pvPara, + uintptr(dwFlags), + 0) + return ret1 != 0 +} + +func PFXImportCertStore(pPFX *CRYPT_DATA_BLOB, szPassword string, dwFlags DWORD) HCERTSTORE { + szPasswordStr := unicode16FromString(szPassword) + ret1 := syscall3(pFXImportCertStore, 3, + uintptr(unsafe.Pointer(pPFX)), + uintptr(unsafe.Pointer(&szPasswordStr[0])), + uintptr(dwFlags)) + return HCERTSTORE(ret1) +} + +func PFXIsPFXBlob(pPFX *CRYPT_DATA_BLOB) bool { + ret1 := syscall3(pFXIsPFXBlob, 1, + uintptr(unsafe.Pointer(pPFX)), + 0, + 0) + return ret1 != 0 +} + +func PFXVerifyPassword(pPFX *CRYPT_DATA_BLOB, szPassword string, dwFlags DWORD) bool { + szPasswordStr := unicode16FromString(szPassword) + ret1 := syscall3(pFXVerifyPassword, 3, + uintptr(unsafe.Pointer(pPFX)), + uintptr(unsafe.Pointer(&szPasswordStr[0])), + uintptr(dwFlags)) + return ret1 != 0 +} + +func I_CertUpdateStore(store1 HCERTSTORE, store2 HCERTSTORE, unk0 DWORD, unk1 DWORD) bool { + ret1 := syscall6(i_CertUpdateStore, 4, + uintptr(store1), + uintptr(store2), + uintptr(unk0), + uintptr(unk1), + 0, + 0) + return ret1 != 0 +} + +func I_CryptAllocTls() DWORD { + ret1 := syscall3(i_CryptAllocTls, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): HLRUCACHE * +// func I_CryptCreateLruCache(unknown uintptr, out HLRUCACHE *) bool + +// TODO: Unknown type(s): HLRUCACHE +// func I_CryptCreateLruEntry(h HLRUCACHE, unk0 DWORD, unk1 DWORD) bool + +func I_CryptDetachTls(dwTlsIndex DWORD) LPVOID { + ret1 := syscall3(i_CryptDetachTls, 1, + uintptr(dwTlsIndex), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func I_CryptFindLruEntry(unk0 DWORD, unk1 DWORD) bool { + ret1 := syscall3(i_CryptFindLruEntry, 2, + uintptr(unk0), + uintptr(unk1), + 0) + return ret1 != 0 +} + +func I_CryptFindLruEntryData(unk0 DWORD, unk1 DWORD, unk2 DWORD) bool { + ret1 := syscall3(i_CryptFindLruEntryData, 3, + uintptr(unk0), + uintptr(unk1), + uintptr(unk2)) + return ret1 != 0 +} + +// TODO: Unknown type(s): HLRUCACHE +// func I_CryptFlushLruCache(h HLRUCACHE, unk0 DWORD, unk1 DWORD) DWORD + +// TODO: Unknown type(s): HLRUCACHE +// func I_CryptFreeLruCache(h HLRUCACHE, unk0 DWORD, unk1 DWORD) HLRUCACHE + +func I_CryptFreeTls(dwTlsIndex DWORD, unknown DWORD) bool { + ret1 := syscall3(i_CryptFreeTls, 2, + uintptr(dwTlsIndex), + uintptr(unknown), + 0) + return ret1 != 0 +} + +func I_CryptGetDefaultCryptProv(reserved DWORD) HCRYPTPROV { + ret1 := syscall3(i_CryptGetDefaultCryptProv, 1, + uintptr(reserved), + 0, + 0) + return HCRYPTPROV(ret1) +} + +func I_CryptGetOssGlobal(x DWORD) bool { + ret1 := syscall3(i_CryptGetOssGlobal, 1, + uintptr(x), + 0, + 0) + return ret1 != 0 +} + +func I_CryptGetTls(dwTlsIndex DWORD) LPVOID { + ret1 := syscall3(i_CryptGetTls, 1, + uintptr(dwTlsIndex), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func I_CryptInstallOssGlobal(x DWORD, y DWORD, z DWORD) DWORD { + ret1 := syscall3(i_CryptInstallOssGlobal, 3, + uintptr(x), + uintptr(y), + uintptr(z)) + return DWORD(ret1) +} + +func I_CryptReadTrustedPublisherDWORDValueFromRegistry(name string, value *uint32) bool { + nameStr := unicode16FromString(name) + ret1 := syscall3(i_CryptReadTrustedPublisherDWORDValueFromRegistry, 2, + uintptr(unsafe.Pointer(&nameStr[0])), + uintptr(unsafe.Pointer(value)), + 0) + return ret1 != 0 +} + +func I_CryptSetTls(dwTlsIndex DWORD, lpTlsValue LPVOID) bool { + ret1 := syscall3(i_CryptSetTls, 2, + uintptr(dwTlsIndex), + uintptr(unsafe.Pointer(lpTlsValue)), + 0) + return ret1 != 0 +} diff --git a/grdp/win/gdi32.go b/grdp/win/gdi32.go new file mode 100644 index 0000000..6ebb0bb --- /dev/null +++ b/grdp/win/gdi32.go @@ -0,0 +1,4498 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "syscall" + "unsafe" +) + +var ( + // Library + libgdi32 uintptr + + // Functions + abortDoc uintptr + abortPath uintptr + addFontMemResourceEx uintptr + addFontResourceEx uintptr + addFontResource uintptr + angleArc uintptr + animatePalette uintptr + arc uintptr + arcTo uintptr + bRUSHOBJ_hGetColorTransform uintptr + bRUSHOBJ_pvAllocRbrush uintptr + bRUSHOBJ_pvGetRbrush uintptr + bRUSHOBJ_ulGetBrushColor uintptr + beginPath uintptr + bitBlt uintptr + cLIPOBJ_bEnum uintptr + cLIPOBJ_cEnumStart uintptr + cancelDC uintptr + checkColorsInGamut uintptr + choosePixelFormat uintptr + chord uintptr + closeEnhMetaFile uintptr + closeFigure uintptr + closeMetaFile uintptr + colorCorrectPalette uintptr + colorMatchToTarget uintptr + combineRgn uintptr + combineTransform uintptr + copyEnhMetaFile uintptr + copyMetaFile uintptr + createBitmap uintptr + createBitmapIndirect uintptr + createBrushIndirect uintptr + createColorSpace uintptr + createCompatibleBitmap uintptr + createCompatibleDC uintptr + createDC uintptr + createDIBPatternBrush uintptr + createDIBPatternBrushPt uintptr + createDIBSection uintptr + createDIBitmap uintptr + createDiscardableBitmap uintptr + createEllipticRgn uintptr + createEllipticRgnIndirect uintptr + createEnhMetaFile uintptr + createFontIndirectEx uintptr + createFontIndirect uintptr + createFont uintptr + createHalftonePalette uintptr + createHatchBrush uintptr + createIC uintptr + createMetaFile uintptr + createPalette uintptr + createPatternBrush uintptr + createPen uintptr + createPenIndirect uintptr + createPolyPolygonRgn uintptr + createPolygonRgn uintptr + createRectRgn uintptr + createRectRgnIndirect uintptr + createRoundRectRgn uintptr + createScalableFontResource uintptr + createSolidBrush uintptr + dPtoLP uintptr + deleteColorSpace uintptr + deleteDC uintptr + deleteEnhMetaFile uintptr + deleteMetaFile uintptr + deleteObject uintptr + describePixelFormat uintptr + drawEscape uintptr + ellipse uintptr + endDoc uintptr + endPage uintptr + endPath uintptr + engAcquireSemaphore uintptr + engAlphaBlend uintptr + engAssociateSurface uintptr + engBitBlt uintptr + engCheckAbort uintptr + engCopyBits uintptr + engCreateBitmap uintptr + engCreateDeviceBitmap uintptr + engCreateDeviceSurface uintptr + engCreatePalette uintptr + engCreateSemaphore uintptr + engDeleteClip uintptr + engDeletePalette uintptr + engDeletePath uintptr + engDeleteSemaphore uintptr + engDeleteSurface uintptr + engEraseSurface uintptr + engFillPath uintptr + engFindResource uintptr + engFreeModule uintptr + engGetCurrentCodePage uintptr + engGetDriverName uintptr + engGetPrinterDataFileName uintptr + engGradientFill uintptr + engLineTo uintptr + engLoadModule uintptr + engMarkBandingSurface uintptr + engMultiByteToUnicodeN uintptr + engMultiByteToWideChar uintptr + engPaint uintptr + engPlgBlt uintptr + engQueryLocalTime uintptr + engReleaseSemaphore uintptr + engStretchBlt uintptr + engStretchBltROP uintptr + engStrokeAndFillPath uintptr + engStrokePath uintptr + engTextOut uintptr + engTransparentBlt uintptr + engUnicodeToMultiByteN uintptr + engUnlockSurface uintptr + engWideCharToMultiByte uintptr + enumEnhMetaFile uintptr + enumFontFamiliesEx uintptr + enumFontFamilies uintptr + enumFonts uintptr + enumICMProfiles uintptr + enumMetaFile uintptr + enumObjects uintptr + equalRgn uintptr + escape uintptr + excludeClipRect uintptr + extCreatePen uintptr + extCreateRegion uintptr + extEscape uintptr + extFloodFill uintptr + extSelectClipRgn uintptr + extTextOut uintptr + fONTOBJ_cGetAllGlyphHandles uintptr + fONTOBJ_cGetGlyphs uintptr + fONTOBJ_pQueryGlyphAttrs uintptr + fONTOBJ_pvTrueTypeFontFile uintptr + fONTOBJ_vGetInfo uintptr + fillPath uintptr + fillRgn uintptr + fixBrushOrgEx uintptr + flattenPath uintptr + floodFill uintptr + frameRgn uintptr + gdiAlphaBlend uintptr + gdiComment uintptr + gdiFlush uintptr + gdiGetBatchLimit uintptr + gdiGradientFill uintptr + gdiSetBatchLimit uintptr + gdiTransparentBlt uintptr + getArcDirection uintptr + getAspectRatioFilterEx uintptr + getBitmapBits uintptr + getBitmapDimensionEx uintptr + getBkColor uintptr + getBkMode uintptr + getBoundsRect uintptr + getBrushOrgEx uintptr + getCharABCWidthsFloat uintptr + getCharABCWidthsI uintptr + getCharABCWidths uintptr + getCharWidth32 uintptr + getCharWidthFloat uintptr + getCharWidthI uintptr + getCharWidth uintptr + getCharacterPlacement uintptr + getClipBox uintptr + getClipRgn uintptr + getColorAdjustment uintptr + getColorSpace uintptr + getCurrentObject uintptr + getCurrentPositionEx uintptr + getDCBrushColor uintptr + getDCOrgEx uintptr + getDCPenColor uintptr + getDIBColorTable uintptr + getDIBits uintptr + getDeviceCaps uintptr + getDeviceGammaRamp uintptr + getEnhMetaFileBits uintptr + getEnhMetaFileDescription uintptr + getEnhMetaFileHeader uintptr + getEnhMetaFilePaletteEntries uintptr + getEnhMetaFilePixelFormat uintptr + getEnhMetaFile uintptr + getFontData uintptr + getFontLanguageInfo uintptr + getFontUnicodeRanges uintptr + getGlyphIndices uintptr + getGlyphOutline uintptr + getGraphicsMode uintptr + getICMProfile uintptr + getKerningPairs uintptr + getLayout uintptr + getLogColorSpace uintptr + getMapMode uintptr + getMetaFileBitsEx uintptr + getMetaFile uintptr + getMetaRgn uintptr + getMiterLimit uintptr + getNearestColor uintptr + getNearestPaletteIndex uintptr + getObjectType uintptr + getObject uintptr + getOutlineTextMetrics uintptr + getPaletteEntries uintptr + getPath uintptr + getPixel uintptr + getPixelFormat uintptr + getPolyFillMode uintptr + getROP2 uintptr + getRandomRgn uintptr + getRasterizerCaps uintptr + getRegionData uintptr + getRgnBox uintptr + getStockObject uintptr + getStretchBltMode uintptr + getSystemPaletteEntries uintptr + getSystemPaletteUse uintptr + getTextAlign uintptr + getTextCharacterExtra uintptr + getTextCharset uintptr + getTextCharsetInfo uintptr + getTextColor uintptr + getTextExtentExPointI uintptr + getTextExtentExPoint uintptr + getTextExtentPoint32 uintptr + getTextExtentPointI uintptr + getTextExtentPoint uintptr + getTextFace uintptr + getTextMetrics uintptr + getViewportExtEx uintptr + getViewportOrgEx uintptr + getWinMetaFileBits uintptr + getWindowExtEx uintptr + getWindowOrgEx uintptr + getWorldTransform uintptr + hT_Get8BPPFormatPalette uintptr + hT_Get8BPPMaskPalette uintptr + intersectClipRect uintptr + invertRgn uintptr + lPtoDP uintptr + lineDDA uintptr + lineTo uintptr + maskBlt uintptr + modifyWorldTransform uintptr + moveToEx uintptr + offsetClipRgn uintptr + offsetRgn uintptr + offsetViewportOrgEx uintptr + offsetWindowOrgEx uintptr + pATHOBJ_bEnum uintptr + pATHOBJ_bEnumClipLines uintptr + pATHOBJ_vEnumStart uintptr + pATHOBJ_vEnumStartClipLines uintptr + pATHOBJ_vGetBounds uintptr + paintRgn uintptr + patBlt uintptr + pathToRegion uintptr + pie uintptr + playEnhMetaFile uintptr + playEnhMetaFileRecord uintptr + playMetaFile uintptr + playMetaFileRecord uintptr + plgBlt uintptr + polyBezier uintptr + polyBezierTo uintptr + polyDraw uintptr + polyPolygon uintptr + polyPolyline uintptr + polyTextOut uintptr + polygon uintptr + polyline uintptr + polylineTo uintptr + ptInRegion uintptr + ptVisible uintptr + realizePalette uintptr + rectInRegion uintptr + rectVisible uintptr + rectangle uintptr + removeFontMemResourceEx uintptr + removeFontResourceEx uintptr + removeFontResource uintptr + resetDC uintptr + resizePalette uintptr + restoreDC uintptr + roundRect uintptr + sTROBJ_bEnum uintptr + sTROBJ_bEnumPositionsOnly uintptr + sTROBJ_bGetAdvanceWidths uintptr + sTROBJ_dwGetCodePage uintptr + sTROBJ_vEnumStart uintptr + saveDC uintptr + scaleViewportExtEx uintptr + scaleWindowExtEx uintptr + selectClipPath uintptr + selectClipRgn uintptr + selectObject uintptr + selectPalette uintptr + setAbortProc uintptr + setArcDirection uintptr + setBitmapBits uintptr + setBitmapDimensionEx uintptr + setBkColor uintptr + setBkMode uintptr + setBoundsRect uintptr + setBrushOrgEx uintptr + setColorAdjustment uintptr + setColorSpace uintptr + setDCBrushColor uintptr + setDCPenColor uintptr + setDIBColorTable uintptr + setDIBits uintptr + setDIBitsToDevice uintptr + setDeviceGammaRamp uintptr + setEnhMetaFileBits uintptr + setGraphicsMode uintptr + setICMMode uintptr + setICMProfile uintptr + setLayout uintptr + setMapMode uintptr + setMapperFlags uintptr + setMetaFileBitsEx uintptr + setMetaRgn uintptr + setMiterLimit uintptr + setPaletteEntries uintptr + setPixel uintptr + setPixelFormat uintptr + setPixelV uintptr + setPolyFillMode uintptr + setROP2 uintptr + setRectRgn uintptr + setStretchBltMode uintptr + setSystemPaletteUse uintptr + setTextAlign uintptr + setTextCharacterExtra uintptr + setTextColor uintptr + setTextJustification uintptr + setViewportExtEx uintptr + setViewportOrgEx uintptr + setWinMetaFileBits uintptr + setWindowExtEx uintptr + setWindowOrgEx uintptr + setWorldTransform uintptr + startDoc uintptr + startPage uintptr + stretchBlt uintptr + stretchDIBits uintptr + strokeAndFillPath uintptr + strokePath uintptr + swapBuffers uintptr + textOut uintptr + translateCharsetInfo uintptr + unrealizeObject uintptr + updateColors uintptr + updateICMRegKey uintptr + widenPath uintptr + xFORMOBJ_bApplyXform uintptr + xFORMOBJ_iGetXform uintptr + xLATEOBJ_cGetPalette uintptr + xLATEOBJ_hGetColorTransform uintptr + xLATEOBJ_iXlate uintptr + enableEUDC uintptr + fontIsLinked uintptr + gdiDescribePixelFormat uintptr + gdiDrawStream uintptr + gdiGetCharDimensions uintptr + gdiGetCodePage uintptr + gdiGetSpoolMessage uintptr + gdiInitSpool uintptr + gdiInitializeLanguagePack uintptr + gdiIsMetaFileDC uintptr + gdiIsMetaPrintDC uintptr + gdiIsPlayMetafileDC uintptr + gdiRealizationInfo uintptr + gdiSetPixelFormat uintptr + gdiSwapBuffers uintptr + getFontResourceInfoW uintptr + getRelAbs uintptr + getTransform uintptr + mirrorRgn uintptr + namedEscape uintptr + setMagicColors uintptr + setRelAbs uintptr + setVirtualResolution uintptr +) + +func init() { + // Library + libgdi32 = doLoadLibrary("gdi32.dll") + + // Functions + abortDoc = doGetProcAddress(libgdi32, "AbortDoc") + abortPath = doGetProcAddress(libgdi32, "AbortPath") + addFontMemResourceEx = doGetProcAddress(libgdi32, "AddFontMemResourceEx") + addFontResourceEx = doGetProcAddress(libgdi32, "AddFontResourceExW") + addFontResource = doGetProcAddress(libgdi32, "AddFontResourceW") + angleArc = doGetProcAddress(libgdi32, "AngleArc") + animatePalette = doGetProcAddress(libgdi32, "AnimatePalette") + arc = doGetProcAddress(libgdi32, "Arc") + arcTo = doGetProcAddress(libgdi32, "ArcTo") + bRUSHOBJ_hGetColorTransform = doGetProcAddress(libgdi32, "BRUSHOBJ_hGetColorTransform") + bRUSHOBJ_pvAllocRbrush = doGetProcAddress(libgdi32, "BRUSHOBJ_pvAllocRbrush") + bRUSHOBJ_pvGetRbrush = doGetProcAddress(libgdi32, "BRUSHOBJ_pvGetRbrush") + bRUSHOBJ_ulGetBrushColor = doGetProcAddress(libgdi32, "BRUSHOBJ_ulGetBrushColor") + beginPath = doGetProcAddress(libgdi32, "BeginPath") + bitBlt = doGetProcAddress(libgdi32, "BitBlt") + cLIPOBJ_bEnum = doGetProcAddress(libgdi32, "CLIPOBJ_bEnum") + cLIPOBJ_cEnumStart = doGetProcAddress(libgdi32, "CLIPOBJ_cEnumStart") + cancelDC = doGetProcAddress(libgdi32, "CancelDC") + checkColorsInGamut = doGetProcAddress(libgdi32, "CheckColorsInGamut") + choosePixelFormat = doGetProcAddress(libgdi32, "ChoosePixelFormat") + chord = doGetProcAddress(libgdi32, "Chord") + closeEnhMetaFile = doGetProcAddress(libgdi32, "CloseEnhMetaFile") + closeFigure = doGetProcAddress(libgdi32, "CloseFigure") + closeMetaFile = doGetProcAddress(libgdi32, "CloseMetaFile") + colorCorrectPalette = doGetProcAddress(libgdi32, "ColorCorrectPalette") + colorMatchToTarget = doGetProcAddress(libgdi32, "ColorMatchToTarget") + combineRgn = doGetProcAddress(libgdi32, "CombineRgn") + combineTransform = doGetProcAddress(libgdi32, "CombineTransform") + copyEnhMetaFile = doGetProcAddress(libgdi32, "CopyEnhMetaFileW") + copyMetaFile = doGetProcAddress(libgdi32, "CopyMetaFileW") + createBitmap = doGetProcAddress(libgdi32, "CreateBitmap") + createBitmapIndirect = doGetProcAddress(libgdi32, "CreateBitmapIndirect") + createBrushIndirect = doGetProcAddress(libgdi32, "CreateBrushIndirect") + createColorSpace = doGetProcAddress(libgdi32, "CreateColorSpaceW") + createCompatibleBitmap = doGetProcAddress(libgdi32, "CreateCompatibleBitmap") + createCompatibleDC = doGetProcAddress(libgdi32, "CreateCompatibleDC") + createDC = doGetProcAddress(libgdi32, "CreateDCW") + createDIBPatternBrush = doGetProcAddress(libgdi32, "CreateDIBPatternBrush") + createDIBPatternBrushPt = doGetProcAddress(libgdi32, "CreateDIBPatternBrushPt") + createDIBSection = doGetProcAddress(libgdi32, "CreateDIBSection") + createDIBitmap = doGetProcAddress(libgdi32, "CreateDIBitmap") + createDiscardableBitmap = doGetProcAddress(libgdi32, "CreateDiscardableBitmap") + createEllipticRgn = doGetProcAddress(libgdi32, "CreateEllipticRgn") + createEllipticRgnIndirect = doGetProcAddress(libgdi32, "CreateEllipticRgnIndirect") + createEnhMetaFile = doGetProcAddress(libgdi32, "CreateEnhMetaFileW") + createFontIndirectEx = doGetProcAddress(libgdi32, "CreateFontIndirectExW") + createFontIndirect = doGetProcAddress(libgdi32, "CreateFontIndirectW") + createFont = doGetProcAddress(libgdi32, "CreateFontW") + createHalftonePalette = doGetProcAddress(libgdi32, "CreateHalftonePalette") + createHatchBrush = doGetProcAddress(libgdi32, "CreateHatchBrush") + createIC = doGetProcAddress(libgdi32, "CreateICW") + createMetaFile = doGetProcAddress(libgdi32, "CreateMetaFileW") + createPalette = doGetProcAddress(libgdi32, "CreatePalette") + createPatternBrush = doGetProcAddress(libgdi32, "CreatePatternBrush") + createPen = doGetProcAddress(libgdi32, "CreatePen") + createPenIndirect = doGetProcAddress(libgdi32, "CreatePenIndirect") + createPolyPolygonRgn = doGetProcAddress(libgdi32, "CreatePolyPolygonRgn") + createPolygonRgn = doGetProcAddress(libgdi32, "CreatePolygonRgn") + createRectRgn = doGetProcAddress(libgdi32, "CreateRectRgn") + createRectRgnIndirect = doGetProcAddress(libgdi32, "CreateRectRgnIndirect") + createRoundRectRgn = doGetProcAddress(libgdi32, "CreateRoundRectRgn") + createScalableFontResource = doGetProcAddress(libgdi32, "CreateScalableFontResourceW") + createSolidBrush = doGetProcAddress(libgdi32, "CreateSolidBrush") + dPtoLP = doGetProcAddress(libgdi32, "DPtoLP") + deleteColorSpace = doGetProcAddress(libgdi32, "DeleteColorSpace") + deleteDC = doGetProcAddress(libgdi32, "DeleteDC") + deleteEnhMetaFile = doGetProcAddress(libgdi32, "DeleteEnhMetaFile") + deleteMetaFile = doGetProcAddress(libgdi32, "DeleteMetaFile") + deleteObject = doGetProcAddress(libgdi32, "DeleteObject") + describePixelFormat = doGetProcAddress(libgdi32, "DescribePixelFormat") + drawEscape = doGetProcAddress(libgdi32, "DrawEscape") + ellipse = doGetProcAddress(libgdi32, "Ellipse") + endDoc = doGetProcAddress(libgdi32, "EndDoc") + endPage = doGetProcAddress(libgdi32, "EndPage") + endPath = doGetProcAddress(libgdi32, "EndPath") + engAcquireSemaphore = doGetProcAddress(libgdi32, "EngAcquireSemaphore") + engAlphaBlend = doGetProcAddress(libgdi32, "EngAlphaBlend") + engAssociateSurface = doGetProcAddress(libgdi32, "EngAssociateSurface") + engBitBlt = doGetProcAddress(libgdi32, "EngBitBlt") + engCheckAbort = doGetProcAddress(libgdi32, "EngCheckAbort") + engCopyBits = doGetProcAddress(libgdi32, "EngCopyBits") + engCreateBitmap = doGetProcAddress(libgdi32, "EngCreateBitmap") + engCreateDeviceBitmap = doGetProcAddress(libgdi32, "EngCreateDeviceBitmap") + engCreateDeviceSurface = doGetProcAddress(libgdi32, "EngCreateDeviceSurface") + engCreatePalette = doGetProcAddress(libgdi32, "EngCreatePalette") + engCreateSemaphore = doGetProcAddress(libgdi32, "EngCreateSemaphore") + engDeleteClip = doGetProcAddress(libgdi32, "EngDeleteClip") + engDeletePalette = doGetProcAddress(libgdi32, "EngDeletePalette") + engDeletePath = doGetProcAddress(libgdi32, "EngDeletePath") + engDeleteSemaphore = doGetProcAddress(libgdi32, "EngDeleteSemaphore") + engDeleteSurface = doGetProcAddress(libgdi32, "EngDeleteSurface") + engEraseSurface = doGetProcAddress(libgdi32, "EngEraseSurface") + engFillPath = doGetProcAddress(libgdi32, "EngFillPath") + engFindResource = doGetProcAddress(libgdi32, "EngFindResource") + engFreeModule = doGetProcAddress(libgdi32, "EngFreeModule") + engGetCurrentCodePage = doGetProcAddress(libgdi32, "EngGetCurrentCodePage") + engGetDriverName = doGetProcAddress(libgdi32, "EngGetDriverName") + engGetPrinterDataFileName = doGetProcAddress(libgdi32, "EngGetPrinterDataFileName") + engGradientFill = doGetProcAddress(libgdi32, "EngGradientFill") + engLineTo = doGetProcAddress(libgdi32, "EngLineTo") + engLoadModule = doGetProcAddress(libgdi32, "EngLoadModule") + engMarkBandingSurface = doGetProcAddress(libgdi32, "EngMarkBandingSurface") + engMultiByteToUnicodeN = doGetProcAddress(libgdi32, "EngMultiByteToUnicodeN") + engMultiByteToWideChar = doGetProcAddress(libgdi32, "EngMultiByteToWideChar") + engPaint = doGetProcAddress(libgdi32, "EngPaint") + engPlgBlt = doGetProcAddress(libgdi32, "EngPlgBlt") + engQueryLocalTime = doGetProcAddress(libgdi32, "EngQueryLocalTime") + engReleaseSemaphore = doGetProcAddress(libgdi32, "EngReleaseSemaphore") + engStretchBlt = doGetProcAddress(libgdi32, "EngStretchBlt") + engStretchBltROP = doGetProcAddress(libgdi32, "EngStretchBltROP") + engStrokeAndFillPath = doGetProcAddress(libgdi32, "EngStrokeAndFillPath") + engStrokePath = doGetProcAddress(libgdi32, "EngStrokePath") + engTextOut = doGetProcAddress(libgdi32, "EngTextOut") + engTransparentBlt = doGetProcAddress(libgdi32, "EngTransparentBlt") + engUnicodeToMultiByteN = doGetProcAddress(libgdi32, "EngUnicodeToMultiByteN") + engUnlockSurface = doGetProcAddress(libgdi32, "EngUnlockSurface") + engWideCharToMultiByte = doGetProcAddress(libgdi32, "EngWideCharToMultiByte") + enumEnhMetaFile = doGetProcAddress(libgdi32, "EnumEnhMetaFile") + enumFontFamiliesEx = doGetProcAddress(libgdi32, "EnumFontFamiliesExW") + enumFontFamilies = doGetProcAddress(libgdi32, "EnumFontFamiliesW") + enumFonts = doGetProcAddress(libgdi32, "EnumFontsW") + enumICMProfiles = doGetProcAddress(libgdi32, "EnumICMProfilesW") + enumMetaFile = doGetProcAddress(libgdi32, "EnumMetaFile") + enumObjects = doGetProcAddress(libgdi32, "EnumObjects") + equalRgn = doGetProcAddress(libgdi32, "EqualRgn") + escape = doGetProcAddress(libgdi32, "Escape") + excludeClipRect = doGetProcAddress(libgdi32, "ExcludeClipRect") + extCreatePen = doGetProcAddress(libgdi32, "ExtCreatePen") + extCreateRegion = doGetProcAddress(libgdi32, "ExtCreateRegion") + extEscape = doGetProcAddress(libgdi32, "ExtEscape") + extFloodFill = doGetProcAddress(libgdi32, "ExtFloodFill") + extSelectClipRgn = doGetProcAddress(libgdi32, "ExtSelectClipRgn") + extTextOut = doGetProcAddress(libgdi32, "ExtTextOutW") + fONTOBJ_cGetAllGlyphHandles = doGetProcAddress(libgdi32, "FONTOBJ_cGetAllGlyphHandles") + fONTOBJ_cGetGlyphs = doGetProcAddress(libgdi32, "FONTOBJ_cGetGlyphs") + fONTOBJ_pQueryGlyphAttrs = doGetProcAddress(libgdi32, "FONTOBJ_pQueryGlyphAttrs") + fONTOBJ_pvTrueTypeFontFile = doGetProcAddress(libgdi32, "FONTOBJ_pvTrueTypeFontFile") + fONTOBJ_vGetInfo = doGetProcAddress(libgdi32, "FONTOBJ_vGetInfo") + fillPath = doGetProcAddress(libgdi32, "FillPath") + fillRgn = doGetProcAddress(libgdi32, "FillRgn") + fixBrushOrgEx = doGetProcAddress(libgdi32, "FixBrushOrgEx") + flattenPath = doGetProcAddress(libgdi32, "FlattenPath") + floodFill = doGetProcAddress(libgdi32, "FloodFill") + frameRgn = doGetProcAddress(libgdi32, "FrameRgn") + gdiAlphaBlend = doGetProcAddress(libgdi32, "GdiAlphaBlend") + gdiComment = doGetProcAddress(libgdi32, "GdiComment") + gdiFlush = doGetProcAddress(libgdi32, "GdiFlush") + gdiGetBatchLimit = doGetProcAddress(libgdi32, "GdiGetBatchLimit") + gdiGradientFill = doGetProcAddress(libgdi32, "GdiGradientFill") + gdiSetBatchLimit = doGetProcAddress(libgdi32, "GdiSetBatchLimit") + gdiTransparentBlt = doGetProcAddress(libgdi32, "GdiTransparentBlt") + getArcDirection = doGetProcAddress(libgdi32, "GetArcDirection") + getAspectRatioFilterEx = doGetProcAddress(libgdi32, "GetAspectRatioFilterEx") + getBitmapBits = doGetProcAddress(libgdi32, "GetBitmapBits") + getBitmapDimensionEx = doGetProcAddress(libgdi32, "GetBitmapDimensionEx") + getBkColor = doGetProcAddress(libgdi32, "GetBkColor") + getBkMode = doGetProcAddress(libgdi32, "GetBkMode") + getBoundsRect = doGetProcAddress(libgdi32, "GetBoundsRect") + getBrushOrgEx = doGetProcAddress(libgdi32, "GetBrushOrgEx") + getCharABCWidthsFloat = doGetProcAddress(libgdi32, "GetCharABCWidthsFloatW") + getCharABCWidthsI = doGetProcAddress(libgdi32, "GetCharABCWidthsI") + getCharABCWidths = doGetProcAddress(libgdi32, "GetCharABCWidthsW") + getCharWidth32 = doGetProcAddress(libgdi32, "GetCharWidth32W") + getCharWidthFloat = doGetProcAddress(libgdi32, "GetCharWidthFloatW") + getCharWidthI = doGetProcAddress(libgdi32, "GetCharWidthI") + getCharWidth = doGetProcAddress(libgdi32, "GetCharWidthW") + getCharacterPlacement = doGetProcAddress(libgdi32, "GetCharacterPlacementW") + getClipBox = doGetProcAddress(libgdi32, "GetClipBox") + getClipRgn = doGetProcAddress(libgdi32, "GetClipRgn") + getColorAdjustment = doGetProcAddress(libgdi32, "GetColorAdjustment") + getColorSpace = doGetProcAddress(libgdi32, "GetColorSpace") + getCurrentObject = doGetProcAddress(libgdi32, "GetCurrentObject") + getCurrentPositionEx = doGetProcAddress(libgdi32, "GetCurrentPositionEx") + getDCBrushColor = doGetProcAddress(libgdi32, "GetDCBrushColor") + getDCOrgEx = doGetProcAddress(libgdi32, "GetDCOrgEx") + getDCPenColor = doGetProcAddress(libgdi32, "GetDCPenColor") + getDIBColorTable = doGetProcAddress(libgdi32, "GetDIBColorTable") + getDIBits = doGetProcAddress(libgdi32, "GetDIBits") + getDeviceCaps = doGetProcAddress(libgdi32, "GetDeviceCaps") + getDeviceGammaRamp = doGetProcAddress(libgdi32, "GetDeviceGammaRamp") + getEnhMetaFileBits = doGetProcAddress(libgdi32, "GetEnhMetaFileBits") + getEnhMetaFileDescription = doGetProcAddress(libgdi32, "GetEnhMetaFileDescriptionW") + getEnhMetaFileHeader = doGetProcAddress(libgdi32, "GetEnhMetaFileHeader") + getEnhMetaFilePaletteEntries = doGetProcAddress(libgdi32, "GetEnhMetaFilePaletteEntries") + getEnhMetaFilePixelFormat = doGetProcAddress(libgdi32, "GetEnhMetaFilePixelFormat") + getEnhMetaFile = doGetProcAddress(libgdi32, "GetEnhMetaFileW") + getFontData = doGetProcAddress(libgdi32, "GetFontData") + getFontLanguageInfo = doGetProcAddress(libgdi32, "GetFontLanguageInfo") + getFontUnicodeRanges = doGetProcAddress(libgdi32, "GetFontUnicodeRanges") + getGlyphIndices = doGetProcAddress(libgdi32, "GetGlyphIndicesW") + getGlyphOutline = doGetProcAddress(libgdi32, "GetGlyphOutlineW") + getGraphicsMode = doGetProcAddress(libgdi32, "GetGraphicsMode") + getICMProfile = doGetProcAddress(libgdi32, "GetICMProfileW") + getKerningPairs = doGetProcAddress(libgdi32, "GetKerningPairsW") + getLayout = doGetProcAddress(libgdi32, "GetLayout") + getLogColorSpace = doGetProcAddress(libgdi32, "GetLogColorSpaceW") + getMapMode = doGetProcAddress(libgdi32, "GetMapMode") + getMetaFileBitsEx = doGetProcAddress(libgdi32, "GetMetaFileBitsEx") + getMetaFile = doGetProcAddress(libgdi32, "GetMetaFileW") + getMetaRgn = doGetProcAddress(libgdi32, "GetMetaRgn") + getMiterLimit = doGetProcAddress(libgdi32, "GetMiterLimit") + getNearestColor = doGetProcAddress(libgdi32, "GetNearestColor") + getNearestPaletteIndex = doGetProcAddress(libgdi32, "GetNearestPaletteIndex") + getObjectType = doGetProcAddress(libgdi32, "GetObjectType") + getObject = doGetProcAddress(libgdi32, "GetObjectW") + getOutlineTextMetrics = doGetProcAddress(libgdi32, "GetOutlineTextMetricsW") + getPaletteEntries = doGetProcAddress(libgdi32, "GetPaletteEntries") + getPath = doGetProcAddress(libgdi32, "GetPath") + getPixel = doGetProcAddress(libgdi32, "GetPixel") + getPixelFormat = doGetProcAddress(libgdi32, "GetPixelFormat") + getPolyFillMode = doGetProcAddress(libgdi32, "GetPolyFillMode") + getROP2 = doGetProcAddress(libgdi32, "GetROP2") + getRandomRgn = doGetProcAddress(libgdi32, "GetRandomRgn") + getRasterizerCaps = doGetProcAddress(libgdi32, "GetRasterizerCaps") + getRegionData = doGetProcAddress(libgdi32, "GetRegionData") + getRgnBox = doGetProcAddress(libgdi32, "GetRgnBox") + getStockObject = doGetProcAddress(libgdi32, "GetStockObject") + getStretchBltMode = doGetProcAddress(libgdi32, "GetStretchBltMode") + getSystemPaletteEntries = doGetProcAddress(libgdi32, "GetSystemPaletteEntries") + getSystemPaletteUse = doGetProcAddress(libgdi32, "GetSystemPaletteUse") + getTextAlign = doGetProcAddress(libgdi32, "GetTextAlign") + getTextCharacterExtra = doGetProcAddress(libgdi32, "GetTextCharacterExtra") + getTextCharset = doGetProcAddress(libgdi32, "GetTextCharset") + getTextCharsetInfo = doGetProcAddress(libgdi32, "GetTextCharsetInfo") + getTextColor = doGetProcAddress(libgdi32, "GetTextColor") + getTextExtentExPointI = doGetProcAddress(libgdi32, "GetTextExtentExPointI") + getTextExtentExPoint = doGetProcAddress(libgdi32, "GetTextExtentExPointW") + getTextExtentPoint32 = doGetProcAddress(libgdi32, "GetTextExtentPoint32W") + getTextExtentPointI = doGetProcAddress(libgdi32, "GetTextExtentPointI") + getTextExtentPoint = doGetProcAddress(libgdi32, "GetTextExtentPointW") + getTextFace = doGetProcAddress(libgdi32, "GetTextFaceW") + getTextMetrics = doGetProcAddress(libgdi32, "GetTextMetricsW") + getViewportExtEx = doGetProcAddress(libgdi32, "GetViewportExtEx") + getViewportOrgEx = doGetProcAddress(libgdi32, "GetViewportOrgEx") + getWinMetaFileBits = doGetProcAddress(libgdi32, "GetWinMetaFileBits") + getWindowExtEx = doGetProcAddress(libgdi32, "GetWindowExtEx") + getWindowOrgEx = doGetProcAddress(libgdi32, "GetWindowOrgEx") + getWorldTransform = doGetProcAddress(libgdi32, "GetWorldTransform") + hT_Get8BPPFormatPalette = doGetProcAddress(libgdi32, "HT_Get8BPPFormatPalette") + hT_Get8BPPMaskPalette = doGetProcAddress(libgdi32, "HT_Get8BPPMaskPalette") + intersectClipRect = doGetProcAddress(libgdi32, "IntersectClipRect") + invertRgn = doGetProcAddress(libgdi32, "InvertRgn") + lPtoDP = doGetProcAddress(libgdi32, "LPtoDP") + lineDDA = doGetProcAddress(libgdi32, "LineDDA") + lineTo = doGetProcAddress(libgdi32, "LineTo") + maskBlt = doGetProcAddress(libgdi32, "MaskBlt") + modifyWorldTransform = doGetProcAddress(libgdi32, "ModifyWorldTransform") + moveToEx = doGetProcAddress(libgdi32, "MoveToEx") + offsetClipRgn = doGetProcAddress(libgdi32, "OffsetClipRgn") + offsetRgn = doGetProcAddress(libgdi32, "OffsetRgn") + offsetViewportOrgEx = doGetProcAddress(libgdi32, "OffsetViewportOrgEx") + offsetWindowOrgEx = doGetProcAddress(libgdi32, "OffsetWindowOrgEx") + pATHOBJ_bEnum = doGetProcAddress(libgdi32, "PATHOBJ_bEnum") + pATHOBJ_bEnumClipLines = doGetProcAddress(libgdi32, "PATHOBJ_bEnumClipLines") + pATHOBJ_vEnumStart = doGetProcAddress(libgdi32, "PATHOBJ_vEnumStart") + pATHOBJ_vEnumStartClipLines = doGetProcAddress(libgdi32, "PATHOBJ_vEnumStartClipLines") + pATHOBJ_vGetBounds = doGetProcAddress(libgdi32, "PATHOBJ_vGetBounds") + paintRgn = doGetProcAddress(libgdi32, "PaintRgn") + patBlt = doGetProcAddress(libgdi32, "PatBlt") + pathToRegion = doGetProcAddress(libgdi32, "PathToRegion") + pie = doGetProcAddress(libgdi32, "Pie") + playEnhMetaFile = doGetProcAddress(libgdi32, "PlayEnhMetaFile") + playEnhMetaFileRecord = doGetProcAddress(libgdi32, "PlayEnhMetaFileRecord") + playMetaFile = doGetProcAddress(libgdi32, "PlayMetaFile") + playMetaFileRecord = doGetProcAddress(libgdi32, "PlayMetaFileRecord") + plgBlt = doGetProcAddress(libgdi32, "PlgBlt") + polyBezier = doGetProcAddress(libgdi32, "PolyBezier") + polyBezierTo = doGetProcAddress(libgdi32, "PolyBezierTo") + polyDraw = doGetProcAddress(libgdi32, "PolyDraw") + polyPolygon = doGetProcAddress(libgdi32, "PolyPolygon") + polyPolyline = doGetProcAddress(libgdi32, "PolyPolyline") + polyTextOut = doGetProcAddress(libgdi32, "PolyTextOutW") + polygon = doGetProcAddress(libgdi32, "Polygon") + polyline = doGetProcAddress(libgdi32, "Polyline") + polylineTo = doGetProcAddress(libgdi32, "PolylineTo") + ptInRegion = doGetProcAddress(libgdi32, "PtInRegion") + ptVisible = doGetProcAddress(libgdi32, "PtVisible") + realizePalette = doGetProcAddress(libgdi32, "RealizePalette") + rectInRegion = doGetProcAddress(libgdi32, "RectInRegion") + rectVisible = doGetProcAddress(libgdi32, "RectVisible") + rectangle = doGetProcAddress(libgdi32, "Rectangle") + removeFontMemResourceEx = doGetProcAddress(libgdi32, "RemoveFontMemResourceEx") + removeFontResourceEx = doGetProcAddress(libgdi32, "RemoveFontResourceExW") + removeFontResource = doGetProcAddress(libgdi32, "RemoveFontResourceW") + resetDC = doGetProcAddress(libgdi32, "ResetDCW") + resizePalette = doGetProcAddress(libgdi32, "ResizePalette") + restoreDC = doGetProcAddress(libgdi32, "RestoreDC") + roundRect = doGetProcAddress(libgdi32, "RoundRect") + sTROBJ_bEnum = doGetProcAddress(libgdi32, "STROBJ_bEnum") + sTROBJ_bEnumPositionsOnly = doGetProcAddress(libgdi32, "STROBJ_bEnumPositionsOnly") + sTROBJ_bGetAdvanceWidths = doGetProcAddress(libgdi32, "STROBJ_bGetAdvanceWidths") + sTROBJ_dwGetCodePage = doGetProcAddress(libgdi32, "STROBJ_dwGetCodePage") + sTROBJ_vEnumStart = doGetProcAddress(libgdi32, "STROBJ_vEnumStart") + saveDC = doGetProcAddress(libgdi32, "SaveDC") + scaleViewportExtEx = doGetProcAddress(libgdi32, "ScaleViewportExtEx") + scaleWindowExtEx = doGetProcAddress(libgdi32, "ScaleWindowExtEx") + selectClipPath = doGetProcAddress(libgdi32, "SelectClipPath") + selectClipRgn = doGetProcAddress(libgdi32, "SelectClipRgn") + selectObject = doGetProcAddress(libgdi32, "SelectObject") + selectPalette = doGetProcAddress(libgdi32, "SelectPalette") + setAbortProc = doGetProcAddress(libgdi32, "SetAbortProc") + setArcDirection = doGetProcAddress(libgdi32, "SetArcDirection") + setBitmapBits = doGetProcAddress(libgdi32, "SetBitmapBits") + setBitmapDimensionEx = doGetProcAddress(libgdi32, "SetBitmapDimensionEx") + setBkColor = doGetProcAddress(libgdi32, "SetBkColor") + setBkMode = doGetProcAddress(libgdi32, "SetBkMode") + setBoundsRect = doGetProcAddress(libgdi32, "SetBoundsRect") + setBrushOrgEx = doGetProcAddress(libgdi32, "SetBrushOrgEx") + setColorAdjustment = doGetProcAddress(libgdi32, "SetColorAdjustment") + setColorSpace = doGetProcAddress(libgdi32, "SetColorSpace") + setDCBrushColor = doGetProcAddress(libgdi32, "SetDCBrushColor") + setDCPenColor = doGetProcAddress(libgdi32, "SetDCPenColor") + setDIBColorTable = doGetProcAddress(libgdi32, "SetDIBColorTable") + setDIBits = doGetProcAddress(libgdi32, "SetDIBits") + setDIBitsToDevice = doGetProcAddress(libgdi32, "SetDIBitsToDevice") + setDeviceGammaRamp = doGetProcAddress(libgdi32, "SetDeviceGammaRamp") + setEnhMetaFileBits = doGetProcAddress(libgdi32, "SetEnhMetaFileBits") + setGraphicsMode = doGetProcAddress(libgdi32, "SetGraphicsMode") + setICMMode = doGetProcAddress(libgdi32, "SetICMMode") + setICMProfile = doGetProcAddress(libgdi32, "SetICMProfileW") + setLayout = doGetProcAddress(libgdi32, "SetLayout") + setMapMode = doGetProcAddress(libgdi32, "SetMapMode") + setMapperFlags = doGetProcAddress(libgdi32, "SetMapperFlags") + setMetaFileBitsEx = doGetProcAddress(libgdi32, "SetMetaFileBitsEx") + setMetaRgn = doGetProcAddress(libgdi32, "SetMetaRgn") + setMiterLimit = doGetProcAddress(libgdi32, "SetMiterLimit") + setPaletteEntries = doGetProcAddress(libgdi32, "SetPaletteEntries") + setPixel = doGetProcAddress(libgdi32, "SetPixel") + setPixelFormat = doGetProcAddress(libgdi32, "SetPixelFormat") + setPixelV = doGetProcAddress(libgdi32, "SetPixelV") + setPolyFillMode = doGetProcAddress(libgdi32, "SetPolyFillMode") + setROP2 = doGetProcAddress(libgdi32, "SetROP2") + setRectRgn = doGetProcAddress(libgdi32, "SetRectRgn") + setStretchBltMode = doGetProcAddress(libgdi32, "SetStretchBltMode") + setSystemPaletteUse = doGetProcAddress(libgdi32, "SetSystemPaletteUse") + setTextAlign = doGetProcAddress(libgdi32, "SetTextAlign") + setTextCharacterExtra = doGetProcAddress(libgdi32, "SetTextCharacterExtra") + setTextColor = doGetProcAddress(libgdi32, "SetTextColor") + setTextJustification = doGetProcAddress(libgdi32, "SetTextJustification") + setViewportExtEx = doGetProcAddress(libgdi32, "SetViewportExtEx") + setViewportOrgEx = doGetProcAddress(libgdi32, "SetViewportOrgEx") + setWinMetaFileBits = doGetProcAddress(libgdi32, "SetWinMetaFileBits") + setWindowExtEx = doGetProcAddress(libgdi32, "SetWindowExtEx") + setWindowOrgEx = doGetProcAddress(libgdi32, "SetWindowOrgEx") + setWorldTransform = doGetProcAddress(libgdi32, "SetWorldTransform") + startDoc = doGetProcAddress(libgdi32, "StartDocW") + startPage = doGetProcAddress(libgdi32, "StartPage") + stretchBlt = doGetProcAddress(libgdi32, "StretchBlt") + stretchDIBits = doGetProcAddress(libgdi32, "StretchDIBits") + strokeAndFillPath = doGetProcAddress(libgdi32, "StrokeAndFillPath") + strokePath = doGetProcAddress(libgdi32, "StrokePath") + swapBuffers = doGetProcAddress(libgdi32, "SwapBuffers") + textOut = doGetProcAddress(libgdi32, "TextOutW") + translateCharsetInfo = doGetProcAddress(libgdi32, "TranslateCharsetInfo") + unrealizeObject = doGetProcAddress(libgdi32, "UnrealizeObject") + updateColors = doGetProcAddress(libgdi32, "UpdateColors") + updateICMRegKey = doGetProcAddress(libgdi32, "UpdateICMRegKeyW") + widenPath = doGetProcAddress(libgdi32, "WidenPath") + xFORMOBJ_bApplyXform = doGetProcAddress(libgdi32, "XFORMOBJ_bApplyXform") + xFORMOBJ_iGetXform = doGetProcAddress(libgdi32, "XFORMOBJ_iGetXform") + xLATEOBJ_cGetPalette = doGetProcAddress(libgdi32, "XLATEOBJ_cGetPalette") + xLATEOBJ_hGetColorTransform = doGetProcAddress(libgdi32, "XLATEOBJ_hGetColorTransform") + xLATEOBJ_iXlate = doGetProcAddress(libgdi32, "XLATEOBJ_iXlate") + enableEUDC = doGetProcAddress(libgdi32, "EnableEUDC") + fontIsLinked = doGetProcAddress(libgdi32, "FontIsLinked") + gdiDescribePixelFormat = doGetProcAddress(libgdi32, "GdiDescribePixelFormat") + gdiDrawStream = doGetProcAddress(libgdi32, "GdiDrawStream") + gdiGetCharDimensions = doGetProcAddress(libgdi32, "GdiGetCharDimensions") + gdiGetCodePage = doGetProcAddress(libgdi32, "GdiGetCodePage") + gdiGetSpoolMessage = doGetProcAddress(libgdi32, "GdiGetSpoolMessage") + gdiInitSpool = doGetProcAddress(libgdi32, "GdiInitSpool") + gdiInitializeLanguagePack = doGetProcAddress(libgdi32, "GdiInitializeLanguagePack") + gdiIsMetaFileDC = doGetProcAddress(libgdi32, "GdiIsMetaFileDC") + gdiIsMetaPrintDC = doGetProcAddress(libgdi32, "GdiIsMetaPrintDC") + gdiIsPlayMetafileDC = doGetProcAddress(libgdi32, "GdiIsPlayMetafileDC") + gdiRealizationInfo = doGetProcAddress(libgdi32, "GdiRealizationInfo") + gdiSetPixelFormat = doGetProcAddress(libgdi32, "GdiSetPixelFormat") + gdiSwapBuffers = doGetProcAddress(libgdi32, "GdiSwapBuffers") + getFontResourceInfoW = doGetProcAddress(libgdi32, "GetFontResourceInfoW") + getRelAbs = doGetProcAddress(libgdi32, "GetRelAbs") + getTransform = doGetProcAddress(libgdi32, "GetTransform") + mirrorRgn = doGetProcAddress(libgdi32, "MirrorRgn") + namedEscape = doGetProcAddress(libgdi32, "NamedEscape") + setMagicColors = doGetProcAddress(libgdi32, "SetMagicColors") + setRelAbs = doGetProcAddress(libgdi32, "SetRelAbs") + setVirtualResolution = doGetProcAddress(libgdi32, "SetVirtualResolution") +} + +func AbortDoc(hdc HDC) int32 { + ret1 := syscall3(abortDoc, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func AbortPath(hdc HDC) bool { + ret1 := syscall3(abortPath, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func AddFontMemResourceEx(pFileView uintptr, cjSize DWORD, pvResrved uintptr, pNumFonts *uint32) HANDLE { + ret1 := syscall6(addFontMemResourceEx, 4, + pFileView, + uintptr(cjSize), + pvResrved, + uintptr(unsafe.Pointer(pNumFonts)), + 0, + 0) + return HANDLE(ret1) +} + +func AddFontResourceEx(name string, fl DWORD, res uintptr) int32 { + nameStr := unicode16FromString(name) + ret1 := syscall3(addFontResourceEx, 3, + uintptr(unsafe.Pointer(&nameStr[0])), + uintptr(fl), + res) + return int32(ret1) +} + +func AddFontResource(unnamed0 string) int32 { + unnamed0Str := unicode16FromString(unnamed0) + ret1 := syscall3(addFontResource, 1, + uintptr(unsafe.Pointer(&unnamed0Str[0])), + 0, + 0) + return int32(ret1) +} + +func AngleArc(hdc HDC, x int32, y int32, r DWORD, startAngle FLOAT, sweepAngle FLOAT) bool { + ret1 := syscall6(angleArc, 6, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(r), + uintptr(startAngle), + uintptr(sweepAngle)) + return ret1 != 0 +} + +func AnimatePalette(hPal HPALETTE, iStartIndex UINT, cEntries UINT, ppe /*const*/ *PALETTEENTRY) bool { + ret1 := syscall6(animatePalette, 4, + uintptr(hPal), + uintptr(iStartIndex), + uintptr(cEntries), + uintptr(unsafe.Pointer(ppe)), + 0, + 0) + return ret1 != 0 +} + +func Arc(hdc HDC, x1 int32, y1 int32, x2 int32, y2 int32, x3 int32, y3 int32, x4 int32, y4 int32) bool { + ret1 := syscall9(arc, 9, + uintptr(hdc), + uintptr(x1), + uintptr(y1), + uintptr(x2), + uintptr(y2), + uintptr(x3), + uintptr(y3), + uintptr(x4), + uintptr(y4)) + return ret1 != 0 +} + +func ArcTo(hdc HDC, left int32, top int32, right int32, bottom int32, xr1 int32, yr1 int32, xr2 int32, yr2 int32) bool { + ret1 := syscall9(arcTo, 9, + uintptr(hdc), + uintptr(left), + uintptr(top), + uintptr(right), + uintptr(bottom), + uintptr(xr1), + uintptr(yr1), + uintptr(xr2), + uintptr(yr2)) + return ret1 != 0 +} + +func BRUSHOBJ_hGetColorTransform(pbo *BRUSHOBJ) HANDLE { + ret1 := syscall3(bRUSHOBJ_hGetColorTransform, 1, + uintptr(unsafe.Pointer(pbo)), + 0, + 0) + return HANDLE(ret1) +} + +func BRUSHOBJ_pvAllocRbrush(pbo *BRUSHOBJ, cj ULONG) uintptr { + ret1 := syscall3(bRUSHOBJ_pvAllocRbrush, 2, + uintptr(unsafe.Pointer(pbo)), + uintptr(cj), + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func BRUSHOBJ_pvGetRbrush(pbo *BRUSHOBJ) uintptr { + ret1 := syscall3(bRUSHOBJ_pvGetRbrush, 1, + uintptr(unsafe.Pointer(pbo)), + 0, + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func BRUSHOBJ_ulGetBrushColor(pbo *BRUSHOBJ) ULONG { + ret1 := syscall3(bRUSHOBJ_ulGetBrushColor, 1, + uintptr(unsafe.Pointer(pbo)), + 0, + 0) + return ULONG(ret1) +} + +func BeginPath(hdc HDC) bool { + ret1 := syscall3(beginPath, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func BitBlt(hdc HDC, x int32, y int32, cx int32, cy int32, hdcSrc HDC, x1 int32, y1 int32, rop DWORD) bool { + ret1 := syscall9(bitBlt, 9, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(cx), + uintptr(cy), + uintptr(hdcSrc), + uintptr(x1), + uintptr(y1), + uintptr(rop)) + return ret1 != 0 +} + +func CLIPOBJ_bEnum(pco *CLIPOBJ, cj ULONG, pv *ULONG) bool { + ret1 := syscall3(cLIPOBJ_bEnum, 3, + uintptr(unsafe.Pointer(pco)), + uintptr(cj), + uintptr(unsafe.Pointer(pv))) + return ret1 != 0 +} + +func CLIPOBJ_cEnumStart(pco *CLIPOBJ, bAll bool, iType ULONG, iDirection ULONG, cLimit ULONG) ULONG { + ret1 := syscall6(cLIPOBJ_cEnumStart, 5, + uintptr(unsafe.Pointer(pco)), + getUintptrFromBool(bAll), + uintptr(iType), + uintptr(iDirection), + uintptr(cLimit), + 0) + return ULONG(ret1) +} + +func CancelDC(hdc HDC) bool { + ret1 := syscall3(cancelDC, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func CheckColorsInGamut(hdc HDC, lpRGBTriple LPVOID, dlpBuffer LPVOID, nCount DWORD) bool { + ret1 := syscall6(checkColorsInGamut, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(lpRGBTriple)), + uintptr(unsafe.Pointer(dlpBuffer)), + uintptr(nCount), + 0, + 0) + return ret1 != 0 +} + +func ChoosePixelFormat(hdc HDC, ppfd /*const*/ *PIXELFORMATDESCRIPTOR) int32 { + ret1 := syscall3(choosePixelFormat, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(ppfd)), + 0) + return int32(ret1) +} + +func Chord(hdc HDC, x1 int32, y1 int32, x2 int32, y2 int32, x3 int32, y3 int32, x4 int32, y4 int32) bool { + ret1 := syscall9(chord, 9, + uintptr(hdc), + uintptr(x1), + uintptr(y1), + uintptr(x2), + uintptr(y2), + uintptr(x3), + uintptr(y3), + uintptr(x4), + uintptr(y4)) + return ret1 != 0 +} + +func CloseEnhMetaFile(hdc HDC) HENHMETAFILE { + ret1 := syscall3(closeEnhMetaFile, 1, + uintptr(hdc), + 0, + 0) + return HENHMETAFILE(ret1) +} + +func CloseFigure(hdc HDC) bool { + ret1 := syscall3(closeFigure, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func CloseMetaFile(hdc HDC) HMETAFILE { + ret1 := syscall3(closeMetaFile, 1, + uintptr(hdc), + 0, + 0) + return HMETAFILE(ret1) +} + +func ColorCorrectPalette(hdc HDC, hPal HPALETTE, deFirst DWORD, num DWORD) bool { + ret1 := syscall6(colorCorrectPalette, 4, + uintptr(hdc), + uintptr(hPal), + uintptr(deFirst), + uintptr(num), + 0, + 0) + return ret1 != 0 +} + +func ColorMatchToTarget(hdc HDC, hdcTarget HDC, action DWORD) bool { + ret1 := syscall3(colorMatchToTarget, 3, + uintptr(hdc), + uintptr(hdcTarget), + uintptr(action)) + return ret1 != 0 +} + +func CombineRgn(hrgnDst HRGN, hrgnSrc1 HRGN, hrgnSrc2 HRGN, iMode int32) int32 { + ret1 := syscall6(combineRgn, 4, + uintptr(hrgnDst), + uintptr(hrgnSrc1), + uintptr(hrgnSrc2), + uintptr(iMode), + 0, + 0) + return int32(ret1) +} + +func CombineTransform(lpxfOut *XFORM, lpxf1 /*const*/ *XFORM, lpxf2 /*const*/ *XFORM) bool { + ret1 := syscall3(combineTransform, 3, + uintptr(unsafe.Pointer(lpxfOut)), + uintptr(unsafe.Pointer(lpxf1)), + uintptr(unsafe.Pointer(lpxf2))) + return ret1 != 0 +} + +func CopyEnhMetaFile(hEnh HENHMETAFILE, lpFileName string) HENHMETAFILE { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(copyEnhMetaFile, 2, + uintptr(hEnh), + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + 0) + return HENHMETAFILE(ret1) +} + +func CopyMetaFile(unnamed0 HMETAFILE, unnamed1 string) HMETAFILE { + unnamed1Str := unicode16FromString(unnamed1) + ret1 := syscall3(copyMetaFile, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(&unnamed1Str[0])), + 0) + return HMETAFILE(ret1) +} + +func CreateBitmap(nWidth int32, nHeight int32, nPlanes UINT, nBitCount UINT, lpBits /*const*/ uintptr) HBITMAP { + ret1 := syscall6(createBitmap, 5, + uintptr(nWidth), + uintptr(nHeight), + uintptr(nPlanes), + uintptr(nBitCount), + lpBits, + 0) + return HBITMAP(ret1) +} + +func CreateBitmapIndirect(pbm /*const*/ *BITMAP) HBITMAP { + ret1 := syscall3(createBitmapIndirect, 1, + uintptr(unsafe.Pointer(pbm)), + 0, + 0) + return HBITMAP(ret1) +} + +func CreateBrushIndirect(plbrush /*const*/ *LOGBRUSH) HBRUSH { + ret1 := syscall3(createBrushIndirect, 1, + uintptr(unsafe.Pointer(plbrush)), + 0, + 0) + return HBRUSH(ret1) +} + +func CreateColorSpace(lplcs LPLOGCOLORSPACE) HCOLORSPACE { + ret1 := syscall3(createColorSpace, 1, + uintptr(unsafe.Pointer(lplcs)), + 0, + 0) + return HCOLORSPACE(ret1) +} + +func CreateCompatibleBitmap(hdc HDC, cx int32, cy int32) HBITMAP { + ret1 := syscall3(createCompatibleBitmap, 3, + uintptr(hdc), + uintptr(cx), + uintptr(cy)) + return HBITMAP(ret1) +} + +func CreateCompatibleDC(hdc HDC) HDC { + ret1 := syscall3(createCompatibleDC, 1, + uintptr(hdc), + 0, + 0) + return HDC(ret1) +} + +func CreateDC(pwszDriver string, pwszDevice string, pszPort string, pdm /*const*/ *DEVMODE) HDC { + pwszDriverStr := unicode16FromString(pwszDriver) + pwszDeviceStr := unicode16FromString(pwszDevice) + pszPortStr := unicode16FromString(pszPort) + ret1 := syscall6(createDC, 4, + uintptr(unsafe.Pointer(&pwszDriverStr[0])), + uintptr(unsafe.Pointer(&pwszDeviceStr[0])), + uintptr(unsafe.Pointer(&pszPortStr[0])), + uintptr(unsafe.Pointer(pdm)), + 0, + 0) + return HDC(ret1) +} + +func CreateDIBPatternBrush(h HGLOBAL, iUsage UINT) HBRUSH { + ret1 := syscall3(createDIBPatternBrush, 2, + uintptr(h), + uintptr(iUsage), + 0) + return HBRUSH(ret1) +} + +func CreateDIBPatternBrushPt(lpPackedDIB /*const*/ uintptr, iUsage UINT) HBRUSH { + ret1 := syscall3(createDIBPatternBrushPt, 2, + lpPackedDIB, + uintptr(iUsage), + 0) + return HBRUSH(ret1) +} + +func CreateDIBSection(hdc HDC, lpbmi /*const*/ *BITMAPINFO, usage UINT, ppvBits uintptr, hSection HANDLE, offset DWORD) HBITMAP { + ret1 := syscall6(createDIBSection, 6, + uintptr(hdc), + uintptr(unsafe.Pointer(lpbmi)), + uintptr(usage), + ppvBits, + uintptr(hSection), + uintptr(offset)) + return HBITMAP(ret1) +} + +func CreateDIBitmap(hdc HDC, pbmih /*const*/ *BITMAPINFOHEADER, flInit DWORD, pjBits /*const*/ uintptr, pbmi /*const*/ *BITMAPINFO, iUsage UINT) HBITMAP { + ret1 := syscall6(createDIBitmap, 6, + uintptr(hdc), + uintptr(unsafe.Pointer(pbmih)), + uintptr(flInit), + pjBits, + uintptr(unsafe.Pointer(pbmi)), + uintptr(iUsage)) + return HBITMAP(ret1) +} + +func CreateDiscardableBitmap(hdc HDC, cx int32, cy int32) HBITMAP { + ret1 := syscall3(createDiscardableBitmap, 3, + uintptr(hdc), + uintptr(cx), + uintptr(cy)) + return HBITMAP(ret1) +} + +func CreateEllipticRgn(x1 int32, y1 int32, x2 int32, y2 int32) HRGN { + ret1 := syscall6(createEllipticRgn, 4, + uintptr(x1), + uintptr(y1), + uintptr(x2), + uintptr(y2), + 0, + 0) + return HRGN(ret1) +} + +func CreateEllipticRgnIndirect(lprect /*const*/ *RECT) HRGN { + ret1 := syscall3(createEllipticRgnIndirect, 1, + uintptr(unsafe.Pointer(lprect)), + 0, + 0) + return HRGN(ret1) +} + +func CreateEnhMetaFile(hdc HDC, lpFilename string, lprc /*const*/ *RECT, lpDesc string) HDC { + lpFilenameStr := unicode16FromString(lpFilename) + lpDescStr := unicode16FromString(lpDesc) + ret1 := syscall6(createEnhMetaFile, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(&lpFilenameStr[0])), + uintptr(unsafe.Pointer(lprc)), + uintptr(unsafe.Pointer(&lpDescStr[0])), + 0, + 0) + return HDC(ret1) +} + +func CreateFontIndirectEx(unnamed0 /*const*/ *ENUMLOGFONTEXDV) HFONT { + ret1 := syscall3(createFontIndirectEx, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return HFONT(ret1) +} + +func CreateFontIndirect(lplf /*const*/ *LOGFONT) HFONT { + ret1 := syscall3(createFontIndirect, 1, + uintptr(unsafe.Pointer(lplf)), + 0, + 0) + return HFONT(ret1) +} + +func CreateFont(cHeight int32, cWidth int32, cEscapement int32, cOrientation int32, cWeight int32, bItalic DWORD, bUnderline DWORD, bStrikeOut DWORD, iCharSet DWORD, iOutPrecision DWORD, iClipPrecision DWORD, iQuality DWORD, iPitchAndFamily DWORD, pszFaceName string) HFONT { + pszFaceNameStr := unicode16FromString(pszFaceName) + ret1 := syscall15(createFont, 14, + uintptr(cHeight), + uintptr(cWidth), + uintptr(cEscapement), + uintptr(cOrientation), + uintptr(cWeight), + uintptr(bItalic), + uintptr(bUnderline), + uintptr(bStrikeOut), + uintptr(iCharSet), + uintptr(iOutPrecision), + uintptr(iClipPrecision), + uintptr(iQuality), + uintptr(iPitchAndFamily), + uintptr(unsafe.Pointer(&pszFaceNameStr[0])), + 0) + return HFONT(ret1) +} + +func CreateHalftonePalette(hdc HDC) HPALETTE { + ret1 := syscall3(createHalftonePalette, 1, + uintptr(hdc), + 0, + 0) + return HPALETTE(ret1) +} + +func CreateHatchBrush(iHatch int32, color COLORREF) HBRUSH { + ret1 := syscall3(createHatchBrush, 2, + uintptr(iHatch), + uintptr(color), + 0) + return HBRUSH(ret1) +} + +func CreateIC(pszDriver string, pszDevice string, pszPort string, pdm /*const*/ *DEVMODE) HDC { + pszDriverStr := unicode16FromString(pszDriver) + pszDeviceStr := unicode16FromString(pszDevice) + pszPortStr := unicode16FromString(pszPort) + ret1 := syscall6(createIC, 4, + uintptr(unsafe.Pointer(&pszDriverStr[0])), + uintptr(unsafe.Pointer(&pszDeviceStr[0])), + uintptr(unsafe.Pointer(&pszPortStr[0])), + uintptr(unsafe.Pointer(pdm)), + 0, + 0) + return HDC(ret1) +} + +func CreateMetaFile(pszFile string) HDC { + pszFileStr := unicode16FromString(pszFile) + ret1 := syscall3(createMetaFile, 1, + uintptr(unsafe.Pointer(&pszFileStr[0])), + 0, + 0) + return HDC(ret1) +} + +func CreatePalette(plpal /*const*/ *LOGPALETTE) HPALETTE { + ret1 := syscall3(createPalette, 1, + uintptr(unsafe.Pointer(plpal)), + 0, + 0) + return HPALETTE(ret1) +} + +func CreatePatternBrush(hbm HBITMAP) HBRUSH { + ret1 := syscall3(createPatternBrush, 1, + uintptr(hbm), + 0, + 0) + return HBRUSH(ret1) +} + +func CreatePen(iStyle int32, cWidth int32, color COLORREF) HPEN { + ret1 := syscall3(createPen, 3, + uintptr(iStyle), + uintptr(cWidth), + uintptr(color)) + return HPEN(ret1) +} + +func CreatePenIndirect(plpen /*const*/ *LOGPEN) HPEN { + ret1 := syscall3(createPenIndirect, 1, + uintptr(unsafe.Pointer(plpen)), + 0, + 0) + return HPEN(ret1) +} + +func CreatePolyPolygonRgn(pptl /*const*/ *POINT, pc /*const*/ *int32, cPoly int32, iMode int32) HRGN { + ret1 := syscall6(createPolyPolygonRgn, 4, + uintptr(unsafe.Pointer(pptl)), + uintptr(unsafe.Pointer(pc)), + uintptr(cPoly), + uintptr(iMode), + 0, + 0) + return HRGN(ret1) +} + +func CreatePolygonRgn(pptl /*const*/ *POINT, cPoint int32, iMode int32) HRGN { + ret1 := syscall3(createPolygonRgn, 3, + uintptr(unsafe.Pointer(pptl)), + uintptr(cPoint), + uintptr(iMode)) + return HRGN(ret1) +} + +func CreateRectRgn(x1 int32, y1 int32, x2 int32, y2 int32) HRGN { + ret1 := syscall6(createRectRgn, 4, + uintptr(x1), + uintptr(y1), + uintptr(x2), + uintptr(y2), + 0, + 0) + return HRGN(ret1) +} + +func CreateRectRgnIndirect(lprect /*const*/ *RECT) HRGN { + ret1 := syscall3(createRectRgnIndirect, 1, + uintptr(unsafe.Pointer(lprect)), + 0, + 0) + return HRGN(ret1) +} + +func CreateRoundRectRgn(x1 int32, y1 int32, x2 int32, y2 int32, w int32, h int32) HRGN { + ret1 := syscall6(createRoundRectRgn, 6, + uintptr(x1), + uintptr(y1), + uintptr(x2), + uintptr(y2), + uintptr(w), + uintptr(h)) + return HRGN(ret1) +} + +func CreateScalableFontResource(fdwHidden DWORD, lpszFont string, lpszFile string, lpszPath string) bool { + lpszFontStr := unicode16FromString(lpszFont) + lpszFileStr := unicode16FromString(lpszFile) + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall6(createScalableFontResource, 4, + uintptr(fdwHidden), + uintptr(unsafe.Pointer(&lpszFontStr[0])), + uintptr(unsafe.Pointer(&lpszFileStr[0])), + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func CreateSolidBrush(color COLORREF) HBRUSH { + ret1 := syscall3(createSolidBrush, 1, + uintptr(color), + 0, + 0) + return HBRUSH(ret1) +} + +func DPtoLP(hdc HDC, lppt *POINT, c int32) bool { + ret1 := syscall3(dPtoLP, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(lppt)), + uintptr(c)) + return ret1 != 0 +} + +func DeleteColorSpace(hcs HCOLORSPACE) bool { + ret1 := syscall3(deleteColorSpace, 1, + uintptr(hcs), + 0, + 0) + return ret1 != 0 +} + +func DeleteDC(hdc HDC) bool { + ret1 := syscall3(deleteDC, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func DeleteEnhMetaFile(hmf HENHMETAFILE) bool { + ret1 := syscall3(deleteEnhMetaFile, 1, + uintptr(hmf), + 0, + 0) + return ret1 != 0 +} + +func DeleteMetaFile(hmf HMETAFILE) bool { + ret1 := syscall3(deleteMetaFile, 1, + uintptr(hmf), + 0, + 0) + return ret1 != 0 +} + +func DeleteObject(ho HGDIOBJ) bool { + ret1 := syscall3(deleteObject, 1, + uintptr(ho), + 0, + 0) + return ret1 != 0 +} + +func DescribePixelFormat(hdc HDC, iPixelFormat int32, nBytes UINT, ppfd *PIXELFORMATDESCRIPTOR) int32 { + ret1 := syscall6(describePixelFormat, 4, + uintptr(hdc), + uintptr(iPixelFormat), + uintptr(nBytes), + uintptr(unsafe.Pointer(ppfd)), + 0, + 0) + return int32(ret1) +} + +func DrawEscape(hdc HDC, iEscape int32, cjIn int32, lpIn /*const*/ LPCSTR) int32 { + ret1 := syscall6(drawEscape, 4, + uintptr(hdc), + uintptr(iEscape), + uintptr(cjIn), + uintptr(unsafe.Pointer(lpIn)), + 0, + 0) + return int32(ret1) +} + +func Ellipse(hdc HDC, left int32, top int32, right int32, bottom int32) bool { + ret1 := syscall6(ellipse, 5, + uintptr(hdc), + uintptr(left), + uintptr(top), + uintptr(right), + uintptr(bottom), + 0) + return ret1 != 0 +} + +func EndDoc(hdc HDC) int32 { + ret1 := syscall3(endDoc, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func EndPage(hdc HDC) int32 { + ret1 := syscall3(endPage, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func EndPath(hdc HDC) bool { + ret1 := syscall3(endPath, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func EngAcquireSemaphore(hsem HSEMAPHORE) { + syscall3(engAcquireSemaphore, 1, + uintptr(hsem), + 0, + 0) +} + +func EngAlphaBlend(psoDest *SURFOBJ, psoSrc *SURFOBJ, pco *CLIPOBJ, pxlo *XLATEOBJ, prclDest *RECTL, prclSrc *RECTL, pBlendObj *BLENDOBJ) bool { + ret1 := syscall9(engAlphaBlend, 7, + uintptr(unsafe.Pointer(psoDest)), + uintptr(unsafe.Pointer(psoSrc)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pxlo)), + uintptr(unsafe.Pointer(prclDest)), + uintptr(unsafe.Pointer(prclSrc)), + uintptr(unsafe.Pointer(pBlendObj)), + 0, + 0) + return ret1 != 0 +} + +func EngAssociateSurface(hsurf HSURF, hdev HDEV, flHooks FLONG) bool { + ret1 := syscall3(engAssociateSurface, 3, + uintptr(hsurf), + uintptr(hdev), + uintptr(flHooks)) + return ret1 != 0 +} + +func EngBitBlt(psoTrg *SURFOBJ, psoSrc *SURFOBJ, psoMask *SURFOBJ, pco *CLIPOBJ, pxlo *XLATEOBJ, prclTrg *RECTL, pptlSrc *POINTL, pptlMask *POINTL, pbo *BRUSHOBJ, pptlBrush *POINTL, rop4 ROP4) bool { + ret1 := syscall12(engBitBlt, 11, + uintptr(unsafe.Pointer(psoTrg)), + uintptr(unsafe.Pointer(psoSrc)), + uintptr(unsafe.Pointer(psoMask)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pxlo)), + uintptr(unsafe.Pointer(prclTrg)), + uintptr(unsafe.Pointer(pptlSrc)), + uintptr(unsafe.Pointer(pptlMask)), + uintptr(unsafe.Pointer(pbo)), + uintptr(unsafe.Pointer(pptlBrush)), + uintptr(rop4), + 0) + return ret1 != 0 +} + +func EngCheckAbort(pso *SURFOBJ) bool { + ret1 := syscall3(engCheckAbort, 1, + uintptr(unsafe.Pointer(pso)), + 0, + 0) + return ret1 != 0 +} + +func EngCopyBits(psoDest *SURFOBJ, psoSrc *SURFOBJ, pco *CLIPOBJ, pxlo *XLATEOBJ, prclDest *RECTL, pptlSrc *POINTL) bool { + ret1 := syscall6(engCopyBits, 6, + uintptr(unsafe.Pointer(psoDest)), + uintptr(unsafe.Pointer(psoSrc)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pxlo)), + uintptr(unsafe.Pointer(prclDest)), + uintptr(unsafe.Pointer(pptlSrc))) + return ret1 != 0 +} + +func EngCreateBitmap(sizl SIZEL, lWidth LONG, iFormat ULONG, fl FLONG, pvBits uintptr) HBITMAP { + ret1 := syscall6(engCreateBitmap, 6, + uintptr(sizl.Cx), + uintptr(sizl.Cy), + uintptr(lWidth), + uintptr(iFormat), + uintptr(fl), + pvBits) + return HBITMAP(ret1) +} + +func EngCreateDeviceBitmap(dhsurf DHSURF, sizl SIZEL, iFormatCompat ULONG) HBITMAP { + ret1 := syscall6(engCreateDeviceBitmap, 4, + uintptr(dhsurf), + uintptr(sizl.Cx), + uintptr(sizl.Cy), + uintptr(iFormatCompat), + 0, + 0) + return HBITMAP(ret1) +} + +func EngCreateDeviceSurface(dhsurf DHSURF, sizl SIZEL, iFormatCompat ULONG) HSURF { + ret1 := syscall6(engCreateDeviceSurface, 4, + uintptr(dhsurf), + uintptr(sizl.Cx), + uintptr(sizl.Cy), + uintptr(iFormatCompat), + 0, + 0) + return HSURF(ret1) +} + +func EngCreatePalette(iMode ULONG, cColors ULONG, pulColors *ULONG, flRed FLONG, flGreen FLONG, flBlue FLONG) HPALETTE { + ret1 := syscall6(engCreatePalette, 6, + uintptr(iMode), + uintptr(cColors), + uintptr(unsafe.Pointer(pulColors)), + uintptr(flRed), + uintptr(flGreen), + uintptr(flBlue)) + return HPALETTE(ret1) +} + +func EngCreateSemaphore() HSEMAPHORE { + ret1 := syscall3(engCreateSemaphore, 0, + 0, + 0, + 0) + return HSEMAPHORE(ret1) +} + +func EngDeleteClip(pco *CLIPOBJ) { + syscall3(engDeleteClip, 1, + uintptr(unsafe.Pointer(pco)), + 0, + 0) +} + +func EngDeletePalette(hpal HPALETTE) bool { + ret1 := syscall3(engDeletePalette, 1, + uintptr(hpal), + 0, + 0) + return ret1 != 0 +} + +func EngDeletePath(ppo *PATHOBJ) { + syscall3(engDeletePath, 1, + uintptr(unsafe.Pointer(ppo)), + 0, + 0) +} + +func EngDeleteSemaphore(hsem HSEMAPHORE) { + syscall3(engDeleteSemaphore, 1, + uintptr(hsem), + 0, + 0) +} + +func EngDeleteSurface(hsurf HSURF) bool { + ret1 := syscall3(engDeleteSurface, 1, + uintptr(hsurf), + 0, + 0) + return ret1 != 0 +} + +func EngEraseSurface(pso *SURFOBJ, prcl *RECTL, iColor ULONG) bool { + ret1 := syscall3(engEraseSurface, 3, + uintptr(unsafe.Pointer(pso)), + uintptr(unsafe.Pointer(prcl)), + uintptr(iColor)) + return ret1 != 0 +} + +func EngFillPath(pso *SURFOBJ, ppo *PATHOBJ, pco *CLIPOBJ, pbo *BRUSHOBJ, pptlBrushOrg *POINTL, mix MIX, flOptions FLONG) bool { + ret1 := syscall9(engFillPath, 7, + uintptr(unsafe.Pointer(pso)), + uintptr(unsafe.Pointer(ppo)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pbo)), + uintptr(unsafe.Pointer(pptlBrushOrg)), + uintptr(mix), + uintptr(flOptions), + 0, + 0) + return ret1 != 0 +} + +func EngFindResource(h HANDLE, iName int32, iType int32, pulSize *uint32) uintptr { + ret1 := syscall6(engFindResource, 4, + uintptr(h), + uintptr(iName), + uintptr(iType), + uintptr(unsafe.Pointer(pulSize)), + 0, + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func EngFreeModule(h HANDLE) { + syscall3(engFreeModule, 1, + uintptr(h), + 0, + 0) +} + +func EngGetCurrentCodePage(oemCodePage PUSHORT, ansiCodePage PUSHORT) { + syscall3(engGetCurrentCodePage, 2, + uintptr(unsafe.Pointer(oemCodePage)), + uintptr(unsafe.Pointer(ansiCodePage)), + 0) +} + +func EngGetDriverName(hdev HDEV) LPWSTR { + ret1 := syscall3(engGetDriverName, 1, + uintptr(hdev), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func EngGetPrinterDataFileName(hdev HDEV) LPWSTR { + ret1 := syscall3(engGetPrinterDataFileName, 1, + uintptr(hdev), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func EngGradientFill(psoDest *SURFOBJ, pco *CLIPOBJ, pxlo *XLATEOBJ, pVertex *TRIVERTEX, nVertex ULONG, pMesh uintptr, nMesh ULONG, prclExtents *RECTL, pptlDitherOrg *POINTL, ulMode ULONG) bool { + ret1 := syscall12(engGradientFill, 10, + uintptr(unsafe.Pointer(psoDest)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pxlo)), + uintptr(unsafe.Pointer(pVertex)), + uintptr(nVertex), + pMesh, + uintptr(nMesh), + uintptr(unsafe.Pointer(prclExtents)), + uintptr(unsafe.Pointer(pptlDitherOrg)), + uintptr(ulMode), + 0, + 0) + return ret1 != 0 +} + +func EngLineTo(pso *SURFOBJ, pco *CLIPOBJ, pbo *BRUSHOBJ, x1 LONG, y1 LONG, x2 LONG, y2 LONG, prclBounds *RECTL, mix MIX) bool { + ret1 := syscall9(engLineTo, 9, + uintptr(unsafe.Pointer(pso)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pbo)), + uintptr(x1), + uintptr(y1), + uintptr(x2), + uintptr(y2), + uintptr(unsafe.Pointer(prclBounds)), + uintptr(mix)) + return ret1 != 0 +} + +func EngLoadModule(pwsz LPWSTR) HANDLE { + ret1 := syscall3(engLoadModule, 1, + uintptr(unsafe.Pointer(pwsz)), + 0, + 0) + return HANDLE(ret1) +} + +func EngMarkBandingSurface(hsurf HSURF) bool { + ret1 := syscall3(engMarkBandingSurface, 1, + uintptr(hsurf), + 0, + 0) + return ret1 != 0 +} + +func EngMultiByteToUnicodeN(unicodeString LPWSTR, maxBytesInUnicodeString ULONG, bytesInUnicodeString *uint32, multiByteString PCHAR, bytesInMultiByteString ULONG) { + syscall6(engMultiByteToUnicodeN, 5, + uintptr(unsafe.Pointer(unicodeString)), + uintptr(maxBytesInUnicodeString), + uintptr(unsafe.Pointer(bytesInUnicodeString)), + uintptr(unsafe.Pointer(multiByteString)), + uintptr(bytesInMultiByteString), + 0) +} + +func EngMultiByteToWideChar(codePage UINT, wideCharString LPWSTR, bytesInWideCharString INT, multiByteString LPSTR, bytesInMultiByteString INT) INT { + ret1 := syscall6(engMultiByteToWideChar, 5, + uintptr(codePage), + uintptr(unsafe.Pointer(wideCharString)), + uintptr(bytesInWideCharString), + uintptr(unsafe.Pointer(multiByteString)), + uintptr(bytesInMultiByteString), + 0) + return INT(ret1) +} + +func EngPaint(pso *SURFOBJ, pco *CLIPOBJ, pbo *BRUSHOBJ, pptlBrushOrg *POINTL, mix MIX) bool { + ret1 := syscall6(engPaint, 5, + uintptr(unsafe.Pointer(pso)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pbo)), + uintptr(unsafe.Pointer(pptlBrushOrg)), + uintptr(mix), + 0) + return ret1 != 0 +} + +func EngPlgBlt(psoTrg *SURFOBJ, psoSrc *SURFOBJ, psoMsk *SURFOBJ, pco *CLIPOBJ, pxlo *XLATEOBJ, pca *COLORADJUSTMENT, pptlBrushOrg *POINTL, pptfx *POINTFIX, prcl *RECTL, pptl *POINTL, iMode ULONG) bool { + ret1 := syscall12(engPlgBlt, 11, + uintptr(unsafe.Pointer(psoTrg)), + uintptr(unsafe.Pointer(psoSrc)), + uintptr(unsafe.Pointer(psoMsk)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pxlo)), + uintptr(unsafe.Pointer(pca)), + uintptr(unsafe.Pointer(pptlBrushOrg)), + uintptr(unsafe.Pointer(pptfx)), + uintptr(unsafe.Pointer(prcl)), + uintptr(unsafe.Pointer(pptl)), + uintptr(iMode), + 0) + return ret1 != 0 +} + +func EngQueryLocalTime(ptf PENG_TIME_FIELDS) { + syscall3(engQueryLocalTime, 1, + uintptr(unsafe.Pointer(ptf)), + 0, + 0) +} + +func EngReleaseSemaphore(hsem HSEMAPHORE) { + syscall3(engReleaseSemaphore, 1, + uintptr(hsem), + 0, + 0) +} + +func EngStretchBlt(psoDest *SURFOBJ, psoSrc *SURFOBJ, psoMask *SURFOBJ, pco *CLIPOBJ, pxlo *XLATEOBJ, pca *COLORADJUSTMENT, pptlHTOrg *POINTL, prclDest *RECTL, prclSrc *RECTL, pptlMask *POINTL, iMode ULONG) bool { + ret1 := syscall12(engStretchBlt, 11, + uintptr(unsafe.Pointer(psoDest)), + uintptr(unsafe.Pointer(psoSrc)), + uintptr(unsafe.Pointer(psoMask)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pxlo)), + uintptr(unsafe.Pointer(pca)), + uintptr(unsafe.Pointer(pptlHTOrg)), + uintptr(unsafe.Pointer(prclDest)), + uintptr(unsafe.Pointer(prclSrc)), + uintptr(unsafe.Pointer(pptlMask)), + uintptr(iMode), + 0) + return ret1 != 0 +} + +func EngStretchBltROP(psoDest *SURFOBJ, psoSrc *SURFOBJ, psoMask *SURFOBJ, pco *CLIPOBJ, pxlo *XLATEOBJ, pca *COLORADJUSTMENT, pptlHTOrg *POINTL, prclDest *RECTL, prclSrc *RECTL, pptlMask *POINTL, iMode ULONG, pbo *BRUSHOBJ, rop4 DWORD) bool { + ret1 := syscall15(engStretchBltROP, 13, + uintptr(unsafe.Pointer(psoDest)), + uintptr(unsafe.Pointer(psoSrc)), + uintptr(unsafe.Pointer(psoMask)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pxlo)), + uintptr(unsafe.Pointer(pca)), + uintptr(unsafe.Pointer(pptlHTOrg)), + uintptr(unsafe.Pointer(prclDest)), + uintptr(unsafe.Pointer(prclSrc)), + uintptr(unsafe.Pointer(pptlMask)), + uintptr(iMode), + uintptr(unsafe.Pointer(pbo)), + uintptr(rop4), + 0, + 0) + return ret1 != 0 +} + +func EngStrokeAndFillPath(pso *SURFOBJ, ppo *PATHOBJ, pco *CLIPOBJ, pxo *XFORMOBJ, pboStroke *BRUSHOBJ, plineattrs *LINEATTRS, pboFill *BRUSHOBJ, pptlBrushOrg *POINTL, mixFill MIX, flOptions FLONG) bool { + ret1 := syscall12(engStrokeAndFillPath, 10, + uintptr(unsafe.Pointer(pso)), + uintptr(unsafe.Pointer(ppo)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pxo)), + uintptr(unsafe.Pointer(pboStroke)), + uintptr(unsafe.Pointer(plineattrs)), + uintptr(unsafe.Pointer(pboFill)), + uintptr(unsafe.Pointer(pptlBrushOrg)), + uintptr(mixFill), + uintptr(flOptions), + 0, + 0) + return ret1 != 0 +} + +func EngStrokePath(pso *SURFOBJ, ppo *PATHOBJ, pco *CLIPOBJ, pxo *XFORMOBJ, pbo *BRUSHOBJ, pptlBrushOrg *POINTL, plineattrs *LINEATTRS, mix MIX) bool { + ret1 := syscall9(engStrokePath, 8, + uintptr(unsafe.Pointer(pso)), + uintptr(unsafe.Pointer(ppo)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pxo)), + uintptr(unsafe.Pointer(pbo)), + uintptr(unsafe.Pointer(pptlBrushOrg)), + uintptr(unsafe.Pointer(plineattrs)), + uintptr(mix), + 0) + return ret1 != 0 +} + +func EngTextOut(pso *SURFOBJ, pstro *STROBJ, pfo *FONTOBJ, pco *CLIPOBJ, prclExtra *RECTL, prclOpaque *RECTL, pboFore *BRUSHOBJ, pboOpaque *BRUSHOBJ, pptlOrg *POINTL, mix MIX) bool { + ret1 := syscall12(engTextOut, 10, + uintptr(unsafe.Pointer(pso)), + uintptr(unsafe.Pointer(pstro)), + uintptr(unsafe.Pointer(pfo)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(prclExtra)), + uintptr(unsafe.Pointer(prclOpaque)), + uintptr(unsafe.Pointer(pboFore)), + uintptr(unsafe.Pointer(pboOpaque)), + uintptr(unsafe.Pointer(pptlOrg)), + uintptr(mix), + 0, + 0) + return ret1 != 0 +} + +func EngTransparentBlt(psoDst *SURFOBJ, psoSrc *SURFOBJ, pco *CLIPOBJ, pxlo *XLATEOBJ, prclDst *RECTL, prclSrc *RECTL, iTransColor ULONG, ulReserved ULONG) bool { + ret1 := syscall9(engTransparentBlt, 8, + uintptr(unsafe.Pointer(psoDst)), + uintptr(unsafe.Pointer(psoSrc)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pxlo)), + uintptr(unsafe.Pointer(prclDst)), + uintptr(unsafe.Pointer(prclSrc)), + uintptr(iTransColor), + uintptr(ulReserved), + 0) + return ret1 != 0 +} + +func EngUnicodeToMultiByteN(multiByteString PCHAR, maxBytesInMultiByteString ULONG, bytesInMultiByteString *uint32, unicodeString PWSTR, bytesInUnicodeString ULONG) { + syscall6(engUnicodeToMultiByteN, 5, + uintptr(unsafe.Pointer(multiByteString)), + uintptr(maxBytesInMultiByteString), + uintptr(unsafe.Pointer(bytesInMultiByteString)), + uintptr(unsafe.Pointer(unicodeString)), + uintptr(bytesInUnicodeString), + 0) +} + +func EngUnlockSurface(pso *SURFOBJ) { + syscall3(engUnlockSurface, 1, + uintptr(unsafe.Pointer(pso)), + 0, + 0) +} + +func EngWideCharToMultiByte(codePage UINT, wideCharString LPWSTR, bytesInWideCharString INT, multiByteString LPSTR, bytesInMultiByteString INT) INT { + ret1 := syscall6(engWideCharToMultiByte, 5, + uintptr(codePage), + uintptr(unsafe.Pointer(wideCharString)), + uintptr(bytesInWideCharString), + uintptr(unsafe.Pointer(multiByteString)), + uintptr(bytesInMultiByteString), + 0) + return INT(ret1) +} + +func EnumEnhMetaFile(hdc HDC, hmf HENHMETAFILE, lpProc ENHMFENUMPROC, lpParam LPVOID, lpRect /*const*/ *RECT) bool { + lpProcCallback := syscall.NewCallback(func(hdcRawArg HDC, lphtRawArg *HANDLETABLE, lpmrRawArg /*const*/ *ENHMETARECORD, nHandlesRawArg int32, dataRawArg LPARAM) uintptr { + ret := lpProc(hdcRawArg, lphtRawArg, lpmrRawArg, nHandlesRawArg, dataRawArg) + return uintptr(ret) + }) + ret1 := syscall6(enumEnhMetaFile, 5, + uintptr(hdc), + uintptr(hmf), + lpProcCallback, + uintptr(unsafe.Pointer(lpParam)), + uintptr(unsafe.Pointer(lpRect)), + 0) + return ret1 != 0 +} + +func EnumFontFamiliesEx(hdc HDC, lpLogfont LPLOGFONT, lpProc FONTENUMPROC, lParam LPARAM, dwFlags DWORD) int32 { + lpProcCallback := syscall.NewCallback(func(unnamed0RawArg /*const*/ *LOGFONT, unnamed1RawArg /*const*/ *TEXTMETRIC, unnamed2RawArg DWORD, unnamed3RawArg LPARAM) uintptr { + ret := lpProc(unnamed0RawArg, unnamed1RawArg, unnamed2RawArg, unnamed3RawArg) + return uintptr(ret) + }) + ret1 := syscall6(enumFontFamiliesEx, 5, + uintptr(hdc), + uintptr(unsafe.Pointer(lpLogfont)), + lpProcCallback, + uintptr(lParam), + uintptr(dwFlags), + 0) + return int32(ret1) +} + +func EnumFontFamilies(hdc HDC, lpLogfont string, lpProc FONTENUMPROC, lParam LPARAM) int32 { + lpLogfontStr := unicode16FromString(lpLogfont) + lpProcCallback := syscall.NewCallback(func(unnamed0RawArg /*const*/ *LOGFONT, unnamed1RawArg /*const*/ *TEXTMETRIC, unnamed2RawArg DWORD, unnamed3RawArg LPARAM) uintptr { + ret := lpProc(unnamed0RawArg, unnamed1RawArg, unnamed2RawArg, unnamed3RawArg) + return uintptr(ret) + }) + ret1 := syscall6(enumFontFamilies, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(&lpLogfontStr[0])), + lpProcCallback, + uintptr(lParam), + 0, + 0) + return int32(ret1) +} + +func EnumFonts(hdc HDC, lpLogfont string, lpProc FONTENUMPROC, lParam LPARAM) int32 { + lpLogfontStr := unicode16FromString(lpLogfont) + lpProcCallback := syscall.NewCallback(func(unnamed0RawArg /*const*/ *LOGFONT, unnamed1RawArg /*const*/ *TEXTMETRIC, unnamed2RawArg DWORD, unnamed3RawArg LPARAM) uintptr { + ret := lpProc(unnamed0RawArg, unnamed1RawArg, unnamed2RawArg, unnamed3RawArg) + return uintptr(ret) + }) + ret1 := syscall6(enumFonts, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(&lpLogfontStr[0])), + lpProcCallback, + uintptr(lParam), + 0, + 0) + return int32(ret1) +} + +func EnumICMProfiles(hdc HDC, lpProc ICMENUMPROC, lParam LPARAM) int32 { + lpProcCallback := syscall.NewCallback(func(unnamed0RawArg LPWSTR, unnamed1RawArg LPARAM) uintptr { + ret := lpProc(unnamed0RawArg, unnamed1RawArg) + return uintptr(ret) + }) + ret1 := syscall3(enumICMProfiles, 3, + uintptr(hdc), + lpProcCallback, + uintptr(lParam)) + return int32(ret1) +} + +func EnumMetaFile(hdc HDC, hmf HMETAFILE, lpProc MFENUMPROC, lParam LPARAM) bool { + lpProcCallback := syscall.NewCallback(func(hdcRawArg HDC, lphtRawArg *HANDLETABLE, lpMRRawArg *METARECORD, nObjRawArg int32, paramRawArg LPARAM) uintptr { + ret := lpProc(hdcRawArg, lphtRawArg, lpMRRawArg, nObjRawArg, paramRawArg) + return uintptr(ret) + }) + ret1 := syscall6(enumMetaFile, 4, + uintptr(hdc), + uintptr(hmf), + lpProcCallback, + uintptr(lParam), + 0, + 0) + return ret1 != 0 +} + +func EnumObjects(hdc HDC, nType int32, lpFunc GOBJENUMPROC, lParam LPARAM) int32 { + lpFuncCallback := syscall.NewCallback(func(unnamed0RawArg LPVOID, unnamed1RawArg LPARAM) uintptr { + ret := lpFunc(unnamed0RawArg, unnamed1RawArg) + return uintptr(ret) + }) + ret1 := syscall6(enumObjects, 4, + uintptr(hdc), + uintptr(nType), + lpFuncCallback, + uintptr(lParam), + 0, + 0) + return int32(ret1) +} + +func EqualRgn(hrgn1 HRGN, hrgn2 HRGN) bool { + ret1 := syscall3(equalRgn, 2, + uintptr(hrgn1), + uintptr(hrgn2), + 0) + return ret1 != 0 +} + +func Escape(hdc HDC, iEscape int32, cjIn int32, pvIn /*const*/ LPCSTR, pvOut LPVOID) int32 { + ret1 := syscall6(escape, 5, + uintptr(hdc), + uintptr(iEscape), + uintptr(cjIn), + uintptr(unsafe.Pointer(pvIn)), + uintptr(unsafe.Pointer(pvOut)), + 0) + return int32(ret1) +} + +func ExcludeClipRect(hdc HDC, left int32, top int32, right int32, bottom int32) int32 { + ret1 := syscall6(excludeClipRect, 5, + uintptr(hdc), + uintptr(left), + uintptr(top), + uintptr(right), + uintptr(bottom), + 0) + return int32(ret1) +} + +func ExtCreatePen(iPenStyle DWORD, cWidth DWORD, plbrush /*const*/ *LOGBRUSH, cStyle DWORD, pstyle /*const*/ *uint32) HPEN { + ret1 := syscall6(extCreatePen, 5, + uintptr(iPenStyle), + uintptr(cWidth), + uintptr(unsafe.Pointer(plbrush)), + uintptr(cStyle), + uintptr(unsafe.Pointer(pstyle)), + 0) + return HPEN(ret1) +} + +func ExtCreateRegion(lpx /*const*/ *XFORM, nCount DWORD, lpData /*const*/ *RGNDATA) HRGN { + ret1 := syscall3(extCreateRegion, 3, + uintptr(unsafe.Pointer(lpx)), + uintptr(nCount), + uintptr(unsafe.Pointer(lpData))) + return HRGN(ret1) +} + +func ExtEscape(hdc HDC, iEscape int32, cjInput int32, lpInData /*const*/ LPCSTR, cjOutput int32, lpOutData LPSTR) int32 { + ret1 := syscall6(extEscape, 6, + uintptr(hdc), + uintptr(iEscape), + uintptr(cjInput), + uintptr(unsafe.Pointer(lpInData)), + uintptr(cjOutput), + uintptr(unsafe.Pointer(lpOutData))) + return int32(ret1) +} + +func ExtFloodFill(hdc HDC, x int32, y int32, color COLORREF, aType UINT) bool { + ret1 := syscall6(extFloodFill, 5, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(color), + uintptr(aType), + 0) + return ret1 != 0 +} + +func ExtSelectClipRgn(hdc HDC, hrgn HRGN, mode int32) int32 { + ret1 := syscall3(extSelectClipRgn, 3, + uintptr(hdc), + uintptr(hrgn), + uintptr(mode)) + return int32(ret1) +} + +func ExtTextOut(hdc HDC, x int32, y int32, options UINT, lprect /*const*/ *RECT, lpString string, c UINT, lpDx /*const*/ *int32) bool { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall9(extTextOut, 8, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(options), + uintptr(unsafe.Pointer(lprect)), + uintptr(unsafe.Pointer(&lpStringStr[0])), + uintptr(c), + uintptr(unsafe.Pointer(lpDx)), + 0) + return ret1 != 0 +} + +func FONTOBJ_cGetAllGlyphHandles(pfo *FONTOBJ, phg *HGLYPH) ULONG { + ret1 := syscall3(fONTOBJ_cGetAllGlyphHandles, 2, + uintptr(unsafe.Pointer(pfo)), + uintptr(unsafe.Pointer(phg)), + 0) + return ULONG(ret1) +} + +func FONTOBJ_cGetGlyphs(pfo *FONTOBJ, iMode ULONG, cGlyph ULONG, phg *HGLYPH, ppvGlyph *PVOID) ULONG { + ret1 := syscall6(fONTOBJ_cGetGlyphs, 5, + uintptr(unsafe.Pointer(pfo)), + uintptr(iMode), + uintptr(cGlyph), + uintptr(unsafe.Pointer(phg)), + uintptr(unsafe.Pointer(ppvGlyph)), + 0) + return ULONG(ret1) +} + +func FONTOBJ_pQueryGlyphAttrs(pfo *FONTOBJ, iMode ULONG) PFD_GLYPHATTR { + ret1 := syscall3(fONTOBJ_pQueryGlyphAttrs, 2, + uintptr(unsafe.Pointer(pfo)), + uintptr(iMode), + 0) + return (PFD_GLYPHATTR)(unsafe.Pointer(ret1)) +} + +func FONTOBJ_pvTrueTypeFontFile(pfo *FONTOBJ, pcjFile *ULONG) uintptr { + ret1 := syscall3(fONTOBJ_pvTrueTypeFontFile, 2, + uintptr(unsafe.Pointer(pfo)), + uintptr(unsafe.Pointer(pcjFile)), + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func FONTOBJ_vGetInfo(pfo *FONTOBJ, cjSize ULONG, pfi *FONTINFO) { + syscall3(fONTOBJ_vGetInfo, 3, + uintptr(unsafe.Pointer(pfo)), + uintptr(cjSize), + uintptr(unsafe.Pointer(pfi))) +} + +func FillPath(hdc HDC) bool { + ret1 := syscall3(fillPath, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func FillRgn(hdc HDC, hrgn HRGN, hbr HBRUSH) bool { + ret1 := syscall3(fillRgn, 3, + uintptr(hdc), + uintptr(hrgn), + uintptr(hbr)) + return ret1 != 0 +} + +func FixBrushOrgEx(hdc HDC, x int32, y int32, ptl *POINT) bool { + ret1 := syscall6(fixBrushOrgEx, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(ptl)), + 0, + 0) + return ret1 != 0 +} + +func FlattenPath(hdc HDC) bool { + ret1 := syscall3(flattenPath, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func FloodFill(hdc HDC, x int32, y int32, color COLORREF) bool { + ret1 := syscall6(floodFill, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(color), + 0, + 0) + return ret1 != 0 +} + +func FrameRgn(hdc HDC, hrgn HRGN, hbr HBRUSH, w int32, h int32) bool { + ret1 := syscall6(frameRgn, 5, + uintptr(hdc), + uintptr(hrgn), + uintptr(hbr), + uintptr(w), + uintptr(h), + 0) + return ret1 != 0 +} + +func GdiAlphaBlend(hdcDest HDC, xoriginDest int32, yoriginDest int32, wDest int32, hDest int32, hdcSrc HDC, xoriginSrc int32, yoriginSrc int32, wSrc int32, hSrc int32, ftn BLENDFUNCTION) bool { + ret1 := syscall12(gdiAlphaBlend, 11, + uintptr(hdcDest), + uintptr(xoriginDest), + uintptr(yoriginDest), + uintptr(wDest), + uintptr(hDest), + uintptr(hdcSrc), + uintptr(xoriginSrc), + uintptr(yoriginSrc), + uintptr(wSrc), + uintptr(hSrc), + getUintptrFromBLENDFUNCTION(ftn), + 0) + return ret1 != 0 +} + +func GdiComment(hdc HDC, nSize UINT, lpData /*const*/ *byte) bool { + ret1 := syscall3(gdiComment, 3, + uintptr(hdc), + uintptr(nSize), + uintptr(unsafe.Pointer(lpData))) + return ret1 != 0 +} + +func GdiFlush() bool { + ret1 := syscall3(gdiFlush, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func GdiGetBatchLimit() DWORD { + ret1 := syscall3(gdiGetBatchLimit, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func GdiGradientFill(hdc HDC, pVertex PTRIVERTEX, nVertex ULONG, pMesh uintptr, nMesh ULONG, ulMode ULONG) bool { + ret1 := syscall6(gdiGradientFill, 6, + uintptr(hdc), + uintptr(unsafe.Pointer(pVertex)), + uintptr(nVertex), + pMesh, + uintptr(nMesh), + uintptr(ulMode)) + return ret1 != 0 +} + +func GdiSetBatchLimit(dw DWORD) DWORD { + ret1 := syscall3(gdiSetBatchLimit, 1, + uintptr(dw), + 0, + 0) + return DWORD(ret1) +} + +func GdiTransparentBlt(hdcDest HDC, xoriginDest int32, yoriginDest int32, wDest int32, hDest int32, hdcSrc HDC, xoriginSrc int32, yoriginSrc int32, wSrc int32, hSrc int32, crTransparent UINT) bool { + ret1 := syscall12(gdiTransparentBlt, 11, + uintptr(hdcDest), + uintptr(xoriginDest), + uintptr(yoriginDest), + uintptr(wDest), + uintptr(hDest), + uintptr(hdcSrc), + uintptr(xoriginSrc), + uintptr(yoriginSrc), + uintptr(wSrc), + uintptr(hSrc), + uintptr(crTransparent), + 0) + return ret1 != 0 +} + +func GetArcDirection(hdc HDC) int32 { + ret1 := syscall3(getArcDirection, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func GetAspectRatioFilterEx(hdc HDC, lpsize *SIZE) bool { + ret1 := syscall3(getAspectRatioFilterEx, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpsize)), + 0) + return ret1 != 0 +} + +func GetBitmapBits(hbit HBITMAP, cb LONG, lpvBits LPVOID) LONG { + ret1 := syscall3(getBitmapBits, 3, + uintptr(hbit), + uintptr(cb), + uintptr(unsafe.Pointer(lpvBits))) + return LONG(ret1) +} + +func GetBitmapDimensionEx(hbit HBITMAP, lpsize *SIZE) bool { + ret1 := syscall3(getBitmapDimensionEx, 2, + uintptr(hbit), + uintptr(unsafe.Pointer(lpsize)), + 0) + return ret1 != 0 +} + +func GetBkColor(hdc HDC) COLORREF { + ret1 := syscall3(getBkColor, 1, + uintptr(hdc), + 0, + 0) + return COLORREF(ret1) +} + +func GetBkMode(hdc HDC) int32 { + ret1 := syscall3(getBkMode, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func GetBoundsRect(hdc HDC, lprect *RECT, flags UINT) UINT { + ret1 := syscall3(getBoundsRect, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(lprect)), + uintptr(flags)) + return UINT(ret1) +} + +func GetBrushOrgEx(hdc HDC, lppt *POINT) bool { + ret1 := syscall3(getBrushOrgEx, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lppt)), + 0) + return ret1 != 0 +} + +func GetCharABCWidthsFloat(hdc HDC, iFirst UINT, iLast UINT, lpABC *ABCFLOAT) bool { + ret1 := syscall6(getCharABCWidthsFloat, 4, + uintptr(hdc), + uintptr(iFirst), + uintptr(iLast), + uintptr(unsafe.Pointer(lpABC)), + 0, + 0) + return ret1 != 0 +} + +func GetCharABCWidthsI(hdc HDC, giFirst UINT, cgi UINT, pgi *uint16, pabc *ABC) bool { + ret1 := syscall6(getCharABCWidthsI, 5, + uintptr(hdc), + uintptr(giFirst), + uintptr(cgi), + uintptr(unsafe.Pointer(pgi)), + uintptr(unsafe.Pointer(pabc)), + 0) + return ret1 != 0 +} + +func GetCharABCWidths(hdc HDC, wFirst UINT, wLast UINT, lpABC *ABC) bool { + ret1 := syscall6(getCharABCWidths, 4, + uintptr(hdc), + uintptr(wFirst), + uintptr(wLast), + uintptr(unsafe.Pointer(lpABC)), + 0, + 0) + return ret1 != 0 +} + +func GetCharWidth32(hdc HDC, iFirst UINT, iLast UINT, lpBuffer *int32) bool { + ret1 := syscall6(getCharWidth32, 4, + uintptr(hdc), + uintptr(iFirst), + uintptr(iLast), + uintptr(unsafe.Pointer(lpBuffer)), + 0, + 0) + return ret1 != 0 +} + +func GetCharWidthFloat(hdc HDC, iFirst UINT, iLast UINT, lpBuffer *float32) bool { + ret1 := syscall6(getCharWidthFloat, 4, + uintptr(hdc), + uintptr(iFirst), + uintptr(iLast), + uintptr(unsafe.Pointer(lpBuffer)), + 0, + 0) + return ret1 != 0 +} + +func GetCharWidthI(hdc HDC, giFirst UINT, cgi UINT, pgi *uint16, piWidths *int32) bool { + ret1 := syscall6(getCharWidthI, 5, + uintptr(hdc), + uintptr(giFirst), + uintptr(cgi), + uintptr(unsafe.Pointer(pgi)), + uintptr(unsafe.Pointer(piWidths)), + 0) + return ret1 != 0 +} + +func GetCharWidth(hdc HDC, iFirst UINT, iLast UINT, lpBuffer *int32) bool { + ret1 := syscall6(getCharWidth, 4, + uintptr(hdc), + uintptr(iFirst), + uintptr(iLast), + uintptr(unsafe.Pointer(lpBuffer)), + 0, + 0) + return ret1 != 0 +} + +func GetCharacterPlacement(hdc HDC, lpString string, nCount int32, nMexExtent int32, lpResults LPGCP_RESULTS, dwFlags DWORD) DWORD { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall6(getCharacterPlacement, 6, + uintptr(hdc), + uintptr(unsafe.Pointer(&lpStringStr[0])), + uintptr(nCount), + uintptr(nMexExtent), + uintptr(unsafe.Pointer(lpResults)), + uintptr(dwFlags)) + return DWORD(ret1) +} + +func GetClipBox(hdc HDC, lprect *RECT) int32 { + ret1 := syscall3(getClipBox, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lprect)), + 0) + return int32(ret1) +} + +func GetClipRgn(hdc HDC, hrgn HRGN) int32 { + ret1 := syscall3(getClipRgn, 2, + uintptr(hdc), + uintptr(hrgn), + 0) + return int32(ret1) +} + +func GetColorAdjustment(hdc HDC, lpca *COLORADJUSTMENT) bool { + ret1 := syscall3(getColorAdjustment, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpca)), + 0) + return ret1 != 0 +} + +func GetColorSpace(hdc HDC) HCOLORSPACE { + ret1 := syscall3(getColorSpace, 1, + uintptr(hdc), + 0, + 0) + return HCOLORSPACE(ret1) +} + +func GetCurrentObject(hdc HDC, aType UINT) HGDIOBJ { + ret1 := syscall3(getCurrentObject, 2, + uintptr(hdc), + uintptr(aType), + 0) + return HGDIOBJ(ret1) +} + +func GetCurrentPositionEx(hdc HDC, lppt *POINT) bool { + ret1 := syscall3(getCurrentPositionEx, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lppt)), + 0) + return ret1 != 0 +} + +func GetDCBrushColor(hdc HDC) COLORREF { + ret1 := syscall3(getDCBrushColor, 1, + uintptr(hdc), + 0, + 0) + return COLORREF(ret1) +} + +func GetDCOrgEx(hdc HDC, lppt *POINT) bool { + ret1 := syscall3(getDCOrgEx, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lppt)), + 0) + return ret1 != 0 +} + +func GetDCPenColor(hdc HDC) COLORREF { + ret1 := syscall3(getDCPenColor, 1, + uintptr(hdc), + 0, + 0) + return COLORREF(ret1) +} + +func GetDIBColorTable(hdc HDC, iStart UINT, cEntries UINT, prgbq *RGBQUAD) UINT { + ret1 := syscall6(getDIBColorTable, 4, + uintptr(hdc), + uintptr(iStart), + uintptr(cEntries), + uintptr(unsafe.Pointer(prgbq)), + 0, + 0) + return UINT(ret1) +} + +func GetDIBits(hdc HDC, hbm HBITMAP, start UINT, cLines UINT, lpvBits LPVOID, lpbmi *BITMAPINFO, usage UINT) int32 { + ret1 := syscall9(getDIBits, 7, + uintptr(hdc), + uintptr(hbm), + uintptr(start), + uintptr(cLines), + uintptr(unsafe.Pointer(lpvBits)), + uintptr(unsafe.Pointer(lpbmi)), + uintptr(usage), + 0, + 0) + return int32(ret1) +} + +func GetDeviceCaps(hdc HDC, index int32) int32 { + ret1 := syscall3(getDeviceCaps, 2, + uintptr(hdc), + uintptr(index), + 0) + return int32(ret1) +} + +func GetDeviceGammaRamp(hdc HDC, lpRamp LPVOID) bool { + ret1 := syscall3(getDeviceGammaRamp, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpRamp)), + 0) + return ret1 != 0 +} + +func GetEnhMetaFileBits(hEMF HENHMETAFILE, nSize UINT, lpData *byte) UINT { + ret1 := syscall3(getEnhMetaFileBits, 3, + uintptr(hEMF), + uintptr(nSize), + uintptr(unsafe.Pointer(lpData))) + return UINT(ret1) +} + +func GetEnhMetaFileDescription(hemf HENHMETAFILE, cchBuffer UINT, lpDescription LPWSTR) UINT { + ret1 := syscall3(getEnhMetaFileDescription, 3, + uintptr(hemf), + uintptr(cchBuffer), + uintptr(unsafe.Pointer(lpDescription))) + return UINT(ret1) +} + +func GetEnhMetaFileHeader(hemf HENHMETAFILE, nSize UINT, lpEnhMetaHeader *ENHMETAHEADER) UINT { + ret1 := syscall3(getEnhMetaFileHeader, 3, + uintptr(hemf), + uintptr(nSize), + uintptr(unsafe.Pointer(lpEnhMetaHeader))) + return UINT(ret1) +} + +func GetEnhMetaFilePaletteEntries(hemf HENHMETAFILE, nNumEntries UINT, lpPaletteEntries *PALETTEENTRY) UINT { + ret1 := syscall3(getEnhMetaFilePaletteEntries, 3, + uintptr(hemf), + uintptr(nNumEntries), + uintptr(unsafe.Pointer(lpPaletteEntries))) + return UINT(ret1) +} + +func GetEnhMetaFilePixelFormat(hemf HENHMETAFILE, cbBuffer UINT, ppfd *PIXELFORMATDESCRIPTOR) UINT { + ret1 := syscall3(getEnhMetaFilePixelFormat, 3, + uintptr(hemf), + uintptr(cbBuffer), + uintptr(unsafe.Pointer(ppfd))) + return UINT(ret1) +} + +func GetEnhMetaFile(lpName string) HENHMETAFILE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall3(getEnhMetaFile, 1, + uintptr(unsafe.Pointer(&lpNameStr[0])), + 0, + 0) + return HENHMETAFILE(ret1) +} + +func GetFontData(hdc HDC, dwTable DWORD, dwOffset DWORD, pvBuffer uintptr, cjBuffer DWORD) DWORD { + ret1 := syscall6(getFontData, 5, + uintptr(hdc), + uintptr(dwTable), + uintptr(dwOffset), + pvBuffer, + uintptr(cjBuffer), + 0) + return DWORD(ret1) +} + +func GetFontLanguageInfo(hdc HDC) DWORD { + ret1 := syscall3(getFontLanguageInfo, 1, + uintptr(hdc), + 0, + 0) + return DWORD(ret1) +} + +func GetFontUnicodeRanges(hdc HDC, lpgs *GLYPHSET) DWORD { + ret1 := syscall3(getFontUnicodeRanges, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpgs)), + 0) + return DWORD(ret1) +} + +func GetGlyphIndices(hdc HDC, lpstr string, c int32, pgi *uint16, fl DWORD) DWORD { + lpstrStr := unicode16FromString(lpstr) + ret1 := syscall6(getGlyphIndices, 5, + uintptr(hdc), + uintptr(unsafe.Pointer(&lpstrStr[0])), + uintptr(c), + uintptr(unsafe.Pointer(pgi)), + uintptr(fl), + 0) + return DWORD(ret1) +} + +func GetGlyphOutline(hdc HDC, uChar UINT, fuFormat UINT, lpgm *GLYPHMETRICS, cjBuffer DWORD, pvBuffer LPVOID, lpmat2 /*const*/ *MAT2) DWORD { + ret1 := syscall9(getGlyphOutline, 7, + uintptr(hdc), + uintptr(uChar), + uintptr(fuFormat), + uintptr(unsafe.Pointer(lpgm)), + uintptr(cjBuffer), + uintptr(unsafe.Pointer(pvBuffer)), + uintptr(unsafe.Pointer(lpmat2)), + 0, + 0) + return DWORD(ret1) +} + +func GetGraphicsMode(hdc HDC) int32 { + ret1 := syscall3(getGraphicsMode, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func GetICMProfile(hdc HDC, pBufSize *uint32, pszFilename LPWSTR) bool { + ret1 := syscall3(getICMProfile, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(pBufSize)), + uintptr(unsafe.Pointer(pszFilename))) + return ret1 != 0 +} + +func GetKerningPairs(hdc HDC, nPairs DWORD, lpKernPair *KERNINGPAIR) DWORD { + ret1 := syscall3(getKerningPairs, 3, + uintptr(hdc), + uintptr(nPairs), + uintptr(unsafe.Pointer(lpKernPair))) + return DWORD(ret1) +} + +func GetLayout(hdc HDC) DWORD { + ret1 := syscall3(getLayout, 1, + uintptr(hdc), + 0, + 0) + return DWORD(ret1) +} + +func GetLogColorSpace(hColorSpace HCOLORSPACE, lpBuffer LPLOGCOLORSPACE, nSize DWORD) bool { + ret1 := syscall3(getLogColorSpace, 3, + uintptr(hColorSpace), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(nSize)) + return ret1 != 0 +} + +func GetMapMode(hdc HDC) int32 { + ret1 := syscall3(getMapMode, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func GetMetaFileBitsEx(hMF HMETAFILE, cbBuffer UINT, lpData LPVOID) UINT { + ret1 := syscall3(getMetaFileBitsEx, 3, + uintptr(hMF), + uintptr(cbBuffer), + uintptr(unsafe.Pointer(lpData))) + return UINT(ret1) +} + +func GetMetaFile(lpName string) HMETAFILE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall3(getMetaFile, 1, + uintptr(unsafe.Pointer(&lpNameStr[0])), + 0, + 0) + return HMETAFILE(ret1) +} + +func GetMetaRgn(hdc HDC, hrgn HRGN) int32 { + ret1 := syscall3(getMetaRgn, 2, + uintptr(hdc), + uintptr(hrgn), + 0) + return int32(ret1) +} + +func GetMiterLimit(hdc HDC, plimit *float32) bool { + ret1 := syscall3(getMiterLimit, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(plimit)), + 0) + return ret1 != 0 +} + +func GetNearestColor(hdc HDC, color COLORREF) COLORREF { + ret1 := syscall3(getNearestColor, 2, + uintptr(hdc), + uintptr(color), + 0) + return COLORREF(ret1) +} + +func GetNearestPaletteIndex(h HPALETTE, color COLORREF) UINT { + ret1 := syscall3(getNearestPaletteIndex, 2, + uintptr(h), + uintptr(color), + 0) + return UINT(ret1) +} + +func GetObjectType(h HGDIOBJ) DWORD { + ret1 := syscall3(getObjectType, 1, + uintptr(h), + 0, + 0) + return DWORD(ret1) +} + +func GetObject(h HANDLE, c int32, pv LPVOID) int32 { + ret1 := syscall3(getObject, 3, + uintptr(h), + uintptr(c), + uintptr(unsafe.Pointer(pv))) + return int32(ret1) +} + +func GetOutlineTextMetrics(hdc HDC, cjCopy UINT, potm LPOUTLINETEXTMETRIC) UINT { + ret1 := syscall3(getOutlineTextMetrics, 3, + uintptr(hdc), + uintptr(cjCopy), + uintptr(unsafe.Pointer(potm))) + return UINT(ret1) +} + +func GetPaletteEntries(hpal HPALETTE, iStart UINT, cEntries UINT, pPalEntries *PALETTEENTRY) UINT { + ret1 := syscall6(getPaletteEntries, 4, + uintptr(hpal), + uintptr(iStart), + uintptr(cEntries), + uintptr(unsafe.Pointer(pPalEntries)), + 0, + 0) + return UINT(ret1) +} + +func GetPath(hdc HDC, apt *POINT, aj *byte, cpt int32) int32 { + ret1 := syscall6(getPath, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(apt)), + uintptr(unsafe.Pointer(aj)), + uintptr(cpt), + 0, + 0) + return int32(ret1) +} + +func GetPixel(hdc HDC, x int32, y int32) COLORREF { + ret1 := syscall3(getPixel, 3, + uintptr(hdc), + uintptr(x), + uintptr(y)) + return COLORREF(ret1) +} + +func GetPixelFormat(hdc HDC) int32 { + ret1 := syscall3(getPixelFormat, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func GetPolyFillMode(hdc HDC) int32 { + ret1 := syscall3(getPolyFillMode, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func GetROP2(hdc HDC) int32 { + ret1 := syscall3(getROP2, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func GetRandomRgn(hdc HDC, hrgn HRGN, i INT) int32 { + ret1 := syscall3(getRandomRgn, 3, + uintptr(hdc), + uintptr(hrgn), + uintptr(i)) + return int32(ret1) +} + +func GetRasterizerCaps(lpraststat LPRASTERIZER_STATUS, cjBytes UINT) bool { + ret1 := syscall3(getRasterizerCaps, 2, + uintptr(unsafe.Pointer(lpraststat)), + uintptr(cjBytes), + 0) + return ret1 != 0 +} + +func GetRegionData(hrgn HRGN, nCount DWORD, lpRgnData *RGNDATA) DWORD { + ret1 := syscall3(getRegionData, 3, + uintptr(hrgn), + uintptr(nCount), + uintptr(unsafe.Pointer(lpRgnData))) + return DWORD(ret1) +} + +func GetRgnBox(hrgn HRGN, lprc *RECT) int32 { + ret1 := syscall3(getRgnBox, 2, + uintptr(hrgn), + uintptr(unsafe.Pointer(lprc)), + 0) + return int32(ret1) +} + +func GetStockObject(i int32) HGDIOBJ { + ret1 := syscall3(getStockObject, 1, + uintptr(i), + 0, + 0) + return HGDIOBJ(ret1) +} + +func GetStretchBltMode(hdc HDC) int32 { + ret1 := syscall3(getStretchBltMode, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func GetSystemPaletteEntries(hdc HDC, iStart UINT, cEntries UINT, pPalEntries *PALETTEENTRY) UINT { + ret1 := syscall6(getSystemPaletteEntries, 4, + uintptr(hdc), + uintptr(iStart), + uintptr(cEntries), + uintptr(unsafe.Pointer(pPalEntries)), + 0, + 0) + return UINT(ret1) +} + +func GetSystemPaletteUse(hdc HDC) UINT { + ret1 := syscall3(getSystemPaletteUse, 1, + uintptr(hdc), + 0, + 0) + return UINT(ret1) +} + +func GetTextAlign(hdc HDC) UINT { + ret1 := syscall3(getTextAlign, 1, + uintptr(hdc), + 0, + 0) + return UINT(ret1) +} + +func GetTextCharacterExtra(hdc HDC) int32 { + ret1 := syscall3(getTextCharacterExtra, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func GetTextCharset(hdc HDC) int32 { + ret1 := syscall3(getTextCharset, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func GetTextCharsetInfo(hdc HDC, lpSig *FONTSIGNATURE, dwFlags DWORD) int32 { + ret1 := syscall3(getTextCharsetInfo, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(lpSig)), + uintptr(dwFlags)) + return int32(ret1) +} + +func GetTextColor(hdc HDC) COLORREF { + ret1 := syscall3(getTextColor, 1, + uintptr(hdc), + 0, + 0) + return COLORREF(ret1) +} + +func GetTextExtentExPointI(hdc HDC, lpwszString *uint16, cwchString int32, nMaxExtent int32, lpnFit *int32, lpnDx *int32, lpSize *SIZE) bool { + ret1 := syscall9(getTextExtentExPointI, 7, + uintptr(hdc), + uintptr(unsafe.Pointer(lpwszString)), + uintptr(cwchString), + uintptr(nMaxExtent), + uintptr(unsafe.Pointer(lpnFit)), + uintptr(unsafe.Pointer(lpnDx)), + uintptr(unsafe.Pointer(lpSize)), + 0, + 0) + return ret1 != 0 +} + +func GetTextExtentExPoint(hdc HDC, lpszString string, cchString int32, nMaxExtent int32, lpnFit *int32, lpnDx *int32, lpSize *SIZE) bool { + lpszStringStr := unicode16FromString(lpszString) + ret1 := syscall9(getTextExtentExPoint, 7, + uintptr(hdc), + uintptr(unsafe.Pointer(&lpszStringStr[0])), + uintptr(cchString), + uintptr(nMaxExtent), + uintptr(unsafe.Pointer(lpnFit)), + uintptr(unsafe.Pointer(lpnDx)), + uintptr(unsafe.Pointer(lpSize)), + 0, + 0) + return ret1 != 0 +} + +func GetTextExtentPoint32(hdc HDC, lpString string, c int32, psizl *SIZE) bool { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall6(getTextExtentPoint32, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(&lpStringStr[0])), + uintptr(c), + uintptr(unsafe.Pointer(psizl)), + 0, + 0) + return ret1 != 0 +} + +func GetTextExtentPointI(hdc HDC, pgiIn *uint16, cgi int32, psize *SIZE) bool { + ret1 := syscall6(getTextExtentPointI, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(pgiIn)), + uintptr(cgi), + uintptr(unsafe.Pointer(psize)), + 0, + 0) + return ret1 != 0 +} + +func GetTextExtentPoint(hdc HDC, lpString string, c int32, lpsz *SIZE) bool { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall6(getTextExtentPoint, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(&lpStringStr[0])), + uintptr(c), + uintptr(unsafe.Pointer(lpsz)), + 0, + 0) + return ret1 != 0 +} + +func GetTextFace(hdc HDC, c int32, lpName LPWSTR) int32 { + ret1 := syscall3(getTextFace, 3, + uintptr(hdc), + uintptr(c), + uintptr(unsafe.Pointer(lpName))) + return int32(ret1) +} + +func GetTextMetrics(hdc HDC, lptm LPTEXTMETRIC) bool { + ret1 := syscall3(getTextMetrics, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lptm)), + 0) + return ret1 != 0 +} + +func GetViewportExtEx(hdc HDC, lpsize *SIZE) bool { + ret1 := syscall3(getViewportExtEx, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpsize)), + 0) + return ret1 != 0 +} + +func GetViewportOrgEx(hdc HDC, lppoint *POINT) bool { + ret1 := syscall3(getViewportOrgEx, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lppoint)), + 0) + return ret1 != 0 +} + +func GetWinMetaFileBits(hemf HENHMETAFILE, cbData16 UINT, pData16 *byte, iMapMode INT, hdcRef HDC) UINT { + ret1 := syscall6(getWinMetaFileBits, 5, + uintptr(hemf), + uintptr(cbData16), + uintptr(unsafe.Pointer(pData16)), + uintptr(iMapMode), + uintptr(hdcRef), + 0) + return UINT(ret1) +} + +func GetWindowExtEx(hdc HDC, lpsize *SIZE) bool { + ret1 := syscall3(getWindowExtEx, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpsize)), + 0) + return ret1 != 0 +} + +func GetWindowOrgEx(hdc HDC, lppoint *POINT) bool { + ret1 := syscall3(getWindowOrgEx, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lppoint)), + 0) + return ret1 != 0 +} + +func GetWorldTransform(hdc HDC, lpxf *XFORM) bool { + ret1 := syscall3(getWorldTransform, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpxf)), + 0) + return ret1 != 0 +} + +func HT_Get8BPPFormatPalette(pPaletteEntry *PALETTEENTRY, redGamma USHORT, greenGamma USHORT, blueGamma USHORT) LONG { + ret1 := syscall6(hT_Get8BPPFormatPalette, 4, + uintptr(unsafe.Pointer(pPaletteEntry)), + uintptr(redGamma), + uintptr(greenGamma), + uintptr(blueGamma), + 0, + 0) + return LONG(ret1) +} + +func HT_Get8BPPMaskPalette(pPaletteEntry *PALETTEENTRY, use8BPPMaskPal bool, cMYMask BYTE, redGamma USHORT, greenGamma USHORT, blueGamma USHORT) LONG { + ret1 := syscall6(hT_Get8BPPMaskPalette, 6, + uintptr(unsafe.Pointer(pPaletteEntry)), + getUintptrFromBool(use8BPPMaskPal), + uintptr(cMYMask), + uintptr(redGamma), + uintptr(greenGamma), + uintptr(blueGamma)) + return LONG(ret1) +} + +func IntersectClipRect(hdc HDC, left int32, top int32, right int32, bottom int32) int32 { + ret1 := syscall6(intersectClipRect, 5, + uintptr(hdc), + uintptr(left), + uintptr(top), + uintptr(right), + uintptr(bottom), + 0) + return int32(ret1) +} + +func InvertRgn(hdc HDC, hrgn HRGN) bool { + ret1 := syscall3(invertRgn, 2, + uintptr(hdc), + uintptr(hrgn), + 0) + return ret1 != 0 +} + +func LPtoDP(hdc HDC, lppt *POINT, c int32) bool { + ret1 := syscall3(lPtoDP, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(lppt)), + uintptr(c)) + return ret1 != 0 +} + +func LineDDA(xStart int32, yStart int32, xEnd int32, yEnd int32, lpProc LINEDDAPROC, data LPARAM) bool { + lpProcCallback := syscall.NewCallback(lpProc) + ret1 := syscall6(lineDDA, 6, + uintptr(xStart), + uintptr(yStart), + uintptr(xEnd), + uintptr(yEnd), + lpProcCallback, + uintptr(data)) + return ret1 != 0 +} + +func LineTo(hdc HDC, x int32, y int32) bool { + ret1 := syscall3(lineTo, 3, + uintptr(hdc), + uintptr(x), + uintptr(y)) + return ret1 != 0 +} + +func MaskBlt(hdcDest HDC, xDest int32, yDest int32, width int32, height int32, hdcSrc HDC, xSrc int32, ySrc int32, hbmMask HBITMAP, xMask int32, yMask int32, rop DWORD) bool { + ret1 := syscall12(maskBlt, 12, + uintptr(hdcDest), + uintptr(xDest), + uintptr(yDest), + uintptr(width), + uintptr(height), + uintptr(hdcSrc), + uintptr(xSrc), + uintptr(ySrc), + uintptr(hbmMask), + uintptr(xMask), + uintptr(yMask), + uintptr(rop)) + return ret1 != 0 +} + +func ModifyWorldTransform(hdc HDC, lpxf /*const*/ *XFORM, mode DWORD) bool { + ret1 := syscall3(modifyWorldTransform, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(lpxf)), + uintptr(mode)) + return ret1 != 0 +} + +func MoveToEx(hdc HDC, x int32, y int32, lppt *POINT) bool { + ret1 := syscall6(moveToEx, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(lppt)), + 0, + 0) + return ret1 != 0 +} + +func OffsetClipRgn(hdc HDC, x int32, y int32) int32 { + ret1 := syscall3(offsetClipRgn, 3, + uintptr(hdc), + uintptr(x), + uintptr(y)) + return int32(ret1) +} + +func OffsetRgn(hrgn HRGN, x int32, y int32) int32 { + ret1 := syscall3(offsetRgn, 3, + uintptr(hrgn), + uintptr(x), + uintptr(y)) + return int32(ret1) +} + +func OffsetViewportOrgEx(hdc HDC, x int32, y int32, lppt *POINT) bool { + ret1 := syscall6(offsetViewportOrgEx, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(lppt)), + 0, + 0) + return ret1 != 0 +} + +func OffsetWindowOrgEx(hdc HDC, x int32, y int32, lppt *POINT) bool { + ret1 := syscall6(offsetWindowOrgEx, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(lppt)), + 0, + 0) + return ret1 != 0 +} + +func PATHOBJ_bEnum(ppo *PATHOBJ, ppd *PATHDATA) bool { + ret1 := syscall3(pATHOBJ_bEnum, 2, + uintptr(unsafe.Pointer(ppo)), + uintptr(unsafe.Pointer(ppd)), + 0) + return ret1 != 0 +} + +func PATHOBJ_bEnumClipLines(ppo *PATHOBJ, cb ULONG, pcl *CLIPLINE) bool { + ret1 := syscall3(pATHOBJ_bEnumClipLines, 3, + uintptr(unsafe.Pointer(ppo)), + uintptr(cb), + uintptr(unsafe.Pointer(pcl))) + return ret1 != 0 +} + +func PATHOBJ_vEnumStart(ppo *PATHOBJ) { + syscall3(pATHOBJ_vEnumStart, 1, + uintptr(unsafe.Pointer(ppo)), + 0, + 0) +} + +func PATHOBJ_vEnumStartClipLines(ppo *PATHOBJ, pco *CLIPOBJ, pso *SURFOBJ, pla *LINEATTRS) { + syscall6(pATHOBJ_vEnumStartClipLines, 4, + uintptr(unsafe.Pointer(ppo)), + uintptr(unsafe.Pointer(pco)), + uintptr(unsafe.Pointer(pso)), + uintptr(unsafe.Pointer(pla)), + 0, + 0) +} + +func PATHOBJ_vGetBounds(ppo *PATHOBJ, prectfx PRECTFX) { + syscall3(pATHOBJ_vGetBounds, 2, + uintptr(unsafe.Pointer(ppo)), + uintptr(unsafe.Pointer(prectfx)), + 0) +} + +func PaintRgn(hdc HDC, hrgn HRGN) bool { + ret1 := syscall3(paintRgn, 2, + uintptr(hdc), + uintptr(hrgn), + 0) + return ret1 != 0 +} + +func PatBlt(hdc HDC, x int32, y int32, w int32, h int32, rop DWORD) bool { + ret1 := syscall6(patBlt, 6, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(w), + uintptr(h), + uintptr(rop)) + return ret1 != 0 +} + +func PathToRegion(hdc HDC) HRGN { + ret1 := syscall3(pathToRegion, 1, + uintptr(hdc), + 0, + 0) + return HRGN(ret1) +} + +func Pie(hdc HDC, left int32, top int32, right int32, bottom int32, xr1 int32, yr1 int32, xr2 int32, yr2 int32) bool { + ret1 := syscall9(pie, 9, + uintptr(hdc), + uintptr(left), + uintptr(top), + uintptr(right), + uintptr(bottom), + uintptr(xr1), + uintptr(yr1), + uintptr(xr2), + uintptr(yr2)) + return ret1 != 0 +} + +func PlayEnhMetaFile(hdc HDC, hmf HENHMETAFILE, lprect /*const*/ *RECT) bool { + ret1 := syscall3(playEnhMetaFile, 3, + uintptr(hdc), + uintptr(hmf), + uintptr(unsafe.Pointer(lprect))) + return ret1 != 0 +} + +func PlayEnhMetaFileRecord(hdc HDC, pht *HANDLETABLE, pmr /*const*/ *ENHMETARECORD, cht UINT) bool { + ret1 := syscall6(playEnhMetaFileRecord, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(pht)), + uintptr(unsafe.Pointer(pmr)), + uintptr(cht), + 0, + 0) + return ret1 != 0 +} + +func PlayMetaFile(hdc HDC, hmf HMETAFILE) bool { + ret1 := syscall3(playMetaFile, 2, + uintptr(hdc), + uintptr(hmf), + 0) + return ret1 != 0 +} + +func PlayMetaFileRecord(hdc HDC, lpHandleTable *HANDLETABLE, lpMR *METARECORD, noObjs UINT) bool { + ret1 := syscall6(playMetaFileRecord, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(lpHandleTable)), + uintptr(unsafe.Pointer(lpMR)), + uintptr(noObjs), + 0, + 0) + return ret1 != 0 +} + +func PlgBlt(hdcDest HDC, lpPoint /*const*/ *POINT, hdcSrc HDC, xSrc int32, ySrc int32, width int32, height int32, hbmMask HBITMAP, xMask int32, yMask int32) bool { + ret1 := syscall12(plgBlt, 10, + uintptr(hdcDest), + uintptr(unsafe.Pointer(lpPoint)), + uintptr(hdcSrc), + uintptr(xSrc), + uintptr(ySrc), + uintptr(width), + uintptr(height), + uintptr(hbmMask), + uintptr(xMask), + uintptr(yMask), + 0, + 0) + return ret1 != 0 +} + +func PolyBezier(hdc HDC, apt /*const*/ *POINT, cpt DWORD) bool { + ret1 := syscall3(polyBezier, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(apt)), + uintptr(cpt)) + return ret1 != 0 +} + +func PolyBezierTo(hdc HDC, apt /*const*/ *POINT, cpt DWORD) bool { + ret1 := syscall3(polyBezierTo, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(apt)), + uintptr(cpt)) + return ret1 != 0 +} + +func PolyDraw(hdc HDC, apt /*const*/ *POINT, aj /*const*/ *byte, cpt int32) bool { + ret1 := syscall6(polyDraw, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(apt)), + uintptr(unsafe.Pointer(aj)), + uintptr(cpt), + 0, + 0) + return ret1 != 0 +} + +func PolyPolygon(hdc HDC, apt /*const*/ *POINT, asz /*const*/ *int32, csz int32) bool { + ret1 := syscall6(polyPolygon, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(apt)), + uintptr(unsafe.Pointer(asz)), + uintptr(csz), + 0, + 0) + return ret1 != 0 +} + +func PolyPolyline(hdc HDC, apt /*const*/ *POINT, asz /*const*/ *uint32, csz DWORD) bool { + ret1 := syscall6(polyPolyline, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(apt)), + uintptr(unsafe.Pointer(asz)), + uintptr(csz), + 0, + 0) + return ret1 != 0 +} + +func PolyTextOut(hdc HDC, ppt /*const*/ *POLYTEXT, nstrings int32) bool { + ret1 := syscall3(polyTextOut, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(ppt)), + uintptr(nstrings)) + return ret1 != 0 +} + +func Polygon(hdc HDC, apt /*const*/ *POINT, cpt int32) bool { + ret1 := syscall3(polygon, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(apt)), + uintptr(cpt)) + return ret1 != 0 +} + +func Polyline(hdc HDC, apt /*const*/ *POINT, cpt int32) bool { + ret1 := syscall3(polyline, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(apt)), + uintptr(cpt)) + return ret1 != 0 +} + +func PolylineTo(hdc HDC, apt /*const*/ *POINT, cpt DWORD) bool { + ret1 := syscall3(polylineTo, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(apt)), + uintptr(cpt)) + return ret1 != 0 +} + +func PtInRegion(hrgn HRGN, x int32, y int32) bool { + ret1 := syscall3(ptInRegion, 3, + uintptr(hrgn), + uintptr(x), + uintptr(y)) + return ret1 != 0 +} + +func PtVisible(hdc HDC, x int32, y int32) bool { + ret1 := syscall3(ptVisible, 3, + uintptr(hdc), + uintptr(x), + uintptr(y)) + return ret1 != 0 +} + +func RealizePalette(hdc HDC) UINT { + ret1 := syscall3(realizePalette, 1, + uintptr(hdc), + 0, + 0) + return UINT(ret1) +} + +func RectInRegion(hrgn HRGN, lprect /*const*/ *RECT) bool { + ret1 := syscall3(rectInRegion, 2, + uintptr(hrgn), + uintptr(unsafe.Pointer(lprect)), + 0) + return ret1 != 0 +} + +func RectVisible(hdc HDC, lprect /*const*/ *RECT) bool { + ret1 := syscall3(rectVisible, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lprect)), + 0) + return ret1 != 0 +} + +func Rectangle(hdc HDC, left int32, top int32, right int32, bottom int32) bool { + ret1 := syscall6(rectangle, 5, + uintptr(hdc), + uintptr(left), + uintptr(top), + uintptr(right), + uintptr(bottom), + 0) + return ret1 != 0 +} + +func RemoveFontMemResourceEx(h HANDLE) bool { + ret1 := syscall3(removeFontMemResourceEx, 1, + uintptr(h), + 0, + 0) + return ret1 != 0 +} + +func RemoveFontResourceEx(name string, fl DWORD, pdv uintptr) bool { + nameStr := unicode16FromString(name) + ret1 := syscall3(removeFontResourceEx, 3, + uintptr(unsafe.Pointer(&nameStr[0])), + uintptr(fl), + pdv) + return ret1 != 0 +} + +func RemoveFontResource(lpFileName string) bool { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(removeFontResource, 1, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + 0, + 0) + return ret1 != 0 +} + +func ResetDC(hdc HDC, lpdm /*const*/ *DEVMODE) HDC { + ret1 := syscall3(resetDC, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpdm)), + 0) + return HDC(ret1) +} + +func ResizePalette(hpal HPALETTE, n UINT) bool { + ret1 := syscall3(resizePalette, 2, + uintptr(hpal), + uintptr(n), + 0) + return ret1 != 0 +} + +func RestoreDC(hdc HDC, nSavedDC int32) bool { + ret1 := syscall3(restoreDC, 2, + uintptr(hdc), + uintptr(nSavedDC), + 0) + return ret1 != 0 +} + +func RoundRect(hdc HDC, left int32, top int32, right int32, bottom int32, width int32, height int32) bool { + ret1 := syscall9(roundRect, 7, + uintptr(hdc), + uintptr(left), + uintptr(top), + uintptr(right), + uintptr(bottom), + uintptr(width), + uintptr(height), + 0, + 0) + return ret1 != 0 +} + +func STROBJ_bEnum(pstro *STROBJ, pc *ULONG, ppgpos *PGLYPHPOS) bool { + ret1 := syscall3(sTROBJ_bEnum, 3, + uintptr(unsafe.Pointer(pstro)), + uintptr(unsafe.Pointer(pc)), + uintptr(unsafe.Pointer(ppgpos))) + return ret1 != 0 +} + +func STROBJ_bEnumPositionsOnly(pstro *STROBJ, pc *ULONG, ppgpos *PGLYPHPOS) bool { + ret1 := syscall3(sTROBJ_bEnumPositionsOnly, 3, + uintptr(unsafe.Pointer(pstro)), + uintptr(unsafe.Pointer(pc)), + uintptr(unsafe.Pointer(ppgpos))) + return ret1 != 0 +} + +func STROBJ_bGetAdvanceWidths(pso *STROBJ, iFirst ULONG, c ULONG, pptqD *POINTQF) bool { + ret1 := syscall6(sTROBJ_bGetAdvanceWidths, 4, + uintptr(unsafe.Pointer(pso)), + uintptr(iFirst), + uintptr(c), + uintptr(unsafe.Pointer(pptqD)), + 0, + 0) + return ret1 != 0 +} + +func STROBJ_dwGetCodePage(pstro *STROBJ) DWORD { + ret1 := syscall3(sTROBJ_dwGetCodePage, 1, + uintptr(unsafe.Pointer(pstro)), + 0, + 0) + return DWORD(ret1) +} + +func STROBJ_vEnumStart(pstro *STROBJ) { + syscall3(sTROBJ_vEnumStart, 1, + uintptr(unsafe.Pointer(pstro)), + 0, + 0) +} + +func SaveDC(hdc HDC) int32 { + ret1 := syscall3(saveDC, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func ScaleViewportExtEx(hdc HDC, xn int32, dx int32, yn int32, yd int32, lpsz *SIZE) bool { + ret1 := syscall6(scaleViewportExtEx, 6, + uintptr(hdc), + uintptr(xn), + uintptr(dx), + uintptr(yn), + uintptr(yd), + uintptr(unsafe.Pointer(lpsz))) + return ret1 != 0 +} + +func ScaleWindowExtEx(hdc HDC, xn int32, xd int32, yn int32, yd int32, lpsz *SIZE) bool { + ret1 := syscall6(scaleWindowExtEx, 6, + uintptr(hdc), + uintptr(xn), + uintptr(xd), + uintptr(yn), + uintptr(yd), + uintptr(unsafe.Pointer(lpsz))) + return ret1 != 0 +} + +func SelectClipPath(hdc HDC, mode int32) bool { + ret1 := syscall3(selectClipPath, 2, + uintptr(hdc), + uintptr(mode), + 0) + return ret1 != 0 +} + +func SelectClipRgn(hdc HDC, hrgn HRGN) int32 { + ret1 := syscall3(selectClipRgn, 2, + uintptr(hdc), + uintptr(hrgn), + 0) + return int32(ret1) +} + +func SelectObject(hdc HDC, h HGDIOBJ) HGDIOBJ { + ret1 := syscall3(selectObject, 2, + uintptr(hdc), + uintptr(h), + 0) + return HGDIOBJ(ret1) +} + +func SelectPalette(hdc HDC, hPal HPALETTE, bForceBkgd bool) HPALETTE { + ret1 := syscall3(selectPalette, 3, + uintptr(hdc), + uintptr(hPal), + getUintptrFromBool(bForceBkgd)) + return HPALETTE(ret1) +} + +func SetAbortProc(hdc HDC, lpProc ABORTPROC) int32 { + lpProcCallback := syscall.NewCallback(func(unnamed0RawArg HDC, unnamed1RawArg int32) uintptr { + ret := lpProc(unnamed0RawArg, unnamed1RawArg) + return uintptr(ret) + }) + ret1 := syscall3(setAbortProc, 2, + uintptr(hdc), + lpProcCallback, + 0) + return int32(ret1) +} + +func SetArcDirection(hdc HDC, dir int32) int32 { + ret1 := syscall3(setArcDirection, 2, + uintptr(hdc), + uintptr(dir), + 0) + return int32(ret1) +} + +func SetBitmapBits(hbm HBITMAP, cb DWORD, pvBits /*const*/ uintptr) LONG { + ret1 := syscall3(setBitmapBits, 3, + uintptr(hbm), + uintptr(cb), + pvBits) + return LONG(ret1) +} + +func SetBitmapDimensionEx(hbm HBITMAP, w int32, h int32, lpsz *SIZE) bool { + ret1 := syscall6(setBitmapDimensionEx, 4, + uintptr(hbm), + uintptr(w), + uintptr(h), + uintptr(unsafe.Pointer(lpsz)), + 0, + 0) + return ret1 != 0 +} + +func SetBkColor(hdc HDC, color COLORREF) COLORREF { + ret1 := syscall3(setBkColor, 2, + uintptr(hdc), + uintptr(color), + 0) + return COLORREF(ret1) +} + +func SetBkMode(hdc HDC, mode int32) int32 { + ret1 := syscall3(setBkMode, 2, + uintptr(hdc), + uintptr(mode), + 0) + return int32(ret1) +} + +func SetBoundsRect(hdc HDC, lprect /*const*/ *RECT, flags UINT) UINT { + ret1 := syscall3(setBoundsRect, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(lprect)), + uintptr(flags)) + return UINT(ret1) +} + +func SetBrushOrgEx(hdc HDC, x int32, y int32, lppt *POINT) bool { + ret1 := syscall6(setBrushOrgEx, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(lppt)), + 0, + 0) + return ret1 != 0 +} + +func SetColorAdjustment(hdc HDC, lpca /*const*/ *COLORADJUSTMENT) bool { + ret1 := syscall3(setColorAdjustment, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpca)), + 0) + return ret1 != 0 +} + +func SetColorSpace(hdc HDC, hcs HCOLORSPACE) HCOLORSPACE { + ret1 := syscall3(setColorSpace, 2, + uintptr(hdc), + uintptr(hcs), + 0) + return HCOLORSPACE(ret1) +} + +func SetDCBrushColor(hdc HDC, color COLORREF) COLORREF { + ret1 := syscall3(setDCBrushColor, 2, + uintptr(hdc), + uintptr(color), + 0) + return COLORREF(ret1) +} + +func SetDCPenColor(hdc HDC, color COLORREF) COLORREF { + ret1 := syscall3(setDCPenColor, 2, + uintptr(hdc), + uintptr(color), + 0) + return COLORREF(ret1) +} + +func SetDIBColorTable(hdc HDC, iStart UINT, cEntries UINT, prgbq /*const*/ *RGBQUAD) UINT { + ret1 := syscall6(setDIBColorTable, 4, + uintptr(hdc), + uintptr(iStart), + uintptr(cEntries), + uintptr(unsafe.Pointer(prgbq)), + 0, + 0) + return UINT(ret1) +} + +func SetDIBits(hdc HDC, hbm HBITMAP, start UINT, cLines UINT, lpBits /*const*/ uintptr, lpbmi /*const*/ *BITMAPINFO, colorUse UINT) int32 { + ret1 := syscall9(setDIBits, 7, + uintptr(hdc), + uintptr(hbm), + uintptr(start), + uintptr(cLines), + lpBits, + uintptr(unsafe.Pointer(lpbmi)), + uintptr(colorUse), + 0, + 0) + return int32(ret1) +} + +func SetDIBitsToDevice(hdc HDC, xDest int32, yDest int32, w DWORD, h DWORD, xSrc int32, ySrc int32, startScan UINT, cLines UINT, lpvBits /*const*/ uintptr, lpbmi /*const*/ *BITMAPINFO, colorUse UINT) int32 { + ret1 := syscall12(setDIBitsToDevice, 12, + uintptr(hdc), + uintptr(xDest), + uintptr(yDest), + uintptr(w), + uintptr(h), + uintptr(xSrc), + uintptr(ySrc), + uintptr(startScan), + uintptr(cLines), + lpvBits, + uintptr(unsafe.Pointer(lpbmi)), + uintptr(colorUse)) + return int32(ret1) +} + +func SetDeviceGammaRamp(hdc HDC, lpRamp LPVOID) bool { + ret1 := syscall3(setDeviceGammaRamp, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpRamp)), + 0) + return ret1 != 0 +} + +func SetEnhMetaFileBits(nSize UINT, pb /*const*/ *byte) HENHMETAFILE { + ret1 := syscall3(setEnhMetaFileBits, 2, + uintptr(nSize), + uintptr(unsafe.Pointer(pb)), + 0) + return HENHMETAFILE(ret1) +} + +func SetGraphicsMode(hdc HDC, iMode int32) int32 { + ret1 := syscall3(setGraphicsMode, 2, + uintptr(hdc), + uintptr(iMode), + 0) + return int32(ret1) +} + +func SetICMMode(hdc HDC, mode int32) int32 { + ret1 := syscall3(setICMMode, 2, + uintptr(hdc), + uintptr(mode), + 0) + return int32(ret1) +} + +func SetICMProfile(hdc HDC, lpFileName LPWSTR) bool { + ret1 := syscall3(setICMProfile, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpFileName)), + 0) + return ret1 != 0 +} + +func SetLayout(hdc HDC, l DWORD) DWORD { + ret1 := syscall3(setLayout, 2, + uintptr(hdc), + uintptr(l), + 0) + return DWORD(ret1) +} + +func SetMapMode(hdc HDC, iMode int32) int32 { + ret1 := syscall3(setMapMode, 2, + uintptr(hdc), + uintptr(iMode), + 0) + return int32(ret1) +} + +func SetMapperFlags(hdc HDC, flags DWORD) DWORD { + ret1 := syscall3(setMapperFlags, 2, + uintptr(hdc), + uintptr(flags), + 0) + return DWORD(ret1) +} + +func SetMetaFileBitsEx(cbBuffer UINT, lpData /*const*/ *byte) HMETAFILE { + ret1 := syscall3(setMetaFileBitsEx, 2, + uintptr(cbBuffer), + uintptr(unsafe.Pointer(lpData)), + 0) + return HMETAFILE(ret1) +} + +func SetMetaRgn(hdc HDC) int32 { + ret1 := syscall3(setMetaRgn, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func SetMiterLimit(hdc HDC, limit FLOAT, old *float32) bool { + ret1 := syscall3(setMiterLimit, 3, + uintptr(hdc), + uintptr(limit), + uintptr(unsafe.Pointer(old))) + return ret1 != 0 +} + +func SetPaletteEntries(hpal HPALETTE, iStart UINT, cEntries UINT, pPalEntries /*const*/ *PALETTEENTRY) UINT { + ret1 := syscall6(setPaletteEntries, 4, + uintptr(hpal), + uintptr(iStart), + uintptr(cEntries), + uintptr(unsafe.Pointer(pPalEntries)), + 0, + 0) + return UINT(ret1) +} + +func SetPixel(hdc HDC, x int32, y int32, color COLORREF) COLORREF { + ret1 := syscall6(setPixel, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(color), + 0, + 0) + return COLORREF(ret1) +} + +func SetPixelFormat(hdc HDC, format int32, ppfd /*const*/ *PIXELFORMATDESCRIPTOR) bool { + ret1 := syscall3(setPixelFormat, 3, + uintptr(hdc), + uintptr(format), + uintptr(unsafe.Pointer(ppfd))) + return ret1 != 0 +} + +func SetPixelV(hdc HDC, x int32, y int32, color COLORREF) bool { + ret1 := syscall6(setPixelV, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(color), + 0, + 0) + return ret1 != 0 +} + +func SetPolyFillMode(hdc HDC, mode int32) int32 { + ret1 := syscall3(setPolyFillMode, 2, + uintptr(hdc), + uintptr(mode), + 0) + return int32(ret1) +} + +func SetROP2(hdc HDC, rop2 int32) int32 { + ret1 := syscall3(setROP2, 2, + uintptr(hdc), + uintptr(rop2), + 0) + return int32(ret1) +} + +func SetRectRgn(hrgn HRGN, left int32, top int32, right int32, bottom int32) bool { + ret1 := syscall6(setRectRgn, 5, + uintptr(hrgn), + uintptr(left), + uintptr(top), + uintptr(right), + uintptr(bottom), + 0) + return ret1 != 0 +} + +func SetStretchBltMode(hdc HDC, mode int32) int32 { + ret1 := syscall3(setStretchBltMode, 2, + uintptr(hdc), + uintptr(mode), + 0) + return int32(ret1) +} + +func SetSystemPaletteUse(hdc HDC, use UINT) UINT { + ret1 := syscall3(setSystemPaletteUse, 2, + uintptr(hdc), + uintptr(use), + 0) + return UINT(ret1) +} + +func SetTextAlign(hdc HDC, align UINT) UINT { + ret1 := syscall3(setTextAlign, 2, + uintptr(hdc), + uintptr(align), + 0) + return UINT(ret1) +} + +func SetTextCharacterExtra(hdc HDC, extra int32) int32 { + ret1 := syscall3(setTextCharacterExtra, 2, + uintptr(hdc), + uintptr(extra), + 0) + return int32(ret1) +} + +func SetTextColor(hdc HDC, color COLORREF) COLORREF { + ret1 := syscall3(setTextColor, 2, + uintptr(hdc), + uintptr(color), + 0) + return COLORREF(ret1) +} + +func SetTextJustification(hdc HDC, extra int32, count int32) bool { + ret1 := syscall3(setTextJustification, 3, + uintptr(hdc), + uintptr(extra), + uintptr(count)) + return ret1 != 0 +} + +func SetViewportExtEx(hdc HDC, x int32, y int32, lpsz *SIZE) bool { + ret1 := syscall6(setViewportExtEx, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(lpsz)), + 0, + 0) + return ret1 != 0 +} + +func SetViewportOrgEx(hdc HDC, x int32, y int32, lppt *POINT) bool { + ret1 := syscall6(setViewportOrgEx, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(lppt)), + 0, + 0) + return ret1 != 0 +} + +func SetWinMetaFileBits(nSize UINT, lpMeta16Data /*const*/ *byte, hdcRef HDC, lpMFP /*const*/ *METAFILEPICT) HENHMETAFILE { + ret1 := syscall6(setWinMetaFileBits, 4, + uintptr(nSize), + uintptr(unsafe.Pointer(lpMeta16Data)), + uintptr(hdcRef), + uintptr(unsafe.Pointer(lpMFP)), + 0, + 0) + return HENHMETAFILE(ret1) +} + +func SetWindowExtEx(hdc HDC, x int32, y int32, lpsz *SIZE) bool { + ret1 := syscall6(setWindowExtEx, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(lpsz)), + 0, + 0) + return ret1 != 0 +} + +func SetWindowOrgEx(hdc HDC, x int32, y int32, lppt *POINT) bool { + ret1 := syscall6(setWindowOrgEx, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(lppt)), + 0, + 0) + return ret1 != 0 +} + +func SetWorldTransform(hdc HDC, lpxf /*const*/ *XFORM) bool { + ret1 := syscall3(setWorldTransform, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpxf)), + 0) + return ret1 != 0 +} + +func StartDoc(hdc HDC, lpdi /*const*/ *DOCINFO) int32 { + ret1 := syscall3(startDoc, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpdi)), + 0) + return int32(ret1) +} + +func StartPage(hdc HDC) int32 { + ret1 := syscall3(startPage, 1, + uintptr(hdc), + 0, + 0) + return int32(ret1) +} + +func StretchBlt(hdcDest HDC, xDest int32, yDest int32, wDest int32, hDest int32, hdcSrc HDC, xSrc int32, ySrc int32, wSrc int32, hSrc int32, rop DWORD) bool { + ret1 := syscall12(stretchBlt, 11, + uintptr(hdcDest), + uintptr(xDest), + uintptr(yDest), + uintptr(wDest), + uintptr(hDest), + uintptr(hdcSrc), + uintptr(xSrc), + uintptr(ySrc), + uintptr(wSrc), + uintptr(hSrc), + uintptr(rop), + 0) + return ret1 != 0 +} + +func StretchDIBits(hdc HDC, xDest int32, yDest int32, destWidth int32, destHeight int32, xSrc int32, ySrc int32, srcWidth int32, srcHeight int32, lpBits /*const*/ uintptr, lpbmi /*const*/ *BITMAPINFO, iUsage UINT, rop DWORD) int32 { + ret1 := syscall15(stretchDIBits, 13, + uintptr(hdc), + uintptr(xDest), + uintptr(yDest), + uintptr(destWidth), + uintptr(destHeight), + uintptr(xSrc), + uintptr(ySrc), + uintptr(srcWidth), + uintptr(srcHeight), + lpBits, + uintptr(unsafe.Pointer(lpbmi)), + uintptr(iUsage), + uintptr(rop), + 0, + 0) + return int32(ret1) +} + +func StrokeAndFillPath(hdc HDC) bool { + ret1 := syscall3(strokeAndFillPath, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func StrokePath(hdc HDC) bool { + ret1 := syscall3(strokePath, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func SwapBuffers(unnamed0 HDC) bool { + ret1 := syscall3(swapBuffers, 1, + uintptr(unnamed0), + 0, + 0) + return ret1 != 0 +} + +func TextOut(hdc HDC, x int32, y int32, lpString string, c int32) bool { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall6(textOut, 5, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(&lpStringStr[0])), + uintptr(c), + 0) + return ret1 != 0 +} + +func TranslateCharsetInfo(lpSrc *uint32, lpCs *CHARSETINFO, dwFlags DWORD) bool { + ret1 := syscall3(translateCharsetInfo, 3, + uintptr(unsafe.Pointer(lpSrc)), + uintptr(unsafe.Pointer(lpCs)), + uintptr(dwFlags)) + return ret1 != 0 +} + +func UnrealizeObject(h HGDIOBJ) bool { + ret1 := syscall3(unrealizeObject, 1, + uintptr(h), + 0, + 0) + return ret1 != 0 +} + +func UpdateColors(hdc HDC) bool { + ret1 := syscall3(updateColors, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func UpdateICMRegKey(reserved DWORD, lpszCMID LPWSTR, lpszFileName LPWSTR, command UINT) bool { + ret1 := syscall6(updateICMRegKey, 4, + uintptr(reserved), + uintptr(unsafe.Pointer(lpszCMID)), + uintptr(unsafe.Pointer(lpszFileName)), + uintptr(command), + 0, + 0) + return ret1 != 0 +} + +func WidenPath(hdc HDC) bool { + ret1 := syscall3(widenPath, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func XFORMOBJ_bApplyXform(pxo *XFORMOBJ, iMode ULONG, cPoints ULONG, pvIn uintptr, pvOut uintptr) bool { + ret1 := syscall6(xFORMOBJ_bApplyXform, 5, + uintptr(unsafe.Pointer(pxo)), + uintptr(iMode), + uintptr(cPoints), + pvIn, + pvOut, + 0) + return ret1 != 0 +} + +func XFORMOBJ_iGetXform(pxo *XFORMOBJ, pxform *XFORML) ULONG { + ret1 := syscall3(xFORMOBJ_iGetXform, 2, + uintptr(unsafe.Pointer(pxo)), + uintptr(unsafe.Pointer(pxform)), + 0) + return ULONG(ret1) +} + +func XLATEOBJ_cGetPalette(pxlo *XLATEOBJ, iPal ULONG, cPal ULONG, pPal *ULONG) ULONG { + ret1 := syscall6(xLATEOBJ_cGetPalette, 4, + uintptr(unsafe.Pointer(pxlo)), + uintptr(iPal), + uintptr(cPal), + uintptr(unsafe.Pointer(pPal)), + 0, + 0) + return ULONG(ret1) +} + +func XLATEOBJ_hGetColorTransform(pxlo *XLATEOBJ) HANDLE { + ret1 := syscall3(xLATEOBJ_hGetColorTransform, 1, + uintptr(unsafe.Pointer(pxlo)), + 0, + 0) + return HANDLE(ret1) +} + +func XLATEOBJ_iXlate(pxlo *XLATEOBJ, iColor ULONG) ULONG { + ret1 := syscall3(xLATEOBJ_iXlate, 2, + uintptr(unsafe.Pointer(pxlo)), + uintptr(iColor), + 0) + return ULONG(ret1) +} + +func EnableEUDC(fEnableEUDC bool) bool { + ret1 := syscall3(enableEUDC, 1, + getUintptrFromBool(fEnableEUDC), + 0, + 0) + return ret1 != 0 +} + +func FontIsLinked(hdc HDC) bool { + ret1 := syscall3(fontIsLinked, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func GdiDescribePixelFormat(hdc HDC, format INT, size UINT, descr *PIXELFORMATDESCRIPTOR) INT { + ret1 := syscall6(gdiDescribePixelFormat, 4, + uintptr(hdc), + uintptr(format), + uintptr(size), + uintptr(unsafe.Pointer(descr)), + 0, + 0) + return INT(ret1) +} + +func GdiDrawStream(hdc HDC, in ULONG, pvin uintptr) bool { + ret1 := syscall3(gdiDrawStream, 3, + uintptr(hdc), + uintptr(in), + pvin) + return ret1 != 0 +} + +func GdiGetCharDimensions(hdc HDC, lptm LPTEXTMETRIC, height *LONG) LONG { + ret1 := syscall3(gdiGetCharDimensions, 3, + uintptr(hdc), + uintptr(unsafe.Pointer(lptm)), + uintptr(unsafe.Pointer(height))) + return LONG(ret1) +} + +func GdiGetCodePage(hdc HDC) DWORD { + ret1 := syscall3(gdiGetCodePage, 1, + uintptr(hdc), + 0, + 0) + return DWORD(ret1) +} + +func GdiGetSpoolMessage(ptr1 LPVOID, data2 DWORD, ptr3 LPVOID, data4 DWORD) DWORD { + ret1 := syscall6(gdiGetSpoolMessage, 4, + uintptr(unsafe.Pointer(ptr1)), + uintptr(data2), + uintptr(unsafe.Pointer(ptr3)), + uintptr(data4), + 0, + 0) + return DWORD(ret1) +} + +func GdiInitSpool() DWORD { + ret1 := syscall3(gdiInitSpool, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func GdiInitializeLanguagePack(arg DWORD) DWORD { + ret1 := syscall3(gdiInitializeLanguagePack, 1, + uintptr(arg), + 0, + 0) + return DWORD(ret1) +} + +func GdiIsMetaFileDC(hdc HDC) bool { + ret1 := syscall3(gdiIsMetaFileDC, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func GdiIsMetaPrintDC(hdc HDC) bool { + ret1 := syscall3(gdiIsMetaPrintDC, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func GdiIsPlayMetafileDC(hdc HDC) bool { + ret1 := syscall3(gdiIsPlayMetafileDC, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func GdiRealizationInfo(hdc HDC, info uintptr) bool { + ret1 := syscall3(gdiRealizationInfo, 2, + uintptr(hdc), + info, + 0) + return ret1 != 0 +} + +func GdiSetPixelFormat(hdc HDC, fmt INT, pfd /*const*/ *PIXELFORMATDESCRIPTOR) bool { + ret1 := syscall3(gdiSetPixelFormat, 3, + uintptr(hdc), + uintptr(fmt), + uintptr(unsafe.Pointer(pfd))) + return ret1 != 0 +} + +func GdiSwapBuffers(hdc HDC) bool { + ret1 := syscall3(gdiSwapBuffers, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func GetFontResourceInfoW(str string, size *uint32, buffer uintptr, aType DWORD) bool { + strStr := unicode16FromString(str) + ret1 := syscall6(getFontResourceInfoW, 4, + uintptr(unsafe.Pointer(&strStr[0])), + uintptr(unsafe.Pointer(size)), + buffer, + uintptr(aType), + 0, + 0) + return ret1 != 0 +} + +func GetRelAbs(hdc HDC, dwIgnore DWORD) INT { + ret1 := syscall3(getRelAbs, 2, + uintptr(hdc), + uintptr(dwIgnore), + 0) + return INT(ret1) +} + +func GetTransform(hdc HDC, which DWORD, xform *XFORM) bool { + ret1 := syscall3(getTransform, 3, + uintptr(hdc), + uintptr(which), + uintptr(unsafe.Pointer(xform))) + return ret1 != 0 +} + +func MirrorRgn(hwnd HWND, hrgn HRGN) bool { + ret1 := syscall3(mirrorRgn, 2, + uintptr(hwnd), + uintptr(hrgn), + 0) + return ret1 != 0 +} + +func NamedEscape(hdc HDC, pDriver string, nEscape INT, cbInput INT, lpszInData /*const*/ LPCSTR, cbOutput INT, lpszOutData LPSTR) INT { + pDriverStr := unicode16FromString(pDriver) + ret1 := syscall9(namedEscape, 7, + uintptr(hdc), + uintptr(unsafe.Pointer(&pDriverStr[0])), + uintptr(nEscape), + uintptr(cbInput), + uintptr(unsafe.Pointer(lpszInData)), + uintptr(cbOutput), + uintptr(unsafe.Pointer(lpszOutData)), + 0, + 0) + return INT(ret1) +} + +func SetMagicColors(hdc HDC, u1 ULONG, u2 ULONG) bool { + ret1 := syscall3(setMagicColors, 3, + uintptr(hdc), + uintptr(u1), + uintptr(u2)) + return ret1 != 0 +} + +func SetRelAbs(hdc HDC, mode INT) INT { + ret1 := syscall3(setRelAbs, 2, + uintptr(hdc), + uintptr(mode), + 0) + return INT(ret1) +} + +func SetVirtualResolution(hdc HDC, horz_res DWORD, vert_res DWORD, horz_size DWORD, vert_size DWORD) bool { + ret1 := syscall6(setVirtualResolution, 5, + uintptr(hdc), + uintptr(horz_res), + uintptr(vert_res), + uintptr(horz_size), + uintptr(vert_size), + 0) + return ret1 != 0 +} diff --git a/grdp/win/gdiplus.go b/grdp/win/gdiplus.go new file mode 100644 index 0000000..773d4f6 --- /dev/null +++ b/grdp/win/gdiplus.go @@ -0,0 +1,53 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "unsafe" +) + +var ( + // Library + libgdiplus uintptr + + // Functions + gdiplusNotificationHook uintptr + gdiplusNotificationUnhook uintptr + gdiplusStartup uintptr +) + +func init() { + // Library + libgdiplus = doLoadLibrary("gdiplus.dll") + + // Functions + gdiplusNotificationHook = doGetProcAddress(libgdiplus, "GdiplusNotificationHook") + gdiplusNotificationUnhook = doGetProcAddress(libgdiplus, "GdiplusNotificationUnhook") + gdiplusStartup = doGetProcAddress(libgdiplus, "GdiplusStartup") +} + +func GdiplusNotificationHook(token *ULONG_PTR) GpStatus { + ret1 := syscall3(gdiplusNotificationHook, 1, + uintptr(unsafe.Pointer(token)), + 0, + 0) + return GpStatus(ret1) +} + +func GdiplusNotificationUnhook(token *uint32) { + syscall3(gdiplusNotificationUnhook, 1, + uintptr(unsafe.Pointer(token)), + 0, + 0) +} + +func GdiplusStartup(token *ULONG_PTR, input /*const*/ *GdiplusStartupInput, output *GdiplusStartupOutput) Status { + ret1 := syscall3(gdiplusStartup, 3, + uintptr(unsafe.Pointer(token)), + uintptr(unsafe.Pointer(input)), + uintptr(unsafe.Pointer(output))) + return Status(ret1) +} diff --git a/grdp/win/imm32.go b/grdp/win/imm32.go new file mode 100644 index 0000000..9f4cadc --- /dev/null +++ b/grdp/win/imm32.go @@ -0,0 +1,715 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "syscall" + "unsafe" +) + +var ( + // Library + libimm32 uintptr + + // Functions + immAssociateContext uintptr + immAssociateContextEx uintptr + immConfigureIME uintptr + immCreateContext uintptr + immDestroyContext uintptr + immDisableIME uintptr + immDisableTextFrameService uintptr + immEnumInputContext uintptr + immEnumRegisterWord uintptr + immEscape uintptr + immGetCandidateListCount uintptr + immGetCandidateList uintptr + immGetCandidateWindow uintptr + immGetCompositionFont uintptr + immGetCompositionString uintptr + immGetCompositionWindow uintptr + immGetContext uintptr + immGetConversionList uintptr + immGetConversionStatus uintptr + immGetDefaultIMEWnd uintptr + immGetDescription uintptr + immGetGuideLine uintptr + immGetIMEFileName uintptr + immGetImeMenuItems uintptr + immGetOpenStatus uintptr + immGetProperty uintptr + immGetRegisterWordStyle uintptr + immGetStatusWindowPos uintptr + immGetVirtualKey uintptr + immInstallIME uintptr + immIsIME uintptr + immIsUIMessage uintptr + immNotifyIME uintptr + immRegisterWord uintptr + immReleaseContext uintptr + immSetCandidateWindow uintptr + immSetCompositionFont uintptr + immSetCompositionString uintptr + immSetCompositionWindow uintptr + immSetConversionStatus uintptr + immSetOpenStatus uintptr + immSetStatusWindowPos uintptr + immSimulateHotKey uintptr + immUnregisterWord uintptr + immCreateIMCC uintptr + immCreateSoftKeyboard uintptr + immDestroyIMCC uintptr + immDestroySoftKeyboard uintptr + immGenerateMessage uintptr + immGetHotKey uintptr + immGetIMCCLockCount uintptr + immGetIMCCSize uintptr + immGetIMCLockCount uintptr + immLockIMC uintptr + immLockIMCC uintptr + immProcessKey uintptr + immReSizeIMCC uintptr + immRequestMessage uintptr + immShowSoftKeyboard uintptr + immTranslateMessage uintptr + immUnlockIMC uintptr + immUnlockIMCC uintptr +) + +func init() { + // Library + libimm32 = doLoadLibrary("imm32.dll") + + // Functions + immAssociateContext = doGetProcAddress(libimm32, "ImmAssociateContext") + immAssociateContextEx = doGetProcAddress(libimm32, "ImmAssociateContextEx") + immConfigureIME = doGetProcAddress(libimm32, "ImmConfigureIMEW") + immCreateContext = doGetProcAddress(libimm32, "ImmCreateContext") + immDestroyContext = doGetProcAddress(libimm32, "ImmDestroyContext") + immDisableIME = doGetProcAddress(libimm32, "ImmDisableIME") + immDisableTextFrameService = doGetProcAddress(libimm32, "ImmDisableTextFrameService") + immEnumInputContext = doGetProcAddress(libimm32, "ImmEnumInputContext") + immEnumRegisterWord = doGetProcAddress(libimm32, "ImmEnumRegisterWordW") + immEscape = doGetProcAddress(libimm32, "ImmEscapeW") + immGetCandidateListCount = doGetProcAddress(libimm32, "ImmGetCandidateListCountW") + immGetCandidateList = doGetProcAddress(libimm32, "ImmGetCandidateListW") + immGetCandidateWindow = doGetProcAddress(libimm32, "ImmGetCandidateWindow") + immGetCompositionFont = doGetProcAddress(libimm32, "ImmGetCompositionFontW") + immGetCompositionString = doGetProcAddress(libimm32, "ImmGetCompositionStringW") + immGetCompositionWindow = doGetProcAddress(libimm32, "ImmGetCompositionWindow") + immGetContext = doGetProcAddress(libimm32, "ImmGetContext") + immGetConversionList = doGetProcAddress(libimm32, "ImmGetConversionListW") + immGetConversionStatus = doGetProcAddress(libimm32, "ImmGetConversionStatus") + immGetDefaultIMEWnd = doGetProcAddress(libimm32, "ImmGetDefaultIMEWnd") + immGetDescription = doGetProcAddress(libimm32, "ImmGetDescriptionW") + immGetGuideLine = doGetProcAddress(libimm32, "ImmGetGuideLineW") + immGetIMEFileName = doGetProcAddress(libimm32, "ImmGetIMEFileNameW") + immGetImeMenuItems = doGetProcAddress(libimm32, "ImmGetImeMenuItemsW") + immGetOpenStatus = doGetProcAddress(libimm32, "ImmGetOpenStatus") + immGetProperty = doGetProcAddress(libimm32, "ImmGetProperty") + immGetRegisterWordStyle = doGetProcAddress(libimm32, "ImmGetRegisterWordStyleW") + immGetStatusWindowPos = doGetProcAddress(libimm32, "ImmGetStatusWindowPos") + immGetVirtualKey = doGetProcAddress(libimm32, "ImmGetVirtualKey") + immInstallIME = doGetProcAddress(libimm32, "ImmInstallIMEW") + immIsIME = doGetProcAddress(libimm32, "ImmIsIME") + immIsUIMessage = doGetProcAddress(libimm32, "ImmIsUIMessageW") + immNotifyIME = doGetProcAddress(libimm32, "ImmNotifyIME") + immRegisterWord = doGetProcAddress(libimm32, "ImmRegisterWordW") + immReleaseContext = doGetProcAddress(libimm32, "ImmReleaseContext") + immSetCandidateWindow = doGetProcAddress(libimm32, "ImmSetCandidateWindow") + immSetCompositionFont = doGetProcAddress(libimm32, "ImmSetCompositionFontW") + immSetCompositionString = doGetProcAddress(libimm32, "ImmSetCompositionStringW") + immSetCompositionWindow = doGetProcAddress(libimm32, "ImmSetCompositionWindow") + immSetConversionStatus = doGetProcAddress(libimm32, "ImmSetConversionStatus") + immSetOpenStatus = doGetProcAddress(libimm32, "ImmSetOpenStatus") + immSetStatusWindowPos = doGetProcAddress(libimm32, "ImmSetStatusWindowPos") + immSimulateHotKey = doGetProcAddress(libimm32, "ImmSimulateHotKey") + immUnregisterWord = doGetProcAddress(libimm32, "ImmUnregisterWordW") + immCreateIMCC = doGetProcAddress(libimm32, "ImmCreateIMCC") + immCreateSoftKeyboard = doGetProcAddress(libimm32, "ImmCreateSoftKeyboard") + immDestroyIMCC = doGetProcAddress(libimm32, "ImmDestroyIMCC") + immDestroySoftKeyboard = doGetProcAddress(libimm32, "ImmDestroySoftKeyboard") + immGenerateMessage = doGetProcAddress(libimm32, "ImmGenerateMessage") + immGetHotKey = doGetProcAddress(libimm32, "ImmGetHotKey") + immGetIMCCLockCount = doGetProcAddress(libimm32, "ImmGetIMCCLockCount") + immGetIMCCSize = doGetProcAddress(libimm32, "ImmGetIMCCSize") + immGetIMCLockCount = doGetProcAddress(libimm32, "ImmGetIMCLockCount") + immLockIMC = doGetProcAddress(libimm32, "ImmLockIMC") + immLockIMCC = doGetProcAddress(libimm32, "ImmLockIMCC") + immProcessKey = doGetProcAddress(libimm32, "ImmProcessKey") + immReSizeIMCC = doGetProcAddress(libimm32, "ImmReSizeIMCC") + immRequestMessage = doGetProcAddress(libimm32, "ImmRequestMessageW") + immShowSoftKeyboard = doGetProcAddress(libimm32, "ImmShowSoftKeyboard") + immTranslateMessage = doGetProcAddress(libimm32, "ImmTranslateMessage") + immUnlockIMC = doGetProcAddress(libimm32, "ImmUnlockIMC") + immUnlockIMCC = doGetProcAddress(libimm32, "ImmUnlockIMCC") +} + +func ImmAssociateContext(unnamed0 HWND, unnamed1 HIMC) HIMC { + ret1 := syscall3(immAssociateContext, 2, + uintptr(unnamed0), + uintptr(unnamed1), + 0) + return HIMC(ret1) +} + +func ImmAssociateContextEx(unnamed0 HWND, unnamed1 HIMC, unnamed2 DWORD) bool { + ret1 := syscall3(immAssociateContextEx, 3, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2)) + return ret1 != 0 +} + +func ImmConfigureIME(unnamed0 HKL, unnamed1 HWND, unnamed2 DWORD, unnamed3 LPVOID) bool { + ret1 := syscall6(immConfigureIME, 4, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2), + uintptr(unsafe.Pointer(unnamed3)), + 0, + 0) + return ret1 != 0 +} + +func ImmCreateContext() HIMC { + ret1 := syscall3(immCreateContext, 0, + 0, + 0, + 0) + return HIMC(ret1) +} + +func ImmDestroyContext(unnamed0 HIMC) bool { + ret1 := syscall3(immDestroyContext, 1, + uintptr(unnamed0), + 0, + 0) + return ret1 != 0 +} + +func ImmDisableIME(unnamed0 DWORD) bool { + ret1 := syscall3(immDisableIME, 1, + uintptr(unnamed0), + 0, + 0) + return ret1 != 0 +} + +func ImmDisableTextFrameService(idThread DWORD) bool { + ret1 := syscall3(immDisableTextFrameService, 1, + uintptr(idThread), + 0, + 0) + return ret1 != 0 +} + +func ImmEnumInputContext(idThread DWORD, lpfn IMCENUMPROC, lParam LPARAM) bool { + lpfnCallback := syscall.NewCallback(func(unnamed0RawArg HIMC, unnamed1RawArg LPARAM) uintptr { + ret := lpfn(unnamed0RawArg, unnamed1RawArg) + return uintptr(ret) + }) + ret1 := syscall3(immEnumInputContext, 3, + uintptr(idThread), + lpfnCallback, + uintptr(lParam)) + return ret1 != 0 +} + +func ImmEnumRegisterWord(unnamed0 HKL, unnamed1 REGISTERWORDENUMPROC, lpszReading string, unnamed3 DWORD, lpszRegister string, unnamed5 LPVOID) UINT { + lpszReadingStr := unicode16FromString(lpszReading) + lpszRegisterStr := unicode16FromString(lpszRegister) + unnamed1Callback := syscall.NewCallback(func(lpszReadingRawArg /*const*/ *uint16, unnamed1RawArg DWORD, lpszStringRawArg /*const*/ *uint16, unnamed3RawArg LPVOID) uintptr { + lpszReading := stringFromUnicode16(lpszReadingRawArg) + lpszString := stringFromUnicode16(lpszStringRawArg) + ret := unnamed1(lpszReading, unnamed1RawArg, lpszString, unnamed3RawArg) + return uintptr(ret) + }) + ret1 := syscall6(immEnumRegisterWord, 6, + uintptr(unnamed0), + unnamed1Callback, + uintptr(unsafe.Pointer(&lpszReadingStr[0])), + uintptr(unnamed3), + uintptr(unsafe.Pointer(&lpszRegisterStr[0])), + uintptr(unsafe.Pointer(unnamed5))) + return UINT(ret1) +} + +func ImmEscape(unnamed0 HKL, unnamed1 HIMC, unnamed2 UINT, unnamed3 LPVOID) LRESULT { + ret1 := syscall6(immEscape, 4, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2), + uintptr(unsafe.Pointer(unnamed3)), + 0, + 0) + return LRESULT(ret1) +} + +func ImmGetCandidateListCount(unnamed0 HIMC, lpdwListCount *uint32) DWORD { + ret1 := syscall3(immGetCandidateListCount, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(lpdwListCount)), + 0) + return DWORD(ret1) +} + +func ImmGetCandidateList(unnamed0 HIMC, deIndex DWORD, unnamed2 *CANDIDATELIST, dwBufLen DWORD) DWORD { + ret1 := syscall6(immGetCandidateList, 4, + uintptr(unnamed0), + uintptr(deIndex), + uintptr(unsafe.Pointer(unnamed2)), + uintptr(dwBufLen), + 0, + 0) + return DWORD(ret1) +} + +func ImmGetCandidateWindow(unnamed0 HIMC, unnamed1 DWORD, unnamed2 *CANDIDATEFORM) bool { + ret1 := syscall3(immGetCandidateWindow, 3, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unsafe.Pointer(unnamed2))) + return ret1 != 0 +} + +func ImmGetCompositionFont(unnamed0 HIMC, unnamed1 LPLOGFONT) bool { + ret1 := syscall3(immGetCompositionFont, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + 0) + return ret1 != 0 +} + +func ImmGetCompositionString(unnamed0 HIMC, unnamed1 DWORD, unnamed2 LPVOID, unnamed3 DWORD) LONG { + ret1 := syscall6(immGetCompositionString, 4, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unsafe.Pointer(unnamed2)), + uintptr(unnamed3), + 0, + 0) + return LONG(ret1) +} + +func ImmGetCompositionWindow(unnamed0 HIMC, unnamed1 *COMPOSITIONFORM) bool { + ret1 := syscall3(immGetCompositionWindow, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + 0) + return ret1 != 0 +} + +func ImmGetContext(unnamed0 HWND) HIMC { + ret1 := syscall3(immGetContext, 1, + uintptr(unnamed0), + 0, + 0) + return HIMC(ret1) +} + +func ImmGetConversionList(unnamed0 HKL, unnamed1 HIMC, unnamed2 string, unnamed3 *CANDIDATELIST, dwBufLen DWORD, uFlag UINT) DWORD { + unnamed2Str := unicode16FromString(unnamed2) + ret1 := syscall6(immGetConversionList, 6, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unsafe.Pointer(&unnamed2Str[0])), + uintptr(unsafe.Pointer(unnamed3)), + uintptr(dwBufLen), + uintptr(uFlag)) + return DWORD(ret1) +} + +func ImmGetConversionStatus(unnamed0 HIMC, unnamed1 *uint32, unnamed2 *uint32) bool { + ret1 := syscall3(immGetConversionStatus, 3, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + uintptr(unsafe.Pointer(unnamed2))) + return ret1 != 0 +} + +func ImmGetDefaultIMEWnd(unnamed0 HWND) HWND { + ret1 := syscall3(immGetDefaultIMEWnd, 1, + uintptr(unnamed0), + 0, + 0) + return HWND(ret1) +} + +func ImmGetDescription(unnamed0 HKL, unnamed1 LPWSTR, uBufLen UINT) UINT { + ret1 := syscall3(immGetDescription, 3, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + uintptr(uBufLen)) + return UINT(ret1) +} + +func ImmGetGuideLine(unnamed0 HIMC, dwIndex DWORD, unnamed2 LPWSTR, dwBufLen DWORD) DWORD { + ret1 := syscall6(immGetGuideLine, 4, + uintptr(unnamed0), + uintptr(dwIndex), + uintptr(unsafe.Pointer(unnamed2)), + uintptr(dwBufLen), + 0, + 0) + return DWORD(ret1) +} + +func ImmGetIMEFileName(unnamed0 HKL, unnamed1 LPWSTR, uBufLen UINT) UINT { + ret1 := syscall3(immGetIMEFileName, 3, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + uintptr(uBufLen)) + return UINT(ret1) +} + +func ImmGetImeMenuItems(unnamed0 HIMC, unnamed1 DWORD, unnamed2 DWORD, unnamed3 LPIMEMENUITEMINFO, unnamed4 LPIMEMENUITEMINFO, unnamed5 DWORD) DWORD { + ret1 := syscall6(immGetImeMenuItems, 6, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2), + uintptr(unsafe.Pointer(unnamed3)), + uintptr(unsafe.Pointer(unnamed4)), + uintptr(unnamed5)) + return DWORD(ret1) +} + +func ImmGetOpenStatus(unnamed0 HIMC) bool { + ret1 := syscall3(immGetOpenStatus, 1, + uintptr(unnamed0), + 0, + 0) + return ret1 != 0 +} + +func ImmGetProperty(unnamed0 HKL, unnamed1 DWORD) DWORD { + ret1 := syscall3(immGetProperty, 2, + uintptr(unnamed0), + uintptr(unnamed1), + 0) + return DWORD(ret1) +} + +func ImmGetRegisterWordStyle(unnamed0 HKL, nItem UINT, unnamed2 LPSTYLEBUF) UINT { + ret1 := syscall3(immGetRegisterWordStyle, 3, + uintptr(unnamed0), + uintptr(nItem), + uintptr(unsafe.Pointer(unnamed2))) + return UINT(ret1) +} + +func ImmGetStatusWindowPos(unnamed0 HIMC, unnamed1 *POINT) bool { + ret1 := syscall3(immGetStatusWindowPos, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + 0) + return ret1 != 0 +} + +func ImmGetVirtualKey(unnamed0 HWND) UINT { + ret1 := syscall3(immGetVirtualKey, 1, + uintptr(unnamed0), + 0, + 0) + return UINT(ret1) +} + +func ImmInstallIME(lpszIMEFileName string, lpszLayoutText string) HKL { + lpszIMEFileNameStr := unicode16FromString(lpszIMEFileName) + lpszLayoutTextStr := unicode16FromString(lpszLayoutText) + ret1 := syscall3(immInstallIME, 2, + uintptr(unsafe.Pointer(&lpszIMEFileNameStr[0])), + uintptr(unsafe.Pointer(&lpszLayoutTextStr[0])), + 0) + return HKL(ret1) +} + +func ImmIsIME(unnamed0 HKL) bool { + ret1 := syscall3(immIsIME, 1, + uintptr(unnamed0), + 0, + 0) + return ret1 != 0 +} + +func ImmIsUIMessage(unnamed0 HWND, unnamed1 UINT, unnamed2 WPARAM, unnamed3 LPARAM) bool { + ret1 := syscall6(immIsUIMessage, 4, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2), + uintptr(unnamed3), + 0, + 0) + return ret1 != 0 +} + +func ImmNotifyIME(unnamed0 HIMC, dwAction DWORD, dwIndex DWORD, dwValue DWORD) bool { + ret1 := syscall6(immNotifyIME, 4, + uintptr(unnamed0), + uintptr(dwAction), + uintptr(dwIndex), + uintptr(dwValue), + 0, + 0) + return ret1 != 0 +} + +func ImmRegisterWord(unnamed0 HKL, lpszReading string, unnamed2 DWORD, lpszRegister string) bool { + lpszReadingStr := unicode16FromString(lpszReading) + lpszRegisterStr := unicode16FromString(lpszRegister) + ret1 := syscall6(immRegisterWord, 4, + uintptr(unnamed0), + uintptr(unsafe.Pointer(&lpszReadingStr[0])), + uintptr(unnamed2), + uintptr(unsafe.Pointer(&lpszRegisterStr[0])), + 0, + 0) + return ret1 != 0 +} + +func ImmReleaseContext(unnamed0 HWND, unnamed1 HIMC) bool { + ret1 := syscall3(immReleaseContext, 2, + uintptr(unnamed0), + uintptr(unnamed1), + 0) + return ret1 != 0 +} + +func ImmSetCandidateWindow(unnamed0 HIMC, unnamed1 *CANDIDATEFORM) bool { + ret1 := syscall3(immSetCandidateWindow, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + 0) + return ret1 != 0 +} + +func ImmSetCompositionFont(unnamed0 HIMC, unnamed1 LPLOGFONT) bool { + ret1 := syscall3(immSetCompositionFont, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + 0) + return ret1 != 0 +} + +func ImmSetCompositionString(unnamed0 HIMC, dwIndex DWORD, lpComp LPVOID, unnamed3 DWORD, lpRead LPVOID, unnamed5 DWORD) bool { + ret1 := syscall6(immSetCompositionString, 6, + uintptr(unnamed0), + uintptr(dwIndex), + uintptr(unsafe.Pointer(lpComp)), + uintptr(unnamed3), + uintptr(unsafe.Pointer(lpRead)), + uintptr(unnamed5)) + return ret1 != 0 +} + +func ImmSetCompositionWindow(unnamed0 HIMC, unnamed1 *COMPOSITIONFORM) bool { + ret1 := syscall3(immSetCompositionWindow, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + 0) + return ret1 != 0 +} + +func ImmSetConversionStatus(unnamed0 HIMC, unnamed1 DWORD, unnamed2 DWORD) bool { + ret1 := syscall3(immSetConversionStatus, 3, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2)) + return ret1 != 0 +} + +func ImmSetOpenStatus(unnamed0 HIMC, unnamed1 bool) bool { + ret1 := syscall3(immSetOpenStatus, 2, + uintptr(unnamed0), + getUintptrFromBool(unnamed1), + 0) + return ret1 != 0 +} + +func ImmSetStatusWindowPos(unnamed0 HIMC, unnamed1 *POINT) bool { + ret1 := syscall3(immSetStatusWindowPos, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + 0) + return ret1 != 0 +} + +func ImmSimulateHotKey(unnamed0 HWND, unnamed1 DWORD) bool { + ret1 := syscall3(immSimulateHotKey, 2, + uintptr(unnamed0), + uintptr(unnamed1), + 0) + return ret1 != 0 +} + +func ImmUnregisterWord(unnamed0 HKL, lpszReading string, unnamed2 DWORD, lpszUnregister string) bool { + lpszReadingStr := unicode16FromString(lpszReading) + lpszUnregisterStr := unicode16FromString(lpszUnregister) + ret1 := syscall6(immUnregisterWord, 4, + uintptr(unnamed0), + uintptr(unsafe.Pointer(&lpszReadingStr[0])), + uintptr(unnamed2), + uintptr(unsafe.Pointer(&lpszUnregisterStr[0])), + 0, + 0) + return ret1 != 0 +} + +func ImmCreateIMCC(size DWORD) HIMCC { + ret1 := syscall3(immCreateIMCC, 1, + uintptr(size), + 0, + 0) + return HIMCC(ret1) +} + +func ImmCreateSoftKeyboard(uType UINT, hOwner UINT, x int32, y int32) HWND { + ret1 := syscall6(immCreateSoftKeyboard, 4, + uintptr(uType), + uintptr(hOwner), + uintptr(x), + uintptr(y), + 0, + 0) + return HWND(ret1) +} + +func ImmDestroyIMCC(block HIMCC) HIMCC { + ret1 := syscall3(immDestroyIMCC, 1, + uintptr(block), + 0, + 0) + return HIMCC(ret1) +} + +func ImmDestroySoftKeyboard(hSoftWnd HWND) bool { + ret1 := syscall3(immDestroySoftKeyboard, 1, + uintptr(hSoftWnd), + 0, + 0) + return ret1 != 0 +} + +func ImmGenerateMessage(hIMC HIMC) bool { + ret1 := syscall3(immGenerateMessage, 1, + uintptr(hIMC), + 0, + 0) + return ret1 != 0 +} + +func ImmGetHotKey(hotkey DWORD, modifiers *UINT, key *UINT, hkl HKL) bool { + ret1 := syscall6(immGetHotKey, 4, + uintptr(hotkey), + uintptr(unsafe.Pointer(modifiers)), + uintptr(unsafe.Pointer(key)), + uintptr(hkl), + 0, + 0) + return ret1 != 0 +} + +func ImmGetIMCCLockCount(imcc HIMCC) DWORD { + ret1 := syscall3(immGetIMCCLockCount, 1, + uintptr(imcc), + 0, + 0) + return DWORD(ret1) +} + +func ImmGetIMCCSize(imcc HIMCC) DWORD { + ret1 := syscall3(immGetIMCCSize, 1, + uintptr(imcc), + 0, + 0) + return DWORD(ret1) +} + +func ImmGetIMCLockCount(hIMC HIMC) DWORD { + ret1 := syscall3(immGetIMCLockCount, 1, + uintptr(hIMC), + 0, + 0) + return DWORD(ret1) +} + +func ImmLockIMC(hIMC HIMC) *INPUTCONTEXT { + ret1 := syscall3(immLockIMC, 1, + uintptr(hIMC), + 0, + 0) + return (*INPUTCONTEXT)(unsafe.Pointer(ret1)) +} + +func ImmLockIMCC(imcc HIMCC) LPVOID { + ret1 := syscall3(immLockIMCC, 1, + uintptr(imcc), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func ImmProcessKey(hwnd HWND, hKL HKL, vKey UINT, lKeyData LPARAM, unknown DWORD) bool { + ret1 := syscall6(immProcessKey, 5, + uintptr(hwnd), + uintptr(hKL), + uintptr(vKey), + uintptr(lKeyData), + uintptr(unknown), + 0) + return ret1 != 0 +} + +func ImmReSizeIMCC(imcc HIMCC, size DWORD) HIMCC { + ret1 := syscall3(immReSizeIMCC, 2, + uintptr(imcc), + uintptr(size), + 0) + return HIMCC(ret1) +} + +func ImmRequestMessage(hIMC HIMC, wParam WPARAM, lParam LPARAM) LRESULT { + ret1 := syscall3(immRequestMessage, 3, + uintptr(hIMC), + uintptr(wParam), + uintptr(lParam)) + return LRESULT(ret1) +} + +func ImmShowSoftKeyboard(hSoftWnd HWND, nCmdShow int32) bool { + ret1 := syscall3(immShowSoftKeyboard, 2, + uintptr(hSoftWnd), + uintptr(nCmdShow), + 0) + return ret1 != 0 +} + +func ImmTranslateMessage(hwnd HWND, msg UINT, wParam WPARAM, lKeyData LPARAM) bool { + ret1 := syscall6(immTranslateMessage, 4, + uintptr(hwnd), + uintptr(msg), + uintptr(wParam), + uintptr(lKeyData), + 0, + 0) + return ret1 != 0 +} + +func ImmUnlockIMC(hIMC HIMC) bool { + ret1 := syscall3(immUnlockIMC, 1, + uintptr(hIMC), + 0, + 0) + return ret1 != 0 +} + +func ImmUnlockIMCC(imcc HIMCC) bool { + ret1 := syscall3(immUnlockIMCC, 1, + uintptr(imcc), + 0, + 0) + return ret1 != 0 +} diff --git a/grdp/win/iphlpapi.go b/grdp/win/iphlpapi.go new file mode 100644 index 0000000..ae7b58c --- /dev/null +++ b/grdp/win/iphlpapi.go @@ -0,0 +1,1250 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "syscall" + "unsafe" +) + +var ( + // Library + libiphlpapi uintptr + + // Functions + addIPAddress uintptr + cancelIPChangeNotify uintptr + createIpForwardEntry uintptr + createIpNetEntry uintptr + createPersistentTcpPortReservation uintptr + createPersistentUdpPortReservation uintptr + createProxyArpEntry uintptr + deleteIPAddress uintptr + deleteIpForwardEntry uintptr + deleteIpNetEntry uintptr + deletePersistentTcpPortReservation uintptr + deletePersistentUdpPortReservation uintptr + deleteProxyArpEntry uintptr + disableMediaSense uintptr + enableRouter uintptr + flushIpNetTable uintptr + getAdapterIndex uintptr + getAdapterOrderMap uintptr + getAdaptersAddresses uintptr + getAdaptersInfo uintptr + getBestInterface uintptr + getBestInterfaceEx uintptr + getBestRoute uintptr + getExtendedTcpTable uintptr + getExtendedUdpTable uintptr + getFriendlyIfIndex uintptr + getIcmpStatistics uintptr + getIcmpStatisticsEx uintptr + getIfEntry uintptr + getIfTable uintptr + getInterfaceInfo uintptr + getIpAddrTable uintptr + getIpErrorString uintptr + getIpForwardTable uintptr + getIpNetTable uintptr + getIpStatistics uintptr + getIpStatisticsEx uintptr + getNetworkParams uintptr + getNumberOfInterfaces uintptr + getOwnerModuleFromTcp6Entry uintptr + getOwnerModuleFromTcpEntry uintptr + getOwnerModuleFromUdp6Entry uintptr + getOwnerModuleFromUdpEntry uintptr + getPerAdapterInfo uintptr + getPerTcp6ConnectionEStats uintptr + getPerTcpConnectionEStats uintptr + getRTTAndHopCount uintptr + getTcp6Table uintptr + getTcp6Table2 uintptr + getTcpStatistics uintptr + getTcpStatisticsEx uintptr + getTcpTable uintptr + getTcpTable2 uintptr + getUdp6Table uintptr + getUdpStatistics uintptr + getUdpStatisticsEx uintptr + getUdpTable uintptr + getUniDirectionalAdapterInfo uintptr + icmp6CreateFile uintptr + icmp6ParseReplies uintptr + icmp6SendEcho2 uintptr + icmpCloseHandle uintptr + icmpCreateFile uintptr + icmpParseReplies uintptr + icmpSendEcho uintptr + icmpSendEcho2 uintptr + ipReleaseAddress uintptr + ipRenewAddress uintptr + lookupPersistentTcpPortReservation uintptr + lookupPersistentUdpPortReservation uintptr + nhpAllocateAndGetInterfaceInfoFromStack uintptr + notifyAddrChange uintptr + notifyRouteChange uintptr + parseNetworkString uintptr + resolveNeighbor uintptr + restoreMediaSense uintptr + sendARP uintptr + setIfEntry uintptr + setIpForwardEntry uintptr + setIpNetEntry uintptr + setIpStatistics uintptr + setIpStatisticsEx uintptr + setIpTTL uintptr + setPerTcp6ConnectionEStats uintptr + setPerTcpConnectionEStats uintptr + setTcpEntry uintptr + unenableRouter uintptr + allocateAndGetIfTableFromStack uintptr + allocateAndGetIpAddrTableFromStack uintptr + allocateAndGetIpForwardTableFromStack uintptr + allocateAndGetIpNetTableFromStack uintptr + allocateAndGetTcpTableFromStack uintptr + allocateAndGetUdpTableFromStack uintptr + cancelMibChangeNotify2 uintptr + convertInterfaceGuidToLuid uintptr + convertInterfaceIndexToLuid uintptr + convertInterfaceLuidToGuid uintptr + convertInterfaceLuidToIndex uintptr + convertInterfaceLuidToName uintptr + convertInterfaceNameToLuid uintptr + createSortedAddressPairs uintptr + freeMibTable uintptr + getIfEntry2 uintptr + getIfTable2 uintptr + icmpSendEcho2Ex uintptr + notifyIpInterfaceChange uintptr + pfBindInterfaceToIPAddress uintptr + pfCreateInterface uintptr + pfDeleteInterface uintptr + pfUnBindInterface uintptr +) + +func init() { + // Library + libiphlpapi = doLoadLibrary("iphlpapi.dll") + + // Functions + addIPAddress = doGetProcAddress(libiphlpapi, "AddIPAddress") + cancelIPChangeNotify = doGetProcAddress(libiphlpapi, "CancelIPChangeNotify") + createIpForwardEntry = doGetProcAddress(libiphlpapi, "CreateIpForwardEntry") + createIpNetEntry = doGetProcAddress(libiphlpapi, "CreateIpNetEntry") + createPersistentTcpPortReservation = doGetProcAddress(libiphlpapi, "CreatePersistentTcpPortReservation") + createPersistentUdpPortReservation = doGetProcAddress(libiphlpapi, "CreatePersistentUdpPortReservation") + createProxyArpEntry = doGetProcAddress(libiphlpapi, "CreateProxyArpEntry") + deleteIPAddress = doGetProcAddress(libiphlpapi, "DeleteIPAddress") + deleteIpForwardEntry = doGetProcAddress(libiphlpapi, "DeleteIpForwardEntry") + deleteIpNetEntry = doGetProcAddress(libiphlpapi, "DeleteIpNetEntry") + deletePersistentTcpPortReservation = doGetProcAddress(libiphlpapi, "DeletePersistentTcpPortReservation") + deletePersistentUdpPortReservation = doGetProcAddress(libiphlpapi, "DeletePersistentUdpPortReservation") + deleteProxyArpEntry = doGetProcAddress(libiphlpapi, "DeleteProxyArpEntry") + disableMediaSense = doGetProcAddress(libiphlpapi, "DisableMediaSense") + enableRouter = doGetProcAddress(libiphlpapi, "EnableRouter") + flushIpNetTable = doGetProcAddress(libiphlpapi, "FlushIpNetTable") + getAdapterIndex = doGetProcAddress(libiphlpapi, "GetAdapterIndex") + getAdapterOrderMap = doGetProcAddress(libiphlpapi, "GetAdapterOrderMap") + getAdaptersAddresses = doGetProcAddress(libiphlpapi, "GetAdaptersAddresses") + getAdaptersInfo = doGetProcAddress(libiphlpapi, "GetAdaptersInfo") + getBestInterface = doGetProcAddress(libiphlpapi, "GetBestInterface") + getBestInterfaceEx = doGetProcAddress(libiphlpapi, "GetBestInterfaceEx") + getBestRoute = doGetProcAddress(libiphlpapi, "GetBestRoute") + getExtendedTcpTable = doGetProcAddress(libiphlpapi, "GetExtendedTcpTable") + getExtendedUdpTable = doGetProcAddress(libiphlpapi, "GetExtendedUdpTable") + getFriendlyIfIndex = doGetProcAddress(libiphlpapi, "GetFriendlyIfIndex") + getIcmpStatistics = doGetProcAddress(libiphlpapi, "GetIcmpStatistics") + getIcmpStatisticsEx = doGetProcAddress(libiphlpapi, "GetIcmpStatisticsEx") + getIfEntry = doGetProcAddress(libiphlpapi, "GetIfEntry") + getIfTable = doGetProcAddress(libiphlpapi, "GetIfTable") + getInterfaceInfo = doGetProcAddress(libiphlpapi, "GetInterfaceInfo") + getIpAddrTable = doGetProcAddress(libiphlpapi, "GetIpAddrTable") + getIpErrorString = doGetProcAddress(libiphlpapi, "GetIpErrorString") + getIpForwardTable = doGetProcAddress(libiphlpapi, "GetIpForwardTable") + getIpNetTable = doGetProcAddress(libiphlpapi, "GetIpNetTable") + getIpStatistics = doGetProcAddress(libiphlpapi, "GetIpStatistics") + getIpStatisticsEx = doGetProcAddress(libiphlpapi, "GetIpStatisticsEx") + getNetworkParams = doGetProcAddress(libiphlpapi, "GetNetworkParams") + getNumberOfInterfaces = doGetProcAddress(libiphlpapi, "GetNumberOfInterfaces") + getOwnerModuleFromTcp6Entry = doGetProcAddress(libiphlpapi, "GetOwnerModuleFromTcp6Entry") + getOwnerModuleFromTcpEntry = doGetProcAddress(libiphlpapi, "GetOwnerModuleFromTcpEntry") + getOwnerModuleFromUdp6Entry = doGetProcAddress(libiphlpapi, "GetOwnerModuleFromUdp6Entry") + getOwnerModuleFromUdpEntry = doGetProcAddress(libiphlpapi, "GetOwnerModuleFromUdpEntry") + getPerAdapterInfo = doGetProcAddress(libiphlpapi, "GetPerAdapterInfo") + getPerTcp6ConnectionEStats = doGetProcAddress(libiphlpapi, "GetPerTcp6ConnectionEStats") + getPerTcpConnectionEStats = doGetProcAddress(libiphlpapi, "GetPerTcpConnectionEStats") + getRTTAndHopCount = doGetProcAddress(libiphlpapi, "GetRTTAndHopCount") + getTcp6Table = doGetProcAddress(libiphlpapi, "GetTcp6Table") + getTcp6Table2 = doGetProcAddress(libiphlpapi, "GetTcp6Table2") + getTcpStatistics = doGetProcAddress(libiphlpapi, "GetTcpStatistics") + getTcpStatisticsEx = doGetProcAddress(libiphlpapi, "GetTcpStatisticsEx") + getTcpTable = doGetProcAddress(libiphlpapi, "GetTcpTable") + getTcpTable2 = doGetProcAddress(libiphlpapi, "GetTcpTable2") + getUdp6Table = doGetProcAddress(libiphlpapi, "GetUdp6Table") + getUdpStatistics = doGetProcAddress(libiphlpapi, "GetUdpStatistics") + getUdpStatisticsEx = doGetProcAddress(libiphlpapi, "GetUdpStatisticsEx") + getUdpTable = doGetProcAddress(libiphlpapi, "GetUdpTable") + getUniDirectionalAdapterInfo = doGetProcAddress(libiphlpapi, "GetUniDirectionalAdapterInfo") + icmp6CreateFile = doGetProcAddress(libiphlpapi, "Icmp6CreateFile") + icmp6ParseReplies = doGetProcAddress(libiphlpapi, "Icmp6ParseReplies") + icmp6SendEcho2 = doGetProcAddress(libiphlpapi, "Icmp6SendEcho2") + icmpCloseHandle = doGetProcAddress(libiphlpapi, "IcmpCloseHandle") + icmpCreateFile = doGetProcAddress(libiphlpapi, "IcmpCreateFile") + icmpParseReplies = doGetProcAddress(libiphlpapi, "IcmpParseReplies") + icmpSendEcho = doGetProcAddress(libiphlpapi, "IcmpSendEcho") + icmpSendEcho2 = doGetProcAddress(libiphlpapi, "IcmpSendEcho2") + ipReleaseAddress = doGetProcAddress(libiphlpapi, "IpReleaseAddress") + ipRenewAddress = doGetProcAddress(libiphlpapi, "IpRenewAddress") + lookupPersistentTcpPortReservation = doGetProcAddress(libiphlpapi, "LookupPersistentTcpPortReservation") + lookupPersistentUdpPortReservation = doGetProcAddress(libiphlpapi, "LookupPersistentUdpPortReservation") + nhpAllocateAndGetInterfaceInfoFromStack = doGetProcAddress(libiphlpapi, "NhpAllocateAndGetInterfaceInfoFromStack") + notifyAddrChange = doGetProcAddress(libiphlpapi, "NotifyAddrChange") + notifyRouteChange = doGetProcAddress(libiphlpapi, "NotifyRouteChange") + parseNetworkString = doGetProcAddress(libiphlpapi, "ParseNetworkString") + resolveNeighbor = doGetProcAddress(libiphlpapi, "ResolveNeighbor") + restoreMediaSense = doGetProcAddress(libiphlpapi, "RestoreMediaSense") + sendARP = doGetProcAddress(libiphlpapi, "SendARP") + setIfEntry = doGetProcAddress(libiphlpapi, "SetIfEntry") + setIpForwardEntry = doGetProcAddress(libiphlpapi, "SetIpForwardEntry") + setIpNetEntry = doGetProcAddress(libiphlpapi, "SetIpNetEntry") + setIpStatistics = doGetProcAddress(libiphlpapi, "SetIpStatistics") + setIpStatisticsEx = doGetProcAddress(libiphlpapi, "SetIpStatisticsEx") + setIpTTL = doGetProcAddress(libiphlpapi, "SetIpTTL") + setPerTcp6ConnectionEStats = doGetProcAddress(libiphlpapi, "SetPerTcp6ConnectionEStats") + setPerTcpConnectionEStats = doGetProcAddress(libiphlpapi, "SetPerTcpConnectionEStats") + setTcpEntry = doGetProcAddress(libiphlpapi, "SetTcpEntry") + unenableRouter = doGetProcAddress(libiphlpapi, "UnenableRouter") + allocateAndGetIfTableFromStack = doGetProcAddress(libiphlpapi, "AllocateAndGetIfTableFromStack") + allocateAndGetIpAddrTableFromStack = doGetProcAddress(libiphlpapi, "AllocateAndGetIpAddrTableFromStack") + allocateAndGetIpForwardTableFromStack = doGetProcAddress(libiphlpapi, "AllocateAndGetIpForwardTableFromStack") + allocateAndGetIpNetTableFromStack = doGetProcAddress(libiphlpapi, "AllocateAndGetIpNetTableFromStack") + allocateAndGetTcpTableFromStack = doGetProcAddress(libiphlpapi, "AllocateAndGetTcpTableFromStack") + allocateAndGetUdpTableFromStack = doGetProcAddress(libiphlpapi, "AllocateAndGetUdpTableFromStack") + cancelMibChangeNotify2 = doGetProcAddress(libiphlpapi, "CancelMibChangeNotify2") + convertInterfaceGuidToLuid = doGetProcAddress(libiphlpapi, "ConvertInterfaceGuidToLuid") + convertInterfaceIndexToLuid = doGetProcAddress(libiphlpapi, "ConvertInterfaceIndexToLuid") + convertInterfaceLuidToGuid = doGetProcAddress(libiphlpapi, "ConvertInterfaceLuidToGuid") + convertInterfaceLuidToIndex = doGetProcAddress(libiphlpapi, "ConvertInterfaceLuidToIndex") + convertInterfaceLuidToName = doGetProcAddress(libiphlpapi, "ConvertInterfaceLuidToNameW") + convertInterfaceNameToLuid = doGetProcAddress(libiphlpapi, "ConvertInterfaceNameToLuidW") + createSortedAddressPairs = doGetProcAddress(libiphlpapi, "CreateSortedAddressPairs") + freeMibTable = doGetProcAddress(libiphlpapi, "FreeMibTable") + getIfEntry2 = doGetProcAddress(libiphlpapi, "GetIfEntry2") + getIfTable2 = doGetProcAddress(libiphlpapi, "GetIfTable2") + icmpSendEcho2Ex = doGetProcAddress(libiphlpapi, "IcmpSendEcho2Ex") + notifyIpInterfaceChange = doGetProcAddress(libiphlpapi, "NotifyIpInterfaceChange") + pfBindInterfaceToIPAddress = doGetProcAddress(libiphlpapi, "PfBindInterfaceToIPAddress") + pfCreateInterface = doGetProcAddress(libiphlpapi, "PfCreateInterface") + pfDeleteInterface = doGetProcAddress(libiphlpapi, "PfDeleteInterface") + pfUnBindInterface = doGetProcAddress(libiphlpapi, "PfUnBindInterface") +} + +func AddIPAddress(address IPAddr, ipMask IPMask, ifIndex DWORD, nTEContext *uint32, nTEInstance *uint32) DWORD { + ret1 := syscall6(addIPAddress, 5, + uintptr(address), + uintptr(ipMask), + uintptr(ifIndex), + uintptr(unsafe.Pointer(nTEContext)), + uintptr(unsafe.Pointer(nTEInstance)), + 0) + return DWORD(ret1) +} + +func CancelIPChangeNotify(notifyOverlapped *OVERLAPPED) bool { + ret1 := syscall3(cancelIPChangeNotify, 1, + uintptr(unsafe.Pointer(notifyOverlapped)), + 0, + 0) + return ret1 != 0 +} + +func CreateIpForwardEntry(pRoute PMIB_IPFORWARDROW) DWORD { + ret1 := syscall3(createIpForwardEntry, 1, + uintptr(unsafe.Pointer(pRoute)), + 0, + 0) + return DWORD(ret1) +} + +func CreateIpNetEntry(pArpEntry PMIB_IPNETROW) DWORD { + ret1 := syscall3(createIpNetEntry, 1, + uintptr(unsafe.Pointer(pArpEntry)), + 0, + 0) + return DWORD(ret1) +} + +func CreatePersistentTcpPortReservation(startPort USHORT, numberOfPorts USHORT, token PULONG64) ULONG { + ret1 := syscall3(createPersistentTcpPortReservation, 3, + uintptr(startPort), + uintptr(numberOfPorts), + uintptr(unsafe.Pointer(token))) + return ULONG(ret1) +} + +func CreatePersistentUdpPortReservation(startPort USHORT, numberOfPorts USHORT, token PULONG64) ULONG { + ret1 := syscall3(createPersistentUdpPortReservation, 3, + uintptr(startPort), + uintptr(numberOfPorts), + uintptr(unsafe.Pointer(token))) + return ULONG(ret1) +} + +func CreateProxyArpEntry(dwAddress DWORD, dwMask DWORD, dwIfIndex DWORD) DWORD { + ret1 := syscall3(createProxyArpEntry, 3, + uintptr(dwAddress), + uintptr(dwMask), + uintptr(dwIfIndex)) + return DWORD(ret1) +} + +func DeleteIPAddress(nTEContext ULONG) DWORD { + ret1 := syscall3(deleteIPAddress, 1, + uintptr(nTEContext), + 0, + 0) + return DWORD(ret1) +} + +func DeleteIpForwardEntry(pRoute PMIB_IPFORWARDROW) DWORD { + ret1 := syscall3(deleteIpForwardEntry, 1, + uintptr(unsafe.Pointer(pRoute)), + 0, + 0) + return DWORD(ret1) +} + +func DeleteIpNetEntry(pArpEntry PMIB_IPNETROW) DWORD { + ret1 := syscall3(deleteIpNetEntry, 1, + uintptr(unsafe.Pointer(pArpEntry)), + 0, + 0) + return DWORD(ret1) +} + +func DeletePersistentTcpPortReservation(startPort USHORT, numberOfPorts USHORT) ULONG { + ret1 := syscall3(deletePersistentTcpPortReservation, 2, + uintptr(startPort), + uintptr(numberOfPorts), + 0) + return ULONG(ret1) +} + +func DeletePersistentUdpPortReservation(startPort USHORT, numberOfPorts USHORT) ULONG { + ret1 := syscall3(deletePersistentUdpPortReservation, 2, + uintptr(startPort), + uintptr(numberOfPorts), + 0) + return ULONG(ret1) +} + +func DeleteProxyArpEntry(dwAddress DWORD, dwMask DWORD, dwIfIndex DWORD) DWORD { + ret1 := syscall3(deleteProxyArpEntry, 3, + uintptr(dwAddress), + uintptr(dwMask), + uintptr(dwIfIndex)) + return DWORD(ret1) +} + +func DisableMediaSense(pHandle *HANDLE, pOverLapped *OVERLAPPED) DWORD { + ret1 := syscall3(disableMediaSense, 2, + uintptr(unsafe.Pointer(pHandle)), + uintptr(unsafe.Pointer(pOverLapped)), + 0) + return DWORD(ret1) +} + +func EnableRouter(pHandle *HANDLE, pOverlapped *OVERLAPPED) DWORD { + ret1 := syscall3(enableRouter, 2, + uintptr(unsafe.Pointer(pHandle)), + uintptr(unsafe.Pointer(pOverlapped)), + 0) + return DWORD(ret1) +} + +func FlushIpNetTable(dwIfIndex DWORD) DWORD { + ret1 := syscall3(flushIpNetTable, 1, + uintptr(dwIfIndex), + 0, + 0) + return DWORD(ret1) +} + +func GetAdapterIndex(adapterName LPWSTR, ifIndex *uint32) DWORD { + ret1 := syscall3(getAdapterIndex, 2, + uintptr(unsafe.Pointer(adapterName)), + uintptr(unsafe.Pointer(ifIndex)), + 0) + return DWORD(ret1) +} + +func GetAdapterOrderMap() PIP_ADAPTER_ORDER_MAP { + ret1 := syscall3(getAdapterOrderMap, 0, + 0, + 0, + 0) + return (PIP_ADAPTER_ORDER_MAP)(unsafe.Pointer(ret1)) +} + +func GetAdaptersAddresses(family ULONG, flags ULONG, reserved uintptr, adapterAddresses PIP_ADAPTER_ADDRESSES, sizePointer *uint32) ULONG { + ret1 := syscall6(getAdaptersAddresses, 5, + uintptr(family), + uintptr(flags), + reserved, + uintptr(unsafe.Pointer(adapterAddresses)), + uintptr(unsafe.Pointer(sizePointer)), + 0) + return ULONG(ret1) +} + +func GetAdaptersInfo(adapterInfo PIP_ADAPTER_INFO, sizePointer *uint32) ULONG { + ret1 := syscall3(getAdaptersInfo, 2, + uintptr(unsafe.Pointer(adapterInfo)), + uintptr(unsafe.Pointer(sizePointer)), + 0) + return ULONG(ret1) +} + +func GetBestInterface(dwDestAddr IPAddr, pdwBestIfIndex *DWORD) DWORD { + ret1 := syscall3(getBestInterface, 2, + uintptr(dwDestAddr), + uintptr(unsafe.Pointer(pdwBestIfIndex)), + 0) + return DWORD(ret1) +} + +func GetBestInterfaceEx(pDestAddr *Sockaddr, pdwBestIfIndex *DWORD) DWORD { + ret1 := syscall3(getBestInterfaceEx, 2, + uintptr(unsafe.Pointer(pDestAddr)), + uintptr(unsafe.Pointer(pdwBestIfIndex)), + 0) + return DWORD(ret1) +} + +func GetBestRoute(dwDestAddr DWORD, dwSourceAddr DWORD, pBestRoute PMIB_IPFORWARDROW) DWORD { + ret1 := syscall3(getBestRoute, 3, + uintptr(dwDestAddr), + uintptr(dwSourceAddr), + uintptr(unsafe.Pointer(pBestRoute))) + return DWORD(ret1) +} + +func GetExtendedTcpTable(pTcpTable uintptr, pdwSize *DWORD, bOrder bool, ulAf ULONG, tableClass TCP_TABLE_CLASS, reserved ULONG) DWORD { + ret1 := syscall6(getExtendedTcpTable, 6, + pTcpTable, + uintptr(unsafe.Pointer(pdwSize)), + getUintptrFromBool(bOrder), + uintptr(ulAf), + uintptr(tableClass), + uintptr(reserved)) + return DWORD(ret1) +} + +func GetExtendedUdpTable(pUdpTable uintptr, pdwSize *DWORD, bOrder bool, ulAf ULONG, tableClass UDP_TABLE_CLASS, reserved ULONG) DWORD { + ret1 := syscall6(getExtendedUdpTable, 6, + pUdpTable, + uintptr(unsafe.Pointer(pdwSize)), + getUintptrFromBool(bOrder), + uintptr(ulAf), + uintptr(tableClass), + uintptr(reserved)) + return DWORD(ret1) +} + +func GetFriendlyIfIndex(ifIndex DWORD) DWORD { + ret1 := syscall3(getFriendlyIfIndex, 1, + uintptr(ifIndex), + 0, + 0) + return DWORD(ret1) +} + +func GetIcmpStatistics(statistics PMIB_ICMP) ULONG { + ret1 := syscall3(getIcmpStatistics, 1, + uintptr(unsafe.Pointer(statistics)), + 0, + 0) + return ULONG(ret1) +} + +func GetIcmpStatisticsEx(statistics PMIB_ICMP_EX, family ULONG) ULONG { + ret1 := syscall3(getIcmpStatisticsEx, 2, + uintptr(unsafe.Pointer(statistics)), + uintptr(family), + 0) + return ULONG(ret1) +} + +func GetIfEntry(pIfRow PMIB_IFROW) DWORD { + ret1 := syscall3(getIfEntry, 1, + uintptr(unsafe.Pointer(pIfRow)), + 0, + 0) + return DWORD(ret1) +} + +func GetIfTable(pIfTable PMIB_IFTABLE, pdwSize *uint32, bOrder bool) DWORD { + ret1 := syscall3(getIfTable, 3, + uintptr(unsafe.Pointer(pIfTable)), + uintptr(unsafe.Pointer(pdwSize)), + getUintptrFromBool(bOrder)) + return DWORD(ret1) +} + +func GetInterfaceInfo(pIfTable PIP_INTERFACE_INFO, dwOutBufLen *uint32) DWORD { + ret1 := syscall3(getInterfaceInfo, 2, + uintptr(unsafe.Pointer(pIfTable)), + uintptr(unsafe.Pointer(dwOutBufLen)), + 0) + return DWORD(ret1) +} + +func GetIpAddrTable(pIpAddrTable PMIB_IPADDRTABLE, pdwSize *uint32, bOrder bool) DWORD { + ret1 := syscall3(getIpAddrTable, 3, + uintptr(unsafe.Pointer(pIpAddrTable)), + uintptr(unsafe.Pointer(pdwSize)), + getUintptrFromBool(bOrder)) + return DWORD(ret1) +} + +func GetIpErrorString(errorCode IP_STATUS, buffer PWSTR, size *DWORD) DWORD { + ret1 := syscall3(getIpErrorString, 3, + uintptr(errorCode), + uintptr(unsafe.Pointer(buffer)), + uintptr(unsafe.Pointer(size))) + return DWORD(ret1) +} + +func GetIpForwardTable(pIpForwardTable PMIB_IPFORWARDTABLE, pdwSize *uint32, bOrder bool) DWORD { + ret1 := syscall3(getIpForwardTable, 3, + uintptr(unsafe.Pointer(pIpForwardTable)), + uintptr(unsafe.Pointer(pdwSize)), + getUintptrFromBool(bOrder)) + return DWORD(ret1) +} + +func GetIpNetTable(ipNetTable PMIB_IPNETTABLE, sizePointer *uint32, order bool) ULONG { + ret1 := syscall3(getIpNetTable, 3, + uintptr(unsafe.Pointer(ipNetTable)), + uintptr(unsafe.Pointer(sizePointer)), + getUintptrFromBool(order)) + return ULONG(ret1) +} + +func GetIpStatistics(statistics PMIB_IPSTATS) ULONG { + ret1 := syscall3(getIpStatistics, 1, + uintptr(unsafe.Pointer(statistics)), + 0, + 0) + return ULONG(ret1) +} + +func GetIpStatisticsEx(statistics PMIB_IPSTATS, family ULONG) ULONG { + ret1 := syscall3(getIpStatisticsEx, 2, + uintptr(unsafe.Pointer(statistics)), + uintptr(family), + 0) + return ULONG(ret1) +} + +func GetNetworkParams(pFixedInfo PFIXED_INFO, pOutBufLen *uint32) DWORD { + ret1 := syscall3(getNetworkParams, 2, + uintptr(unsafe.Pointer(pFixedInfo)), + uintptr(unsafe.Pointer(pOutBufLen)), + 0) + return DWORD(ret1) +} + +func GetNumberOfInterfaces(pdwNumIf *DWORD) DWORD { + ret1 := syscall3(getNumberOfInterfaces, 1, + uintptr(unsafe.Pointer(pdwNumIf)), + 0, + 0) + return DWORD(ret1) +} + +func GetOwnerModuleFromTcp6Entry(pTcpEntry PMIB_TCP6ROW_OWNER_MODULE, class TCPIP_OWNER_MODULE_INFO_CLASS, pBuffer uintptr, pdwSize *DWORD) DWORD { + ret1 := syscall6(getOwnerModuleFromTcp6Entry, 4, + uintptr(unsafe.Pointer(pTcpEntry)), + uintptr(class), + pBuffer, + uintptr(unsafe.Pointer(pdwSize)), + 0, + 0) + return DWORD(ret1) +} + +func GetOwnerModuleFromTcpEntry(pTcpEntry PMIB_TCPROW_OWNER_MODULE, class TCPIP_OWNER_MODULE_INFO_CLASS, pBuffer uintptr, pdwSize *DWORD) DWORD { + ret1 := syscall6(getOwnerModuleFromTcpEntry, 4, + uintptr(unsafe.Pointer(pTcpEntry)), + uintptr(class), + pBuffer, + uintptr(unsafe.Pointer(pdwSize)), + 0, + 0) + return DWORD(ret1) +} + +func GetOwnerModuleFromUdp6Entry(pUdpEntry PMIB_UDP6ROW_OWNER_MODULE, class TCPIP_OWNER_MODULE_INFO_CLASS, pBuffer uintptr, pdwSize *DWORD) DWORD { + ret1 := syscall6(getOwnerModuleFromUdp6Entry, 4, + uintptr(unsafe.Pointer(pUdpEntry)), + uintptr(class), + pBuffer, + uintptr(unsafe.Pointer(pdwSize)), + 0, + 0) + return DWORD(ret1) +} + +func GetOwnerModuleFromUdpEntry(pUdpEntry PMIB_UDPROW_OWNER_MODULE, class TCPIP_OWNER_MODULE_INFO_CLASS, pBuffer uintptr, pdwSize *DWORD) DWORD { + ret1 := syscall6(getOwnerModuleFromUdpEntry, 4, + uintptr(unsafe.Pointer(pUdpEntry)), + uintptr(class), + pBuffer, + uintptr(unsafe.Pointer(pdwSize)), + 0, + 0) + return DWORD(ret1) +} + +func GetPerAdapterInfo(ifIndex ULONG, pPerAdapterInfo PIP_PER_ADAPTER_INFO, pOutBufLen *uint32) DWORD { + ret1 := syscall3(getPerAdapterInfo, 3, + uintptr(ifIndex), + uintptr(unsafe.Pointer(pPerAdapterInfo)), + uintptr(unsafe.Pointer(pOutBufLen))) + return DWORD(ret1) +} + +func GetPerTcp6ConnectionEStats(row PMIB_TCP6ROW, estatsType TCP_ESTATS_TYPE, rw PUCHAR, rwVersion ULONG, rwSize ULONG, ros PUCHAR, rosVersion ULONG, rosSize ULONG, rod PUCHAR, rodVersion ULONG, rodSize ULONG) ULONG { + ret1 := syscall12(getPerTcp6ConnectionEStats, 11, + uintptr(unsafe.Pointer(row)), + uintptr(estatsType), + uintptr(unsafe.Pointer(rw)), + uintptr(rwVersion), + uintptr(rwSize), + uintptr(unsafe.Pointer(ros)), + uintptr(rosVersion), + uintptr(rosSize), + uintptr(unsafe.Pointer(rod)), + uintptr(rodVersion), + uintptr(rodSize), + 0) + return ULONG(ret1) +} + +func GetPerTcpConnectionEStats(row PMIB_TCPROW, estatsType TCP_ESTATS_TYPE, rw PUCHAR, rwVersion ULONG, rwSize ULONG, ros PUCHAR, rosVersion ULONG, rosSize ULONG, rod PUCHAR, rodVersion ULONG, rodSize ULONG) ULONG { + ret1 := syscall12(getPerTcpConnectionEStats, 11, + uintptr(unsafe.Pointer(row)), + uintptr(estatsType), + uintptr(unsafe.Pointer(rw)), + uintptr(rwVersion), + uintptr(rwSize), + uintptr(unsafe.Pointer(ros)), + uintptr(rosVersion), + uintptr(rosSize), + uintptr(unsafe.Pointer(rod)), + uintptr(rodVersion), + uintptr(rodSize), + 0) + return ULONG(ret1) +} + +func GetRTTAndHopCount(destIpAddress IPAddr, hopCount *uint32, maxHops ULONG, rTT *uint32) bool { + ret1 := syscall6(getRTTAndHopCount, 4, + uintptr(destIpAddress), + uintptr(unsafe.Pointer(hopCount)), + uintptr(maxHops), + uintptr(unsafe.Pointer(rTT)), + 0, + 0) + return ret1 != 0 +} + +func GetTcp6Table(tcpTable PMIB_TCP6TABLE, sizePointer *uint32, order bool) ULONG { + ret1 := syscall3(getTcp6Table, 3, + uintptr(unsafe.Pointer(tcpTable)), + uintptr(unsafe.Pointer(sizePointer)), + getUintptrFromBool(order)) + return ULONG(ret1) +} + +func GetTcp6Table2(tcpTable PMIB_TCP6TABLE2, sizePointer *uint32, order bool) ULONG { + ret1 := syscall3(getTcp6Table2, 3, + uintptr(unsafe.Pointer(tcpTable)), + uintptr(unsafe.Pointer(sizePointer)), + getUintptrFromBool(order)) + return ULONG(ret1) +} + +func GetTcpStatistics(statistics PMIB_TCPSTATS) ULONG { + ret1 := syscall3(getTcpStatistics, 1, + uintptr(unsafe.Pointer(statistics)), + 0, + 0) + return ULONG(ret1) +} + +func GetTcpStatisticsEx(statistics PMIB_TCPSTATS, family ULONG) ULONG { + ret1 := syscall3(getTcpStatisticsEx, 2, + uintptr(unsafe.Pointer(statistics)), + uintptr(family), + 0) + return ULONG(ret1) +} + +func GetTcpTable(tcpTable PMIB_TCPTABLE, sizePointer *uint32, order bool) ULONG { + ret1 := syscall3(getTcpTable, 3, + uintptr(unsafe.Pointer(tcpTable)), + uintptr(unsafe.Pointer(sizePointer)), + getUintptrFromBool(order)) + return ULONG(ret1) +} + +func GetTcpTable2(tcpTable PMIB_TCPTABLE2, sizePointer *uint32, order bool) ULONG { + ret1 := syscall3(getTcpTable2, 3, + uintptr(unsafe.Pointer(tcpTable)), + uintptr(unsafe.Pointer(sizePointer)), + getUintptrFromBool(order)) + return ULONG(ret1) +} + +func GetUdp6Table(udp6Table PMIB_UDP6TABLE, sizePointer *uint32, order bool) ULONG { + ret1 := syscall3(getUdp6Table, 3, + uintptr(unsafe.Pointer(udp6Table)), + uintptr(unsafe.Pointer(sizePointer)), + getUintptrFromBool(order)) + return ULONG(ret1) +} + +func GetUdpStatistics(stats PMIB_UDPSTATS) ULONG { + ret1 := syscall3(getUdpStatistics, 1, + uintptr(unsafe.Pointer(stats)), + 0, + 0) + return ULONG(ret1) +} + +func GetUdpStatisticsEx(statistics PMIB_UDPSTATS, family ULONG) ULONG { + ret1 := syscall3(getUdpStatisticsEx, 2, + uintptr(unsafe.Pointer(statistics)), + uintptr(family), + 0) + return ULONG(ret1) +} + +func GetUdpTable(udpTable PMIB_UDPTABLE, sizePointer *uint32, order bool) ULONG { + ret1 := syscall3(getUdpTable, 3, + uintptr(unsafe.Pointer(udpTable)), + uintptr(unsafe.Pointer(sizePointer)), + getUintptrFromBool(order)) + return ULONG(ret1) +} + +func GetUniDirectionalAdapterInfo(pIPIfInfo PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS, dwOutBufLen *uint32) DWORD { + ret1 := syscall3(getUniDirectionalAdapterInfo, 2, + uintptr(unsafe.Pointer(pIPIfInfo)), + uintptr(unsafe.Pointer(dwOutBufLen)), + 0) + return DWORD(ret1) +} + +func Icmp6CreateFile() HANDLE { + ret1 := syscall3(icmp6CreateFile, 0, + 0, + 0, + 0) + return HANDLE(ret1) +} + +func Icmp6ParseReplies(replyBuffer LPVOID, replySize DWORD) DWORD { + ret1 := syscall3(icmp6ParseReplies, 2, + uintptr(unsafe.Pointer(replyBuffer)), + uintptr(replySize), + 0) + return DWORD(ret1) +} + +func Icmp6SendEcho2(icmpHandle HANDLE, event HANDLE, apcRoutine PIO_APC_ROUTINE, apcContext uintptr, sourceAddress *SOCKADDR_IN6_LH, destinationAddress *SOCKADDR_IN6_LH, requestData LPVOID, requestSize WORD, requestOptions PIP_OPTION_INFORMATION, replyBuffer LPVOID, replySize DWORD, timeout DWORD) DWORD { + apcRoutineCallback := syscall.NewCallback(apcRoutine) + ret1 := syscall12(icmp6SendEcho2, 12, + uintptr(icmpHandle), + uintptr(event), + apcRoutineCallback, + apcContext, + uintptr(unsafe.Pointer(sourceAddress)), + uintptr(unsafe.Pointer(destinationAddress)), + uintptr(unsafe.Pointer(requestData)), + uintptr(requestSize), + uintptr(unsafe.Pointer(requestOptions)), + uintptr(unsafe.Pointer(replyBuffer)), + uintptr(replySize), + uintptr(timeout)) + return DWORD(ret1) +} + +func IcmpCloseHandle(icmpHandle HANDLE) bool { + ret1 := syscall3(icmpCloseHandle, 1, + uintptr(icmpHandle), + 0, + 0) + return ret1 != 0 +} + +func IcmpCreateFile() HANDLE { + ret1 := syscall3(icmpCreateFile, 0, + 0, + 0, + 0) + return HANDLE(ret1) +} + +func IcmpParseReplies(replyBuffer LPVOID, replySize DWORD) DWORD { + ret1 := syscall3(icmpParseReplies, 2, + uintptr(unsafe.Pointer(replyBuffer)), + uintptr(replySize), + 0) + return DWORD(ret1) +} + +func IcmpSendEcho(icmpHandle HANDLE, destinationAddress IPAddr, requestData LPVOID, requestSize WORD, requestOptions PIP_OPTION_INFORMATION, replyBuffer LPVOID, replySize DWORD, timeout DWORD) DWORD { + ret1 := syscall9(icmpSendEcho, 8, + uintptr(icmpHandle), + uintptr(destinationAddress), + uintptr(unsafe.Pointer(requestData)), + uintptr(requestSize), + uintptr(unsafe.Pointer(requestOptions)), + uintptr(unsafe.Pointer(replyBuffer)), + uintptr(replySize), + uintptr(timeout), + 0) + return DWORD(ret1) +} + +func IcmpSendEcho2(icmpHandle HANDLE, event HANDLE, apcRoutine PIO_APC_ROUTINE, apcContext uintptr, destinationAddress IPAddr, requestData LPVOID, requestSize WORD, requestOptions PIP_OPTION_INFORMATION, replyBuffer LPVOID, replySize DWORD, timeout DWORD) DWORD { + apcRoutineCallback := syscall.NewCallback(apcRoutine) + ret1 := syscall12(icmpSendEcho2, 11, + uintptr(icmpHandle), + uintptr(event), + apcRoutineCallback, + apcContext, + uintptr(destinationAddress), + uintptr(unsafe.Pointer(requestData)), + uintptr(requestSize), + uintptr(unsafe.Pointer(requestOptions)), + uintptr(unsafe.Pointer(replyBuffer)), + uintptr(replySize), + uintptr(timeout), + 0) + return DWORD(ret1) +} + +func IpReleaseAddress(adapterInfo PIP_ADAPTER_INDEX_MAP) DWORD { + ret1 := syscall3(ipReleaseAddress, 1, + uintptr(unsafe.Pointer(adapterInfo)), + 0, + 0) + return DWORD(ret1) +} + +func IpRenewAddress(adapterInfo PIP_ADAPTER_INDEX_MAP) DWORD { + ret1 := syscall3(ipRenewAddress, 1, + uintptr(unsafe.Pointer(adapterInfo)), + 0, + 0) + return DWORD(ret1) +} + +func LookupPersistentTcpPortReservation(startPort USHORT, numberOfPorts USHORT, token PULONG64) ULONG { + ret1 := syscall3(lookupPersistentTcpPortReservation, 3, + uintptr(startPort), + uintptr(numberOfPorts), + uintptr(unsafe.Pointer(token))) + return ULONG(ret1) +} + +func LookupPersistentUdpPortReservation(startPort USHORT, numberOfPorts USHORT, token PULONG64) ULONG { + ret1 := syscall3(lookupPersistentUdpPortReservation, 3, + uintptr(startPort), + uintptr(numberOfPorts), + uintptr(unsafe.Pointer(token))) + return ULONG(ret1) +} + +func NhpAllocateAndGetInterfaceInfoFromStack(ppTable **IP_INTERFACE_NAME_INFO, pdwCount *DWORD, bOrder bool, hHeap HANDLE, dwFlags DWORD) DWORD { + ret1 := syscall6(nhpAllocateAndGetInterfaceInfoFromStack, 5, + uintptr(unsafe.Pointer(ppTable)), + uintptr(unsafe.Pointer(pdwCount)), + getUintptrFromBool(bOrder), + uintptr(hHeap), + uintptr(dwFlags), + 0) + return DWORD(ret1) +} + +func NotifyAddrChange(handle *HANDLE, overlapped *OVERLAPPED) DWORD { + ret1 := syscall3(notifyAddrChange, 2, + uintptr(unsafe.Pointer(handle)), + uintptr(unsafe.Pointer(overlapped)), + 0) + return DWORD(ret1) +} + +func NotifyRouteChange(handle *HANDLE, overlapped *OVERLAPPED) DWORD { + ret1 := syscall3(notifyRouteChange, 2, + uintptr(unsafe.Pointer(handle)), + uintptr(unsafe.Pointer(overlapped)), + 0) + return DWORD(ret1) +} + +func ParseNetworkString(networkString /*const*/ *WCHAR, types DWORD, addressInfo PNET_ADDRESS_INFO, portNumber *USHORT, prefixLength *byte) DWORD { + ret1 := syscall6(parseNetworkString, 5, + uintptr(unsafe.Pointer(networkString)), + uintptr(types), + uintptr(unsafe.Pointer(addressInfo)), + uintptr(unsafe.Pointer(portNumber)), + uintptr(unsafe.Pointer(prefixLength)), + 0) + return DWORD(ret1) +} + +func ResolveNeighbor(networkAddress *SOCKADDR, physicalAddress uintptr, physicalAddressLength *uint32) ULONG { + ret1 := syscall3(resolveNeighbor, 3, + uintptr(unsafe.Pointer(networkAddress)), + physicalAddress, + uintptr(unsafe.Pointer(physicalAddressLength))) + return ULONG(ret1) +} + +func RestoreMediaSense(pOverlapped *OVERLAPPED, lpdwEnableCount *uint32) DWORD { + ret1 := syscall3(restoreMediaSense, 2, + uintptr(unsafe.Pointer(pOverlapped)), + uintptr(unsafe.Pointer(lpdwEnableCount)), + 0) + return DWORD(ret1) +} + +func SendARP(destIP IPAddr, srcIP IPAddr, pMacAddr uintptr, phyAddrLen *uint32) DWORD { + ret1 := syscall6(sendARP, 4, + uintptr(destIP), + uintptr(srcIP), + pMacAddr, + uintptr(unsafe.Pointer(phyAddrLen)), + 0, + 0) + return DWORD(ret1) +} + +func SetIfEntry(pIfRow PMIB_IFROW) DWORD { + ret1 := syscall3(setIfEntry, 1, + uintptr(unsafe.Pointer(pIfRow)), + 0, + 0) + return DWORD(ret1) +} + +func SetIpForwardEntry(pRoute PMIB_IPFORWARDROW) DWORD { + ret1 := syscall3(setIpForwardEntry, 1, + uintptr(unsafe.Pointer(pRoute)), + 0, + 0) + return DWORD(ret1) +} + +func SetIpNetEntry(pArpEntry PMIB_IPNETROW) DWORD { + ret1 := syscall3(setIpNetEntry, 1, + uintptr(unsafe.Pointer(pArpEntry)), + 0, + 0) + return DWORD(ret1) +} + +func SetIpStatistics(pIpStats PMIB_IPSTATS) DWORD { + ret1 := syscall3(setIpStatistics, 1, + uintptr(unsafe.Pointer(pIpStats)), + 0, + 0) + return DWORD(ret1) +} + +func SetIpStatisticsEx(statistics PMIB_IPSTATS, family ULONG) ULONG { + ret1 := syscall3(setIpStatisticsEx, 2, + uintptr(unsafe.Pointer(statistics)), + uintptr(family), + 0) + return ULONG(ret1) +} + +func SetIpTTL(nTTL UINT) DWORD { + ret1 := syscall3(setIpTTL, 1, + uintptr(nTTL), + 0, + 0) + return DWORD(ret1) +} + +func SetPerTcp6ConnectionEStats(row PMIB_TCP6ROW, estatsType TCP_ESTATS_TYPE, rw PUCHAR, rwVersion ULONG, rwSize ULONG, offset ULONG) ULONG { + ret1 := syscall6(setPerTcp6ConnectionEStats, 6, + uintptr(unsafe.Pointer(row)), + uintptr(estatsType), + uintptr(unsafe.Pointer(rw)), + uintptr(rwVersion), + uintptr(rwSize), + uintptr(offset)) + return ULONG(ret1) +} + +func SetPerTcpConnectionEStats(row PMIB_TCPROW, estatsType TCP_ESTATS_TYPE, rw PUCHAR, rwVersion ULONG, rwSize ULONG, offset ULONG) ULONG { + ret1 := syscall6(setPerTcpConnectionEStats, 6, + uintptr(unsafe.Pointer(row)), + uintptr(estatsType), + uintptr(unsafe.Pointer(rw)), + uintptr(rwVersion), + uintptr(rwSize), + uintptr(offset)) + return ULONG(ret1) +} + +func SetTcpEntry(pTcpRow PMIB_TCPROW) DWORD { + ret1 := syscall3(setTcpEntry, 1, + uintptr(unsafe.Pointer(pTcpRow)), + 0, + 0) + return DWORD(ret1) +} + +func UnenableRouter(pOverlapped *OVERLAPPED, lpdwEnableCount *uint32) DWORD { + ret1 := syscall3(unenableRouter, 2, + uintptr(unsafe.Pointer(pOverlapped)), + uintptr(unsafe.Pointer(lpdwEnableCount)), + 0) + return DWORD(ret1) +} + +func AllocateAndGetIfTableFromStack(ppIfTable *PMIB_IFTABLE, bOrder bool, heap HANDLE, flags DWORD) DWORD { + ret1 := syscall6(allocateAndGetIfTableFromStack, 4, + uintptr(unsafe.Pointer(ppIfTable)), + getUintptrFromBool(bOrder), + uintptr(heap), + uintptr(flags), + 0, + 0) + return DWORD(ret1) +} + +func AllocateAndGetIpAddrTableFromStack(ppIpAddrTable *PMIB_IPADDRTABLE, bOrder bool, heap HANDLE, flags DWORD) DWORD { + ret1 := syscall6(allocateAndGetIpAddrTableFromStack, 4, + uintptr(unsafe.Pointer(ppIpAddrTable)), + getUintptrFromBool(bOrder), + uintptr(heap), + uintptr(flags), + 0, + 0) + return DWORD(ret1) +} + +func AllocateAndGetIpForwardTableFromStack(ppIpForwardTable *PMIB_IPFORWARDTABLE, bOrder bool, heap HANDLE, flags DWORD) DWORD { + ret1 := syscall6(allocateAndGetIpForwardTableFromStack, 4, + uintptr(unsafe.Pointer(ppIpForwardTable)), + getUintptrFromBool(bOrder), + uintptr(heap), + uintptr(flags), + 0, + 0) + return DWORD(ret1) +} + +func AllocateAndGetIpNetTableFromStack(ppIpNetTable *PMIB_IPNETTABLE, bOrder bool, heap HANDLE, flags DWORD) DWORD { + ret1 := syscall6(allocateAndGetIpNetTableFromStack, 4, + uintptr(unsafe.Pointer(ppIpNetTable)), + getUintptrFromBool(bOrder), + uintptr(heap), + uintptr(flags), + 0, + 0) + return DWORD(ret1) +} + +func AllocateAndGetTcpTableFromStack(ppTcpTable *PMIB_TCPTABLE, bOrder bool, heap HANDLE, flags DWORD) DWORD { + ret1 := syscall6(allocateAndGetTcpTableFromStack, 4, + uintptr(unsafe.Pointer(ppTcpTable)), + getUintptrFromBool(bOrder), + uintptr(heap), + uintptr(flags), + 0, + 0) + return DWORD(ret1) +} + +func AllocateAndGetUdpTableFromStack(ppUdpTable *PMIB_UDPTABLE, bOrder bool, heap HANDLE, flags DWORD) DWORD { + ret1 := syscall6(allocateAndGetUdpTableFromStack, 4, + uintptr(unsafe.Pointer(ppUdpTable)), + getUintptrFromBool(bOrder), + uintptr(heap), + uintptr(flags), + 0, + 0) + return DWORD(ret1) +} + +func CancelMibChangeNotify2(handle HANDLE) DWORD { + ret1 := syscall3(cancelMibChangeNotify2, 1, + uintptr(handle), + 0, + 0) + return DWORD(ret1) +} + +func ConvertInterfaceGuidToLuid(guid /*const*/ *GUID, luid *NET_LUID) DWORD { + ret1 := syscall3(convertInterfaceGuidToLuid, 2, + uintptr(unsafe.Pointer(guid)), + uintptr(unsafe.Pointer(luid)), + 0) + return DWORD(ret1) +} + +func ConvertInterfaceIndexToLuid(index NET_IFINDEX, luid *NET_LUID) DWORD { + ret1 := syscall3(convertInterfaceIndexToLuid, 2, + uintptr(index), + uintptr(unsafe.Pointer(luid)), + 0) + return DWORD(ret1) +} + +func ConvertInterfaceLuidToGuid(luid /*const*/ *NET_LUID, guid *GUID) DWORD { + ret1 := syscall3(convertInterfaceLuidToGuid, 2, + uintptr(unsafe.Pointer(luid)), + uintptr(unsafe.Pointer(guid)), + 0) + return DWORD(ret1) +} + +func ConvertInterfaceLuidToIndex(luid /*const*/ *NET_LUID, index *NET_IFINDEX) DWORD { + ret1 := syscall3(convertInterfaceLuidToIndex, 2, + uintptr(unsafe.Pointer(luid)), + uintptr(unsafe.Pointer(index)), + 0) + return DWORD(ret1) +} + +func ConvertInterfaceLuidToName(luid /*const*/ *NET_LUID, name *WCHAR, aLen SIZE_T) DWORD { + ret1 := syscall3(convertInterfaceLuidToName, 3, + uintptr(unsafe.Pointer(luid)), + uintptr(unsafe.Pointer(name)), + uintptr(aLen)) + return DWORD(ret1) +} + +func ConvertInterfaceNameToLuid(name /*const*/ *WCHAR, luid *NET_LUID) DWORD { + ret1 := syscall3(convertInterfaceNameToLuid, 2, + uintptr(unsafe.Pointer(name)), + uintptr(unsafe.Pointer(luid)), + 0) + return DWORD(ret1) +} + +func CreateSortedAddressPairs(src_list /*const*/ PSOCKADDR_IN6, src_count DWORD, dst_list /*const*/ PSOCKADDR_IN6, dst_count DWORD, options DWORD, pair_list *PSOCKADDR_IN6_PAIR, pair_count *uint32) DWORD { + ret1 := syscall9(createSortedAddressPairs, 7, + uintptr(unsafe.Pointer(src_list)), + uintptr(src_count), + uintptr(unsafe.Pointer(dst_list)), + uintptr(dst_count), + uintptr(options), + uintptr(unsafe.Pointer(pair_list)), + uintptr(unsafe.Pointer(pair_count)), + 0, + 0) + return DWORD(ret1) +} + +func FreeMibTable(ptr uintptr) { + syscall3(freeMibTable, 1, + ptr, + 0, + 0) +} + +func GetIfEntry2(row2 *MIB_IF_ROW2) DWORD { + ret1 := syscall3(getIfEntry2, 1, + uintptr(unsafe.Pointer(row2)), + 0, + 0) + return DWORD(ret1) +} + +func GetIfTable2(table **MIB_IF_TABLE2) DWORD { + ret1 := syscall3(getIfTable2, 1, + uintptr(unsafe.Pointer(table)), + 0, + 0) + return DWORD(ret1) +} + +func IcmpSendEcho2Ex(icmpHandle HANDLE, event HANDLE, apcRoutine PIO_APC_ROUTINE, apcContext uintptr, sourceAddress IPAddr, destinationAddress IPAddr, requestData LPVOID, requestSize WORD, requestOptions PIP_OPTION_INFORMATION, replyBuffer LPVOID, replySize DWORD, timeout DWORD) DWORD { + apcRoutineCallback := syscall.NewCallback(apcRoutine) + ret1 := syscall12(icmpSendEcho2Ex, 12, + uintptr(icmpHandle), + uintptr(event), + apcRoutineCallback, + apcContext, + uintptr(sourceAddress), + uintptr(destinationAddress), + uintptr(unsafe.Pointer(requestData)), + uintptr(requestSize), + uintptr(unsafe.Pointer(requestOptions)), + uintptr(unsafe.Pointer(replyBuffer)), + uintptr(replySize), + uintptr(timeout)) + return DWORD(ret1) +} + +func NotifyIpInterfaceChange(family ULONG, callback uintptr, context uintptr, init_notify BOOLEAN, handle *HANDLE) DWORD { + ret1 := syscall6(notifyIpInterfaceChange, 5, + uintptr(family), + callback, + context, + uintptr(init_notify), + uintptr(unsafe.Pointer(handle)), + 0) + return DWORD(ret1) +} + +func PfBindInterfaceToIPAddress(aInterface INTERFACE_HANDLE, aType PFADDRESSTYPE, ip *byte) DWORD { + ret1 := syscall3(pfBindInterfaceToIPAddress, 3, + uintptr(aInterface), + uintptr(aType), + uintptr(unsafe.Pointer(ip))) + return DWORD(ret1) +} + +func PfCreateInterface(dwName DWORD, inAction PFFORWARD_ACTION, outAction PFFORWARD_ACTION, bUseLog bool, bMustBeUnique bool, ppInterface *INTERFACE_HANDLE) DWORD { + ret1 := syscall6(pfCreateInterface, 6, + uintptr(dwName), + uintptr(inAction), + uintptr(outAction), + getUintptrFromBool(bUseLog), + getUintptrFromBool(bMustBeUnique), + uintptr(unsafe.Pointer(ppInterface))) + return DWORD(ret1) +} + +func PfDeleteInterface(aInterface INTERFACE_HANDLE) DWORD { + ret1 := syscall3(pfDeleteInterface, 1, + uintptr(aInterface), + 0, + 0) + return DWORD(ret1) +} + +func PfUnBindInterface(aInterface INTERFACE_HANDLE) DWORD { + ret1 := syscall3(pfUnBindInterface, 1, + uintptr(aInterface), + 0, + 0) + return DWORD(ret1) +} diff --git a/grdp/win/kernel32.go b/grdp/win/kernel32.go new file mode 100644 index 0000000..b79fddc --- /dev/null +++ b/grdp/win/kernel32.go @@ -0,0 +1,8315 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "syscall" + "unsafe" +) + +var ( + // Library + libkernel32 uintptr + + // Functions + acquireSRWLockExclusive uintptr + acquireSRWLockShared uintptr + activateActCtx uintptr + addAtom uintptr + addConsoleAlias uintptr + addIntegrityLabelToBoundaryDescriptor uintptr + addRefActCtx uintptr + addSIDToBoundaryDescriptor uintptr + addSecureMemoryCacheCallback uintptr + allocConsole uintptr + applicationRecoveryFinished uintptr + applicationRecoveryInProgress uintptr + areFileApisANSI uintptr + assignProcessToJobObject uintptr + attachConsole uintptr + backupRead uintptr + backupSeek uintptr + backupWrite uintptr + beep uintptr + beginUpdateResource uintptr + callNamedPipe uintptr + cancelDeviceWakeupRequest uintptr + cancelIo uintptr + cancelIoEx uintptr + cancelSynchronousIo uintptr + cancelTimerQueueTimer uintptr + cancelWaitableTimer uintptr + changeTimerQueueTimer uintptr + checkNameLegalDOS8Dot3 uintptr + checkRemoteDebuggerPresent uintptr + clearCommBreak uintptr + closeHandle uintptr + closePrivateNamespace uintptr + compareFileTime uintptr + connectNamedPipe uintptr + continueDebugEvent uintptr + convertDefaultLocale uintptr + convertFiberToThread uintptr + convertThreadToFiber uintptr + convertThreadToFiberEx uintptr + copyFile uintptr + copyLZFile uintptr + createBoundaryDescriptor uintptr + createConsoleScreenBuffer uintptr + createDirectoryEx uintptr + createDirectoryTransacted uintptr + createDirectory uintptr + createEventEx uintptr + createEvent uintptr + createFileMappingNuma uintptr + createFileMapping uintptr + createFileTransacted uintptr + createFile uintptr + createHardLinkTransacted uintptr + createHardLink uintptr + createIoCompletionPort uintptr + createJobObject uintptr + createMailslot uintptr + createMutexEx uintptr + createMutex uintptr + createNamedPipe uintptr + createPipe uintptr + createPrivateNamespace uintptr + createProcess uintptr + createRemoteThread uintptr + createSemaphoreEx uintptr + createSemaphore uintptr + createSymbolicLinkTransacted uintptr + createSymbolicLink uintptr + createTapePartition uintptr + createThread uintptr + createTimerQueue uintptr + createToolhelp32Snapshot uintptr + createWaitableTimerEx uintptr + createWaitableTimer uintptr + deactivateActCtx uintptr + debugActiveProcess uintptr + debugActiveProcessStop uintptr + debugBreak uintptr + debugBreakProcess uintptr + debugSetProcessKillOnExit uintptr + decodePointer uintptr + decodeSystemPointer uintptr + defineDosDevice uintptr + deleteAtom uintptr + deleteBoundaryDescriptor uintptr + deleteFiber uintptr + deleteFileTransacted uintptr + deleteFile uintptr + deleteTimerQueue uintptr + deleteTimerQueueEx uintptr + deleteTimerQueueTimer uintptr + deleteVolumeMountPoint uintptr + deviceIoControl uintptr + disableThreadLibraryCalls uintptr + disableThreadProfiling uintptr + discardVirtualMemory uintptr + disconnectNamedPipe uintptr + dnsHostnameToComputerName uintptr + dosDateTimeToFileTime uintptr + duplicateHandle uintptr + encodePointer uintptr + encodeSystemPointer uintptr + endUpdateResource uintptr + enumResourceLanguagesEx uintptr + enumResourceLanguages uintptr + enumSystemFirmwareTables uintptr + eraseTape uintptr + escapeCommFunction uintptr + exitProcess uintptr + exitThread uintptr + expandEnvironmentStrings uintptr + fatalAppExit uintptr + fatalExit uintptr + fileTimeToDosDateTime uintptr + fileTimeToLocalFileTime uintptr + fileTimeToSystemTime uintptr + fillConsoleOutputAttribute uintptr + fillConsoleOutputCharacter uintptr + findAtom uintptr + findClose uintptr + findCloseChangeNotification uintptr + findFirstChangeNotification uintptr + findFirstFileNameTransactedW uintptr + findFirstFileNameW uintptr + findFirstVolumeMountPoint uintptr + findFirstVolume uintptr + findNLSString uintptr + findNextChangeNotification uintptr + findNextFileNameW uintptr + findNextStreamW uintptr + findNextVolumeMountPoint uintptr + findNextVolume uintptr + findResourceEx uintptr + findResource uintptr + findStringOrdinal uintptr + findVolumeClose uintptr + findVolumeMountPointClose uintptr + flsFree uintptr + flsGetValue uintptr + flsSetValue uintptr + flushConsoleInputBuffer uintptr + flushFileBuffers uintptr + flushInstructionCache uintptr + flushProcessWriteBuffers uintptr + flushViewOfFile uintptr + freeConsole uintptr + freeLibrary uintptr + freeLibraryAndExitThread uintptr + freeResource uintptr + generateConsoleCtrlEvent uintptr + getACP uintptr + getActiveProcessorCount uintptr + getActiveProcessorGroupCount uintptr + getApplicationRestartSettings uintptr + getAtomName uintptr + getBinaryType uintptr + getCPInfo uintptr + getCPInfoEx uintptr + getCalendarInfoEx uintptr + getCalendarInfo uintptr + getCommMask uintptr + getCommModemStatus uintptr + getCommandLine uintptr + getCompressedFileSizeTransacted uintptr + getCompressedFileSize uintptr + getComputerName uintptr + getConsoleAliasExesLength uintptr + getConsoleAliasExes uintptr + getConsoleAlias uintptr + getConsoleAliasesLength uintptr + getConsoleAliases uintptr + getConsoleCP uintptr + getConsoleDisplayMode uintptr + getConsoleFontSize uintptr + getConsoleMode uintptr + getConsoleOriginalTitle uintptr + getConsoleOutputCP uintptr + getConsoleProcessList uintptr + getConsoleScreenBufferInfo uintptr + getConsoleScreenBufferInfoEx uintptr + getConsoleTitle uintptr + getConsoleWindow uintptr + getCurrentActCtx uintptr + getCurrentDirectory uintptr + getCurrentProcess uintptr + getCurrentProcessId uintptr + getCurrentProcessorNumber uintptr + getCurrentThread uintptr + getCurrentThreadId uintptr + getDateFormatEx uintptr + getDateFormat uintptr + getDevicePowerState uintptr + getDiskFreeSpace uintptr + getDiskFreeSpaceEx uintptr + getDllDirectory uintptr + getDriveType uintptr + getDurationFormat uintptr + getDurationFormatEx uintptr + getEnvironmentVariable uintptr + getErrorMode uintptr + getExitCodeProcess uintptr + getExitCodeThread uintptr + getExpandedName uintptr + getFileAttributes uintptr + getFileBandwidthReservation uintptr + getFileSize uintptr + getFileTime uintptr + getFileType uintptr + getFinalPathNameByHandle uintptr + getFirmwareEnvironmentVariable uintptr + getFullPathNameTransacted uintptr + getFullPathName uintptr + getHandleInformation uintptr + getLargePageMinimum uintptr + getLargestConsoleWindowSize uintptr + getLastError uintptr + getLocalTime uintptr + getLocaleInfoEx uintptr + getLocaleInfo uintptr + getLogicalDriveStrings uintptr + getLogicalDrives uintptr + getLogicalProcessorInformationEx uintptr + getLongPathNameTransacted uintptr + getLongPathName uintptr + getMailslotInfo uintptr + getMaximumProcessorCount uintptr + getMaximumProcessorGroupCount uintptr + getModuleFileName uintptr + getModuleHandleEx uintptr + getModuleHandle uintptr + getNamedPipeClientComputerName uintptr + getNamedPipeClientProcessId uintptr + getNamedPipeClientSessionId uintptr + getNamedPipeHandleState uintptr + getNamedPipeInfo uintptr + getNamedPipeServerProcessId uintptr + getNamedPipeServerSessionId uintptr + getNativeSystemInfo uintptr + getNumaHighestNodeNumber uintptr + getNumaNodeNumberFromHandle uintptr + getNumaProcessorNode uintptr + getNumaProximityNode uintptr + getNumaProximityNodeEx uintptr + getNumberOfConsoleInputEvents uintptr + getNumberOfConsoleMouseButtons uintptr + getOEMCP uintptr + getOverlappedResult uintptr + getPriorityClass uintptr + getPrivateProfileInt uintptr + getPrivateProfileSectionNames uintptr + getPrivateProfileSection uintptr + getPrivateProfileString uintptr + getPrivateProfileStruct uintptr + getProcAddress uintptr + getProcessAffinityMask uintptr + getProcessDEPPolicy uintptr + getProcessGroupAffinity uintptr + getProcessHandleCount uintptr + getProcessHeap uintptr + getProcessHeaps uintptr + getProcessId uintptr + getProcessIdOfThread uintptr + getProcessPriorityBoost uintptr + getProcessShutdownParameters uintptr + getProcessTimes uintptr + getProcessVersion uintptr + getProductInfo uintptr + getProfileInt uintptr + getProfileSection uintptr + getProfileString uintptr + getShortPathName uintptr + getStartupInfo uintptr + getStdHandle uintptr + getStringScripts uintptr + getSystemDefaultLCID uintptr + getSystemDefaultLangID uintptr + getSystemDefaultLocaleName uintptr + getSystemDefaultUILanguage uintptr + getSystemDirectory uintptr + getSystemFirmwareTable uintptr + getSystemInfo uintptr + getSystemRegistryQuota uintptr + getSystemTime uintptr + getSystemTimeAdjustment uintptr + getSystemTimeAsFileTime uintptr + getSystemTimePreciseAsFileTime uintptr + getSystemTimes uintptr + getSystemWindowsDirectory uintptr + getSystemWow64Directory uintptr + getTapeParameters uintptr + getTapePosition uintptr + getTapeStatus uintptr + getTempFileName uintptr + getTempPath uintptr + getThreadErrorMode uintptr + getThreadIOPendingFlag uintptr + getThreadId uintptr + getThreadLocale uintptr + getThreadPriority uintptr + getThreadPriorityBoost uintptr + getThreadTimes uintptr + getThreadUILanguage uintptr + getTickCount uintptr + getTickCount64 uintptr + getTimeFormatEx uintptr + getTimeFormat uintptr + getUserDefaultLCID uintptr + getUserDefaultLangID uintptr + getUserDefaultLocaleName uintptr + getUserDefaultUILanguage uintptr + getVersion uintptr + getVolumeInformationByHandleW uintptr + getVolumeInformation uintptr + getVolumeNameForVolumeMountPoint uintptr + getVolumePathName uintptr + getWindowsDirectory uintptr + getWriteWatch uintptr + globalAddAtom uintptr + globalAlloc uintptr + globalCompact uintptr + globalDeleteAtom uintptr + globalFindAtom uintptr + globalFix uintptr + globalFlags uintptr + globalFree uintptr + globalGetAtomName uintptr + globalHandle uintptr + globalLock uintptr + globalMemoryStatusEx uintptr + globalReAlloc uintptr + globalSize uintptr + globalUnWire uintptr + globalUnfix uintptr + globalUnlock uintptr + globalWire uintptr + heapAlloc uintptr + heapCompact uintptr + heapCreate uintptr + heapDestroy uintptr + heapFree uintptr + heapLock uintptr + heapReAlloc uintptr + heapSize uintptr + heapUnlock uintptr + heapValidate uintptr + idnToAscii uintptr + idnToNameprepUnicode uintptr + idnToUnicode uintptr + initAtomTable uintptr + initializeSRWLock uintptr + isBadCodePtr uintptr + isBadHugeReadPtr uintptr + isBadHugeWritePtr uintptr + isBadReadPtr uintptr + isBadStringPtr uintptr + isBadWritePtr uintptr + isDBCSLeadByte uintptr + isDBCSLeadByteEx uintptr + isDebuggerPresent uintptr + isProcessInJob uintptr + isProcessorFeaturePresent uintptr + isSystemResumeAutomatic uintptr + isThreadAFiber uintptr + isValidCodePage uintptr + isValidLocale uintptr + isValidLocaleName uintptr + isWow64Process uintptr + lCIDToLocaleName uintptr + lCMapString uintptr + lZClose uintptr + lZCopy uintptr + lZDone uintptr + lZInit uintptr + lZRead uintptr + lZSeek uintptr + lZStart uintptr + loadLibraryEx uintptr + loadLibrary uintptr + loadModule uintptr + loadPackagedLibrary uintptr + loadResource uintptr + localAlloc uintptr + localCompact uintptr + localFileTimeToFileTime uintptr + localFlags uintptr + localFree uintptr + localHandle uintptr + localLock uintptr + localReAlloc uintptr + localShrink uintptr + localSize uintptr + localUnlock uintptr + localeNameToLCID uintptr + lockFile uintptr + lockFileEx uintptr + lockResource uintptr + mapViewOfFile uintptr + mapViewOfFileEx uintptr + mapViewOfFileExNuma uintptr + moveFileEx uintptr + moveFile uintptr + mulDiv uintptr + needCurrentDirectoryForExePath uintptr + notifyUILanguageChange uintptr + openEvent uintptr + openFileMapping uintptr + openJobObject uintptr + openMutex uintptr + openPrivateNamespace uintptr + openProcess uintptr + openSemaphore uintptr + openThread uintptr + openWaitableTimer uintptr + outputDebugString uintptr + peekNamedPipe uintptr + postQueuedCompletionStatus uintptr + prepareTape uintptr + process32Next uintptr + processIdToSessionId uintptr + pulseEvent uintptr + purgeComm uintptr + queryActCtxSettingsW uintptr + queryActCtxW uintptr + queryDosDevice uintptr + queryFullProcessImageName uintptr + queryIdleProcessorCycleTime uintptr + queryIdleProcessorCycleTimeEx uintptr + queryMemoryResourceNotification uintptr + queryPerformanceCounter uintptr + queryPerformanceFrequency uintptr + queryProcessAffinityUpdateMode uintptr + queryProcessCycleTime uintptr + queryThreadCycleTime uintptr + queueUserWorkItem uintptr + raiseException uintptr + reOpenFile uintptr + readConsoleOutputAttribute uintptr + readConsoleOutputCharacter uintptr + readConsole uintptr + readFile uintptr + readProcessMemory uintptr + reclaimVirtualMemory uintptr + registerApplicationRestart uintptr + releaseActCtx uintptr + releaseMutex uintptr + releaseSRWLockExclusive uintptr + releaseSRWLockShared uintptr + releaseSemaphore uintptr + removeDirectoryTransacted uintptr + removeDirectory uintptr + removeSecureMemoryCacheCallback uintptr + removeVectoredContinueHandler uintptr + removeVectoredExceptionHandler uintptr + replaceFile uintptr + replacePartitionUnit uintptr + requestDeviceWakeup uintptr + resetEvent uintptr + resetWriteWatch uintptr + resolveLocaleName uintptr + restoreLastError uintptr + resumeThread uintptr + searchPath uintptr + setCalendarInfo uintptr + setCommBreak uintptr + setCommMask uintptr + setComputerName uintptr + setConsoleActiveScreenBuffer uintptr + setConsoleCP uintptr + setConsoleCursorPosition uintptr + setConsoleMode uintptr + setConsoleOutputCP uintptr + setConsoleScreenBufferInfoEx uintptr + setConsoleScreenBufferSize uintptr + setConsoleTextAttribute uintptr + setConsoleTitle uintptr + setConsoleWindowInfo uintptr + setCurrentDirectory uintptr + setDllDirectory uintptr + setEndOfFile uintptr + setEnvironmentVariable uintptr + setErrorMode uintptr + setEvent uintptr + setFileApisToANSI uintptr + setFileApisToOEM uintptr + setFileAttributesTransacted uintptr + setFileAttributes uintptr + setFileBandwidthReservation uintptr + setFileCompletionNotificationModes uintptr + setFileIoOverlappedRange uintptr + setFilePointer uintptr + setFileShortName uintptr + setFileTime uintptr + setFileValidData uintptr + setFirmwareEnvironmentVariable uintptr + setHandleCount uintptr + setHandleInformation uintptr + setLastError uintptr + setLocalTime uintptr + setLocaleInfo uintptr + setMailslotInfo uintptr + setMessageWaitingIndicator uintptr + setNamedPipeHandleState uintptr + setPriorityClass uintptr + setProcessAffinityMask uintptr + setProcessAffinityUpdateMode uintptr + setProcessDEPPolicy uintptr + setProcessPreferredUILanguages uintptr + setProcessPriorityBoost uintptr + setProcessShutdownParameters uintptr + setProcessWorkingSetSize uintptr + setProcessWorkingSetSizeEx uintptr + setSearchPathMode uintptr + setStdHandle uintptr + setStdHandleEx uintptr + setSystemFileCacheSize uintptr + setSystemPowerState uintptr + setSystemTime uintptr + setSystemTimeAdjustment uintptr + setTapeParameters uintptr + setTapePosition uintptr + setThreadAffinityMask uintptr + setThreadErrorMode uintptr + setThreadIdealProcessor uintptr + setThreadLocale uintptr + setThreadPreferredUILanguages uintptr + setThreadPriority uintptr + setThreadPriorityBoost uintptr + setThreadStackGuarantee uintptr + setThreadUILanguage uintptr + setUserGeoID uintptr + setVolumeLabel uintptr + setVolumeMountPoint uintptr + setupComm uintptr + signalObjectAndWait uintptr + sizeofResource uintptr + sleep uintptr + sleepEx uintptr + suspendThread uintptr + switchToFiber uintptr + switchToThread uintptr + systemTimeToFileTime uintptr + terminateJobObject uintptr + terminateProcess uintptr + terminateThread uintptr + tlsAlloc uintptr + tlsFree uintptr + tlsGetValue uintptr + tlsSetValue uintptr + toolhelp32ReadProcessMemory uintptr + transactNamedPipe uintptr + transmitCommChar uintptr + tryAcquireSRWLockExclusive uintptr + tryAcquireSRWLockShared uintptr + unlockFile uintptr + unlockFileEx uintptr + unmapViewOfFile uintptr + unregisterApplicationRecoveryCallback uintptr + unregisterApplicationRestart uintptr + unregisterWait uintptr + unregisterWaitEx uintptr + updateResource uintptr + verLanguageName uintptr + verifyScripts uintptr + virtualAlloc uintptr + virtualAllocEx uintptr + virtualAllocExNuma uintptr + virtualFree uintptr + virtualFreeEx uintptr + virtualLock uintptr + virtualProtect uintptr + virtualProtectEx uintptr + virtualUnlock uintptr + wTSGetActiveConsoleSessionId uintptr + waitCommEvent uintptr + waitForMultipleObjects uintptr + waitForMultipleObjectsEx uintptr + waitForSingleObject uintptr + waitForSingleObjectEx uintptr + waitNamedPipe uintptr + werGetFlags uintptr + werRegisterMemoryBlock uintptr + werRegisterRuntimeExceptionModule uintptr + werSetFlags uintptr + werUnregisterFile uintptr + werUnregisterMemoryBlock uintptr + werUnregisterRuntimeExceptionModule uintptr + winExec uintptr + wow64DisableWow64FsRedirection uintptr + wow64EnableWow64FsRedirection uintptr + wow64RevertWow64FsRedirection uintptr + wow64SuspendThread uintptr + writeConsoleOutputAttribute uintptr + writeConsoleOutputCharacter uintptr + writeConsole uintptr + writeFile uintptr + writePrivateProfileSection uintptr + writePrivateProfileString uintptr + writePrivateProfileStruct uintptr + writeProcessMemory uintptr + writeProfileSection uintptr + writeProfileString uintptr + writeTapemark uintptr + zombifyActCtx uintptr + lstrcat uintptr + lstrcmp uintptr + lstrcmpi uintptr + lstrcpy uintptr + lstrcpyn uintptr + lstrlen uintptr + closeConsoleHandle uintptr + closeProfileUserMapping uintptr + cmdBatNotification uintptr + delayLoadFailureHook uintptr + duplicateConsoleHandle uintptr + expungeConsoleCommandHistory uintptr + getConsoleCommandHistoryLength uintptr + getConsoleCommandHistory uintptr + getConsoleInputExeName uintptr + getConsoleInputWaitHandle uintptr + getConsoleKeyboardLayoutName uintptr + getNumberOfConsoleFonts uintptr + k32EmptyWorkingSet uintptr + k32EnumDeviceDrivers uintptr + k32EnumPageFiles uintptr + k32EnumProcessModules uintptr + k32EnumProcessModulesEx uintptr + k32EnumProcesses uintptr + k32GetDeviceDriverBaseName uintptr + k32GetDeviceDriverFileName uintptr + k32GetMappedFileName uintptr + k32GetModuleBaseName uintptr + k32GetModuleFileNameEx uintptr + k32GetModuleInformation uintptr + k32GetProcessImageFileName uintptr + k32GetProcessMemoryInfo uintptr + k32GetWsChanges uintptr + k32InitializeProcessForWsWatch uintptr + k32QueryWorkingSet uintptr + k32QueryWorkingSetEx uintptr + openConsoleW uintptr + openProfileUserMapping uintptr + rtlCaptureStackBackTrace uintptr + rtlCompareMemory uintptr + rtlCopyMemory uintptr + rtlFillMemory uintptr + rtlMoveMemory uintptr + rtlPcToFileHeader uintptr + rtlZeroMemory uintptr + setCPGlobal uintptr + setConsoleFont uintptr + setConsoleIcon uintptr + setConsoleInputExeName uintptr + setConsoleKeyShortcuts uintptr + setTermsrvAppInstallMode uintptr + termsrvAppInstallMode uintptr + uTRegister uintptr + uTUnRegister uintptr + verSetConditionMask uintptr + verifyConsoleIoHandle uintptr +) + +func init() { + // Library + libkernel32 = doLoadLibrary("kernel32.dll") + + // Functions + acquireSRWLockExclusive = doGetProcAddress(libkernel32, "AcquireSRWLockExclusive") + acquireSRWLockShared = doGetProcAddress(libkernel32, "AcquireSRWLockShared") + activateActCtx = doGetProcAddress(libkernel32, "ActivateActCtx") + addAtom = doGetProcAddress(libkernel32, "AddAtomW") + addConsoleAlias = doGetProcAddress(libkernel32, "AddConsoleAliasW") + addIntegrityLabelToBoundaryDescriptor = doGetProcAddress(libkernel32, "AddIntegrityLabelToBoundaryDescriptor") + addRefActCtx = doGetProcAddress(libkernel32, "AddRefActCtx") + addSIDToBoundaryDescriptor = doGetProcAddress(libkernel32, "AddSIDToBoundaryDescriptor") + addSecureMemoryCacheCallback = doGetProcAddress(libkernel32, "AddSecureMemoryCacheCallback") + allocConsole = doGetProcAddress(libkernel32, "AllocConsole") + applicationRecoveryFinished = doGetProcAddress(libkernel32, "ApplicationRecoveryFinished") + applicationRecoveryInProgress = doGetProcAddress(libkernel32, "ApplicationRecoveryInProgress") + areFileApisANSI = doGetProcAddress(libkernel32, "AreFileApisANSI") + assignProcessToJobObject = doGetProcAddress(libkernel32, "AssignProcessToJobObject") + attachConsole = doGetProcAddress(libkernel32, "AttachConsole") + backupRead = doGetProcAddress(libkernel32, "BackupRead") + backupSeek = doGetProcAddress(libkernel32, "BackupSeek") + backupWrite = doGetProcAddress(libkernel32, "BackupWrite") + beep = doGetProcAddress(libkernel32, "Beep") + beginUpdateResource = doGetProcAddress(libkernel32, "BeginUpdateResourceW") + callNamedPipe = doGetProcAddress(libkernel32, "CallNamedPipeW") + cancelDeviceWakeupRequest = doGetProcAddress(libkernel32, "CancelDeviceWakeupRequest") + cancelIo = doGetProcAddress(libkernel32, "CancelIo") + cancelIoEx = doGetProcAddress(libkernel32, "CancelIoEx") + cancelSynchronousIo = doGetProcAddress(libkernel32, "CancelSynchronousIo") + cancelTimerQueueTimer = doGetProcAddress(libkernel32, "CancelTimerQueueTimer") + cancelWaitableTimer = doGetProcAddress(libkernel32, "CancelWaitableTimer") + changeTimerQueueTimer = doGetProcAddress(libkernel32, "ChangeTimerQueueTimer") + checkNameLegalDOS8Dot3 = doGetProcAddress(libkernel32, "CheckNameLegalDOS8Dot3W") + checkRemoteDebuggerPresent = doGetProcAddress(libkernel32, "CheckRemoteDebuggerPresent") + clearCommBreak = doGetProcAddress(libkernel32, "ClearCommBreak") + closeHandle = doGetProcAddress(libkernel32, "CloseHandle") + closePrivateNamespace = doGetProcAddress(libkernel32, "ClosePrivateNamespace") + compareFileTime = doGetProcAddress(libkernel32, "CompareFileTime") + connectNamedPipe = doGetProcAddress(libkernel32, "ConnectNamedPipe") + continueDebugEvent = doGetProcAddress(libkernel32, "ContinueDebugEvent") + convertDefaultLocale = doGetProcAddress(libkernel32, "ConvertDefaultLocale") + convertFiberToThread = doGetProcAddress(libkernel32, "ConvertFiberToThread") + convertThreadToFiber = doGetProcAddress(libkernel32, "ConvertThreadToFiber") + convertThreadToFiberEx = doGetProcAddress(libkernel32, "ConvertThreadToFiberEx") + copyFile = doGetProcAddress(libkernel32, "CopyFileW") + copyLZFile = doGetProcAddress(libkernel32, "CopyLZFile") + createBoundaryDescriptor = doGetProcAddress(libkernel32, "CreateBoundaryDescriptorW") + createConsoleScreenBuffer = doGetProcAddress(libkernel32, "CreateConsoleScreenBuffer") + createDirectoryEx = doGetProcAddress(libkernel32, "CreateDirectoryExW") + createDirectoryTransacted = doGetProcAddress(libkernel32, "CreateDirectoryTransactedW") + createDirectory = doGetProcAddress(libkernel32, "CreateDirectoryW") + createEventEx = doGetProcAddress(libkernel32, "CreateEventExW") + createEvent = doGetProcAddress(libkernel32, "CreateEventW") + createFileMappingNuma = doGetProcAddress(libkernel32, "CreateFileMappingNumaW") + createFileMapping = doGetProcAddress(libkernel32, "CreateFileMappingW") + createFileTransacted = doGetProcAddress(libkernel32, "CreateFileTransactedW") + createFile = doGetProcAddress(libkernel32, "CreateFileW") + createHardLinkTransacted = doGetProcAddress(libkernel32, "CreateHardLinkTransactedW") + createHardLink = doGetProcAddress(libkernel32, "CreateHardLinkW") + createIoCompletionPort = doGetProcAddress(libkernel32, "CreateIoCompletionPort") + createJobObject = doGetProcAddress(libkernel32, "CreateJobObjectW") + createMailslot = doGetProcAddress(libkernel32, "CreateMailslotW") + createMutexEx = doGetProcAddress(libkernel32, "CreateMutexExW") + createMutex = doGetProcAddress(libkernel32, "CreateMutexW") + createNamedPipe = doGetProcAddress(libkernel32, "CreateNamedPipeW") + createPipe = doGetProcAddress(libkernel32, "CreatePipe") + createPrivateNamespace = doGetProcAddress(libkernel32, "CreatePrivateNamespaceW") + createProcess = doGetProcAddress(libkernel32, "CreateProcessW") + createRemoteThread = doGetProcAddress(libkernel32, "CreateRemoteThread") + createSemaphoreEx = doGetProcAddress(libkernel32, "CreateSemaphoreExW") + createSemaphore = doGetProcAddress(libkernel32, "CreateSemaphoreW") + createSymbolicLinkTransacted = doGetProcAddress(libkernel32, "CreateSymbolicLinkTransactedW") + createSymbolicLink = doGetProcAddress(libkernel32, "CreateSymbolicLinkW") + createTapePartition = doGetProcAddress(libkernel32, "CreateTapePartition") + createThread = doGetProcAddress(libkernel32, "CreateThread") + createTimerQueue = doGetProcAddress(libkernel32, "CreateTimerQueue") + createToolhelp32Snapshot = doGetProcAddress(libkernel32, "CreateToolhelp32Snapshot") + createWaitableTimerEx = doGetProcAddress(libkernel32, "CreateWaitableTimerExW") + createWaitableTimer = doGetProcAddress(libkernel32, "CreateWaitableTimerW") + deactivateActCtx = doGetProcAddress(libkernel32, "DeactivateActCtx") + debugActiveProcess = doGetProcAddress(libkernel32, "DebugActiveProcess") + debugActiveProcessStop = doGetProcAddress(libkernel32, "DebugActiveProcessStop") + debugBreak = doGetProcAddress(libkernel32, "DebugBreak") + debugBreakProcess = doGetProcAddress(libkernel32, "DebugBreakProcess") + debugSetProcessKillOnExit = doGetProcAddress(libkernel32, "DebugSetProcessKillOnExit") + decodePointer = doGetProcAddress(libkernel32, "DecodePointer") + decodeSystemPointer = doGetProcAddress(libkernel32, "DecodeSystemPointer") + defineDosDevice = doGetProcAddress(libkernel32, "DefineDosDeviceW") + deleteAtom = doGetProcAddress(libkernel32, "DeleteAtom") + deleteBoundaryDescriptor = doGetProcAddress(libkernel32, "DeleteBoundaryDescriptor") + deleteFiber = doGetProcAddress(libkernel32, "DeleteFiber") + deleteFileTransacted = doGetProcAddress(libkernel32, "DeleteFileTransactedW") + deleteFile = doGetProcAddress(libkernel32, "DeleteFileW") + deleteTimerQueue = doGetProcAddress(libkernel32, "DeleteTimerQueue") + deleteTimerQueueEx = doGetProcAddress(libkernel32, "DeleteTimerQueueEx") + deleteTimerQueueTimer = doGetProcAddress(libkernel32, "DeleteTimerQueueTimer") + deleteVolumeMountPoint = doGetProcAddress(libkernel32, "DeleteVolumeMountPointW") + deviceIoControl = doGetProcAddress(libkernel32, "DeviceIoControl") + disableThreadLibraryCalls = doGetProcAddress(libkernel32, "DisableThreadLibraryCalls") + disableThreadProfiling = doGetProcAddress(libkernel32, "DisableThreadProfiling") + discardVirtualMemory = doGetProcAddress(libkernel32, "DiscardVirtualMemory") + disconnectNamedPipe = doGetProcAddress(libkernel32, "DisconnectNamedPipe") + dnsHostnameToComputerName = doGetProcAddress(libkernel32, "DnsHostnameToComputerNameW") + dosDateTimeToFileTime = doGetProcAddress(libkernel32, "DosDateTimeToFileTime") + duplicateHandle = doGetProcAddress(libkernel32, "DuplicateHandle") + encodePointer = doGetProcAddress(libkernel32, "EncodePointer") + encodeSystemPointer = doGetProcAddress(libkernel32, "EncodeSystemPointer") + endUpdateResource = doGetProcAddress(libkernel32, "EndUpdateResourceW") + enumResourceLanguagesEx = doGetProcAddress(libkernel32, "EnumResourceLanguagesExW") + enumResourceLanguages = doGetProcAddress(libkernel32, "EnumResourceLanguagesW") + enumSystemFirmwareTables = doGetProcAddress(libkernel32, "EnumSystemFirmwareTables") + eraseTape = doGetProcAddress(libkernel32, "EraseTape") + escapeCommFunction = doGetProcAddress(libkernel32, "EscapeCommFunction") + exitProcess = doGetProcAddress(libkernel32, "ExitProcess") + exitThread = doGetProcAddress(libkernel32, "ExitThread") + expandEnvironmentStrings = doGetProcAddress(libkernel32, "ExpandEnvironmentStringsW") + fatalAppExit = doGetProcAddress(libkernel32, "FatalAppExitW") + fatalExit = doGetProcAddress(libkernel32, "FatalExit") + fileTimeToDosDateTime = doGetProcAddress(libkernel32, "FileTimeToDosDateTime") + fileTimeToLocalFileTime = doGetProcAddress(libkernel32, "FileTimeToLocalFileTime") + fileTimeToSystemTime = doGetProcAddress(libkernel32, "FileTimeToSystemTime") + fillConsoleOutputAttribute = doGetProcAddress(libkernel32, "FillConsoleOutputAttribute") + fillConsoleOutputCharacter = doGetProcAddress(libkernel32, "FillConsoleOutputCharacterW") + findAtom = doGetProcAddress(libkernel32, "FindAtomW") + findClose = doGetProcAddress(libkernel32, "FindClose") + findCloseChangeNotification = doGetProcAddress(libkernel32, "FindCloseChangeNotification") + findFirstChangeNotification = doGetProcAddress(libkernel32, "FindFirstChangeNotificationW") + findFirstFileNameTransactedW = doGetProcAddress(libkernel32, "FindFirstFileNameTransactedW") + findFirstFileNameW = doGetProcAddress(libkernel32, "FindFirstFileNameW") + findFirstVolumeMountPoint = doGetProcAddress(libkernel32, "FindFirstVolumeMountPointW") + findFirstVolume = doGetProcAddress(libkernel32, "FindFirstVolumeW") + findNLSString = doGetProcAddress(libkernel32, "FindNLSString") + findNextChangeNotification = doGetProcAddress(libkernel32, "FindNextChangeNotification") + findNextFileNameW = doGetProcAddress(libkernel32, "FindNextFileNameW") + findNextStreamW = doGetProcAddress(libkernel32, "FindNextStreamW") + findNextVolumeMountPoint = doGetProcAddress(libkernel32, "FindNextVolumeMountPointW") + findNextVolume = doGetProcAddress(libkernel32, "FindNextVolumeW") + findResourceEx = doGetProcAddress(libkernel32, "FindResourceExW") + findResource = doGetProcAddress(libkernel32, "FindResourceW") + findStringOrdinal = doGetProcAddress(libkernel32, "FindStringOrdinal") + findVolumeClose = doGetProcAddress(libkernel32, "FindVolumeClose") + findVolumeMountPointClose = doGetProcAddress(libkernel32, "FindVolumeMountPointClose") + flsFree = doGetProcAddress(libkernel32, "FlsFree") + flsGetValue = doGetProcAddress(libkernel32, "FlsGetValue") + flsSetValue = doGetProcAddress(libkernel32, "FlsSetValue") + flushConsoleInputBuffer = doGetProcAddress(libkernel32, "FlushConsoleInputBuffer") + flushFileBuffers = doGetProcAddress(libkernel32, "FlushFileBuffers") + flushInstructionCache = doGetProcAddress(libkernel32, "FlushInstructionCache") + flushProcessWriteBuffers = doGetProcAddress(libkernel32, "FlushProcessWriteBuffers") + flushViewOfFile = doGetProcAddress(libkernel32, "FlushViewOfFile") + freeConsole = doGetProcAddress(libkernel32, "FreeConsole") + freeLibrary = doGetProcAddress(libkernel32, "FreeLibrary") + freeLibraryAndExitThread = doGetProcAddress(libkernel32, "FreeLibraryAndExitThread") + freeResource = doGetProcAddress(libkernel32, "FreeResource") + generateConsoleCtrlEvent = doGetProcAddress(libkernel32, "GenerateConsoleCtrlEvent") + getACP = doGetProcAddress(libkernel32, "GetACP") + getActiveProcessorCount = doGetProcAddress(libkernel32, "GetActiveProcessorCount") + getActiveProcessorGroupCount = doGetProcAddress(libkernel32, "GetActiveProcessorGroupCount") + getApplicationRestartSettings = doGetProcAddress(libkernel32, "GetApplicationRestartSettings") + getAtomName = doGetProcAddress(libkernel32, "GetAtomNameW") + getBinaryType = doGetProcAddress(libkernel32, "GetBinaryTypeW") + getCPInfo = doGetProcAddress(libkernel32, "GetCPInfo") + getCPInfoEx = doGetProcAddress(libkernel32, "GetCPInfoExW") + getCalendarInfoEx = doGetProcAddress(libkernel32, "GetCalendarInfoEx") + getCalendarInfo = doGetProcAddress(libkernel32, "GetCalendarInfoW") + getCommMask = doGetProcAddress(libkernel32, "GetCommMask") + getCommModemStatus = doGetProcAddress(libkernel32, "GetCommModemStatus") + getCommandLine = doGetProcAddress(libkernel32, "GetCommandLineW") + getCompressedFileSizeTransacted = doGetProcAddress(libkernel32, "GetCompressedFileSizeTransactedW") + getCompressedFileSize = doGetProcAddress(libkernel32, "GetCompressedFileSizeW") + getComputerName = doGetProcAddress(libkernel32, "GetComputerNameW") + getConsoleAliasExesLength = doGetProcAddress(libkernel32, "GetConsoleAliasExesLengthW") + getConsoleAliasExes = doGetProcAddress(libkernel32, "GetConsoleAliasExesW") + getConsoleAlias = doGetProcAddress(libkernel32, "GetConsoleAliasW") + getConsoleAliasesLength = doGetProcAddress(libkernel32, "GetConsoleAliasesLengthW") + getConsoleAliases = doGetProcAddress(libkernel32, "GetConsoleAliasesW") + getConsoleCP = doGetProcAddress(libkernel32, "GetConsoleCP") + getConsoleDisplayMode = doGetProcAddress(libkernel32, "GetConsoleDisplayMode") + getConsoleFontSize = doGetProcAddress(libkernel32, "GetConsoleFontSize") + getConsoleMode = doGetProcAddress(libkernel32, "GetConsoleMode") + getConsoleOriginalTitle = doGetProcAddress(libkernel32, "GetConsoleOriginalTitleW") + getConsoleOutputCP = doGetProcAddress(libkernel32, "GetConsoleOutputCP") + getConsoleProcessList = doGetProcAddress(libkernel32, "GetConsoleProcessList") + getConsoleScreenBufferInfo = doGetProcAddress(libkernel32, "GetConsoleScreenBufferInfo") + getConsoleScreenBufferInfoEx = doGetProcAddress(libkernel32, "GetConsoleScreenBufferInfoEx") + getConsoleTitle = doGetProcAddress(libkernel32, "GetConsoleTitleW") + getConsoleWindow = doGetProcAddress(libkernel32, "GetConsoleWindow") + getCurrentActCtx = doGetProcAddress(libkernel32, "GetCurrentActCtx") + getCurrentDirectory = doGetProcAddress(libkernel32, "GetCurrentDirectoryW") + getCurrentProcess = doGetProcAddress(libkernel32, "GetCurrentProcess") + getCurrentProcessId = doGetProcAddress(libkernel32, "GetCurrentProcessId") + getCurrentProcessorNumber = doGetProcAddress(libkernel32, "GetCurrentProcessorNumber") + getCurrentThread = doGetProcAddress(libkernel32, "GetCurrentThread") + getCurrentThreadId = doGetProcAddress(libkernel32, "GetCurrentThreadId") + getDateFormatEx = doGetProcAddress(libkernel32, "GetDateFormatEx") + getDateFormat = doGetProcAddress(libkernel32, "GetDateFormatW") + getDevicePowerState = doGetProcAddress(libkernel32, "GetDevicePowerState") + getDiskFreeSpace = doGetProcAddress(libkernel32, "GetDiskFreeSpaceW") + getDiskFreeSpaceEx = doGetProcAddress(libkernel32, "GetDiskFreeSpaceExW") + getDllDirectory = doGetProcAddress(libkernel32, "GetDllDirectoryW") + getDriveType = doGetProcAddress(libkernel32, "GetDriveTypeW") + getDurationFormat = doGetProcAddress(libkernel32, "GetDurationFormat") + getDurationFormatEx = doGetProcAddress(libkernel32, "GetDurationFormatEx") + getEnvironmentVariable = doGetProcAddress(libkernel32, "GetEnvironmentVariableW") + getErrorMode = doGetProcAddress(libkernel32, "GetErrorMode") + getExitCodeProcess = doGetProcAddress(libkernel32, "GetExitCodeProcess") + getExitCodeThread = doGetProcAddress(libkernel32, "GetExitCodeThread") + getExpandedName = doGetProcAddress(libkernel32, "GetExpandedNameW") + getFileAttributes = doGetProcAddress(libkernel32, "GetFileAttributesW") + getFileBandwidthReservation = doGetProcAddress(libkernel32, "GetFileBandwidthReservation") + getFileSize = doGetProcAddress(libkernel32, "GetFileSize") + getFileTime = doGetProcAddress(libkernel32, "GetFileTime") + getFileType = doGetProcAddress(libkernel32, "GetFileType") + getFinalPathNameByHandle = doGetProcAddress(libkernel32, "GetFinalPathNameByHandleW") + getFirmwareEnvironmentVariable = doGetProcAddress(libkernel32, "GetFirmwareEnvironmentVariableW") + getFullPathNameTransacted = doGetProcAddress(libkernel32, "GetFullPathNameTransactedW") + getFullPathName = doGetProcAddress(libkernel32, "GetFullPathNameW") + getHandleInformation = doGetProcAddress(libkernel32, "GetHandleInformation") + getLargePageMinimum = doGetProcAddress(libkernel32, "GetLargePageMinimum") + getLargestConsoleWindowSize = doGetProcAddress(libkernel32, "GetLargestConsoleWindowSize") + getLastError = doGetProcAddress(libkernel32, "GetLastError") + getLocalTime = doGetProcAddress(libkernel32, "GetLocalTime") + getLocaleInfoEx = doGetProcAddress(libkernel32, "GetLocaleInfoEx") + getLocaleInfo = doGetProcAddress(libkernel32, "GetLocaleInfoW") + getLogicalDriveStrings = doGetProcAddress(libkernel32, "GetLogicalDriveStringsW") + getLogicalDrives = doGetProcAddress(libkernel32, "GetLogicalDrives") + getLogicalProcessorInformationEx = doGetProcAddress(libkernel32, "GetLogicalProcessorInformationEx") + getLongPathNameTransacted = doGetProcAddress(libkernel32, "GetLongPathNameTransactedW") + getLongPathName = doGetProcAddress(libkernel32, "GetLongPathNameW") + getMailslotInfo = doGetProcAddress(libkernel32, "GetMailslotInfo") + getMaximumProcessorCount = doGetProcAddress(libkernel32, "GetMaximumProcessorCount") + getMaximumProcessorGroupCount = doGetProcAddress(libkernel32, "GetMaximumProcessorGroupCount") + getModuleFileName = doGetProcAddress(libkernel32, "GetModuleFileNameW") + getModuleHandleEx = doGetProcAddress(libkernel32, "GetModuleHandleExW") + getModuleHandle = doGetProcAddress(libkernel32, "GetModuleHandleW") + getNamedPipeClientComputerName = doGetProcAddress(libkernel32, "GetNamedPipeClientComputerNameW") + getNamedPipeClientProcessId = doGetProcAddress(libkernel32, "GetNamedPipeClientProcessId") + getNamedPipeClientSessionId = doGetProcAddress(libkernel32, "GetNamedPipeClientSessionId") + getNamedPipeHandleState = doGetProcAddress(libkernel32, "GetNamedPipeHandleStateW") + getNamedPipeInfo = doGetProcAddress(libkernel32, "GetNamedPipeInfo") + getNamedPipeServerProcessId = doGetProcAddress(libkernel32, "GetNamedPipeServerProcessId") + getNamedPipeServerSessionId = doGetProcAddress(libkernel32, "GetNamedPipeServerSessionId") + getNativeSystemInfo = doGetProcAddress(libkernel32, "GetNativeSystemInfo") + getNumaHighestNodeNumber = doGetProcAddress(libkernel32, "GetNumaHighestNodeNumber") + getNumaNodeNumberFromHandle = doGetProcAddress(libkernel32, "GetNumaNodeNumberFromHandle") + getNumaProcessorNode = doGetProcAddress(libkernel32, "GetNumaProcessorNode") + getNumaProximityNode = doGetProcAddress(libkernel32, "GetNumaProximityNode") + getNumaProximityNodeEx = doGetProcAddress(libkernel32, "GetNumaProximityNodeEx") + getNumberOfConsoleInputEvents = doGetProcAddress(libkernel32, "GetNumberOfConsoleInputEvents") + getNumberOfConsoleMouseButtons = doGetProcAddress(libkernel32, "GetNumberOfConsoleMouseButtons") + getOEMCP = doGetProcAddress(libkernel32, "GetOEMCP") + getOverlappedResult = doGetProcAddress(libkernel32, "GetOverlappedResult") + getPriorityClass = doGetProcAddress(libkernel32, "GetPriorityClass") + getPrivateProfileInt = doGetProcAddress(libkernel32, "GetPrivateProfileIntW") + getPrivateProfileSectionNames = doGetProcAddress(libkernel32, "GetPrivateProfileSectionNamesW") + getPrivateProfileSection = doGetProcAddress(libkernel32, "GetPrivateProfileSectionW") + getPrivateProfileString = doGetProcAddress(libkernel32, "GetPrivateProfileStringW") + getPrivateProfileStruct = doGetProcAddress(libkernel32, "GetPrivateProfileStructW") + getProcAddress = doGetProcAddress(libkernel32, "GetProcAddress") + getProcessAffinityMask = doGetProcAddress(libkernel32, "GetProcessAffinityMask") + getProcessDEPPolicy = doGetProcAddress(libkernel32, "GetProcessDEPPolicy") + getProcessGroupAffinity = doGetProcAddress(libkernel32, "GetProcessGroupAffinity") + getProcessHandleCount = doGetProcAddress(libkernel32, "GetProcessHandleCount") + getProcessHeap = doGetProcAddress(libkernel32, "GetProcessHeap") + getProcessHeaps = doGetProcAddress(libkernel32, "GetProcessHeaps") + getProcessId = doGetProcAddress(libkernel32, "GetProcessId") + getProcessIdOfThread = doGetProcAddress(libkernel32, "GetProcessIdOfThread") + getProcessPriorityBoost = doGetProcAddress(libkernel32, "GetProcessPriorityBoost") + getProcessShutdownParameters = doGetProcAddress(libkernel32, "GetProcessShutdownParameters") + getProcessTimes = doGetProcAddress(libkernel32, "GetProcessTimes") + getProcessVersion = doGetProcAddress(libkernel32, "GetProcessVersion") + getProductInfo = doGetProcAddress(libkernel32, "GetProductInfo") + getProfileInt = doGetProcAddress(libkernel32, "GetProfileIntW") + getProfileSection = doGetProcAddress(libkernel32, "GetProfileSectionW") + getProfileString = doGetProcAddress(libkernel32, "GetProfileStringW") + getShortPathName = doGetProcAddress(libkernel32, "GetShortPathNameW") + getStartupInfo = doGetProcAddress(libkernel32, "GetStartupInfoW") + getStdHandle = doGetProcAddress(libkernel32, "GetStdHandle") + getStringScripts = doGetProcAddress(libkernel32, "GetStringScripts") + getSystemDefaultLCID = doGetProcAddress(libkernel32, "GetSystemDefaultLCID") + getSystemDefaultLangID = doGetProcAddress(libkernel32, "GetSystemDefaultLangID") + getSystemDefaultLocaleName = doGetProcAddress(libkernel32, "GetSystemDefaultLocaleName") + getSystemDefaultUILanguage = doGetProcAddress(libkernel32, "GetSystemDefaultUILanguage") + getSystemDirectory = doGetProcAddress(libkernel32, "GetSystemDirectoryW") + getSystemFirmwareTable = doGetProcAddress(libkernel32, "GetSystemFirmwareTable") + getSystemInfo = doGetProcAddress(libkernel32, "GetSystemInfo") + getSystemRegistryQuota = doGetProcAddress(libkernel32, "GetSystemRegistryQuota") + getSystemTime = doGetProcAddress(libkernel32, "GetSystemTime") + getSystemTimeAdjustment = doGetProcAddress(libkernel32, "GetSystemTimeAdjustment") + getSystemTimeAsFileTime = doGetProcAddress(libkernel32, "GetSystemTimeAsFileTime") + getSystemTimePreciseAsFileTime = doGetProcAddress(libkernel32, "GetSystemTimePreciseAsFileTime") + getSystemTimes = doGetProcAddress(libkernel32, "GetSystemTimes") + getSystemWindowsDirectory = doGetProcAddress(libkernel32, "GetSystemWindowsDirectoryW") + getSystemWow64Directory = doGetProcAddress(libkernel32, "GetSystemWow64DirectoryW") + getTapeParameters = doGetProcAddress(libkernel32, "GetTapeParameters") + getTapePosition = doGetProcAddress(libkernel32, "GetTapePosition") + getTapeStatus = doGetProcAddress(libkernel32, "GetTapeStatus") + getTempFileName = doGetProcAddress(libkernel32, "GetTempFileNameW") + getTempPath = doGetProcAddress(libkernel32, "GetTempPathW") + getThreadErrorMode = doGetProcAddress(libkernel32, "GetThreadErrorMode") + getThreadIOPendingFlag = doGetProcAddress(libkernel32, "GetThreadIOPendingFlag") + getThreadId = doGetProcAddress(libkernel32, "GetThreadId") + getThreadLocale = doGetProcAddress(libkernel32, "GetThreadLocale") + getThreadPriority = doGetProcAddress(libkernel32, "GetThreadPriority") + getThreadPriorityBoost = doGetProcAddress(libkernel32, "GetThreadPriorityBoost") + getThreadTimes = doGetProcAddress(libkernel32, "GetThreadTimes") + getThreadUILanguage = doGetProcAddress(libkernel32, "GetThreadUILanguage") + getTickCount = doGetProcAddress(libkernel32, "GetTickCount") + getTickCount64 = doGetProcAddress(libkernel32, "GetTickCount64") + getTimeFormatEx = doGetProcAddress(libkernel32, "GetTimeFormatEx") + getTimeFormat = doGetProcAddress(libkernel32, "GetTimeFormatW") + getUserDefaultLCID = doGetProcAddress(libkernel32, "GetUserDefaultLCID") + getUserDefaultLangID = doGetProcAddress(libkernel32, "GetUserDefaultLangID") + getUserDefaultLocaleName = doGetProcAddress(libkernel32, "GetUserDefaultLocaleName") + getUserDefaultUILanguage = doGetProcAddress(libkernel32, "GetUserDefaultUILanguage") + getVersion = doGetProcAddress(libkernel32, "GetVersion") + getVolumeInformationByHandleW = doGetProcAddress(libkernel32, "GetVolumeInformationByHandleW") + getVolumeInformation = doGetProcAddress(libkernel32, "GetVolumeInformationW") + getVolumeNameForVolumeMountPoint = doGetProcAddress(libkernel32, "GetVolumeNameForVolumeMountPointW") + getVolumePathName = doGetProcAddress(libkernel32, "GetVolumePathNameW") + getWindowsDirectory = doGetProcAddress(libkernel32, "GetWindowsDirectoryW") + getWriteWatch = doGetProcAddress(libkernel32, "GetWriteWatch") + globalAddAtom = doGetProcAddress(libkernel32, "GlobalAddAtomW") + globalAlloc = doGetProcAddress(libkernel32, "GlobalAlloc") + globalCompact = doGetProcAddress(libkernel32, "GlobalCompact") + globalDeleteAtom = doGetProcAddress(libkernel32, "GlobalDeleteAtom") + globalFindAtom = doGetProcAddress(libkernel32, "GlobalFindAtomW") + globalFix = doGetProcAddress(libkernel32, "GlobalFix") + globalFlags = doGetProcAddress(libkernel32, "GlobalFlags") + globalFree = doGetProcAddress(libkernel32, "GlobalFree") + globalGetAtomName = doGetProcAddress(libkernel32, "GlobalGetAtomNameW") + globalHandle = doGetProcAddress(libkernel32, "GlobalHandle") + globalLock = doGetProcAddress(libkernel32, "GlobalLock") + globalMemoryStatusEx = doGetProcAddress(libkernel32, "GlobalMemoryStatusEx") + globalReAlloc = doGetProcAddress(libkernel32, "GlobalReAlloc") + globalSize = doGetProcAddress(libkernel32, "GlobalSize") + globalUnWire = doGetProcAddress(libkernel32, "GlobalUnWire") + globalUnfix = doGetProcAddress(libkernel32, "GlobalUnfix") + globalUnlock = doGetProcAddress(libkernel32, "GlobalUnlock") + globalWire = doGetProcAddress(libkernel32, "GlobalWire") + heapAlloc = doGetProcAddress(libkernel32, "HeapAlloc") + heapCompact = doGetProcAddress(libkernel32, "HeapCompact") + heapCreate = doGetProcAddress(libkernel32, "HeapCreate") + heapDestroy = doGetProcAddress(libkernel32, "HeapDestroy") + heapFree = doGetProcAddress(libkernel32, "HeapFree") + heapLock = doGetProcAddress(libkernel32, "HeapLock") + heapReAlloc = doGetProcAddress(libkernel32, "HeapReAlloc") + heapSize = doGetProcAddress(libkernel32, "HeapSize") + heapUnlock = doGetProcAddress(libkernel32, "HeapUnlock") + heapValidate = doGetProcAddress(libkernel32, "HeapValidate") + idnToAscii = doGetProcAddress(libkernel32, "IdnToAscii") + idnToNameprepUnicode = doGetProcAddress(libkernel32, "IdnToNameprepUnicode") + idnToUnicode = doGetProcAddress(libkernel32, "IdnToUnicode") + initAtomTable = doGetProcAddress(libkernel32, "InitAtomTable") + initializeSRWLock = doGetProcAddress(libkernel32, "InitializeSRWLock") + isBadCodePtr = doGetProcAddress(libkernel32, "IsBadCodePtr") + isBadHugeReadPtr = doGetProcAddress(libkernel32, "IsBadHugeReadPtr") + isBadHugeWritePtr = doGetProcAddress(libkernel32, "IsBadHugeWritePtr") + isBadReadPtr = doGetProcAddress(libkernel32, "IsBadReadPtr") + isBadStringPtr = doGetProcAddress(libkernel32, "IsBadStringPtrW") + isBadWritePtr = doGetProcAddress(libkernel32, "IsBadWritePtr") + isDBCSLeadByte = doGetProcAddress(libkernel32, "IsDBCSLeadByte") + isDBCSLeadByteEx = doGetProcAddress(libkernel32, "IsDBCSLeadByteEx") + isDebuggerPresent = doGetProcAddress(libkernel32, "IsDebuggerPresent") + isProcessInJob = doGetProcAddress(libkernel32, "IsProcessInJob") + isProcessorFeaturePresent = doGetProcAddress(libkernel32, "IsProcessorFeaturePresent") + isSystemResumeAutomatic = doGetProcAddress(libkernel32, "IsSystemResumeAutomatic") + isThreadAFiber = doGetProcAddress(libkernel32, "IsThreadAFiber") + isValidCodePage = doGetProcAddress(libkernel32, "IsValidCodePage") + isValidLocale = doGetProcAddress(libkernel32, "IsValidLocale") + isValidLocaleName = doGetProcAddress(libkernel32, "IsValidLocaleName") + isWow64Process = doGetProcAddress(libkernel32, "IsWow64Process") + lCIDToLocaleName = doGetProcAddress(libkernel32, "LCIDToLocaleName") + lCMapString = doGetProcAddress(libkernel32, "LCMapStringW") + lZClose = doGetProcAddress(libkernel32, "LZClose") + lZCopy = doGetProcAddress(libkernel32, "LZCopy") + lZDone = doGetProcAddress(libkernel32, "LZDone") + lZInit = doGetProcAddress(libkernel32, "LZInit") + lZRead = doGetProcAddress(libkernel32, "LZRead") + lZSeek = doGetProcAddress(libkernel32, "LZSeek") + lZStart = doGetProcAddress(libkernel32, "LZStart") + loadLibraryEx = doGetProcAddress(libkernel32, "LoadLibraryExW") + loadLibrary = doGetProcAddress(libkernel32, "LoadLibraryW") + loadModule = doGetProcAddress(libkernel32, "LoadModule") + loadPackagedLibrary = doGetProcAddress(libkernel32, "LoadPackagedLibrary") + loadResource = doGetProcAddress(libkernel32, "LoadResource") + localAlloc = doGetProcAddress(libkernel32, "LocalAlloc") + localCompact = doGetProcAddress(libkernel32, "LocalCompact") + localFileTimeToFileTime = doGetProcAddress(libkernel32, "LocalFileTimeToFileTime") + localFlags = doGetProcAddress(libkernel32, "LocalFlags") + localFree = doGetProcAddress(libkernel32, "LocalFree") + localHandle = doGetProcAddress(libkernel32, "LocalHandle") + localLock = doGetProcAddress(libkernel32, "LocalLock") + localReAlloc = doGetProcAddress(libkernel32, "LocalReAlloc") + localShrink = doGetProcAddress(libkernel32, "LocalShrink") + localSize = doGetProcAddress(libkernel32, "LocalSize") + localUnlock = doGetProcAddress(libkernel32, "LocalUnlock") + localeNameToLCID = doGetProcAddress(libkernel32, "LocaleNameToLCID") + lockFile = doGetProcAddress(libkernel32, "LockFile") + lockFileEx = doGetProcAddress(libkernel32, "LockFileEx") + lockResource = doGetProcAddress(libkernel32, "LockResource") + mapViewOfFile = doGetProcAddress(libkernel32, "MapViewOfFile") + mapViewOfFileEx = doGetProcAddress(libkernel32, "MapViewOfFileEx") + mapViewOfFileExNuma = doGetProcAddress(libkernel32, "MapViewOfFileExNuma") + moveFileEx = doGetProcAddress(libkernel32, "MoveFileExW") + moveFile = doGetProcAddress(libkernel32, "MoveFileW") + mulDiv = doGetProcAddress(libkernel32, "MulDiv") + needCurrentDirectoryForExePath = doGetProcAddress(libkernel32, "NeedCurrentDirectoryForExePathW") + notifyUILanguageChange = doGetProcAddress(libkernel32, "NotifyUILanguageChange") + openEvent = doGetProcAddress(libkernel32, "OpenEventW") + openFileMapping = doGetProcAddress(libkernel32, "OpenFileMappingW") + openJobObject = doGetProcAddress(libkernel32, "OpenJobObjectW") + openMutex = doGetProcAddress(libkernel32, "OpenMutexW") + openPrivateNamespace = doGetProcAddress(libkernel32, "OpenPrivateNamespaceW") + openProcess = doGetProcAddress(libkernel32, "OpenProcess") + openSemaphore = doGetProcAddress(libkernel32, "OpenSemaphoreW") + openThread = doGetProcAddress(libkernel32, "OpenThread") + openWaitableTimer = doGetProcAddress(libkernel32, "OpenWaitableTimerW") + outputDebugString = doGetProcAddress(libkernel32, "OutputDebugStringW") + peekNamedPipe = doGetProcAddress(libkernel32, "PeekNamedPipe") + postQueuedCompletionStatus = doGetProcAddress(libkernel32, "PostQueuedCompletionStatus") + prepareTape = doGetProcAddress(libkernel32, "PrepareTape") + process32Next = doGetProcAddress(libkernel32, "Process32Next") + processIdToSessionId = doGetProcAddress(libkernel32, "ProcessIdToSessionId") + pulseEvent = doGetProcAddress(libkernel32, "PulseEvent") + purgeComm = doGetProcAddress(libkernel32, "PurgeComm") + queryActCtxSettingsW = doGetProcAddress(libkernel32, "QueryActCtxSettingsW") + queryActCtxW = doGetProcAddress(libkernel32, "QueryActCtxW") + queryDosDevice = doGetProcAddress(libkernel32, "QueryDosDeviceW") + queryFullProcessImageName = doGetProcAddress(libkernel32, "QueryFullProcessImageNameW") + queryIdleProcessorCycleTime = doGetProcAddress(libkernel32, "QueryIdleProcessorCycleTime") + queryIdleProcessorCycleTimeEx = doGetProcAddress(libkernel32, "QueryIdleProcessorCycleTimeEx") + queryMemoryResourceNotification = doGetProcAddress(libkernel32, "QueryMemoryResourceNotification") + queryPerformanceCounter = doGetProcAddress(libkernel32, "QueryPerformanceCounter") + queryPerformanceFrequency = doGetProcAddress(libkernel32, "QueryPerformanceFrequency") + queryProcessAffinityUpdateMode = doGetProcAddress(libkernel32, "QueryProcessAffinityUpdateMode") + queryProcessCycleTime = doGetProcAddress(libkernel32, "QueryProcessCycleTime") + queryThreadCycleTime = doGetProcAddress(libkernel32, "QueryThreadCycleTime") + queueUserWorkItem = doGetProcAddress(libkernel32, "QueueUserWorkItem") + raiseException = doGetProcAddress(libkernel32, "RaiseException") + reOpenFile = doGetProcAddress(libkernel32, "ReOpenFile") + readConsoleOutputAttribute = doGetProcAddress(libkernel32, "ReadConsoleOutputAttribute") + readConsoleOutputCharacter = doGetProcAddress(libkernel32, "ReadConsoleOutputCharacterW") + readConsole = doGetProcAddress(libkernel32, "ReadConsoleW") + readFile = doGetProcAddress(libkernel32, "ReadFile") + readProcessMemory = doGetProcAddress(libkernel32, "ReadProcessMemory") + reclaimVirtualMemory = doGetProcAddress(libkernel32, "ReclaimVirtualMemory") + registerApplicationRestart = doGetProcAddress(libkernel32, "RegisterApplicationRestart") + releaseActCtx = doGetProcAddress(libkernel32, "ReleaseActCtx") + releaseMutex = doGetProcAddress(libkernel32, "ReleaseMutex") + releaseSRWLockExclusive = doGetProcAddress(libkernel32, "ReleaseSRWLockExclusive") + releaseSRWLockShared = doGetProcAddress(libkernel32, "ReleaseSRWLockShared") + releaseSemaphore = doGetProcAddress(libkernel32, "ReleaseSemaphore") + removeDirectoryTransacted = doGetProcAddress(libkernel32, "RemoveDirectoryTransactedW") + removeDirectory = doGetProcAddress(libkernel32, "RemoveDirectoryW") + removeSecureMemoryCacheCallback = doGetProcAddress(libkernel32, "RemoveSecureMemoryCacheCallback") + removeVectoredContinueHandler = doGetProcAddress(libkernel32, "RemoveVectoredContinueHandler") + removeVectoredExceptionHandler = doGetProcAddress(libkernel32, "RemoveVectoredExceptionHandler") + replaceFile = doGetProcAddress(libkernel32, "ReplaceFileW") + replacePartitionUnit = doGetProcAddress(libkernel32, "ReplacePartitionUnit") + requestDeviceWakeup = doGetProcAddress(libkernel32, "RequestDeviceWakeup") + resetEvent = doGetProcAddress(libkernel32, "ResetEvent") + resetWriteWatch = doGetProcAddress(libkernel32, "ResetWriteWatch") + resolveLocaleName = doGetProcAddress(libkernel32, "ResolveLocaleName") + restoreLastError = doGetProcAddress(libkernel32, "RestoreLastError") + resumeThread = doGetProcAddress(libkernel32, "ResumeThread") + searchPath = doGetProcAddress(libkernel32, "SearchPathW") + setCalendarInfo = doGetProcAddress(libkernel32, "SetCalendarInfoW") + setCommBreak = doGetProcAddress(libkernel32, "SetCommBreak") + setCommMask = doGetProcAddress(libkernel32, "SetCommMask") + setComputerName = doGetProcAddress(libkernel32, "SetComputerNameW") + setConsoleActiveScreenBuffer = doGetProcAddress(libkernel32, "SetConsoleActiveScreenBuffer") + setConsoleCP = doGetProcAddress(libkernel32, "SetConsoleCP") + setConsoleCursorPosition = doGetProcAddress(libkernel32, "SetConsoleCursorPosition") + setConsoleMode = doGetProcAddress(libkernel32, "SetConsoleMode") + setConsoleOutputCP = doGetProcAddress(libkernel32, "SetConsoleOutputCP") + setConsoleScreenBufferInfoEx = doGetProcAddress(libkernel32, "SetConsoleScreenBufferInfoEx") + setConsoleScreenBufferSize = doGetProcAddress(libkernel32, "SetConsoleScreenBufferSize") + setConsoleTextAttribute = doGetProcAddress(libkernel32, "SetConsoleTextAttribute") + setConsoleTitle = doGetProcAddress(libkernel32, "SetConsoleTitleW") + setConsoleWindowInfo = doGetProcAddress(libkernel32, "SetConsoleWindowInfo") + setCurrentDirectory = doGetProcAddress(libkernel32, "SetCurrentDirectoryW") + setDllDirectory = doGetProcAddress(libkernel32, "SetDllDirectoryW") + setEndOfFile = doGetProcAddress(libkernel32, "SetEndOfFile") + setEnvironmentVariable = doGetProcAddress(libkernel32, "SetEnvironmentVariableW") + setErrorMode = doGetProcAddress(libkernel32, "SetErrorMode") + setEvent = doGetProcAddress(libkernel32, "SetEvent") + setFileApisToANSI = doGetProcAddress(libkernel32, "SetFileApisToANSI") + setFileApisToOEM = doGetProcAddress(libkernel32, "SetFileApisToOEM") + setFileAttributesTransacted = doGetProcAddress(libkernel32, "SetFileAttributesTransactedW") + setFileAttributes = doGetProcAddress(libkernel32, "SetFileAttributesW") + setFileBandwidthReservation = doGetProcAddress(libkernel32, "SetFileBandwidthReservation") + setFileCompletionNotificationModes = doGetProcAddress(libkernel32, "SetFileCompletionNotificationModes") + setFileIoOverlappedRange = doGetProcAddress(libkernel32, "SetFileIoOverlappedRange") + setFilePointer = doGetProcAddress(libkernel32, "SetFilePointer") + setFileShortName = doGetProcAddress(libkernel32, "SetFileShortNameW") + setFileTime = doGetProcAddress(libkernel32, "SetFileTime") + setFileValidData = doGetProcAddress(libkernel32, "SetFileValidData") + setFirmwareEnvironmentVariable = doGetProcAddress(libkernel32, "SetFirmwareEnvironmentVariableW") + setHandleCount = doGetProcAddress(libkernel32, "SetHandleCount") + setHandleInformation = doGetProcAddress(libkernel32, "SetHandleInformation") + setLastError = doGetProcAddress(libkernel32, "SetLastError") + setLocalTime = doGetProcAddress(libkernel32, "SetLocalTime") + setLocaleInfo = doGetProcAddress(libkernel32, "SetLocaleInfoW") + setMailslotInfo = doGetProcAddress(libkernel32, "SetMailslotInfo") + setMessageWaitingIndicator = doGetProcAddress(libkernel32, "SetMessageWaitingIndicator") + setNamedPipeHandleState = doGetProcAddress(libkernel32, "SetNamedPipeHandleState") + setPriorityClass = doGetProcAddress(libkernel32, "SetPriorityClass") + setProcessAffinityMask = doGetProcAddress(libkernel32, "SetProcessAffinityMask") + setProcessAffinityUpdateMode = doGetProcAddress(libkernel32, "SetProcessAffinityUpdateMode") + setProcessDEPPolicy = doGetProcAddress(libkernel32, "SetProcessDEPPolicy") + setProcessPreferredUILanguages = doGetProcAddress(libkernel32, "SetProcessPreferredUILanguages") + setProcessPriorityBoost = doGetProcAddress(libkernel32, "SetProcessPriorityBoost") + setProcessShutdownParameters = doGetProcAddress(libkernel32, "SetProcessShutdownParameters") + setProcessWorkingSetSize = doGetProcAddress(libkernel32, "SetProcessWorkingSetSize") + setProcessWorkingSetSizeEx = doGetProcAddress(libkernel32, "SetProcessWorkingSetSizeEx") + setSearchPathMode = doGetProcAddress(libkernel32, "SetSearchPathMode") + setStdHandle = doGetProcAddress(libkernel32, "SetStdHandle") + setStdHandleEx = doGetProcAddress(libkernel32, "SetStdHandleEx") + setSystemFileCacheSize = doGetProcAddress(libkernel32, "SetSystemFileCacheSize") + setSystemPowerState = doGetProcAddress(libkernel32, "SetSystemPowerState") + setSystemTime = doGetProcAddress(libkernel32, "SetSystemTime") + setSystemTimeAdjustment = doGetProcAddress(libkernel32, "SetSystemTimeAdjustment") + setTapeParameters = doGetProcAddress(libkernel32, "SetTapeParameters") + setTapePosition = doGetProcAddress(libkernel32, "SetTapePosition") + setThreadAffinityMask = doGetProcAddress(libkernel32, "SetThreadAffinityMask") + setThreadErrorMode = doGetProcAddress(libkernel32, "SetThreadErrorMode") + setThreadIdealProcessor = doGetProcAddress(libkernel32, "SetThreadIdealProcessor") + setThreadLocale = doGetProcAddress(libkernel32, "SetThreadLocale") + setThreadPreferredUILanguages = doGetProcAddress(libkernel32, "SetThreadPreferredUILanguages") + setThreadPriority = doGetProcAddress(libkernel32, "SetThreadPriority") + setThreadPriorityBoost = doGetProcAddress(libkernel32, "SetThreadPriorityBoost") + setThreadStackGuarantee = doGetProcAddress(libkernel32, "SetThreadStackGuarantee") + setThreadUILanguage = doGetProcAddress(libkernel32, "SetThreadUILanguage") + setUserGeoID = doGetProcAddress(libkernel32, "SetUserGeoID") + setVolumeLabel = doGetProcAddress(libkernel32, "SetVolumeLabelW") + setVolumeMountPoint = doGetProcAddress(libkernel32, "SetVolumeMountPointW") + setupComm = doGetProcAddress(libkernel32, "SetupComm") + signalObjectAndWait = doGetProcAddress(libkernel32, "SignalObjectAndWait") + sizeofResource = doGetProcAddress(libkernel32, "SizeofResource") + sleep = doGetProcAddress(libkernel32, "Sleep") + sleepEx = doGetProcAddress(libkernel32, "SleepEx") + suspendThread = doGetProcAddress(libkernel32, "SuspendThread") + switchToFiber = doGetProcAddress(libkernel32, "SwitchToFiber") + switchToThread = doGetProcAddress(libkernel32, "SwitchToThread") + systemTimeToFileTime = doGetProcAddress(libkernel32, "SystemTimeToFileTime") + terminateJobObject = doGetProcAddress(libkernel32, "TerminateJobObject") + terminateProcess = doGetProcAddress(libkernel32, "TerminateProcess") + terminateThread = doGetProcAddress(libkernel32, "TerminateThread") + tlsAlloc = doGetProcAddress(libkernel32, "TlsAlloc") + tlsFree = doGetProcAddress(libkernel32, "TlsFree") + tlsGetValue = doGetProcAddress(libkernel32, "TlsGetValue") + tlsSetValue = doGetProcAddress(libkernel32, "TlsSetValue") + toolhelp32ReadProcessMemory = doGetProcAddress(libkernel32, "Toolhelp32ReadProcessMemory") + transactNamedPipe = doGetProcAddress(libkernel32, "TransactNamedPipe") + transmitCommChar = doGetProcAddress(libkernel32, "TransmitCommChar") + tryAcquireSRWLockExclusive = doGetProcAddress(libkernel32, "TryAcquireSRWLockExclusive") + tryAcquireSRWLockShared = doGetProcAddress(libkernel32, "TryAcquireSRWLockShared") + unlockFile = doGetProcAddress(libkernel32, "UnlockFile") + unlockFileEx = doGetProcAddress(libkernel32, "UnlockFileEx") + unmapViewOfFile = doGetProcAddress(libkernel32, "UnmapViewOfFile") + unregisterApplicationRecoveryCallback = doGetProcAddress(libkernel32, "UnregisterApplicationRecoveryCallback") + unregisterApplicationRestart = doGetProcAddress(libkernel32, "UnregisterApplicationRestart") + unregisterWait = doGetProcAddress(libkernel32, "UnregisterWait") + unregisterWaitEx = doGetProcAddress(libkernel32, "UnregisterWaitEx") + updateResource = doGetProcAddress(libkernel32, "UpdateResourceW") + verLanguageName = doGetProcAddress(libkernel32, "VerLanguageNameW") + verifyScripts = doGetProcAddress(libkernel32, "VerifyScripts") + virtualAlloc = doGetProcAddress(libkernel32, "VirtualAlloc") + virtualAllocEx = doGetProcAddress(libkernel32, "VirtualAllocEx") + virtualAllocExNuma = doGetProcAddress(libkernel32, "VirtualAllocExNuma") + virtualFree = doGetProcAddress(libkernel32, "VirtualFree") + virtualFreeEx = doGetProcAddress(libkernel32, "VirtualFreeEx") + virtualLock = doGetProcAddress(libkernel32, "VirtualLock") + virtualProtect = doGetProcAddress(libkernel32, "VirtualProtect") + virtualProtectEx = doGetProcAddress(libkernel32, "VirtualProtectEx") + virtualUnlock = doGetProcAddress(libkernel32, "VirtualUnlock") + wTSGetActiveConsoleSessionId = doGetProcAddress(libkernel32, "WTSGetActiveConsoleSessionId") + waitCommEvent = doGetProcAddress(libkernel32, "WaitCommEvent") + waitForMultipleObjects = doGetProcAddress(libkernel32, "WaitForMultipleObjects") + waitForMultipleObjectsEx = doGetProcAddress(libkernel32, "WaitForMultipleObjectsEx") + waitForSingleObject = doGetProcAddress(libkernel32, "WaitForSingleObject") + waitForSingleObjectEx = doGetProcAddress(libkernel32, "WaitForSingleObjectEx") + waitNamedPipe = doGetProcAddress(libkernel32, "WaitNamedPipeW") + werGetFlags = doGetProcAddress(libkernel32, "WerGetFlags") + werRegisterMemoryBlock = doGetProcAddress(libkernel32, "WerRegisterMemoryBlock") + werRegisterRuntimeExceptionModule = doGetProcAddress(libkernel32, "WerRegisterRuntimeExceptionModule") + werSetFlags = doGetProcAddress(libkernel32, "WerSetFlags") + werUnregisterFile = doGetProcAddress(libkernel32, "WerUnregisterFile") + werUnregisterMemoryBlock = doGetProcAddress(libkernel32, "WerUnregisterMemoryBlock") + werUnregisterRuntimeExceptionModule = doGetProcAddress(libkernel32, "WerUnregisterRuntimeExceptionModule") + winExec = doGetProcAddress(libkernel32, "WinExec") + wow64DisableWow64FsRedirection = doGetProcAddress(libkernel32, "Wow64DisableWow64FsRedirection") + wow64EnableWow64FsRedirection = doGetProcAddress(libkernel32, "Wow64EnableWow64FsRedirection") + wow64RevertWow64FsRedirection = doGetProcAddress(libkernel32, "Wow64RevertWow64FsRedirection") + wow64SuspendThread = doGetProcAddress(libkernel32, "Wow64SuspendThread") + writeConsoleOutputAttribute = doGetProcAddress(libkernel32, "WriteConsoleOutputAttribute") + writeConsoleOutputCharacter = doGetProcAddress(libkernel32, "WriteConsoleOutputCharacterW") + writeConsole = doGetProcAddress(libkernel32, "WriteConsoleW") + writeFile = doGetProcAddress(libkernel32, "WriteFile") + writePrivateProfileSection = doGetProcAddress(libkernel32, "WritePrivateProfileSectionW") + writePrivateProfileString = doGetProcAddress(libkernel32, "WritePrivateProfileStringW") + writePrivateProfileStruct = doGetProcAddress(libkernel32, "WritePrivateProfileStructW") + writeProcessMemory = doGetProcAddress(libkernel32, "WriteProcessMemory") + writeProfileSection = doGetProcAddress(libkernel32, "WriteProfileSectionW") + writeProfileString = doGetProcAddress(libkernel32, "WriteProfileStringW") + writeTapemark = doGetProcAddress(libkernel32, "WriteTapemark") + zombifyActCtx = doGetProcAddress(libkernel32, "ZombifyActCtx") + lstrcat = doGetProcAddress(libkernel32, "lstrcatW") + lstrcmp = doGetProcAddress(libkernel32, "lstrcmpW") + lstrcmpi = doGetProcAddress(libkernel32, "lstrcmpiW") + lstrcpy = doGetProcAddress(libkernel32, "lstrcpyW") + lstrcpyn = doGetProcAddress(libkernel32, "lstrcpynW") + lstrlen = doGetProcAddress(libkernel32, "lstrlenW") + closeConsoleHandle = doGetProcAddress(libkernel32, "CloseConsoleHandle") + closeProfileUserMapping = doGetProcAddress(libkernel32, "CloseProfileUserMapping") + cmdBatNotification = doGetProcAddress(libkernel32, "CmdBatNotification") + delayLoadFailureHook = doGetProcAddress(libkernel32, "DelayLoadFailureHook") + duplicateConsoleHandle = doGetProcAddress(libkernel32, "DuplicateConsoleHandle") + expungeConsoleCommandHistory = doGetProcAddress(libkernel32, "ExpungeConsoleCommandHistoryW") + getConsoleCommandHistoryLength = doGetProcAddress(libkernel32, "GetConsoleCommandHistoryLengthW") + getConsoleCommandHistory = doGetProcAddress(libkernel32, "GetConsoleCommandHistoryW") + getConsoleInputExeName = doGetProcAddress(libkernel32, "GetConsoleInputExeNameW") + getConsoleInputWaitHandle = doGetProcAddress(libkernel32, "GetConsoleInputWaitHandle") + getConsoleKeyboardLayoutName = doGetProcAddress(libkernel32, "GetConsoleKeyboardLayoutNameW") + getNumberOfConsoleFonts = doGetProcAddress(libkernel32, "GetNumberOfConsoleFonts") + k32EmptyWorkingSet = doGetProcAddress(libkernel32, "K32EmptyWorkingSet") + k32EnumDeviceDrivers = doGetProcAddress(libkernel32, "K32EnumDeviceDrivers") + k32EnumPageFiles = doGetProcAddress(libkernel32, "K32EnumPageFilesW") + k32EnumProcessModules = doGetProcAddress(libkernel32, "K32EnumProcessModules") + k32EnumProcessModulesEx = doGetProcAddress(libkernel32, "K32EnumProcessModulesEx") + k32EnumProcesses = doGetProcAddress(libkernel32, "K32EnumProcesses") + k32GetDeviceDriverBaseName = doGetProcAddress(libkernel32, "K32GetDeviceDriverBaseNameW") + k32GetDeviceDriverFileName = doGetProcAddress(libkernel32, "K32GetDeviceDriverFileNameW") + k32GetMappedFileName = doGetProcAddress(libkernel32, "K32GetMappedFileNameW") + k32GetModuleBaseName = doGetProcAddress(libkernel32, "K32GetModuleBaseNameW") + k32GetModuleFileNameEx = doGetProcAddress(libkernel32, "K32GetModuleFileNameExW") + k32GetModuleInformation = doGetProcAddress(libkernel32, "K32GetModuleInformation") + k32GetProcessImageFileName = doGetProcAddress(libkernel32, "K32GetProcessImageFileNameW") + k32GetProcessMemoryInfo = doGetProcAddress(libkernel32, "K32GetProcessMemoryInfo") + k32GetWsChanges = doGetProcAddress(libkernel32, "K32GetWsChanges") + k32InitializeProcessForWsWatch = doGetProcAddress(libkernel32, "K32InitializeProcessForWsWatch") + k32QueryWorkingSet = doGetProcAddress(libkernel32, "K32QueryWorkingSet") + k32QueryWorkingSetEx = doGetProcAddress(libkernel32, "K32QueryWorkingSetEx") + openConsoleW = doGetProcAddress(libkernel32, "OpenConsoleW") + openProfileUserMapping = doGetProcAddress(libkernel32, "OpenProfileUserMapping") + rtlCaptureStackBackTrace = doGetProcAddress(libkernel32, "RtlCaptureStackBackTrace") + rtlCompareMemory = doGetProcAddress(libkernel32, "RtlCompareMemory") + rtlCopyMemory = doGetProcAddress(libkernel32, "RtlCopyMemory") + rtlFillMemory = doGetProcAddress(libkernel32, "RtlFillMemory") + rtlMoveMemory = doGetProcAddress(libkernel32, "RtlMoveMemory") + rtlPcToFileHeader = doGetProcAddress(libkernel32, "RtlPcToFileHeader") + rtlZeroMemory = doGetProcAddress(libkernel32, "RtlZeroMemory") + setCPGlobal = doGetProcAddress(libkernel32, "SetCPGlobal") + setConsoleFont = doGetProcAddress(libkernel32, "SetConsoleFont") + setConsoleIcon = doGetProcAddress(libkernel32, "SetConsoleIcon") + setConsoleInputExeName = doGetProcAddress(libkernel32, "SetConsoleInputExeNameW") + setConsoleKeyShortcuts = doGetProcAddress(libkernel32, "SetConsoleKeyShortcuts") + setTermsrvAppInstallMode = doGetProcAddress(libkernel32, "SetTermsrvAppInstallMode") + termsrvAppInstallMode = doGetProcAddress(libkernel32, "TermsrvAppInstallMode") + uTRegister = doGetProcAddress(libkernel32, "UTRegister") + uTUnRegister = doGetProcAddress(libkernel32, "UTUnRegister") + verSetConditionMask = doGetProcAddress(libkernel32, "VerSetConditionMask") + verifyConsoleIoHandle = doGetProcAddress(libkernel32, "VerifyConsoleIoHandle") +} + +func AcquireSRWLockExclusive(sRWLock PSRWLOCK) { + syscall3(acquireSRWLockExclusive, 1, + uintptr(unsafe.Pointer(sRWLock)), + 0, + 0) +} + +func AcquireSRWLockShared(sRWLock PSRWLOCK) { + syscall3(acquireSRWLockShared, 1, + uintptr(unsafe.Pointer(sRWLock)), + 0, + 0) +} + +func ActivateActCtx(hActCtx HANDLE, lpCookie *ULONG_PTR) bool { + ret1 := syscall3(activateActCtx, 2, + uintptr(hActCtx), + uintptr(unsafe.Pointer(lpCookie)), + 0) + return ret1 != 0 +} + +func AddAtom(lpString string) ATOM { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(addAtom, 1, + uintptr(unsafe.Pointer(&lpStringStr[0])), + 0, + 0) + return ATOM(ret1) +} + +func AddConsoleAlias(source LPWSTR, target LPWSTR, exeName LPWSTR) bool { + ret1 := syscall3(addConsoleAlias, 3, + uintptr(unsafe.Pointer(source)), + uintptr(unsafe.Pointer(target)), + uintptr(unsafe.Pointer(exeName))) + return ret1 != 0 +} + +func AddIntegrityLabelToBoundaryDescriptor(boundaryDescriptor *HANDLE, integrityLabel PSID) bool { + ret1 := syscall3(addIntegrityLabelToBoundaryDescriptor, 2, + uintptr(unsafe.Pointer(boundaryDescriptor)), + uintptr(integrityLabel), + 0) + return ret1 != 0 +} + +func AddRefActCtx(hActCtx HANDLE) { + syscall3(addRefActCtx, 1, + uintptr(hActCtx), + 0, + 0) +} + +func AddSIDToBoundaryDescriptor(boundaryDescriptor *HANDLE, requiredSid PSID) bool { + ret1 := syscall3(addSIDToBoundaryDescriptor, 2, + uintptr(unsafe.Pointer(boundaryDescriptor)), + uintptr(requiredSid), + 0) + return ret1 != 0 +} + +func AddSecureMemoryCacheCallback(pfnCallBack PSECURE_MEMORY_CACHE_CALLBACK) bool { + pfnCallBackCallback := syscall.NewCallback(func(AddrRawArg PVOID, RangeRawArg SIZE_T) uintptr { + ret := pfnCallBack(AddrRawArg, RangeRawArg) + return uintptr(ret) + }) + ret1 := syscall3(addSecureMemoryCacheCallback, 1, + pfnCallBackCallback, + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PVECTORED_EXCEPTION_HANDLER +// func AddVectoredContinueHandler(first ULONG, handler PVECTORED_EXCEPTION_HANDLER) uintptr + +// TODO: Unknown type(s): PVECTORED_EXCEPTION_HANDLER +// func AddVectoredExceptionHandler(first ULONG, handler PVECTORED_EXCEPTION_HANDLER) uintptr + +func AllocConsole() bool { + ret1 := syscall3(allocConsole, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PULONG_PTR +// func AllocateUserPhysicalPages(hProcess HANDLE, numberOfPages PULONG_PTR, pageArray PULONG_PTR) bool + +// TODO: Unknown type(s): PULONG_PTR +// func AllocateUserPhysicalPagesNuma(hProcess HANDLE, numberOfPages PULONG_PTR, pageArray PULONG_PTR, nndPreferred DWORD) bool + +func ApplicationRecoveryFinished(bSuccess bool) { + syscall3(applicationRecoveryFinished, 1, + getUintptrFromBool(bSuccess), + 0, + 0) +} + +func ApplicationRecoveryInProgress(pbCancelled *BOOL) HRESULT { + ret1 := syscall3(applicationRecoveryInProgress, 1, + uintptr(unsafe.Pointer(pbCancelled)), + 0, + 0) + return HRESULT(ret1) +} + +func AreFileApisANSI() bool { + ret1 := syscall3(areFileApisANSI, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func AssignProcessToJobObject(hJob HANDLE, hProcess HANDLE) bool { + ret1 := syscall3(assignProcessToJobObject, 2, + uintptr(hJob), + uintptr(hProcess), + 0) + return ret1 != 0 +} + +func AttachConsole(dwProcessId DWORD) bool { + ret1 := syscall3(attachConsole, 1, + uintptr(dwProcessId), + 0, + 0) + return ret1 != 0 +} + +func BackupRead(hFile HANDLE, lpBuffer *byte, nNumberOfBytesToRead DWORD, lpNumberOfBytesRead *uint32, bAbort bool, bProcessSecurity bool, lpContext *LPVOID) bool { + ret1 := syscall9(backupRead, 7, + uintptr(hFile), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(nNumberOfBytesToRead), + uintptr(unsafe.Pointer(lpNumberOfBytesRead)), + getUintptrFromBool(bAbort), + getUintptrFromBool(bProcessSecurity), + uintptr(unsafe.Pointer(lpContext)), + 0, + 0) + return ret1 != 0 +} + +func BackupSeek(hFile HANDLE, dwLowBytesToSeek DWORD, dwHighBytesToSeek DWORD, lpdwLowByteSeeked *uint32, lpdwHighByteSeeked *uint32, lpContext *LPVOID) bool { + ret1 := syscall6(backupSeek, 6, + uintptr(hFile), + uintptr(dwLowBytesToSeek), + uintptr(dwHighBytesToSeek), + uintptr(unsafe.Pointer(lpdwLowByteSeeked)), + uintptr(unsafe.Pointer(lpdwHighByteSeeked)), + uintptr(unsafe.Pointer(lpContext))) + return ret1 != 0 +} + +func BackupWrite(hFile HANDLE, lpBuffer *byte, nNumberOfBytesToWrite DWORD, lpNumberOfBytesWritten *uint32, bAbort bool, bProcessSecurity bool, lpContext *LPVOID) bool { + ret1 := syscall9(backupWrite, 7, + uintptr(hFile), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(nNumberOfBytesToWrite), + uintptr(unsafe.Pointer(lpNumberOfBytesWritten)), + getUintptrFromBool(bAbort), + getUintptrFromBool(bProcessSecurity), + uintptr(unsafe.Pointer(lpContext)), + 0, + 0) + return ret1 != 0 +} + +func Beep(dwFreq DWORD, dwDuration DWORD) bool { + ret1 := syscall3(beep, 2, + uintptr(dwFreq), + uintptr(dwDuration), + 0) + return ret1 != 0 +} + +func BeginUpdateResource(pFileName string, bDeleteExistingResources bool) HANDLE { + pFileNameStr := unicode16FromString(pFileName) + ret1 := syscall3(beginUpdateResource, 2, + uintptr(unsafe.Pointer(&pFileNameStr[0])), + getUintptrFromBool(bDeleteExistingResources), + 0) + return HANDLE(ret1) +} + +// TODO: Unknown type(s): LPOVERLAPPED_COMPLETION_ROUTINE +// func BindIoCompletionCallback(fileHandle HANDLE, function LPOVERLAPPED_COMPLETION_ROUTINE, flags ULONG) bool + +// TODO: Unknown type(s): LPCOMMTIMEOUTS, LPDCB +// func BuildCommDCBAndTimeouts(lpDef string, lpDCB LPDCB, lpCommTimeouts LPCOMMTIMEOUTS) bool + +// TODO: Unknown type(s): LPDCB +// func BuildCommDCB(lpDef string, lpDCB LPDCB) bool + +func CallNamedPipe(lpNamedPipeName string, lpInBuffer LPVOID, nInBufferSize DWORD, lpOutBuffer LPVOID, nOutBufferSize DWORD, lpBytesRead *uint32, nTimeOut DWORD) bool { + lpNamedPipeNameStr := unicode16FromString(lpNamedPipeName) + ret1 := syscall9(callNamedPipe, 7, + uintptr(unsafe.Pointer(&lpNamedPipeNameStr[0])), + uintptr(unsafe.Pointer(lpInBuffer)), + uintptr(nInBufferSize), + uintptr(unsafe.Pointer(lpOutBuffer)), + uintptr(nOutBufferSize), + uintptr(unsafe.Pointer(lpBytesRead)), + uintptr(nTimeOut), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PTP_CALLBACK_INSTANCE +// func CallbackMayRunLong(pci PTP_CALLBACK_INSTANCE) bool + +func CancelDeviceWakeupRequest(hDevice HANDLE) bool { + ret1 := syscall3(cancelDeviceWakeupRequest, 1, + uintptr(hDevice), + 0, + 0) + return ret1 != 0 +} + +func CancelIo(hFile HANDLE) bool { + ret1 := syscall3(cancelIo, 1, + uintptr(hFile), + 0, + 0) + return ret1 != 0 +} + +func CancelIoEx(hFile HANDLE, lpOverlapped *OVERLAPPED) bool { + ret1 := syscall3(cancelIoEx, 2, + uintptr(hFile), + uintptr(unsafe.Pointer(lpOverlapped)), + 0) + return ret1 != 0 +} + +func CancelSynchronousIo(hThread HANDLE) bool { + ret1 := syscall3(cancelSynchronousIo, 1, + uintptr(hThread), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PTP_IO +// func CancelThreadpoolIo(pio PTP_IO) + +func CancelTimerQueueTimer(timerQueue HANDLE, timer HANDLE) bool { + ret1 := syscall3(cancelTimerQueueTimer, 2, + uintptr(timerQueue), + uintptr(timer), + 0) + return ret1 != 0 +} + +func CancelWaitableTimer(hTimer HANDLE) bool { + ret1 := syscall3(cancelWaitableTimer, 1, + uintptr(hTimer), + 0, + 0) + return ret1 != 0 +} + +func ChangeTimerQueueTimer(timerQueue HANDLE, timer HANDLE, dueTime ULONG, period ULONG) bool { + ret1 := syscall6(changeTimerQueueTimer, 4, + uintptr(timerQueue), + uintptr(timer), + uintptr(dueTime), + uintptr(period), + 0, + 0) + return ret1 != 0 +} + +func CheckNameLegalDOS8Dot3(lpName string, lpOemName LPSTR, oemNameSize DWORD, pbNameContainsSpaces *BOOL, pbNameLegal *BOOL) bool { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall6(checkNameLegalDOS8Dot3, 5, + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(unsafe.Pointer(lpOemName)), + uintptr(oemNameSize), + uintptr(unsafe.Pointer(pbNameContainsSpaces)), + uintptr(unsafe.Pointer(pbNameLegal)), + 0) + return ret1 != 0 +} + +func CheckRemoteDebuggerPresent(hProcess HANDLE, pbDebuggerPresent *BOOL) bool { + ret1 := syscall3(checkRemoteDebuggerPresent, 2, + uintptr(hProcess), + uintptr(unsafe.Pointer(pbDebuggerPresent)), + 0) + return ret1 != 0 +} + +func ClearCommBreak(hFile HANDLE) bool { + ret1 := syscall3(clearCommBreak, 1, + uintptr(hFile), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPCOMSTAT +// func ClearCommError(hFile HANDLE, lpErrors *uint32, lpStat LPCOMSTAT) bool + +func CloseHandle(hObject HANDLE) bool { + ret1 := syscall3(closeHandle, 1, + uintptr(hObject), + 0, + 0) + return ret1 != 0 +} + +func ClosePrivateNamespace(handle HANDLE, flags ULONG) BOOLEAN { + ret1 := syscall3(closePrivateNamespace, 2, + uintptr(handle), + uintptr(flags), + 0) + return BOOLEAN(ret1) +} + +// TODO: Unknown type(s): PTP_POOL +// func CloseThreadpool(ptpp PTP_POOL) + +// TODO: Unknown type(s): PTP_CLEANUP_GROUP +// func CloseThreadpoolCleanupGroup(ptpcg PTP_CLEANUP_GROUP) + +// TODO: Unknown type(s): PTP_CLEANUP_GROUP +// func CloseThreadpoolCleanupGroupMembers(ptpcg PTP_CLEANUP_GROUP, fCancelPendingCallbacks bool, pvCleanupContext uintptr) + +// TODO: Unknown type(s): PTP_IO +// func CloseThreadpoolIo(pio PTP_IO) + +// TODO: Unknown type(s): PTP_TIMER +// func CloseThreadpoolTimer(pti PTP_TIMER) + +// TODO: Unknown type(s): PTP_WAIT +// func CloseThreadpoolWait(pwa PTP_WAIT) + +// TODO: Unknown type(s): PTP_WORK +// func CloseThreadpoolWork(pwk PTP_WORK) + +// TODO: Unknown type(s): LPCOMMCONFIG +// func CommConfigDialog(lpszName string, hWnd HWND, lpCC LPCOMMCONFIG) bool + +func CompareFileTime(lpFileTime1 /*const*/ *FILETIME, lpFileTime2 /*const*/ *FILETIME) LONG { + ret1 := syscall3(compareFileTime, 2, + uintptr(unsafe.Pointer(lpFileTime1)), + uintptr(unsafe.Pointer(lpFileTime2)), + 0) + return LONG(ret1) +} + +// TODO: Unknown type(s): LPCWCH, LPNLSVERSIONINFO +// func CompareStringEx(lpLocaleName string, dwCmpFlags DWORD, lpString1 LPCWCH, cchCount1 int32, lpString2 LPCWCH, cchCount2 int32, lpVersionInformation LPNLSVERSIONINFO, lpReserved LPVOID, lParam LPARAM) int32 + +// TODO: Unknown type(s): LPCWCH +// func CompareStringOrdinal(lpString1 LPCWCH, cchCount1 int32, lpString2 LPCWCH, cchCount2 int32, bIgnoreCase bool) int32 + +// TODO: Unknown type(s): PCNZWCH +// func CompareString(locale LCID, dwCmpFlags DWORD, lpString1 PCNZWCH, cchCount1 int32, lpString2 PCNZWCH, cchCount2 int32) int32 + +func ConnectNamedPipe(hNamedPipe HANDLE, lpOverlapped *OVERLAPPED) bool { + ret1 := syscall3(connectNamedPipe, 2, + uintptr(hNamedPipe), + uintptr(unsafe.Pointer(lpOverlapped)), + 0) + return ret1 != 0 +} + +func ContinueDebugEvent(dwProcessId DWORD, dwThreadId DWORD, dwContinueStatus DWORD) bool { + ret1 := syscall3(continueDebugEvent, 3, + uintptr(dwProcessId), + uintptr(dwThreadId), + uintptr(dwContinueStatus)) + return ret1 != 0 +} + +func ConvertDefaultLocale(locale LCID) LCID { + ret1 := syscall3(convertDefaultLocale, 1, + uintptr(locale), + 0, + 0) + return LCID(ret1) +} + +func ConvertFiberToThread() bool { + ret1 := syscall3(convertFiberToThread, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func ConvertThreadToFiber(lpParameter LPVOID) LPVOID { + ret1 := syscall3(convertThreadToFiber, 1, + uintptr(unsafe.Pointer(lpParameter)), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func ConvertThreadToFiberEx(lpParameter LPVOID, dwFlags DWORD) LPVOID { + ret1 := syscall3(convertThreadToFiberEx, 2, + uintptr(unsafe.Pointer(lpParameter)), + uintptr(dwFlags), + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): LPPROGRESS_ROUTINE +// func CopyFileEx(lpExistingFileName string, lpNewFileName string, lpProgressRoutine LPPROGRESS_ROUTINE, lpData LPVOID, pbCancel *BOOL, dwCopyFlags DWORD) bool + +// TODO: Unknown type(s): LPPROGRESS_ROUTINE +// func CopyFileTransacted(lpExistingFileName string, lpNewFileName string, lpProgressRoutine LPPROGRESS_ROUTINE, lpData LPVOID, pbCancel *BOOL, dwCopyFlags DWORD, hTransaction HANDLE) bool + +func CopyFile(lpExistingFileName string, lpNewFileName string, bFailIfExists bool) bool { + lpExistingFileNameStr := unicode16FromString(lpExistingFileName) + lpNewFileNameStr := unicode16FromString(lpNewFileName) + ret1 := syscall3(copyFile, 3, + uintptr(unsafe.Pointer(&lpExistingFileNameStr[0])), + uintptr(unsafe.Pointer(&lpNewFileNameStr[0])), + getUintptrFromBool(bFailIfExists)) + return ret1 != 0 +} + +func CopyLZFile(unnamed0 INT, unnamed1 INT) LONG { + ret1 := syscall3(copyLZFile, 2, + uintptr(unnamed0), + uintptr(unnamed1), + 0) + return LONG(ret1) +} + +// TODO: Unknown type(s): PCACTCTXW +// func CreateActCtx(pActCtx PCACTCTXW) HANDLE + +func CreateBoundaryDescriptor(name string, flags ULONG) HANDLE { + nameStr := unicode16FromString(name) + ret1 := syscall3(createBoundaryDescriptor, 2, + uintptr(unsafe.Pointer(&nameStr[0])), + uintptr(flags), + 0) + return HANDLE(ret1) +} + +func CreateConsoleScreenBuffer(dwDesiredAccess DWORD, dwShareMode DWORD, lpSecurityAttributes /*const*/ *SECURITY_ATTRIBUTES, dwFlags DWORD, lpScreenBufferData LPVOID) HANDLE { + ret1 := syscall6(createConsoleScreenBuffer, 5, + uintptr(dwDesiredAccess), + uintptr(dwShareMode), + uintptr(unsafe.Pointer(lpSecurityAttributes)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpScreenBufferData)), + 0) + return HANDLE(ret1) +} + +func CreateDirectoryEx(lpTemplateDirectory string, lpNewDirectory string, lpSecurityAttributes *SECURITY_ATTRIBUTES) bool { + lpTemplateDirectoryStr := unicode16FromString(lpTemplateDirectory) + lpNewDirectoryStr := unicode16FromString(lpNewDirectory) + ret1 := syscall3(createDirectoryEx, 3, + uintptr(unsafe.Pointer(&lpTemplateDirectoryStr[0])), + uintptr(unsafe.Pointer(&lpNewDirectoryStr[0])), + uintptr(unsafe.Pointer(lpSecurityAttributes))) + return ret1 != 0 +} + +func CreateDirectoryTransacted(lpTemplateDirectory string, lpNewDirectory string, lpSecurityAttributes *SECURITY_ATTRIBUTES, hTransaction HANDLE) bool { + lpTemplateDirectoryStr := unicode16FromString(lpTemplateDirectory) + lpNewDirectoryStr := unicode16FromString(lpNewDirectory) + ret1 := syscall6(createDirectoryTransacted, 4, + uintptr(unsafe.Pointer(&lpTemplateDirectoryStr[0])), + uintptr(unsafe.Pointer(&lpNewDirectoryStr[0])), + uintptr(unsafe.Pointer(lpSecurityAttributes)), + uintptr(hTransaction), + 0, + 0) + return ret1 != 0 +} + +func CreateDirectory(lpPathName string, lpSecurityAttributes *SECURITY_ATTRIBUTES) bool { + lpPathNameStr := unicode16FromString(lpPathName) + ret1 := syscall3(createDirectory, 2, + uintptr(unsafe.Pointer(&lpPathNameStr[0])), + uintptr(unsafe.Pointer(lpSecurityAttributes)), + 0) + return ret1 != 0 +} + +func CreateEventEx(lpEventAttributes *SECURITY_ATTRIBUTES, lpName string, dwFlags DWORD, dwDesiredAccess DWORD) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall6(createEventEx, 4, + uintptr(unsafe.Pointer(lpEventAttributes)), + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(dwFlags), + uintptr(dwDesiredAccess), + 0, + 0) + return HANDLE(ret1) +} + +func CreateEvent(lpEventAttributes *SECURITY_ATTRIBUTES, bManualReset bool, bInitialState bool, lpName string) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall6(createEvent, 4, + uintptr(unsafe.Pointer(lpEventAttributes)), + getUintptrFromBool(bManualReset), + getUintptrFromBool(bInitialState), + uintptr(unsafe.Pointer(&lpNameStr[0])), + 0, + 0) + return HANDLE(ret1) +} + +// TODO: Unknown type(s): LPFIBER_START_ROUTINE +// func CreateFiber(dwStackSize SIZE_T, lpStartAddress LPFIBER_START_ROUTINE, lpParameter LPVOID) LPVOID + +// TODO: Unknown type(s): LPFIBER_START_ROUTINE +// func CreateFiberEx(dwStackCommitSize SIZE_T, dwStackReserveSize SIZE_T, dwFlags DWORD, lpStartAddress LPFIBER_START_ROUTINE, lpParameter LPVOID) LPVOID + +// TODO: Unknown type(s): LPCREATEFILE2_EXTENDED_PARAMETERS +// func CreateFile2(lpFileName string, dwDesiredAccess DWORD, dwShareMode DWORD, dwCreationDisposition DWORD, pCreateExParams LPCREATEFILE2_EXTENDED_PARAMETERS) HANDLE + +func CreateFileMappingNuma(hFile HANDLE, lpFileMappingAttributes *SECURITY_ATTRIBUTES, flProtect DWORD, dwMaximumSizeHigh DWORD, dwMaximumSizeLow DWORD, lpName string, nndPreferred DWORD) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall9(createFileMappingNuma, 7, + uintptr(hFile), + uintptr(unsafe.Pointer(lpFileMappingAttributes)), + uintptr(flProtect), + uintptr(dwMaximumSizeHigh), + uintptr(dwMaximumSizeLow), + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(nndPreferred), + 0, + 0) + return HANDLE(ret1) +} + +func CreateFileMapping(hFile HANDLE, lpFileMappingAttributes *SECURITY_ATTRIBUTES, flProtect DWORD, dwMaximumSizeHigh DWORD, dwMaximumSizeLow DWORD, lpName string) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall6(createFileMapping, 6, + uintptr(hFile), + uintptr(unsafe.Pointer(lpFileMappingAttributes)), + uintptr(flProtect), + uintptr(dwMaximumSizeHigh), + uintptr(dwMaximumSizeLow), + uintptr(unsafe.Pointer(&lpNameStr[0]))) + return HANDLE(ret1) +} + +func CreateFileTransacted(lpFileName string, dwDesiredAccess DWORD, dwShareMode DWORD, lpSecurityAttributes *SECURITY_ATTRIBUTES, dwCreationDisposition DWORD, dwFlagsAndAttributes DWORD, hTemplateFile HANDLE, hTransaction HANDLE, pusMiniVersion PUSHORT, lpExtendedParameter uintptr) HANDLE { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall12(createFileTransacted, 10, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(dwDesiredAccess), + uintptr(dwShareMode), + uintptr(unsafe.Pointer(lpSecurityAttributes)), + uintptr(dwCreationDisposition), + uintptr(dwFlagsAndAttributes), + uintptr(hTemplateFile), + uintptr(hTransaction), + uintptr(unsafe.Pointer(pusMiniVersion)), + lpExtendedParameter, + 0, + 0) + return HANDLE(ret1) +} + +func CreateFile(lpFileName string, dwDesiredAccess DWORD, dwShareMode DWORD, lpSecurityAttributes *SECURITY_ATTRIBUTES, dwCreationDisposition DWORD, dwFlagsAndAttributes DWORD, hTemplateFile HANDLE) HANDLE { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall9(createFile, 7, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(dwDesiredAccess), + uintptr(dwShareMode), + uintptr(unsafe.Pointer(lpSecurityAttributes)), + uintptr(dwCreationDisposition), + uintptr(dwFlagsAndAttributes), + uintptr(hTemplateFile), + 0, + 0) + return HANDLE(ret1) +} + +func CreateHardLinkTransacted(lpFileName string, lpExistingFileName string, lpSecurityAttributes *SECURITY_ATTRIBUTES, hTransaction HANDLE) bool { + lpFileNameStr := unicode16FromString(lpFileName) + lpExistingFileNameStr := unicode16FromString(lpExistingFileName) + ret1 := syscall6(createHardLinkTransacted, 4, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(unsafe.Pointer(&lpExistingFileNameStr[0])), + uintptr(unsafe.Pointer(lpSecurityAttributes)), + uintptr(hTransaction), + 0, + 0) + return ret1 != 0 +} + +func CreateHardLink(lpFileName string, lpExistingFileName string, lpSecurityAttributes *SECURITY_ATTRIBUTES) bool { + lpFileNameStr := unicode16FromString(lpFileName) + lpExistingFileNameStr := unicode16FromString(lpExistingFileName) + ret1 := syscall3(createHardLink, 3, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(unsafe.Pointer(&lpExistingFileNameStr[0])), + uintptr(unsafe.Pointer(lpSecurityAttributes))) + return ret1 != 0 +} + +func CreateIoCompletionPort(fileHandle HANDLE, existingCompletionPort HANDLE, completionKey *uint32, numberOfConcurrentThreads DWORD) HANDLE { + ret1 := syscall6(createIoCompletionPort, 4, + uintptr(fileHandle), + uintptr(existingCompletionPort), + uintptr(unsafe.Pointer(completionKey)), + uintptr(numberOfConcurrentThreads), + 0, + 0) + return HANDLE(ret1) +} + +func CreateJobObject(lpJobAttributes *SECURITY_ATTRIBUTES, lpName string) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall3(createJobObject, 2, + uintptr(unsafe.Pointer(lpJobAttributes)), + uintptr(unsafe.Pointer(&lpNameStr[0])), + 0) + return HANDLE(ret1) +} + +// TODO: Unknown type(s): PJOB_SET_ARRAY +// func CreateJobSet(numJob ULONG, userJobSet PJOB_SET_ARRAY, flags ULONG) bool + +func CreateMailslot(lpName string, nMaxMessageSize DWORD, lReadTimeout DWORD, lpSecurityAttributes *SECURITY_ATTRIBUTES) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall6(createMailslot, 4, + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(nMaxMessageSize), + uintptr(lReadTimeout), + uintptr(unsafe.Pointer(lpSecurityAttributes)), + 0, + 0) + return HANDLE(ret1) +} + +// TODO: Unknown type(s): MEMORY_RESOURCE_NOTIFICATION_TYPE +// func CreateMemoryResourceNotification(notificationType MEMORY_RESOURCE_NOTIFICATION_TYPE) HANDLE + +func CreateMutexEx(lpMutexAttributes *SECURITY_ATTRIBUTES, lpName string, dwFlags DWORD, dwDesiredAccess DWORD) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall6(createMutexEx, 4, + uintptr(unsafe.Pointer(lpMutexAttributes)), + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(dwFlags), + uintptr(dwDesiredAccess), + 0, + 0) + return HANDLE(ret1) +} + +func CreateMutex(lpMutexAttributes *SECURITY_ATTRIBUTES, bInitialOwner bool, lpName string) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall3(createMutex, 3, + uintptr(unsafe.Pointer(lpMutexAttributes)), + getUintptrFromBool(bInitialOwner), + uintptr(unsafe.Pointer(&lpNameStr[0]))) + return HANDLE(ret1) +} + +func CreateNamedPipe(lpName string, dwOpenMode DWORD, dwPipeMode DWORD, nMaxInstances DWORD, nOutBufferSize DWORD, nInBufferSize DWORD, nDefaultTimeOut DWORD, lpSecurityAttributes *SECURITY_ATTRIBUTES) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall9(createNamedPipe, 8, + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(dwOpenMode), + uintptr(dwPipeMode), + uintptr(nMaxInstances), + uintptr(nOutBufferSize), + uintptr(nInBufferSize), + uintptr(nDefaultTimeOut), + uintptr(unsafe.Pointer(lpSecurityAttributes)), + 0) + return HANDLE(ret1) +} + +func CreatePipe(hReadPipe *HANDLE, hWritePipe *HANDLE, lpPipeAttributes *SECURITY_ATTRIBUTES, nSize DWORD) bool { + ret1 := syscall6(createPipe, 4, + uintptr(unsafe.Pointer(hReadPipe)), + uintptr(unsafe.Pointer(hWritePipe)), + uintptr(unsafe.Pointer(lpPipeAttributes)), + uintptr(nSize), + 0, + 0) + return ret1 != 0 +} + +func CreatePrivateNamespace(lpPrivateNamespaceAttributes *SECURITY_ATTRIBUTES, lpBoundaryDescriptor LPVOID, lpAliasPrefix string) HANDLE { + lpAliasPrefixStr := unicode16FromString(lpAliasPrefix) + ret1 := syscall3(createPrivateNamespace, 3, + uintptr(unsafe.Pointer(lpPrivateNamespaceAttributes)), + uintptr(unsafe.Pointer(lpBoundaryDescriptor)), + uintptr(unsafe.Pointer(&lpAliasPrefixStr[0]))) + return HANDLE(ret1) +} + +func CreateProcess(lpApplicationName string, lpCommandLine LPWSTR, lpProcessAttributes *SECURITY_ATTRIBUTES, lpThreadAttributes *SECURITY_ATTRIBUTES, bInheritHandles bool, dwCreationFlags DWORD, lpEnvironment LPVOID, lpCurrentDirectory string, lpStartupInfo *STARTUPINFO, lpProcessInformation *PROCESS_INFORMATION) bool { + lpApplicationNameStr := unicode16FromString(lpApplicationName) + lpCurrentDirectoryStr := unicode16FromString(lpCurrentDirectory) + ret1 := syscall12(createProcess, 10, + uintptr(unsafe.Pointer(&lpApplicationNameStr[0])), + uintptr(unsafe.Pointer(lpCommandLine)), + uintptr(unsafe.Pointer(lpProcessAttributes)), + uintptr(unsafe.Pointer(lpThreadAttributes)), + getUintptrFromBool(bInheritHandles), + uintptr(dwCreationFlags), + uintptr(unsafe.Pointer(lpEnvironment)), + uintptr(unsafe.Pointer(&lpCurrentDirectoryStr[0])), + uintptr(unsafe.Pointer(lpStartupInfo)), + uintptr(unsafe.Pointer(lpProcessInformation)), + 0, + 0) + return ret1 != 0 +} + +func CreateRemoteThread(hProcess HANDLE, lpThreadAttributes *SECURITY_ATTRIBUTES, dwStackSize SIZE_T, lpStartAddress THREAD_START_ROUTINE, lpParameter LPVOID, dwCreationFlags DWORD, lpThreadId *uint32) HANDLE { + lpStartAddressCallback := syscall.NewCallback(func(lpThreadParameterRawArg LPVOID) uintptr { + ret := lpStartAddress(lpThreadParameterRawArg) + return uintptr(ret) + }) + ret1 := syscall9(createRemoteThread, 7, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpThreadAttributes)), + uintptr(dwStackSize), + lpStartAddressCallback, + uintptr(unsafe.Pointer(lpParameter)), + uintptr(dwCreationFlags), + uintptr(unsafe.Pointer(lpThreadId)), + 0, + 0) + return HANDLE(ret1) +} + +// TODO: Unknown type(s): LPPROC_THREAD_ATTRIBUTE_LIST +// func CreateRemoteThreadEx(hProcess HANDLE, lpThreadAttributes *SECURITY_ATTRIBUTES, dwStackSize SIZE_T, lpStartAddress THREAD_START_ROUTINE, lpParameter LPVOID, dwCreationFlags DWORD, lpAttributeList LPPROC_THREAD_ATTRIBUTE_LIST, lpThreadId *uint32) HANDLE + +func CreateSemaphoreEx(lpSemaphoreAttributes *SECURITY_ATTRIBUTES, lInitialCount LONG, lMaximumCount LONG, lpName string, dwFlags DWORD, dwDesiredAccess DWORD) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall6(createSemaphoreEx, 6, + uintptr(unsafe.Pointer(lpSemaphoreAttributes)), + uintptr(lInitialCount), + uintptr(lMaximumCount), + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(dwFlags), + uintptr(dwDesiredAccess)) + return HANDLE(ret1) +} + +func CreateSemaphore(lpSemaphoreAttributes *SECURITY_ATTRIBUTES, lInitialCount LONG, lMaximumCount LONG, lpName string) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall6(createSemaphore, 4, + uintptr(unsafe.Pointer(lpSemaphoreAttributes)), + uintptr(lInitialCount), + uintptr(lMaximumCount), + uintptr(unsafe.Pointer(&lpNameStr[0])), + 0, + 0) + return HANDLE(ret1) +} + +func CreateSymbolicLinkTransacted(lpSymlinkFileName string, lpTargetFileName string, dwFlags DWORD, hTransaction HANDLE) BOOLEAN { + lpSymlinkFileNameStr := unicode16FromString(lpSymlinkFileName) + lpTargetFileNameStr := unicode16FromString(lpTargetFileName) + ret1 := syscall6(createSymbolicLinkTransacted, 4, + uintptr(unsafe.Pointer(&lpSymlinkFileNameStr[0])), + uintptr(unsafe.Pointer(&lpTargetFileNameStr[0])), + uintptr(dwFlags), + uintptr(hTransaction), + 0, + 0) + return BOOLEAN(ret1) +} + +func CreateSymbolicLink(lpSymlinkFileName string, lpTargetFileName string, dwFlags DWORD) BOOLEAN { + lpSymlinkFileNameStr := unicode16FromString(lpSymlinkFileName) + lpTargetFileNameStr := unicode16FromString(lpTargetFileName) + ret1 := syscall3(createSymbolicLink, 3, + uintptr(unsafe.Pointer(&lpSymlinkFileNameStr[0])), + uintptr(unsafe.Pointer(&lpTargetFileNameStr[0])), + uintptr(dwFlags)) + return BOOLEAN(ret1) +} + +func CreateTapePartition(hDevice HANDLE, dwPartitionMethod DWORD, dwCount DWORD, dwSize DWORD) DWORD { + ret1 := syscall6(createTapePartition, 4, + uintptr(hDevice), + uintptr(dwPartitionMethod), + uintptr(dwCount), + uintptr(dwSize), + 0, + 0) + return DWORD(ret1) +} + +func CreateThread(lpThreadAttributes *SECURITY_ATTRIBUTES, dwStackSize SIZE_T, lpStartAddress THREAD_START_ROUTINE, lpParameter LPVOID, dwCreationFlags DWORD, lpThreadId *uint32) HANDLE { + lpStartAddressCallback := syscall.NewCallback(func(lpThreadParameterRawArg LPVOID) uintptr { + ret := lpStartAddress(lpThreadParameterRawArg) + return uintptr(ret) + }) + ret1 := syscall6(createThread, 6, + uintptr(unsafe.Pointer(lpThreadAttributes)), + uintptr(dwStackSize), + lpStartAddressCallback, + uintptr(unsafe.Pointer(lpParameter)), + uintptr(dwCreationFlags), + uintptr(unsafe.Pointer(lpThreadId))) + return HANDLE(ret1) +} + +// TODO: Unknown type(s): PTP_POOL +// func CreateThreadpool(reserved uintptr) PTP_POOL + +// TODO: Unknown type(s): PTP_CLEANUP_GROUP +// func CreateThreadpoolCleanupGroup() PTP_CLEANUP_GROUP + +// TODO: Unknown type(s): PTP_CALLBACK_ENVIRON, PTP_IO, PTP_WIN32_IO_CALLBACK +// func CreateThreadpoolIo(fl HANDLE, pfnio PTP_WIN32_IO_CALLBACK, pv uintptr, pcbe PTP_CALLBACK_ENVIRON) PTP_IO + +// TODO: Unknown type(s): PTP_CALLBACK_ENVIRON, PTP_TIMER, PTP_TIMER_CALLBACK +// func CreateThreadpoolTimer(pfnti PTP_TIMER_CALLBACK, pv uintptr, pcbe PTP_CALLBACK_ENVIRON) PTP_TIMER + +// TODO: Unknown type(s): PTP_CALLBACK_ENVIRON, PTP_WAIT, PTP_WAIT_CALLBACK +// func CreateThreadpoolWait(pfnwa PTP_WAIT_CALLBACK, pv uintptr, pcbe PTP_CALLBACK_ENVIRON) PTP_WAIT + +// TODO: Unknown type(s): PTP_CALLBACK_ENVIRON, PTP_WORK, PTP_WORK_CALLBACK +// func CreateThreadpoolWork(pfnwk PTP_WORK_CALLBACK, pv uintptr, pcbe PTP_CALLBACK_ENVIRON) PTP_WORK + +func CreateTimerQueue() HANDLE { + ret1 := syscall3(createTimerQueue, 0, + 0, + 0, + 0) + return HANDLE(ret1) +} + +// TODO: Unknown type(s): WAITORTIMERCALLBACK +// func CreateTimerQueueTimer(phNewTimer *HANDLE, timerQueue HANDLE, callback WAITORTIMERCALLBACK, parameter uintptr, dueTime DWORD, period DWORD, flags ULONG) bool + +func CreateToolhelp32Snapshot(dwFlags DWORD, th32ProcessID DWORD) HANDLE { + ret1 := syscall3(createToolhelp32Snapshot, 2, + uintptr(dwFlags), + uintptr(th32ProcessID), + 0) + return HANDLE(ret1) +} + +func CreateWaitableTimerEx(lpTimerAttributes *SECURITY_ATTRIBUTES, lpTimerName string, dwFlags DWORD, dwDesiredAccess DWORD) HANDLE { + lpTimerNameStr := unicode16FromString(lpTimerName) + ret1 := syscall6(createWaitableTimerEx, 4, + uintptr(unsafe.Pointer(lpTimerAttributes)), + uintptr(unsafe.Pointer(&lpTimerNameStr[0])), + uintptr(dwFlags), + uintptr(dwDesiredAccess), + 0, + 0) + return HANDLE(ret1) +} + +func CreateWaitableTimer(lpTimerAttributes *SECURITY_ATTRIBUTES, bManualReset bool, lpTimerName string) HANDLE { + lpTimerNameStr := unicode16FromString(lpTimerName) + ret1 := syscall3(createWaitableTimer, 3, + uintptr(unsafe.Pointer(lpTimerAttributes)), + getUintptrFromBool(bManualReset), + uintptr(unsafe.Pointer(&lpTimerNameStr[0]))) + return HANDLE(ret1) +} + +func DeactivateActCtx(dwFlags DWORD, ulCookie *uint32) bool { + ret1 := syscall3(deactivateActCtx, 2, + uintptr(dwFlags), + uintptr(unsafe.Pointer(ulCookie)), + 0) + return ret1 != 0 +} + +func DebugActiveProcess(dwProcessId DWORD) bool { + ret1 := syscall3(debugActiveProcess, 1, + uintptr(dwProcessId), + 0, + 0) + return ret1 != 0 +} + +func DebugActiveProcessStop(dwProcessId DWORD) bool { + ret1 := syscall3(debugActiveProcessStop, 1, + uintptr(dwProcessId), + 0, + 0) + return ret1 != 0 +} + +func DebugBreak() { + syscall3(debugBreak, 0, + 0, + 0, + 0) +} + +func DebugBreakProcess(process HANDLE) bool { + ret1 := syscall3(debugBreakProcess, 1, + uintptr(process), + 0, + 0) + return ret1 != 0 +} + +func DebugSetProcessKillOnExit(killOnExit bool) bool { + ret1 := syscall3(debugSetProcessKillOnExit, 1, + getUintptrFromBool(killOnExit), + 0, + 0) + return ret1 != 0 +} + +func DecodePointer(ptr uintptr) uintptr { + ret1 := syscall3(decodePointer, 1, + ptr, + 0, + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func DecodeSystemPointer(ptr uintptr) uintptr { + ret1 := syscall3(decodeSystemPointer, 1, + ptr, + 0, + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func DefineDosDevice(dwFlags DWORD, lpDeviceName string, lpTargetPath string) bool { + lpDeviceNameStr := unicode16FromString(lpDeviceName) + lpTargetPathStr := unicode16FromString(lpTargetPath) + ret1 := syscall3(defineDosDevice, 3, + uintptr(dwFlags), + uintptr(unsafe.Pointer(&lpDeviceNameStr[0])), + uintptr(unsafe.Pointer(&lpTargetPathStr[0]))) + return ret1 != 0 +} + +func DeleteAtom(nAtom ATOM) ATOM { + ret1 := syscall3(deleteAtom, 1, + uintptr(nAtom), + 0, + 0) + return ATOM(ret1) +} + +func DeleteBoundaryDescriptor(boundaryDescriptor HANDLE) { + syscall3(deleteBoundaryDescriptor, 1, + uintptr(boundaryDescriptor), + 0, + 0) +} + +// TODO: Unknown type(s): LPCRITICAL_SECTION +// func DeleteCriticalSection(lpCriticalSection LPCRITICAL_SECTION) + +func DeleteFiber(lpFiber LPVOID) { + syscall3(deleteFiber, 1, + uintptr(unsafe.Pointer(lpFiber)), + 0, + 0) +} + +func DeleteFileTransacted(lpFileName string, hTransaction HANDLE) bool { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(deleteFileTransacted, 2, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(hTransaction), + 0) + return ret1 != 0 +} + +func DeleteFile(lpFileName string) bool { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(deleteFile, 1, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPPROC_THREAD_ATTRIBUTE_LIST +// func DeleteProcThreadAttributeList(lpAttributeList LPPROC_THREAD_ATTRIBUTE_LIST) + +func DeleteTimerQueue(timerQueue HANDLE) bool { + ret1 := syscall3(deleteTimerQueue, 1, + uintptr(timerQueue), + 0, + 0) + return ret1 != 0 +} + +func DeleteTimerQueueEx(timerQueue HANDLE, completionEvent HANDLE) bool { + ret1 := syscall3(deleteTimerQueueEx, 2, + uintptr(timerQueue), + uintptr(completionEvent), + 0) + return ret1 != 0 +} + +func DeleteTimerQueueTimer(timerQueue HANDLE, timer HANDLE, completionEvent HANDLE) bool { + ret1 := syscall3(deleteTimerQueueTimer, 3, + uintptr(timerQueue), + uintptr(timer), + uintptr(completionEvent)) + return ret1 != 0 +} + +func DeleteVolumeMountPoint(lpszVolumeMountPoint string) bool { + lpszVolumeMountPointStr := unicode16FromString(lpszVolumeMountPoint) + ret1 := syscall3(deleteVolumeMountPoint, 1, + uintptr(unsafe.Pointer(&lpszVolumeMountPointStr[0])), + 0, + 0) + return ret1 != 0 +} + +func DeviceIoControl(hDevice HANDLE, dwIoControlCode DWORD, lpInBuffer LPVOID, nInBufferSize DWORD, lpOutBuffer LPVOID, nOutBufferSize DWORD, lpBytesReturned *uint32, lpOverlapped *OVERLAPPED) bool { + ret1 := syscall9(deviceIoControl, 8, + uintptr(hDevice), + uintptr(dwIoControlCode), + uintptr(unsafe.Pointer(lpInBuffer)), + uintptr(nInBufferSize), + uintptr(unsafe.Pointer(lpOutBuffer)), + uintptr(nOutBufferSize), + uintptr(unsafe.Pointer(lpBytesReturned)), + uintptr(unsafe.Pointer(lpOverlapped)), + 0) + return ret1 != 0 +} + +func DisableThreadLibraryCalls(hLibModule HMODULE) bool { + ret1 := syscall3(disableThreadLibraryCalls, 1, + uintptr(hLibModule), + 0, + 0) + return ret1 != 0 +} + +func DisableThreadProfiling(performanceDataHandle HANDLE) DWORD { + ret1 := syscall3(disableThreadProfiling, 1, + uintptr(performanceDataHandle), + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PTP_CALLBACK_INSTANCE +// func DisassociateCurrentThreadFromCallback(pci PTP_CALLBACK_INSTANCE) + +func DiscardVirtualMemory(virtualAddress uintptr, size SIZE_T) DWORD { + ret1 := syscall3(discardVirtualMemory, 2, + virtualAddress, + uintptr(size), + 0) + return DWORD(ret1) +} + +func DisconnectNamedPipe(hNamedPipe HANDLE) bool { + ret1 := syscall3(disconnectNamedPipe, 1, + uintptr(hNamedPipe), + 0, + 0) + return ret1 != 0 +} + +func DnsHostnameToComputerName(hostname string, computerName LPWSTR, nSize *uint32) bool { + hostnameStr := unicode16FromString(hostname) + ret1 := syscall3(dnsHostnameToComputerName, 3, + uintptr(unsafe.Pointer(&hostnameStr[0])), + uintptr(unsafe.Pointer(computerName)), + uintptr(unsafe.Pointer(nSize))) + return ret1 != 0 +} + +func DosDateTimeToFileTime(wFatDate WORD, wFatTime WORD, lpFileTime *FILETIME) bool { + ret1 := syscall3(dosDateTimeToFileTime, 3, + uintptr(wFatDate), + uintptr(wFatTime), + uintptr(unsafe.Pointer(lpFileTime))) + return ret1 != 0 +} + +func DuplicateHandle(hSourceProcessHandle HANDLE, hSourceHandle HANDLE, hTargetProcessHandle HANDLE, lpTargetHandle *HANDLE, dwDesiredAccess DWORD, bInheritHandle bool, dwOptions DWORD) bool { + ret1 := syscall9(duplicateHandle, 7, + uintptr(hSourceProcessHandle), + uintptr(hSourceHandle), + uintptr(hTargetProcessHandle), + uintptr(unsafe.Pointer(lpTargetHandle)), + uintptr(dwDesiredAccess), + getUintptrFromBool(bInheritHandle), + uintptr(dwOptions), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): DWORD64 +// func EnableThreadProfiling(threadHandle HANDLE, flags DWORD, hardwareCounters DWORD64, performanceDataHandle *HANDLE) DWORD + +func EncodePointer(ptr uintptr) uintptr { + ret1 := syscall3(encodePointer, 1, + ptr, + 0, + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func EncodeSystemPointer(ptr uintptr) uintptr { + ret1 := syscall3(encodeSystemPointer, 1, + ptr, + 0, + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func EndUpdateResource(hUpdate HANDLE, fDiscard bool) bool { + ret1 := syscall3(endUpdateResource, 2, + uintptr(hUpdate), + getUintptrFromBool(fDiscard), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPCRITICAL_SECTION +// func EnterCriticalSection(lpCriticalSection LPCRITICAL_SECTION) + +// TODO: Unknown type(s): CALINFO_ENUMPROCEXEX +// func EnumCalendarInfoExEx(pCalInfoEnumProcExEx CALINFO_ENUMPROCEXEX, lpLocaleName string, calendar CALID, lpReserved string, calType CALTYPE, lParam LPARAM) bool + +// TODO: Unknown type(s): CALINFO_ENUMPROCEXW +// func EnumCalendarInfoEx(lpCalInfoEnumProcEx CALINFO_ENUMPROCEXW, locale LCID, calendar CALID, calType CALTYPE) bool + +// TODO: Unknown type(s): CALINFO_ENUMPROCW +// func EnumCalendarInfo(lpCalInfoEnumProc CALINFO_ENUMPROCW, locale LCID, calendar CALID, calType CALTYPE) bool + +// TODO: Unknown type(s): DATEFMT_ENUMPROCEXEX +// func EnumDateFormatsExEx(lpDateFmtEnumProcExEx DATEFMT_ENUMPROCEXEX, lpLocaleName string, dwFlags DWORD, lParam LPARAM) bool + +// TODO: Unknown type(s): DATEFMT_ENUMPROCEXW +// func EnumDateFormatsEx(lpDateFmtEnumProcEx DATEFMT_ENUMPROCEXW, locale LCID, dwFlags DWORD) bool + +// TODO: Unknown type(s): DATEFMT_ENUMPROCW +// func EnumDateFormats(lpDateFmtEnumProc DATEFMT_ENUMPROCW, locale LCID, dwFlags DWORD) bool + +// TODO: Unknown type(s): LANGGROUPLOCALE_ENUMPROCW, LGRPID +// func EnumLanguageGroupLocales(lpLangGroupLocaleEnumProc LANGGROUPLOCALE_ENUMPROCW, languageGroup LGRPID, dwFlags DWORD, lParam uintptr) bool + +func EnumResourceLanguagesEx(hModule HMODULE, lpType string, lpName string, lpEnumFunc ENUMRESLANGPROC, lParam uintptr, dwFlags DWORD, langId LANGID) bool { + lpTypeStr := unicode16FromString(lpType) + lpNameStr := unicode16FromString(lpName) + lpEnumFuncCallback := syscall.NewCallback(func(hModuleRawArg HMODULE, lpTypeRawArg /*const*/ *uint16, lpNameRawArg /*const*/ *uint16, wLanguageRawArg WORD, lParamRawArg LONG_PTR) uintptr { + lpType := stringFromUnicode16(lpTypeRawArg) + lpName := stringFromUnicode16(lpNameRawArg) + ret := lpEnumFunc(hModuleRawArg, lpType, lpName, wLanguageRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall9(enumResourceLanguagesEx, 7, + uintptr(hModule), + uintptr(unsafe.Pointer(&lpTypeStr[0])), + uintptr(unsafe.Pointer(&lpNameStr[0])), + lpEnumFuncCallback, + lParam, + uintptr(dwFlags), + uintptr(langId), + 0, + 0) + return ret1 != 0 +} + +func EnumResourceLanguages(hModule HMODULE, lpType string, lpName string, lpEnumFunc ENUMRESLANGPROC, lParam uintptr) bool { + lpTypeStr := unicode16FromString(lpType) + lpNameStr := unicode16FromString(lpName) + lpEnumFuncCallback := syscall.NewCallback(func(hModuleRawArg HMODULE, lpTypeRawArg /*const*/ *uint16, lpNameRawArg /*const*/ *uint16, wLanguageRawArg WORD, lParamRawArg LONG_PTR) uintptr { + lpType := stringFromUnicode16(lpTypeRawArg) + lpName := stringFromUnicode16(lpNameRawArg) + ret := lpEnumFunc(hModuleRawArg, lpType, lpName, wLanguageRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall6(enumResourceLanguages, 5, + uintptr(hModule), + uintptr(unsafe.Pointer(&lpTypeStr[0])), + uintptr(unsafe.Pointer(&lpNameStr[0])), + lpEnumFuncCallback, + lParam, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): ENUMRESNAMEPROCW +// func EnumResourceNamesEx(hModule HMODULE, lpType string, lpEnumFunc ENUMRESNAMEPROCW, lParam uintptr, dwFlags DWORD, langId LANGID) bool + +// TODO: Unknown type(s): ENUMRESNAMEPROCW +// func EnumResourceNames(hModule HMODULE, lpType string, lpEnumFunc ENUMRESNAMEPROCW, lParam uintptr) bool + +// TODO: Unknown type(s): ENUMRESTYPEPROCW +// func EnumResourceTypesEx(hModule HMODULE, lpEnumFunc ENUMRESTYPEPROCW, lParam uintptr, dwFlags DWORD, langId LANGID) bool + +// TODO: Unknown type(s): ENUMRESTYPEPROCW +// func EnumResourceTypes(hModule HMODULE, lpEnumFunc ENUMRESTYPEPROCW, lParam uintptr) bool + +// TODO: Unknown type(s): CODEPAGE_ENUMPROCW +// func EnumSystemCodePages(lpCodePageEnumProc CODEPAGE_ENUMPROCW, dwFlags DWORD) bool + +func EnumSystemFirmwareTables(firmwareTableProviderSignature DWORD, pFirmwareTableEnumBuffer uintptr, bufferSize DWORD) UINT { + ret1 := syscall3(enumSystemFirmwareTables, 3, + uintptr(firmwareTableProviderSignature), + pFirmwareTableEnumBuffer, + uintptr(bufferSize)) + return UINT(ret1) +} + +// TODO: Unknown type(s): GEOCLASS, GEO_ENUMPROC +// func EnumSystemGeoID(geoClass GEOCLASS, parentGeoId GEOID, lpGeoEnumProc GEO_ENUMPROC) bool + +// TODO: Unknown type(s): LANGUAGEGROUP_ENUMPROCW +// func EnumSystemLanguageGroups(lpLanguageGroupEnumProc LANGUAGEGROUP_ENUMPROCW, dwFlags DWORD, lParam uintptr) bool + +// TODO: Unknown type(s): LOCALE_ENUMPROCEX +// func EnumSystemLocalesEx(lpLocaleEnumProcEx LOCALE_ENUMPROCEX, dwFlags DWORD, lParam LPARAM, lpReserved LPVOID) bool + +// TODO: Unknown type(s): LOCALE_ENUMPROCW +// func EnumSystemLocales(lpLocaleEnumProc LOCALE_ENUMPROCW, dwFlags DWORD) bool + +// TODO: Unknown type(s): TIMEFMT_ENUMPROCEX +// func EnumTimeFormatsEx(lpTimeFmtEnumProcEx TIMEFMT_ENUMPROCEX, lpLocaleName string, dwFlags DWORD, lParam LPARAM) bool + +// TODO: Unknown type(s): TIMEFMT_ENUMPROCW +// func EnumTimeFormats(lpTimeFmtEnumProc TIMEFMT_ENUMPROCW, locale LCID, dwFlags DWORD) bool + +// TODO: Unknown type(s): UILANGUAGE_ENUMPROCW +// func EnumUILanguages(lpUILanguageEnumProc UILANGUAGE_ENUMPROCW, dwFlags DWORD, lParam uintptr) bool + +func EraseTape(hDevice HANDLE, dwEraseType DWORD, bImmediate bool) DWORD { + ret1 := syscall3(eraseTape, 3, + uintptr(hDevice), + uintptr(dwEraseType), + getUintptrFromBool(bImmediate)) + return DWORD(ret1) +} + +func EscapeCommFunction(hFile HANDLE, dwFunc DWORD) bool { + ret1 := syscall3(escapeCommFunction, 2, + uintptr(hFile), + uintptr(dwFunc), + 0) + return ret1 != 0 +} + +func ExitProcess(uExitCode UINT) { + syscall3(exitProcess, 1, + uintptr(uExitCode), + 0, + 0) +} + +func ExitThread(dwExitCode DWORD) { + syscall3(exitThread, 1, + uintptr(dwExitCode), + 0, + 0) +} + +func ExpandEnvironmentStrings(lpSrc string, lpDst LPWSTR, nSize DWORD) DWORD { + lpSrcStr := unicode16FromString(lpSrc) + ret1 := syscall3(expandEnvironmentStrings, 3, + uintptr(unsafe.Pointer(&lpSrcStr[0])), + uintptr(unsafe.Pointer(lpDst)), + uintptr(nSize)) + return DWORD(ret1) +} + +func FatalAppExit(uAction UINT, lpMessageText string) { + lpMessageTextStr := unicode16FromString(lpMessageText) + syscall3(fatalAppExit, 2, + uintptr(uAction), + uintptr(unsafe.Pointer(&lpMessageTextStr[0])), + 0) +} + +func FatalExit(exitCode int32) { + syscall3(fatalExit, 1, + uintptr(exitCode), + 0, + 0) +} + +func FileTimeToDosDateTime(lpFileTime /*const*/ *FILETIME, lpFatDate *uint16, lpFatTime *uint16) bool { + ret1 := syscall3(fileTimeToDosDateTime, 3, + uintptr(unsafe.Pointer(lpFileTime)), + uintptr(unsafe.Pointer(lpFatDate)), + uintptr(unsafe.Pointer(lpFatTime))) + return ret1 != 0 +} + +func FileTimeToLocalFileTime(lpFileTime /*const*/ *FILETIME, lpLocalFileTime *FILETIME) bool { + ret1 := syscall3(fileTimeToLocalFileTime, 2, + uintptr(unsafe.Pointer(lpFileTime)), + uintptr(unsafe.Pointer(lpLocalFileTime)), + 0) + return ret1 != 0 +} + +func FileTimeToSystemTime(lpFileTime /*const*/ *FILETIME, lpSystemTime *SYSTEMTIME) bool { + ret1 := syscall3(fileTimeToSystemTime, 2, + uintptr(unsafe.Pointer(lpFileTime)), + uintptr(unsafe.Pointer(lpSystemTime)), + 0) + return ret1 != 0 +} + +func FillConsoleOutputAttribute(hConsoleOutput HANDLE, wAttribute WORD, nLength DWORD, dwWriteCoord COORD, lpNumberOfAttrsWritten *uint32) bool { + ret1 := syscall6(fillConsoleOutputAttribute, 5, + uintptr(hConsoleOutput), + uintptr(wAttribute), + uintptr(nLength), + getUintptrFromCOORD(dwWriteCoord), + uintptr(unsafe.Pointer(lpNumberOfAttrsWritten)), + 0) + return ret1 != 0 +} + +func FillConsoleOutputCharacter(hConsoleOutput HANDLE, cCharacter WCHAR, nLength DWORD, dwWriteCoord COORD, lpNumberOfCharsWritten *uint32) bool { + ret1 := syscall6(fillConsoleOutputCharacter, 5, + uintptr(hConsoleOutput), + uintptr(cCharacter), + uintptr(nLength), + getUintptrFromCOORD(dwWriteCoord), + uintptr(unsafe.Pointer(lpNumberOfCharsWritten)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PACTCTX_SECTION_KEYED_DATA +// func FindActCtxSectionGuid(dwFlags DWORD, lpExtensionGuid /*const*/ *GUID, ulSectionId ULONG, lpGuidToFind /*const*/ *GUID, returnedData PACTCTX_SECTION_KEYED_DATA) bool + +// TODO: Unknown type(s): PACTCTX_SECTION_KEYED_DATA +// func FindActCtxSectionString(dwFlags DWORD, lpExtensionGuid /*const*/ *GUID, ulSectionId ULONG, lpStringToFind string, returnedData PACTCTX_SECTION_KEYED_DATA) bool + +func FindAtom(lpString string) ATOM { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(findAtom, 1, + uintptr(unsafe.Pointer(&lpStringStr[0])), + 0, + 0) + return ATOM(ret1) +} + +func FindClose(hFindFile HANDLE) bool { + ret1 := syscall3(findClose, 1, + uintptr(hFindFile), + 0, + 0) + return ret1 != 0 +} + +func FindCloseChangeNotification(hChangeHandle HANDLE) bool { + ret1 := syscall3(findCloseChangeNotification, 1, + uintptr(hChangeHandle), + 0, + 0) + return ret1 != 0 +} + +func FindFirstChangeNotification(lpPathName string, bWatchSubtree bool, dwNotifyFilter DWORD) HANDLE { + lpPathNameStr := unicode16FromString(lpPathName) + ret1 := syscall3(findFirstChangeNotification, 3, + uintptr(unsafe.Pointer(&lpPathNameStr[0])), + getUintptrFromBool(bWatchSubtree), + uintptr(dwNotifyFilter)) + return HANDLE(ret1) +} + +// TODO: Unknown type(s): FINDEX_INFO_LEVELS, FINDEX_SEARCH_OPS +// func FindFirstFileEx(lpFileName string, fInfoLevelId FINDEX_INFO_LEVELS, lpFindFileData LPVOID, fSearchOp FINDEX_SEARCH_OPS, lpSearchFilter LPVOID, dwAdditionalFlags DWORD) HANDLE + +func FindFirstFileNameTransactedW(lpFileName string, dwFlags DWORD, stringLength *uint32, linkName PWSTR, hTransaction HANDLE) HANDLE { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall6(findFirstFileNameTransactedW, 5, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(dwFlags), + uintptr(unsafe.Pointer(stringLength)), + uintptr(unsafe.Pointer(linkName)), + uintptr(hTransaction), + 0) + return HANDLE(ret1) +} + +func FindFirstFileNameW(lpFileName string, dwFlags DWORD, stringLength *uint32, linkName PWSTR) HANDLE { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall6(findFirstFileNameW, 4, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(dwFlags), + uintptr(unsafe.Pointer(stringLength)), + uintptr(unsafe.Pointer(linkName)), + 0, + 0) + return HANDLE(ret1) +} + +// TODO: Unknown type(s): FINDEX_INFO_LEVELS, FINDEX_SEARCH_OPS +// func FindFirstFileTransacted(lpFileName string, fInfoLevelId FINDEX_INFO_LEVELS, lpFindFileData LPVOID, fSearchOp FINDEX_SEARCH_OPS, lpSearchFilter LPVOID, dwAdditionalFlags DWORD, hTransaction HANDLE) HANDLE + +// TODO: Unknown type(s): LPWIN32_FIND_DATAW +// func FindFirstFile(lpFileName string, lpFindFileData LPWIN32_FIND_DATAW) HANDLE + +// TODO: Unknown type(s): STREAM_INFO_LEVELS +// func FindFirstStreamTransactedW(lpFileName string, infoLevel STREAM_INFO_LEVELS, lpFindStreamData LPVOID, dwFlags DWORD, hTransaction HANDLE) HANDLE + +// TODO: Unknown type(s): STREAM_INFO_LEVELS +// func FindFirstStreamW(lpFileName string, infoLevel STREAM_INFO_LEVELS, lpFindStreamData LPVOID, dwFlags DWORD) HANDLE + +func FindFirstVolumeMountPoint(lpszRootPathName string, lpszVolumeMountPoint LPWSTR, cchBufferLength DWORD) HANDLE { + lpszRootPathNameStr := unicode16FromString(lpszRootPathName) + ret1 := syscall3(findFirstVolumeMountPoint, 3, + uintptr(unsafe.Pointer(&lpszRootPathNameStr[0])), + uintptr(unsafe.Pointer(lpszVolumeMountPoint)), + uintptr(cchBufferLength)) + return HANDLE(ret1) +} + +func FindFirstVolume(lpszVolumeName LPWSTR, cchBufferLength DWORD) HANDLE { + ret1 := syscall3(findFirstVolume, 2, + uintptr(unsafe.Pointer(lpszVolumeName)), + uintptr(cchBufferLength), + 0) + return HANDLE(ret1) +} + +func FindNLSString(locale LCID, dwFindNLSStringFlags DWORD, lpStringSource string, cchSource int32, lpStringValue string, cchValue int32, pcchFound *int32) int32 { + lpStringSourceStr := unicode16FromString(lpStringSource) + lpStringValueStr := unicode16FromString(lpStringValue) + ret1 := syscall9(findNLSString, 7, + uintptr(locale), + uintptr(dwFindNLSStringFlags), + uintptr(unsafe.Pointer(&lpStringSourceStr[0])), + uintptr(cchSource), + uintptr(unsafe.Pointer(&lpStringValueStr[0])), + uintptr(cchValue), + uintptr(unsafe.Pointer(pcchFound)), + 0, + 0) + return int32(ret1) +} + +// TODO: Unknown type(s): LPNLSVERSIONINFO +// func FindNLSStringEx(lpLocaleName string, dwFindNLSStringFlags DWORD, lpStringSource string, cchSource int32, lpStringValue string, cchValue int32, pcchFound *int32, lpVersionInformation LPNLSVERSIONINFO, lpReserved LPVOID, sortHandle LPARAM) int32 + +func FindNextChangeNotification(hChangeHandle HANDLE) bool { + ret1 := syscall3(findNextChangeNotification, 1, + uintptr(hChangeHandle), + 0, + 0) + return ret1 != 0 +} + +func FindNextFileNameW(hFindStream HANDLE, stringLength *uint32, linkName PWSTR) bool { + ret1 := syscall3(findNextFileNameW, 3, + uintptr(hFindStream), + uintptr(unsafe.Pointer(stringLength)), + uintptr(unsafe.Pointer(linkName))) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPWIN32_FIND_DATAW +// func FindNextFile(hFindFile HANDLE, lpFindFileData LPWIN32_FIND_DATAW) bool + +func FindNextStreamW(hFindStream HANDLE, lpFindStreamData LPVOID) bool { + ret1 := syscall3(findNextStreamW, 2, + uintptr(hFindStream), + uintptr(unsafe.Pointer(lpFindStreamData)), + 0) + return ret1 != 0 +} + +func FindNextVolumeMountPoint(hFindVolumeMountPoint HANDLE, lpszVolumeMountPoint LPWSTR, cchBufferLength DWORD) bool { + ret1 := syscall3(findNextVolumeMountPoint, 3, + uintptr(hFindVolumeMountPoint), + uintptr(unsafe.Pointer(lpszVolumeMountPoint)), + uintptr(cchBufferLength)) + return ret1 != 0 +} + +func FindNextVolume(hFindVolume HANDLE, lpszVolumeName LPWSTR, cchBufferLength DWORD) bool { + ret1 := syscall3(findNextVolume, 3, + uintptr(hFindVolume), + uintptr(unsafe.Pointer(lpszVolumeName)), + uintptr(cchBufferLength)) + return ret1 != 0 +} + +func FindResourceEx(hModule HMODULE, lpType string, lpName string, wLanguage WORD) HRSRC { + lpTypeStr := unicode16FromString(lpType) + lpNameStr := unicode16FromString(lpName) + ret1 := syscall6(findResourceEx, 4, + uintptr(hModule), + uintptr(unsafe.Pointer(&lpTypeStr[0])), + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(wLanguage), + 0, + 0) + return HRSRC(ret1) +} + +func FindResource(hModule HMODULE, lpName string, lpType string) HRSRC { + lpNameStr := unicode16FromString(lpName) + lpTypeStr := unicode16FromString(lpType) + ret1 := syscall3(findResource, 3, + uintptr(hModule), + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(unsafe.Pointer(&lpTypeStr[0]))) + return HRSRC(ret1) +} + +func FindStringOrdinal(dwFindStringOrdinalFlags DWORD, lpStringSource string, cchSource int32, lpStringValue string, cchValue int32, bIgnoreCase bool) int32 { + lpStringSourceStr := unicode16FromString(lpStringSource) + lpStringValueStr := unicode16FromString(lpStringValue) + ret1 := syscall6(findStringOrdinal, 6, + uintptr(dwFindStringOrdinalFlags), + uintptr(unsafe.Pointer(&lpStringSourceStr[0])), + uintptr(cchSource), + uintptr(unsafe.Pointer(&lpStringValueStr[0])), + uintptr(cchValue), + getUintptrFromBool(bIgnoreCase)) + return int32(ret1) +} + +func FindVolumeClose(hFindVolume HANDLE) bool { + ret1 := syscall3(findVolumeClose, 1, + uintptr(hFindVolume), + 0, + 0) + return ret1 != 0 +} + +func FindVolumeMountPointClose(hFindVolumeMountPoint HANDLE) bool { + ret1 := syscall3(findVolumeMountPointClose, 1, + uintptr(hFindVolumeMountPoint), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PFLS_CALLBACK_FUNCTION +// func FlsAlloc(lpCallback PFLS_CALLBACK_FUNCTION) DWORD + +func FlsFree(dwFlsIndex DWORD) bool { + ret1 := syscall3(flsFree, 1, + uintptr(dwFlsIndex), + 0, + 0) + return ret1 != 0 +} + +func FlsGetValue(dwFlsIndex DWORD) uintptr { + ret1 := syscall3(flsGetValue, 1, + uintptr(dwFlsIndex), + 0, + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func FlsSetValue(dwFlsIndex DWORD, lpFlsData uintptr) bool { + ret1 := syscall3(flsSetValue, 2, + uintptr(dwFlsIndex), + lpFlsData, + 0) + return ret1 != 0 +} + +func FlushConsoleInputBuffer(hConsoleInput HANDLE) bool { + ret1 := syscall3(flushConsoleInputBuffer, 1, + uintptr(hConsoleInput), + 0, + 0) + return ret1 != 0 +} + +func FlushFileBuffers(hFile HANDLE) bool { + ret1 := syscall3(flushFileBuffers, 1, + uintptr(hFile), + 0, + 0) + return ret1 != 0 +} + +func FlushInstructionCache(hProcess HANDLE, lpBaseAddress /*const*/ uintptr, dwSize SIZE_T) bool { + ret1 := syscall3(flushInstructionCache, 3, + uintptr(hProcess), + lpBaseAddress, + uintptr(dwSize)) + return ret1 != 0 +} + +func FlushProcessWriteBuffers() { + syscall3(flushProcessWriteBuffers, 0, + 0, + 0, + 0) +} + +func FlushViewOfFile(lpBaseAddress /*const*/ uintptr, dwNumberOfBytesToFlush SIZE_T) bool { + ret1 := syscall3(flushViewOfFile, 2, + lpBaseAddress, + uintptr(dwNumberOfBytesToFlush), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPCWCH +// func FoldString(dwMapFlags DWORD, lpSrcStr LPCWCH, cchSrc int32, lpDestStr LPWSTR, cchDest int32) int32 + +func FreeConsole() bool { + ret1 := syscall3(freeConsole, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPWCH +// func FreeEnvironmentStrings(penv LPWCH) bool + +func FreeLibrary(hLibModule HMODULE) bool { + ret1 := syscall3(freeLibrary, 1, + uintptr(hLibModule), + 0, + 0) + return ret1 != 0 +} + +func FreeLibraryAndExitThread(hLibModule HMODULE, dwExitCode DWORD) { + syscall3(freeLibraryAndExitThread, 2, + uintptr(hLibModule), + uintptr(dwExitCode), + 0) +} + +// TODO: Unknown type(s): PTP_CALLBACK_INSTANCE +// func FreeLibraryWhenCallbackReturns(pci PTP_CALLBACK_INSTANCE, mod HMODULE) + +func FreeResource(hResData HGLOBAL) bool { + ret1 := syscall3(freeResource, 1, + uintptr(hResData), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PULONG_PTR +// func FreeUserPhysicalPages(hProcess HANDLE, numberOfPages PULONG_PTR, pageArray PULONG_PTR) bool + +func GenerateConsoleCtrlEvent(dwCtrlEvent DWORD, dwProcessGroupId DWORD) bool { + ret1 := syscall3(generateConsoleCtrlEvent, 2, + uintptr(dwCtrlEvent), + uintptr(dwProcessGroupId), + 0) + return ret1 != 0 +} + +func GetACP() UINT { + ret1 := syscall3(getACP, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func GetActiveProcessorCount(groupNumber WORD) DWORD { + ret1 := syscall3(getActiveProcessorCount, 1, + uintptr(groupNumber), + 0, + 0) + return DWORD(ret1) +} + +func GetActiveProcessorGroupCount() WORD { + ret1 := syscall3(getActiveProcessorGroupCount, 0, + 0, + 0, + 0) + return WORD(ret1) +} + +// TODO: Unknown type(s): APPLICATION_RECOVERY_CALLBACK * +// func GetApplicationRecoveryCallback(hProcess HANDLE, pRecoveryCallback APPLICATION_RECOVERY_CALLBACK *, ppvParameter *PVOID, pdwPingInterval *DWORD, pdwFlags *DWORD) HRESULT + +func GetApplicationRestartSettings(hProcess HANDLE, pwzCommandline PWSTR, pcchSize *DWORD, pdwFlags *DWORD) HRESULT { + ret1 := syscall6(getApplicationRestartSettings, 4, + uintptr(hProcess), + uintptr(unsafe.Pointer(pwzCommandline)), + uintptr(unsafe.Pointer(pcchSize)), + uintptr(unsafe.Pointer(pdwFlags)), + 0, + 0) + return HRESULT(ret1) +} + +func GetAtomName(nAtom ATOM, lpBuffer LPWSTR, nSize int32) UINT { + ret1 := syscall3(getAtomName, 3, + uintptr(nAtom), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(nSize)) + return UINT(ret1) +} + +func GetBinaryType(lpApplicationName string, lpBinaryType *uint32) bool { + lpApplicationNameStr := unicode16FromString(lpApplicationName) + ret1 := syscall3(getBinaryType, 2, + uintptr(unsafe.Pointer(&lpApplicationNameStr[0])), + uintptr(unsafe.Pointer(lpBinaryType)), + 0) + return ret1 != 0 +} + +func GetCPInfo(codePage UINT, lpCPInfo LPCPINFO) bool { + ret1 := syscall3(getCPInfo, 2, + uintptr(codePage), + uintptr(unsafe.Pointer(lpCPInfo)), + 0) + return ret1 != 0 +} + +func GetCPInfoEx(codePage UINT, dwFlags DWORD, lpCPInfoEx LPCPINFOEX) bool { + ret1 := syscall3(getCPInfoEx, 3, + uintptr(codePage), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpCPInfoEx))) + return ret1 != 0 +} + +func GetCalendarInfoEx(lpLocaleName string, calendar CALID, lpReserved string, calType CALTYPE, lpCalData LPWSTR, cchData int32, lpValue *uint32) int32 { + lpLocaleNameStr := unicode16FromString(lpLocaleName) + lpReservedStr := unicode16FromString(lpReserved) + ret1 := syscall9(getCalendarInfoEx, 7, + uintptr(unsafe.Pointer(&lpLocaleNameStr[0])), + uintptr(calendar), + uintptr(unsafe.Pointer(&lpReservedStr[0])), + uintptr(calType), + uintptr(unsafe.Pointer(lpCalData)), + uintptr(cchData), + uintptr(unsafe.Pointer(lpValue)), + 0, + 0) + return int32(ret1) +} + +func GetCalendarInfo(locale LCID, calendar CALID, calType CALTYPE, lpCalData LPWSTR, cchData int32, lpValue *uint32) int32 { + ret1 := syscall6(getCalendarInfo, 6, + uintptr(locale), + uintptr(calendar), + uintptr(calType), + uintptr(unsafe.Pointer(lpCalData)), + uintptr(cchData), + uintptr(unsafe.Pointer(lpValue))) + return int32(ret1) +} + +// TODO: Unknown type(s): LPCOMMCONFIG +// func GetCommConfig(hCommDev HANDLE, lpCC LPCOMMCONFIG, lpdwSize *uint32) bool + +func GetCommMask(hFile HANDLE, lpEvtMask *uint32) bool { + ret1 := syscall3(getCommMask, 2, + uintptr(hFile), + uintptr(unsafe.Pointer(lpEvtMask)), + 0) + return ret1 != 0 +} + +func GetCommModemStatus(hFile HANDLE, lpModemStat *uint32) bool { + ret1 := syscall3(getCommModemStatus, 2, + uintptr(hFile), + uintptr(unsafe.Pointer(lpModemStat)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPCOMMPROP +// func GetCommProperties(hFile HANDLE, lpCommProp LPCOMMPROP) bool + +// TODO: Unknown type(s): LPDCB +// func GetCommState(hFile HANDLE, lpDCB LPDCB) bool + +// TODO: Unknown type(s): LPCOMMTIMEOUTS +// func GetCommTimeouts(hFile HANDLE, lpCommTimeouts LPCOMMTIMEOUTS) bool + +func GetCommandLine() LPWSTR { + ret1 := syscall3(getCommandLine, 0, + 0, + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func GetCompressedFileSizeTransacted(lpFileName string, lpFileSizeHigh *uint32, hTransaction HANDLE) DWORD { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(getCompressedFileSizeTransacted, 3, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(unsafe.Pointer(lpFileSizeHigh)), + uintptr(hTransaction)) + return DWORD(ret1) +} + +func GetCompressedFileSize(lpFileName string, lpFileSizeHigh *uint32) DWORD { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(getCompressedFileSize, 2, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(unsafe.Pointer(lpFileSizeHigh)), + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): COMPUTER_NAME_FORMAT +// func GetComputerNameEx(nameType COMPUTER_NAME_FORMAT, lpBuffer LPWSTR, nSize *uint32) bool + +func GetComputerName(lpBuffer LPWSTR, nSize *uint32) bool { + ret1 := syscall3(getComputerName, 2, + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(unsafe.Pointer(nSize)), + 0) + return ret1 != 0 +} + +func GetConsoleAliasExesLength() DWORD { + ret1 := syscall3(getConsoleAliasExesLength, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func GetConsoleAliasExes(exeNameBuffer LPWSTR, exeNameBufferLength DWORD) DWORD { + ret1 := syscall3(getConsoleAliasExes, 2, + uintptr(unsafe.Pointer(exeNameBuffer)), + uintptr(exeNameBufferLength), + 0) + return DWORD(ret1) +} + +func GetConsoleAlias(source LPWSTR, targetBuffer LPWSTR, targetBufferLength DWORD, exeName LPWSTR) DWORD { + ret1 := syscall6(getConsoleAlias, 4, + uintptr(unsafe.Pointer(source)), + uintptr(unsafe.Pointer(targetBuffer)), + uintptr(targetBufferLength), + uintptr(unsafe.Pointer(exeName)), + 0, + 0) + return DWORD(ret1) +} + +func GetConsoleAliasesLength(exeName LPWSTR) DWORD { + ret1 := syscall3(getConsoleAliasesLength, 1, + uintptr(unsafe.Pointer(exeName)), + 0, + 0) + return DWORD(ret1) +} + +func GetConsoleAliases(aliasBuffer LPWSTR, aliasBufferLength DWORD, exeName LPWSTR) DWORD { + ret1 := syscall3(getConsoleAliases, 3, + uintptr(unsafe.Pointer(aliasBuffer)), + uintptr(aliasBufferLength), + uintptr(unsafe.Pointer(exeName))) + return DWORD(ret1) +} + +func GetConsoleCP() UINT { + ret1 := syscall3(getConsoleCP, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +// TODO: Unknown type(s): PCONSOLE_CURSOR_INFO +// func GetConsoleCursorInfo(hConsoleOutput HANDLE, lpConsoleCursorInfo PCONSOLE_CURSOR_INFO) bool + +func GetConsoleDisplayMode(lpModeFlags *uint32) bool { + ret1 := syscall3(getConsoleDisplayMode, 1, + uintptr(unsafe.Pointer(lpModeFlags)), + 0, + 0) + return ret1 != 0 +} + +func GetConsoleFontSize(hConsoleOutput HANDLE, nFont DWORD) COORD { + ret1 := syscall3(getConsoleFontSize, 2, + uintptr(hConsoleOutput), + uintptr(nFont), + 0) + return getCOORDFromUintptr(ret1) +} + +// TODO: Unknown type(s): PCONSOLE_HISTORY_INFO +// func GetConsoleHistoryInfo(lpConsoleHistoryInfo PCONSOLE_HISTORY_INFO) bool + +func GetConsoleMode(hConsoleHandle HANDLE, lpMode *uint32) bool { + ret1 := syscall3(getConsoleMode, 2, + uintptr(hConsoleHandle), + uintptr(unsafe.Pointer(lpMode)), + 0) + return ret1 != 0 +} + +func GetConsoleOriginalTitle(lpConsoleTitle LPWSTR, nSize DWORD) DWORD { + ret1 := syscall3(getConsoleOriginalTitle, 2, + uintptr(unsafe.Pointer(lpConsoleTitle)), + uintptr(nSize), + 0) + return DWORD(ret1) +} + +func GetConsoleOutputCP() UINT { + ret1 := syscall3(getConsoleOutputCP, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func GetConsoleProcessList(lpdwProcessList *uint32, dwProcessCount DWORD) DWORD { + ret1 := syscall3(getConsoleProcessList, 2, + uintptr(unsafe.Pointer(lpdwProcessList)), + uintptr(dwProcessCount), + 0) + return DWORD(ret1) +} + +func GetConsoleScreenBufferInfo(hConsoleOutput HANDLE, lpConsoleScreenBufferInfo PCONSOLE_SCREEN_BUFFER_INFO) bool { + ret1 := syscall3(getConsoleScreenBufferInfo, 2, + uintptr(hConsoleOutput), + uintptr(unsafe.Pointer(lpConsoleScreenBufferInfo)), + 0) + return ret1 != 0 +} + +func GetConsoleScreenBufferInfoEx(hConsoleOutput HANDLE, lpConsoleScreenBufferInfoEx PCONSOLE_SCREEN_BUFFER_INFOEX) bool { + ret1 := syscall3(getConsoleScreenBufferInfoEx, 2, + uintptr(hConsoleOutput), + uintptr(unsafe.Pointer(lpConsoleScreenBufferInfoEx)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCONSOLE_SELECTION_INFO +// func GetConsoleSelectionInfo(lpConsoleSelectionInfo PCONSOLE_SELECTION_INFO) bool + +func GetConsoleTitle(lpConsoleTitle LPWSTR, nSize DWORD) DWORD { + ret1 := syscall3(getConsoleTitle, 2, + uintptr(unsafe.Pointer(lpConsoleTitle)), + uintptr(nSize), + 0) + return DWORD(ret1) +} + +func GetConsoleWindow() HWND { + ret1 := syscall3(getConsoleWindow, 0, + 0, + 0, + 0) + return HWND(ret1) +} + +// TODO: Unknown type(s): CONST CURRENCYFMTW * +// func GetCurrencyFormatEx(lpLocaleName string, dwFlags DWORD, lpValue string, lpFormat /*const*/ CONST CURRENCYFMTW *, lpCurrencyStr LPWSTR, cchCurrency int32) int32 + +// TODO: Unknown type(s): CONST CURRENCYFMTW * +// func GetCurrencyFormat(locale LCID, dwFlags DWORD, lpValue string, lpFormat /*const*/ CONST CURRENCYFMTW *, lpCurrencyStr LPWSTR, cchCurrency int32) int32 + +func GetCurrentActCtx(lphActCtx *HANDLE) bool { + ret1 := syscall3(getCurrentActCtx, 1, + uintptr(unsafe.Pointer(lphActCtx)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCONSOLE_FONT_INFO +// func GetCurrentConsoleFont(hConsoleOutput HANDLE, bMaximumWindow bool, lpConsoleCurrentFont PCONSOLE_FONT_INFO) bool + +// TODO: Unknown type(s): PCONSOLE_FONT_INFOEX +// func GetCurrentConsoleFontEx(hConsoleOutput HANDLE, bMaximumWindow bool, lpConsoleCurrentFontEx PCONSOLE_FONT_INFOEX) bool + +func GetCurrentDirectory(nBufferLength DWORD, lpBuffer LPWSTR) DWORD { + ret1 := syscall3(getCurrentDirectory, 2, + uintptr(nBufferLength), + uintptr(unsafe.Pointer(lpBuffer)), + 0) + return DWORD(ret1) +} + +func GetCurrentProcess() HANDLE { + ret1 := syscall3(getCurrentProcess, 0, + 0, + 0, + 0) + return HANDLE(ret1) +} + +func GetCurrentProcessId() DWORD { + ret1 := syscall3(getCurrentProcessId, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func GetCurrentProcessorNumber() DWORD { + ret1 := syscall3(getCurrentProcessorNumber, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PPROCESSOR_NUMBER +// func GetCurrentProcessorNumberEx(procNumber PPROCESSOR_NUMBER) + +func GetCurrentThread() HANDLE { + ret1 := syscall3(getCurrentThread, 0, + 0, + 0, + 0) + return HANDLE(ret1) +} + +func GetCurrentThreadId() DWORD { + ret1 := syscall3(getCurrentThreadId, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func GetDateFormatEx(lpLocaleName string, dwFlags DWORD, lpDate /*const*/ *SYSTEMTIME, lpFormat string, lpDateStr LPWSTR, cchDate int32, lpCalendar string) int32 { + lpLocaleNameStr := unicode16FromString(lpLocaleName) + lpFormatStr := unicode16FromString(lpFormat) + lpCalendarStr := unicode16FromString(lpCalendar) + ret1 := syscall9(getDateFormatEx, 7, + uintptr(unsafe.Pointer(&lpLocaleNameStr[0])), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpDate)), + uintptr(unsafe.Pointer(&lpFormatStr[0])), + uintptr(unsafe.Pointer(lpDateStr)), + uintptr(cchDate), + uintptr(unsafe.Pointer(&lpCalendarStr[0])), + 0, + 0) + return int32(ret1) +} + +func GetDateFormat(locale LCID, dwFlags DWORD, lpDate /*const*/ *SYSTEMTIME, lpFormat string, lpDateStr LPWSTR, cchDate int32) int32 { + lpFormatStr := unicode16FromString(lpFormat) + ret1 := syscall6(getDateFormat, 6, + uintptr(locale), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpDate)), + uintptr(unsafe.Pointer(&lpFormatStr[0])), + uintptr(unsafe.Pointer(lpDateStr)), + uintptr(cchDate)) + return int32(ret1) +} + +// TODO: Unknown type(s): LPCOMMCONFIG +// func GetDefaultCommConfig(lpszName string, lpCC LPCOMMCONFIG, lpdwSize *uint32) bool + +func GetDevicePowerState(hDevice HANDLE, pfOn *BOOL) bool { + ret1 := syscall3(getDevicePowerState, 2, + uintptr(hDevice), + uintptr(unsafe.Pointer(pfOn)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PULARGE_INTEGER +func GetDiskFreeSpaceEx(lpDirectoryName string, lpFreeBytesAvailableToCaller uint64, lpTotalNumberOfBytes *uint64, lpTotalNumberOfFreeBytes *uint64) bool { + lpDirectoryNameStr := unicode16FromString(lpDirectoryName) + ret1 := syscall6(getDiskFreeSpaceEx, 5, + uintptr(unsafe.Pointer(&lpDirectoryNameStr[0])), + uintptr(unsafe.Pointer(&lpFreeBytesAvailableToCaller)), + uintptr(unsafe.Pointer(lpTotalNumberOfBytes)), + uintptr(unsafe.Pointer(lpTotalNumberOfFreeBytes)), + 0, + 0) + return ret1 != 0 +} + +func GetDiskFreeSpace(lpRootPathName string, lpSectorsPerCluster *uint32, lpBytesPerSector *uint32, lpNumberOfFreeClusters *uint32, lpTotalNumberOfClusters *uint32) bool { + lpRootPathNameStr := unicode16FromString(lpRootPathName) + ret1 := syscall6(getDiskFreeSpace, 5, + uintptr(unsafe.Pointer(&lpRootPathNameStr[0])), + uintptr(unsafe.Pointer(lpSectorsPerCluster)), + uintptr(unsafe.Pointer(lpBytesPerSector)), + uintptr(unsafe.Pointer(lpNumberOfFreeClusters)), + uintptr(unsafe.Pointer(lpTotalNumberOfClusters)), + 0) + return ret1 != 0 +} + +func GetDllDirectory(nBufferLength DWORD, lpBuffer LPWSTR) DWORD { + ret1 := syscall3(getDllDirectory, 2, + uintptr(nBufferLength), + uintptr(unsafe.Pointer(lpBuffer)), + 0) + return DWORD(ret1) +} + +func GetDriveType(lpRootPathName string) UINT { + lpRootPathNameStr := unicode16FromString(lpRootPathName) + ret1 := syscall3(getDriveType, 1, + uintptr(unsafe.Pointer(&lpRootPathNameStr[0])), + 0, + 0) + return UINT(ret1) +} + +func GetDurationFormat(locale LCID, dwFlags DWORD, lpDuration /*const*/ *SYSTEMTIME, ullDuration ULONGLONG, lpFormat string, lpDurationStr LPWSTR, cchDuration int32) int32 { + lpFormatStr := unicode16FromString(lpFormat) + ret1 := syscall9(getDurationFormat, 7, + uintptr(locale), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpDuration)), + uintptr(ullDuration), + uintptr(unsafe.Pointer(&lpFormatStr[0])), + uintptr(unsafe.Pointer(lpDurationStr)), + uintptr(cchDuration), + 0, + 0) + return int32(ret1) +} + +func GetDurationFormatEx(lpLocaleName string, dwFlags DWORD, lpDuration /*const*/ *SYSTEMTIME, ullDuration ULONGLONG, lpFormat string, lpDurationStr LPWSTR, cchDuration int32) int32 { + lpLocaleNameStr := unicode16FromString(lpLocaleName) + lpFormatStr := unicode16FromString(lpFormat) + ret1 := syscall9(getDurationFormatEx, 7, + uintptr(unsafe.Pointer(&lpLocaleNameStr[0])), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpDuration)), + uintptr(ullDuration), + uintptr(unsafe.Pointer(&lpFormatStr[0])), + uintptr(unsafe.Pointer(lpDurationStr)), + uintptr(cchDuration), + 0, + 0) + return int32(ret1) +} + +// TODO: Unknown type(s): PDYNAMIC_TIME_ZONE_INFORMATION +// func GetDynamicTimeZoneInformation(pTimeZoneInformation PDYNAMIC_TIME_ZONE_INFORMATION) DWORD + +// TODO: Unknown type(s): LPWCH +// func GetEnvironmentStrings() LPWCH + +func GetEnvironmentVariable(lpName string, lpBuffer LPWSTR, nSize DWORD) DWORD { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall3(getEnvironmentVariable, 3, + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(nSize)) + return DWORD(ret1) +} + +func GetErrorMode() UINT { + ret1 := syscall3(getErrorMode, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func GetExitCodeProcess(hProcess HANDLE, lpExitCode *uint32) bool { + ret1 := syscall3(getExitCodeProcess, 2, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpExitCode)), + 0) + return ret1 != 0 +} + +func GetExitCodeThread(hThread HANDLE, lpExitCode *uint32) bool { + ret1 := syscall3(getExitCodeThread, 2, + uintptr(hThread), + uintptr(unsafe.Pointer(lpExitCode)), + 0) + return ret1 != 0 +} + +func GetExpandedName(unnamed0 LPWSTR, unnamed1 LPWSTR) INT { + ret1 := syscall3(getExpandedName, 2, + uintptr(unsafe.Pointer(unnamed0)), + uintptr(unsafe.Pointer(unnamed1)), + 0) + return INT(ret1) +} + +// TODO: Unknown type(s): GET_FILEEX_INFO_LEVELS +// func GetFileAttributesEx(lpFileName string, fInfoLevelId GET_FILEEX_INFO_LEVELS, lpFileInformation LPVOID) bool + +// TODO: Unknown type(s): GET_FILEEX_INFO_LEVELS +// func GetFileAttributesTransacted(lpFileName string, fInfoLevelId GET_FILEEX_INFO_LEVELS, lpFileInformation LPVOID, hTransaction HANDLE) bool + +func GetFileAttributes(lpFileName string) DWORD { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(getFileAttributes, 1, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + 0, + 0) + return DWORD(ret1) +} + +func GetFileBandwidthReservation(hFile HANDLE, lpPeriodMilliseconds *uint32, lpBytesPerPeriod *uint32, pDiscardable *BOOL, lpTransferSize *uint32, lpNumOutstandingRequests *uint32) bool { + ret1 := syscall6(getFileBandwidthReservation, 6, + uintptr(hFile), + uintptr(unsafe.Pointer(lpPeriodMilliseconds)), + uintptr(unsafe.Pointer(lpBytesPerPeriod)), + uintptr(unsafe.Pointer(pDiscardable)), + uintptr(unsafe.Pointer(lpTransferSize)), + uintptr(unsafe.Pointer(lpNumOutstandingRequests))) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPBY_HANDLE_FILE_INFORMATION +// func GetFileInformationByHandle(hFile HANDLE, lpFileInformation LPBY_HANDLE_FILE_INFORMATION) bool + +// TODO: Unknown type(s): FILE_INFO_BY_HANDLE_CLASS +// func GetFileInformationByHandleEx(hFile HANDLE, fileInformationClass FILE_INFO_BY_HANDLE_CLASS, lpFileInformation LPVOID, dwBufferSize DWORD) bool + +// TODO: Unknown type(s): PFILEMUIINFO +// func GetFileMUIInfo(dwFlags DWORD, pcwszFilePath string, pFileMUIInfo PFILEMUIINFO, pcbFileMUIInfo *uint32) bool + +// TODO: Unknown type(s): PULONGLONG +// func GetFileMUIPath(dwFlags DWORD, pcwszFilePath string, pwszLanguage PWSTR, pcchLanguage *uint32, pwszFileMUIPath PWSTR, pcchFileMUIPath *uint32, pululEnumerator PULONGLONG) bool + +func GetFileSize(hFile HANDLE, lpFileSizeHigh *uint32) DWORD { + ret1 := syscall3(getFileSize, 2, + uintptr(hFile), + uintptr(unsafe.Pointer(lpFileSizeHigh)), + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PLARGE_INTEGER +// func GetFileSizeEx(hFile HANDLE, lpFileSize PLARGE_INTEGER) bool + +func GetFileTime(hFile HANDLE, lpCreationTime *FILETIME, lpLastAccessTime *FILETIME, lpLastWriteTime *FILETIME) bool { + ret1 := syscall6(getFileTime, 4, + uintptr(hFile), + uintptr(unsafe.Pointer(lpCreationTime)), + uintptr(unsafe.Pointer(lpLastAccessTime)), + uintptr(unsafe.Pointer(lpLastWriteTime)), + 0, + 0) + return ret1 != 0 +} + +func GetFileType(hFile HANDLE) DWORD { + ret1 := syscall3(getFileType, 1, + uintptr(hFile), + 0, + 0) + return DWORD(ret1) +} + +func GetFinalPathNameByHandle(hFile HANDLE, lpszFilePath LPWSTR, cchFilePath DWORD, dwFlags DWORD) DWORD { + ret1 := syscall6(getFinalPathNameByHandle, 4, + uintptr(hFile), + uintptr(unsafe.Pointer(lpszFilePath)), + uintptr(cchFilePath), + uintptr(dwFlags), + 0, + 0) + return DWORD(ret1) +} + +func GetFirmwareEnvironmentVariable(lpName string, lpGuid string, pBuffer uintptr, nSize DWORD) DWORD { + lpNameStr := unicode16FromString(lpName) + lpGuidStr := unicode16FromString(lpGuid) + ret1 := syscall6(getFirmwareEnvironmentVariable, 4, + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(unsafe.Pointer(&lpGuidStr[0])), + pBuffer, + uintptr(nSize), + 0, + 0) + return DWORD(ret1) +} + +func GetFullPathNameTransacted(lpFileName string, nBufferLength DWORD, lpBuffer LPWSTR, lpFilePart *LPWSTR, hTransaction HANDLE) DWORD { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall6(getFullPathNameTransacted, 5, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(nBufferLength), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(unsafe.Pointer(lpFilePart)), + uintptr(hTransaction), + 0) + return DWORD(ret1) +} + +func GetFullPathName(lpFileName string, nBufferLength DWORD, lpBuffer LPWSTR, lpFilePart *LPWSTR) DWORD { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall6(getFullPathName, 4, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(nBufferLength), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(unsafe.Pointer(lpFilePart)), + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): GEOTYPE +// func GetGeoInfo(location GEOID, geoType GEOTYPE, lpGeoData LPWSTR, cchData int32, langId LANGID) int32 + +func GetHandleInformation(hObject HANDLE, lpdwFlags *uint32) bool { + ret1 := syscall3(getHandleInformation, 2, + uintptr(hObject), + uintptr(unsafe.Pointer(lpdwFlags)), + 0) + return ret1 != 0 +} + +func GetLargePageMinimum() SIZE_T { + ret1 := syscall3(getLargePageMinimum, 0, + 0, + 0, + 0) + return SIZE_T(ret1) +} + +func GetLargestConsoleWindowSize(hConsoleOutput HANDLE) COORD { + ret1 := syscall3(getLargestConsoleWindowSize, 1, + uintptr(hConsoleOutput), + 0, + 0) + return getCOORDFromUintptr(ret1) +} + +func GetLastError() DWORD { + ret1 := syscall3(getLastError, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func GetLocalTime(lpSystemTime *SYSTEMTIME) { + syscall3(getLocalTime, 1, + uintptr(unsafe.Pointer(lpSystemTime)), + 0, + 0) +} + +func GetLocaleInfoEx(lpLocaleName string, lCType LCTYPE, lpLCData LPWSTR, cchData int32) int32 { + lpLocaleNameStr := unicode16FromString(lpLocaleName) + ret1 := syscall6(getLocaleInfoEx, 4, + uintptr(unsafe.Pointer(&lpLocaleNameStr[0])), + uintptr(lCType), + uintptr(unsafe.Pointer(lpLCData)), + uintptr(cchData), + 0, + 0) + return int32(ret1) +} + +func GetLocaleInfo(locale LCID, lCType LCTYPE, lpLCData LPWSTR, cchData int32) int32 { + ret1 := syscall6(getLocaleInfo, 4, + uintptr(locale), + uintptr(lCType), + uintptr(unsafe.Pointer(lpLCData)), + uintptr(cchData), + 0, + 0) + return int32(ret1) +} + +func GetLogicalDriveStrings(nBufferLength DWORD, lpBuffer LPWSTR) DWORD { + ret1 := syscall3(getLogicalDriveStrings, 2, + uintptr(nBufferLength), + uintptr(unsafe.Pointer(lpBuffer)), + 0) + return DWORD(ret1) +} + +func GetLogicalDrives() DWORD { + ret1 := syscall3(getLogicalDrives, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PSYSTEM_LOGICAL_PROCESSOR_INFORMATION +// func GetLogicalProcessorInformation(buffer PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, returnedLength *DWORD) bool +type LOGICAL_PROCESSOR_RELATIONSHIP int32 + +const ( + //Retrieves information about logical processors that share a single processor core. + RelationProcessorCore = 0 + //Retrieves information about logical processors that are part of the same NUMA node. + RelationNumaNode = 1 + //Retrieves information about logical processors that share a cache. + RelationCache = 2 + //Retrieves information about logical processors that share a physical package. + RelationProcessorPackage = 3 + //Retrieves information about logical processors that share a processor group. + RelationGroup = 4 + //Retrieves information about logical processors for all relationship types + RelationAll = 0xffff +) + +func (s LOGICAL_PROCESSOR_RELATIONSHIP) String() string { + if s == RelationProcessorCore { + return "RelationProcessorCore" + } else if s == RelationNumaNode { + return "RelationNumaNode" + } else if s == RelationCache { + return "RelationCache" + } else if s == RelationProcessorPackage { + return "RelationProcessorPackage" + } else if s == RelationGroup { + return "RelationGroup" + } + return "Unknown" +} + +/*type SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX struct{ + LOGICAL_PROCESSOR_RELATIONSHIP Relationship; + DWORD Size; + union { + PROCESSOR_RELATIONSHIP Processor; + NUMA_NODE_RELATIONSHIP NumaNode; + CACHE_RELATIONSHIP Cache; + GROUP_RELATIONSHIP Group; + }; +} */ +type SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX struct { + Relationship LOGICAL_PROCESSOR_RELATIONSHIP + Size DWORD + RelShip [4096]byte +} + +type PROCESSOR_CACHE_TYPE int32 + +const ( + CacheUnified PROCESSOR_CACHE_TYPE = iota + CacheInstruction + CacheData + CacheTrace +) + +type KAFFINITY ULONG_PTR + +const GROUP_SIZE = 100 +const LTP_PC_SMT = 0x1 + +type GROUP_AFFINITY struct { + //Mask [10]uint32 + Mask KAFFINITY + Group DWORD + Reserved [3]DWORD +} + +type PROCESSOR_RELATIONSHIP struct { + Flags BYTE + EfficiencyClass BYTE + Reserved [21]BYTE + GroupCount DWORD + GroupMask [GROUP_SIZE]GROUP_AFFINITY +} + +type NUMA_NODE_RELATIONSHIP struct { + NodeNumber DWORD + Reserved [20]BYTE + GroupMask GROUP_AFFINITY +} +type CACHE_RELATIONSHIP struct { + Level BYTE //1,2,3 + Associativity BYTE + LineSize DWORD + CacheSize DWORD + Type DWORD //PROCESSOR_CACHE_TYPE + Reserved [20]BYTE + GroupMask GROUP_AFFINITY +} +type GROUP_RELATIONSHIP struct { + MaximumGroupCount DWORD + ActiveGroupCount DWORD + Reserved [20]BYTE + GroupInfo [GROUP_SIZE]PROCESSOR_GROUP_INFO +} +type PROCESSOR_GROUP_INFO struct { + MaximumProcessorCount BYTE + ActiveProcessorCount BYTE + Reserved [38]BYTE + ActiveProcessorMask KAFFINITY +} + +// TODO: Unknown type(s): LOGICAL_PROCESSOR_RELATIONSHIP, PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX +//func GetLogicalProcessorInformationEx(relationshipType LOGICAL_PROCESSOR_RELATIONSHIP, buffer PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, returnedLength *DWORD) bool +func GetLogicalProcessorInformationEx(relationshipType LOGICAL_PROCESSOR_RELATIONSHIP, buffer LPWSTR, returnedLength *DWORD) DWORD { + ret1 := syscall3(getLogicalProcessorInformationEx, 3, + uintptr(relationshipType), + uintptr(unsafe.Pointer(buffer)), + uintptr(unsafe.Pointer(returnedLength))) + return DWORD(ret1) +} + +func GetLongPathNameTransacted(lpszShortPath string, lpszLongPath LPWSTR, cchBuffer DWORD, hTransaction HANDLE) DWORD { + lpszShortPathStr := unicode16FromString(lpszShortPath) + ret1 := syscall6(getLongPathNameTransacted, 4, + uintptr(unsafe.Pointer(&lpszShortPathStr[0])), + uintptr(unsafe.Pointer(lpszLongPath)), + uintptr(cchBuffer), + uintptr(hTransaction), + 0, + 0) + return DWORD(ret1) +} + +func GetLongPathName(lpszShortPath string, lpszLongPath LPWSTR, cchBuffer DWORD) DWORD { + lpszShortPathStr := unicode16FromString(lpszShortPath) + ret1 := syscall3(getLongPathName, 3, + uintptr(unsafe.Pointer(&lpszShortPathStr[0])), + uintptr(unsafe.Pointer(lpszLongPath)), + uintptr(cchBuffer)) + return DWORD(ret1) +} + +func GetMailslotInfo(hMailslot HANDLE, lpMaxMessageSize *uint32, lpNextSize *uint32, lpMessageCount *uint32, lpReadTimeout *uint32) bool { + ret1 := syscall6(getMailslotInfo, 5, + uintptr(hMailslot), + uintptr(unsafe.Pointer(lpMaxMessageSize)), + uintptr(unsafe.Pointer(lpNextSize)), + uintptr(unsafe.Pointer(lpMessageCount)), + uintptr(unsafe.Pointer(lpReadTimeout)), + 0) + return ret1 != 0 +} + +func GetMaximumProcessorCount(groupNumber WORD) DWORD { + ret1 := syscall3(getMaximumProcessorCount, 1, + uintptr(groupNumber), + 0, + 0) + return DWORD(ret1) +} + +func GetMaximumProcessorGroupCount() WORD { + ret1 := syscall3(getMaximumProcessorGroupCount, 0, + 0, + 0, + 0) + return WORD(ret1) +} + +func GetModuleFileName(hModule HMODULE, lpFilename LPWSTR, nSize DWORD) DWORD { + ret1 := syscall3(getModuleFileName, 3, + uintptr(hModule), + uintptr(unsafe.Pointer(lpFilename)), + uintptr(nSize)) + return DWORD(ret1) +} + +func GetModuleHandleEx(dwFlags DWORD, lpModuleName string, phModule *HMODULE) bool { + lpModuleNameStr := unicode16FromString(lpModuleName) + ret1 := syscall3(getModuleHandleEx, 3, + uintptr(dwFlags), + uintptr(unsafe.Pointer(&lpModuleNameStr[0])), + uintptr(unsafe.Pointer(phModule))) + return ret1 != 0 +} + +func GetModuleHandle(lpModuleName string) HMODULE { + lpModuleNameStr := unicode16FromString(lpModuleName) + ret1 := syscall3(getModuleHandle, 1, + uintptr(unsafe.Pointer(&lpModuleNameStr[0])), + 0, + 0) + return HMODULE(ret1) +} + +// TODO: Unknown type(s): LPNLSVERSIONINFO, NLS_FUNCTION +// func GetNLSVersion(function NLS_FUNCTION, locale LCID, lpVersionInformation LPNLSVERSIONINFO) bool + +// TODO: Unknown type(s): LPNLSVERSIONINFOEX, NLS_FUNCTION +// func GetNLSVersionEx(function NLS_FUNCTION, lpLocaleName string, lpVersionInformation LPNLSVERSIONINFOEX) bool + +func GetNamedPipeClientComputerName(pipe HANDLE, clientComputerName LPWSTR, clientComputerNameLength ULONG) bool { + ret1 := syscall3(getNamedPipeClientComputerName, 3, + uintptr(pipe), + uintptr(unsafe.Pointer(clientComputerName)), + uintptr(clientComputerNameLength)) + return ret1 != 0 +} + +func GetNamedPipeClientProcessId(pipe HANDLE, clientProcessId *uint32) bool { + ret1 := syscall3(getNamedPipeClientProcessId, 2, + uintptr(pipe), + uintptr(unsafe.Pointer(clientProcessId)), + 0) + return ret1 != 0 +} + +func GetNamedPipeClientSessionId(pipe HANDLE, clientSessionId *uint32) bool { + ret1 := syscall3(getNamedPipeClientSessionId, 2, + uintptr(pipe), + uintptr(unsafe.Pointer(clientSessionId)), + 0) + return ret1 != 0 +} + +func GetNamedPipeHandleState(hNamedPipe HANDLE, lpState *uint32, lpCurInstances *uint32, lpMaxCollectionCount *uint32, lpCollectDataTimeout *uint32, lpUserName LPWSTR, nMaxUserNameSize DWORD) bool { + ret1 := syscall9(getNamedPipeHandleState, 7, + uintptr(hNamedPipe), + uintptr(unsafe.Pointer(lpState)), + uintptr(unsafe.Pointer(lpCurInstances)), + uintptr(unsafe.Pointer(lpMaxCollectionCount)), + uintptr(unsafe.Pointer(lpCollectDataTimeout)), + uintptr(unsafe.Pointer(lpUserName)), + uintptr(nMaxUserNameSize), + 0, + 0) + return ret1 != 0 +} + +func GetNamedPipeInfo(hNamedPipe HANDLE, lpFlags *uint32, lpOutBufferSize *uint32, lpInBufferSize *uint32, lpMaxInstances *uint32) bool { + ret1 := syscall6(getNamedPipeInfo, 5, + uintptr(hNamedPipe), + uintptr(unsafe.Pointer(lpFlags)), + uintptr(unsafe.Pointer(lpOutBufferSize)), + uintptr(unsafe.Pointer(lpInBufferSize)), + uintptr(unsafe.Pointer(lpMaxInstances)), + 0) + return ret1 != 0 +} + +func GetNamedPipeServerProcessId(pipe HANDLE, serverProcessId *uint32) bool { + ret1 := syscall3(getNamedPipeServerProcessId, 2, + uintptr(pipe), + uintptr(unsafe.Pointer(serverProcessId)), + 0) + return ret1 != 0 +} + +func GetNamedPipeServerSessionId(pipe HANDLE, serverSessionId *uint32) bool { + ret1 := syscall3(getNamedPipeServerSessionId, 2, + uintptr(pipe), + uintptr(unsafe.Pointer(serverSessionId)), + 0) + return ret1 != 0 +} + +func GetNativeSystemInfo(lpSystemInfo *SYSTEM_INFO) { + syscall3(getNativeSystemInfo, 1, + uintptr(unsafe.Pointer(lpSystemInfo)), + 0, + 0) +} + +// TODO: Unknown type(s): PULONGLONG +// func GetNumaAvailableMemoryNode(node UCHAR, availableBytes PULONGLONG) bool + +// TODO: Unknown type(s): PULONGLONG +// func GetNumaAvailableMemoryNodeEx(node USHORT, availableBytes PULONGLONG) bool + +func GetNumaHighestNodeNumber(highestNodeNumber *uint32) bool { + ret1 := syscall3(getNumaHighestNodeNumber, 1, + uintptr(unsafe.Pointer(highestNodeNumber)), + 0, + 0) + return ret1 != 0 +} + +func GetNumaNodeNumberFromHandle(hFile HANDLE, nodeNumber PUSHORT) bool { + ret1 := syscall3(getNumaNodeNumberFromHandle, 2, + uintptr(hFile), + uintptr(unsafe.Pointer(nodeNumber)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PULONGLONG +// func GetNumaNodeProcessorMask(node UCHAR, processorMask PULONGLONG) bool + +// TODO: Unknown type(s): PGROUP_AFFINITY +// func GetNumaNodeProcessorMaskEx(node USHORT, processorMask PGROUP_AFFINITY) bool + +func GetNumaProcessorNode(processor UCHAR, nodeNumber PUCHAR) bool { + ret1 := syscall3(getNumaProcessorNode, 2, + uintptr(processor), + uintptr(unsafe.Pointer(nodeNumber)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PPROCESSOR_NUMBER +// func GetNumaProcessorNodeEx(processor PPROCESSOR_NUMBER, nodeNumber PUSHORT) bool + +func GetNumaProximityNode(proximityId ULONG, nodeNumber PUCHAR) bool { + ret1 := syscall3(getNumaProximityNode, 2, + uintptr(proximityId), + uintptr(unsafe.Pointer(nodeNumber)), + 0) + return ret1 != 0 +} + +func GetNumaProximityNodeEx(proximityId ULONG, nodeNumber PUSHORT) bool { + ret1 := syscall3(getNumaProximityNodeEx, 2, + uintptr(proximityId), + uintptr(unsafe.Pointer(nodeNumber)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): CONST NUMBERFMTW * +// func GetNumberFormatEx(lpLocaleName string, dwFlags DWORD, lpValue string, lpFormat /*const*/ CONST NUMBERFMTW *, lpNumberStr LPWSTR, cchNumber int32) int32 + +// TODO: Unknown type(s): CONST NUMBERFMTW * +// func GetNumberFormat(locale LCID, dwFlags DWORD, lpValue string, lpFormat /*const*/ CONST NUMBERFMTW *, lpNumberStr LPWSTR, cchNumber int32) int32 + +func GetNumberOfConsoleInputEvents(hConsoleInput HANDLE, lpNumberOfEvents *uint32) bool { + ret1 := syscall3(getNumberOfConsoleInputEvents, 2, + uintptr(hConsoleInput), + uintptr(unsafe.Pointer(lpNumberOfEvents)), + 0) + return ret1 != 0 +} + +func GetNumberOfConsoleMouseButtons(lpNumberOfMouseButtons *uint32) bool { + ret1 := syscall3(getNumberOfConsoleMouseButtons, 1, + uintptr(unsafe.Pointer(lpNumberOfMouseButtons)), + 0, + 0) + return ret1 != 0 +} + +func GetOEMCP() UINT { + ret1 := syscall3(getOEMCP, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func GetOverlappedResult(hFile HANDLE, lpOverlapped *OVERLAPPED, lpNumberOfBytesTransferred *uint32, bWait bool) bool { + ret1 := syscall6(getOverlappedResult, 4, + uintptr(hFile), + uintptr(unsafe.Pointer(lpOverlapped)), + uintptr(unsafe.Pointer(lpNumberOfBytesTransferred)), + getUintptrFromBool(bWait), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PULONGLONG +// func GetPhysicallyInstalledSystemMemory(totalMemoryInKilobytes PULONGLONG) bool + +func GetPriorityClass(hProcess HANDLE) DWORD { + ret1 := syscall3(getPriorityClass, 1, + uintptr(hProcess), + 0, + 0) + return DWORD(ret1) +} + +func GetPrivateProfileInt(lpAppName string, lpKeyName string, nDefault INT, lpFileName string) UINT { + lpAppNameStr := unicode16FromString(lpAppName) + lpKeyNameStr := unicode16FromString(lpKeyName) + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall6(getPrivateProfileInt, 4, + uintptr(unsafe.Pointer(&lpAppNameStr[0])), + uintptr(unsafe.Pointer(&lpKeyNameStr[0])), + uintptr(nDefault), + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + 0, + 0) + return UINT(ret1) +} + +func GetPrivateProfileSectionNames(lpszReturnBuffer LPWSTR, nSize DWORD, lpFileName string) DWORD { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(getPrivateProfileSectionNames, 3, + uintptr(unsafe.Pointer(lpszReturnBuffer)), + uintptr(nSize), + uintptr(unsafe.Pointer(&lpFileNameStr[0]))) + return DWORD(ret1) +} + +func GetPrivateProfileSection(lpAppName string, lpReturnedString LPWSTR, nSize DWORD, lpFileName string) DWORD { + lpAppNameStr := unicode16FromString(lpAppName) + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall6(getPrivateProfileSection, 4, + uintptr(unsafe.Pointer(&lpAppNameStr[0])), + uintptr(unsafe.Pointer(lpReturnedString)), + uintptr(nSize), + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + 0, + 0) + return DWORD(ret1) +} + +func GetPrivateProfileString(lpAppName string, lpKeyName string, lpDefault string, lpReturnedString LPWSTR, nSize DWORD, lpFileName string) DWORD { + lpAppNameStr := unicode16FromString(lpAppName) + lpKeyNameStr := unicode16FromString(lpKeyName) + lpDefaultStr := unicode16FromString(lpDefault) + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall6(getPrivateProfileString, 6, + uintptr(unsafe.Pointer(&lpAppNameStr[0])), + uintptr(unsafe.Pointer(&lpKeyNameStr[0])), + uintptr(unsafe.Pointer(&lpDefaultStr[0])), + uintptr(unsafe.Pointer(lpReturnedString)), + uintptr(nSize), + uintptr(unsafe.Pointer(&lpFileNameStr[0]))) + return DWORD(ret1) +} + +func GetPrivateProfileStruct(lpszSection string, lpszKey string, lpStruct LPVOID, uSizeStruct UINT, szFile string) bool { + lpszSectionStr := unicode16FromString(lpszSection) + lpszKeyStr := unicode16FromString(lpszKey) + szFileStr := unicode16FromString(szFile) + ret1 := syscall6(getPrivateProfileStruct, 5, + uintptr(unsafe.Pointer(&lpszSectionStr[0])), + uintptr(unsafe.Pointer(&lpszKeyStr[0])), + uintptr(unsafe.Pointer(lpStruct)), + uintptr(uSizeStruct), + uintptr(unsafe.Pointer(&szFileStr[0])), + 0) + return ret1 != 0 +} + +func GetProcAddress(hModule HMODULE, lpProcName /*const*/ LPCSTR) FARPROC { + ret1 := syscall3(getProcAddress, 2, + uintptr(hModule), + uintptr(unsafe.Pointer(lpProcName)), + 0) + return func() INT_PTR { + ret2 := syscall3(ret1, 0, + 0, + 0, + 0) + return (INT_PTR)(unsafe.Pointer(ret2)) + } +} + +func GetProcessAffinityMask(hProcess HANDLE, lpProcessAffinityMask *uintptr, lpSystemAffinityMask *uintptr) bool { + ret1 := syscall3(getProcessAffinityMask, 3, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpProcessAffinityMask)), + uintptr(unsafe.Pointer(lpSystemAffinityMask))) + return ret1 != 0 +} + +func GetProcessDEPPolicy(hProcess HANDLE, lpFlags *uint32, lpPermanent *BOOL) bool { + ret1 := syscall3(getProcessDEPPolicy, 3, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpFlags)), + uintptr(unsafe.Pointer(lpPermanent))) + return ret1 != 0 +} + +func GetProcessGroupAffinity(hProcess HANDLE, groupCount PUSHORT, groupArray PUSHORT) bool { + ret1 := syscall3(getProcessGroupAffinity, 3, + uintptr(hProcess), + uintptr(unsafe.Pointer(groupCount)), + uintptr(unsafe.Pointer(groupArray))) + return ret1 != 0 +} + +func GetProcessHandleCount(hProcess HANDLE, pdwHandleCount *DWORD) bool { + ret1 := syscall3(getProcessHandleCount, 2, + uintptr(hProcess), + uintptr(unsafe.Pointer(pdwHandleCount)), + 0) + return ret1 != 0 +} + +func GetProcessHeap() HANDLE { + ret1 := syscall3(getProcessHeap, 0, + 0, + 0, + 0) + return HANDLE(ret1) +} + +func GetProcessHeaps(numberOfHeaps DWORD, processHeaps *HANDLE) DWORD { + ret1 := syscall3(getProcessHeaps, 2, + uintptr(numberOfHeaps), + uintptr(unsafe.Pointer(processHeaps)), + 0) + return DWORD(ret1) +} + +func GetProcessId(process HANDLE) DWORD { + ret1 := syscall3(getProcessId, 1, + uintptr(process), + 0, + 0) + return DWORD(ret1) +} + +func GetProcessIdOfThread(thread HANDLE) DWORD { + ret1 := syscall3(getProcessIdOfThread, 1, + uintptr(thread), + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PIO_COUNTERS +// func GetProcessIoCounters(hProcess HANDLE, lpIoCounters PIO_COUNTERS) bool + +// TODO: Unknown type(s): PZZWSTR +// func GetProcessPreferredUILanguages(dwFlags DWORD, pulNumLanguages *uint32, pwszLanguagesBuffer PZZWSTR, pcchLanguagesBuffer *uint32) bool + +func GetProcessPriorityBoost(hProcess HANDLE, pDisablePriorityBoost *BOOL) bool { + ret1 := syscall3(getProcessPriorityBoost, 2, + uintptr(hProcess), + uintptr(unsafe.Pointer(pDisablePriorityBoost)), + 0) + return ret1 != 0 +} + +func GetProcessShutdownParameters(lpdwLevel *uint32, lpdwFlags *uint32) bool { + ret1 := syscall3(getProcessShutdownParameters, 2, + uintptr(unsafe.Pointer(lpdwLevel)), + uintptr(unsafe.Pointer(lpdwFlags)), + 0) + return ret1 != 0 +} + +func GetProcessTimes(hProcess HANDLE, lpCreationTime *FILETIME, lpExitTime *FILETIME, lpKernelTime *FILETIME, lpUserTime *FILETIME) bool { + ret1 := syscall6(getProcessTimes, 5, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpCreationTime)), + uintptr(unsafe.Pointer(lpExitTime)), + uintptr(unsafe.Pointer(lpKernelTime)), + uintptr(unsafe.Pointer(lpUserTime)), + 0) + return ret1 != 0 +} + +func GetProcessVersion(processId DWORD) DWORD { + ret1 := syscall3(getProcessVersion, 1, + uintptr(processId), + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PSIZE_T +// func GetProcessWorkingSetSize(hProcess HANDLE, lpMinimumWorkingSetSize PSIZE_T, lpMaximumWorkingSetSize PSIZE_T) bool + +// TODO: Unknown type(s): PSIZE_T +// func GetProcessWorkingSetSizeEx(hProcess HANDLE, lpMinimumWorkingSetSize PSIZE_T, lpMaximumWorkingSetSize PSIZE_T, flags *DWORD) bool + +// TODO: Unknown type(s): PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION +// func GetProcessorSystemCycleTime(group USHORT, buffer PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION, returnedLength *DWORD) bool + +func GetProductInfo(dwOSMajorVersion DWORD, dwOSMinorVersion DWORD, dwSpMajorVersion DWORD, dwSpMinorVersion DWORD, pdwReturnedProductType *DWORD) bool { + ret1 := syscall6(getProductInfo, 5, + uintptr(dwOSMajorVersion), + uintptr(dwOSMinorVersion), + uintptr(dwSpMajorVersion), + uintptr(dwSpMinorVersion), + uintptr(unsafe.Pointer(pdwReturnedProductType)), + 0) + return ret1 != 0 +} + +func GetProfileInt(lpAppName string, lpKeyName string, nDefault INT) UINT { + lpAppNameStr := unicode16FromString(lpAppName) + lpKeyNameStr := unicode16FromString(lpKeyName) + ret1 := syscall3(getProfileInt, 3, + uintptr(unsafe.Pointer(&lpAppNameStr[0])), + uintptr(unsafe.Pointer(&lpKeyNameStr[0])), + uintptr(nDefault)) + return UINT(ret1) +} + +func GetProfileSection(lpAppName string, lpReturnedString LPWSTR, nSize DWORD) DWORD { + lpAppNameStr := unicode16FromString(lpAppName) + ret1 := syscall3(getProfileSection, 3, + uintptr(unsafe.Pointer(&lpAppNameStr[0])), + uintptr(unsafe.Pointer(lpReturnedString)), + uintptr(nSize)) + return DWORD(ret1) +} + +func GetProfileString(lpAppName string, lpKeyName string, lpDefault string, lpReturnedString LPWSTR, nSize DWORD) DWORD { + lpAppNameStr := unicode16FromString(lpAppName) + lpKeyNameStr := unicode16FromString(lpKeyName) + lpDefaultStr := unicode16FromString(lpDefault) + ret1 := syscall6(getProfileString, 5, + uintptr(unsafe.Pointer(&lpAppNameStr[0])), + uintptr(unsafe.Pointer(&lpKeyNameStr[0])), + uintptr(unsafe.Pointer(&lpDefaultStr[0])), + uintptr(unsafe.Pointer(lpReturnedString)), + uintptr(nSize), + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PULONG_PTR +// func GetQueuedCompletionStatus(completionPort HANDLE, lpNumberOfBytesTransferred *uint32, lpCompletionKey PULONG_PTR, lpOverlapped *LPOVERLAPPED, dwMilliseconds DWORD) bool + +// TODO: Unknown type(s): LPOVERLAPPED_ENTRY +// func GetQueuedCompletionStatusEx(completionPort HANDLE, lpCompletionPortEntries LPOVERLAPPED_ENTRY, ulCount ULONG, ulNumEntriesRemoved *uint32, dwMilliseconds DWORD, fAlertable bool) bool + +func GetShortPathName(lpszLongPath string, lpszShortPath LPWSTR, cchBuffer DWORD) DWORD { + lpszLongPathStr := unicode16FromString(lpszLongPath) + ret1 := syscall3(getShortPathName, 3, + uintptr(unsafe.Pointer(&lpszLongPathStr[0])), + uintptr(unsafe.Pointer(lpszShortPath)), + uintptr(cchBuffer)) + return DWORD(ret1) +} + +func GetStartupInfo(lpStartupInfo *STARTUPINFO) { + syscall3(getStartupInfo, 1, + uintptr(unsafe.Pointer(lpStartupInfo)), + 0, + 0) +} + +func GetStdHandle(nStdHandle DWORD) HANDLE { + ret1 := syscall3(getStdHandle, 1, + uintptr(nStdHandle), + 0, + 0) + return HANDLE(ret1) +} + +func GetStringScripts(dwFlags DWORD, lpString string, cchString int32, lpScripts LPWSTR, cchScripts int32) int32 { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall6(getStringScripts, 5, + uintptr(dwFlags), + uintptr(unsafe.Pointer(&lpStringStr[0])), + uintptr(cchString), + uintptr(unsafe.Pointer(lpScripts)), + uintptr(cchScripts), + 0) + return int32(ret1) +} + +// TODO: Unknown type(s): LPCWCH +// func GetStringTypeEx(locale LCID, dwInfoType DWORD, lpSrcStr LPCWCH, cchSrc int32, lpCharType *uint16) bool + +// TODO: Unknown type(s): LPCWCH +// func GetStringType(dwInfoType DWORD, lpSrcStr LPCWCH, cchSrc int32, lpCharType *uint16) bool + +// TODO: Unknown type(s): DEP_SYSTEM_POLICY_TYPE +// func GetSystemDEPPolicy() DEP_SYSTEM_POLICY_TYPE + +func GetSystemDefaultLCID() LCID { + ret1 := syscall3(getSystemDefaultLCID, 0, + 0, + 0, + 0) + return LCID(ret1) +} + +func GetSystemDefaultLangID() LANGID { + ret1 := syscall3(getSystemDefaultLangID, 0, + 0, + 0, + 0) + return LANGID(ret1) +} + +func GetSystemDefaultLocaleName(lpLocaleName LPWSTR, cchLocaleName int32) int32 { + ret1 := syscall3(getSystemDefaultLocaleName, 2, + uintptr(unsafe.Pointer(lpLocaleName)), + uintptr(cchLocaleName), + 0) + return int32(ret1) +} + +func GetSystemDefaultUILanguage() LANGID { + ret1 := syscall3(getSystemDefaultUILanguage, 0, + 0, + 0, + 0) + return LANGID(ret1) +} + +func GetSystemDirectory(lpBuffer LPWSTR, uSize UINT) UINT { + ret1 := syscall3(getSystemDirectory, 2, + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(uSize), + 0) + return UINT(ret1) +} + +// TODO: Unknown type(s): PSIZE_T +// func GetSystemFileCacheSize(lpMinimumFileCacheSize PSIZE_T, lpMaximumFileCacheSize PSIZE_T, lpFlags *DWORD) bool + +func GetSystemFirmwareTable(firmwareTableProviderSignature DWORD, firmwareTableID DWORD, pFirmwareTableBuffer uintptr, bufferSize DWORD) UINT { + ret1 := syscall6(getSystemFirmwareTable, 4, + uintptr(firmwareTableProviderSignature), + uintptr(firmwareTableID), + pFirmwareTableBuffer, + uintptr(bufferSize), + 0, + 0) + return UINT(ret1) +} + +func GetSystemInfo(lpSystemInfo *SYSTEM_INFO) { + syscall3(getSystemInfo, 1, + uintptr(unsafe.Pointer(lpSystemInfo)), + 0, + 0) +} + +// TODO: Unknown type(s): LPSYSTEM_POWER_STATUS +// func GetSystemPowerStatus(lpSystemPowerStatus LPSYSTEM_POWER_STATUS) bool + +// TODO: Unknown type(s): PZZWSTR +// func GetSystemPreferredUILanguages(dwFlags DWORD, pulNumLanguages *uint32, pwszLanguagesBuffer PZZWSTR, pcchLanguagesBuffer *uint32) bool + +func GetSystemRegistryQuota(pdwQuotaAllowed *DWORD, pdwQuotaUsed *DWORD) bool { + ret1 := syscall3(getSystemRegistryQuota, 2, + uintptr(unsafe.Pointer(pdwQuotaAllowed)), + uintptr(unsafe.Pointer(pdwQuotaUsed)), + 0) + return ret1 != 0 +} + +func GetSystemTime(lpSystemTime *SYSTEMTIME) { + syscall3(getSystemTime, 1, + uintptr(unsafe.Pointer(lpSystemTime)), + 0, + 0) +} + +func GetSystemTimeAdjustment(lpTimeAdjustment *DWORD, lpTimeIncrement *DWORD, lpTimeAdjustmentDisabled *BOOL) bool { + ret1 := syscall3(getSystemTimeAdjustment, 3, + uintptr(unsafe.Pointer(lpTimeAdjustment)), + uintptr(unsafe.Pointer(lpTimeIncrement)), + uintptr(unsafe.Pointer(lpTimeAdjustmentDisabled))) + return ret1 != 0 +} + +func GetSystemTimeAsFileTime(lpSystemTimeAsFileTime *FILETIME) { + syscall3(getSystemTimeAsFileTime, 1, + uintptr(unsafe.Pointer(lpSystemTimeAsFileTime)), + 0, + 0) +} + +func GetSystemTimePreciseAsFileTime(lpSystemTimeAsFileTime *FILETIME) { + syscall3(getSystemTimePreciseAsFileTime, 1, + uintptr(unsafe.Pointer(lpSystemTimeAsFileTime)), + 0, + 0) +} + +func GetSystemTimes(lpIdleTime *FILETIME, lpKernelTime *FILETIME, lpUserTime *FILETIME) bool { + ret1 := syscall3(getSystemTimes, 3, + uintptr(unsafe.Pointer(lpIdleTime)), + uintptr(unsafe.Pointer(lpKernelTime)), + uintptr(unsafe.Pointer(lpUserTime))) + return ret1 != 0 +} + +func GetSystemWindowsDirectory(lpBuffer LPWSTR, uSize UINT) UINT { + ret1 := syscall3(getSystemWindowsDirectory, 2, + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(uSize), + 0) + return UINT(ret1) +} + +func GetSystemWow64Directory(lpBuffer LPWSTR, uSize UINT) UINT { + ret1 := syscall3(getSystemWow64Directory, 2, + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(uSize), + 0) + return UINT(ret1) +} + +func GetTapeParameters(hDevice HANDLE, dwOperation DWORD, lpdwSize *uint32, lpTapeInformation LPVOID) DWORD { + ret1 := syscall6(getTapeParameters, 4, + uintptr(hDevice), + uintptr(dwOperation), + uintptr(unsafe.Pointer(lpdwSize)), + uintptr(unsafe.Pointer(lpTapeInformation)), + 0, + 0) + return DWORD(ret1) +} + +func GetTapePosition(hDevice HANDLE, dwPositionType DWORD, lpdwPartition *uint32, lpdwOffsetLow *uint32, lpdwOffsetHigh *uint32) DWORD { + ret1 := syscall6(getTapePosition, 5, + uintptr(hDevice), + uintptr(dwPositionType), + uintptr(unsafe.Pointer(lpdwPartition)), + uintptr(unsafe.Pointer(lpdwOffsetLow)), + uintptr(unsafe.Pointer(lpdwOffsetHigh)), + 0) + return DWORD(ret1) +} + +func GetTapeStatus(hDevice HANDLE) DWORD { + ret1 := syscall3(getTapeStatus, 1, + uintptr(hDevice), + 0, + 0) + return DWORD(ret1) +} + +func GetTempFileName(lpPathName string, lpPrefixString string, uUnique UINT, lpTempFileName LPWSTR) UINT { + lpPathNameStr := unicode16FromString(lpPathName) + lpPrefixStringStr := unicode16FromString(lpPrefixString) + ret1 := syscall6(getTempFileName, 4, + uintptr(unsafe.Pointer(&lpPathNameStr[0])), + uintptr(unsafe.Pointer(&lpPrefixStringStr[0])), + uintptr(uUnique), + uintptr(unsafe.Pointer(lpTempFileName)), + 0, + 0) + return UINT(ret1) +} + +func GetTempPath(nBufferLength DWORD, lpBuffer LPWSTR) DWORD { + ret1 := syscall3(getTempPath, 2, + uintptr(nBufferLength), + uintptr(unsafe.Pointer(lpBuffer)), + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): LPCONTEXT +// func GetThreadContext(hThread HANDLE, lpContext LPCONTEXT) bool + +func GetThreadErrorMode() DWORD { + ret1 := syscall3(getThreadErrorMode, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PGROUP_AFFINITY +// func GetThreadGroupAffinity(hThread HANDLE, groupAffinity PGROUP_AFFINITY) bool + +func GetThreadIOPendingFlag(hThread HANDLE, lpIOIsPending *BOOL) bool { + ret1 := syscall3(getThreadIOPendingFlag, 2, + uintptr(hThread), + uintptr(unsafe.Pointer(lpIOIsPending)), + 0) + return ret1 != 0 +} + +func GetThreadId(thread HANDLE) DWORD { + ret1 := syscall3(getThreadId, 1, + uintptr(thread), + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PPROCESSOR_NUMBER +// func GetThreadIdealProcessorEx(hThread HANDLE, lpIdealProcessor PPROCESSOR_NUMBER) bool + +func GetThreadLocale() LCID { + ret1 := syscall3(getThreadLocale, 0, + 0, + 0, + 0) + return LCID(ret1) +} + +// TODO: Unknown type(s): PZZWSTR +// func GetThreadPreferredUILanguages(dwFlags DWORD, pulNumLanguages *uint32, pwszLanguagesBuffer PZZWSTR, pcchLanguagesBuffer *uint32) bool + +func GetThreadPriority(hThread HANDLE) int32 { + ret1 := syscall3(getThreadPriority, 1, + uintptr(hThread), + 0, + 0) + return int32(ret1) +} + +func GetThreadPriorityBoost(hThread HANDLE, pDisablePriorityBoost *BOOL) bool { + ret1 := syscall3(getThreadPriorityBoost, 2, + uintptr(hThread), + uintptr(unsafe.Pointer(pDisablePriorityBoost)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPLDT_ENTRY +// func GetThreadSelectorEntry(hThread HANDLE, dwSelector DWORD, lpSelectorEntry LPLDT_ENTRY) bool + +func GetThreadTimes(hThread HANDLE, lpCreationTime *FILETIME, lpExitTime *FILETIME, lpKernelTime *FILETIME, lpUserTime *FILETIME) bool { + ret1 := syscall6(getThreadTimes, 5, + uintptr(hThread), + uintptr(unsafe.Pointer(lpCreationTime)), + uintptr(unsafe.Pointer(lpExitTime)), + uintptr(unsafe.Pointer(lpKernelTime)), + uintptr(unsafe.Pointer(lpUserTime)), + 0) + return ret1 != 0 +} + +func GetThreadUILanguage() LANGID { + ret1 := syscall3(getThreadUILanguage, 0, + 0, + 0, + 0) + return LANGID(ret1) +} + +func GetTickCount() DWORD { + ret1 := syscall3(getTickCount, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func GetTickCount64() ULONGLONG { + ret1 := syscall3(getTickCount64, 0, + 0, + 0, + 0) + return ULONGLONG(ret1) +} + +func GetTimeFormatEx(lpLocaleName string, dwFlags DWORD, lpTime /*const*/ *SYSTEMTIME, lpFormat string, lpTimeStr LPWSTR, cchTime int32) int32 { + lpLocaleNameStr := unicode16FromString(lpLocaleName) + lpFormatStr := unicode16FromString(lpFormat) + ret1 := syscall6(getTimeFormatEx, 6, + uintptr(unsafe.Pointer(&lpLocaleNameStr[0])), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpTime)), + uintptr(unsafe.Pointer(&lpFormatStr[0])), + uintptr(unsafe.Pointer(lpTimeStr)), + uintptr(cchTime)) + return int32(ret1) +} + +func GetTimeFormat(locale LCID, dwFlags DWORD, lpTime /*const*/ *SYSTEMTIME, lpFormat string, lpTimeStr LPWSTR, cchTime int32) int32 { + lpFormatStr := unicode16FromString(lpFormat) + ret1 := syscall6(getTimeFormat, 6, + uintptr(locale), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpTime)), + uintptr(unsafe.Pointer(&lpFormatStr[0])), + uintptr(unsafe.Pointer(lpTimeStr)), + uintptr(cchTime)) + return int32(ret1) +} + +// TODO: Unknown type(s): LPTIME_ZONE_INFORMATION +// func GetTimeZoneInformation(lpTimeZoneInformation LPTIME_ZONE_INFORMATION) DWORD + +// TODO: Unknown type(s): LPTIME_ZONE_INFORMATION, PDYNAMIC_TIME_ZONE_INFORMATION +// func GetTimeZoneInformationForYear(wYear USHORT, pdtzi PDYNAMIC_TIME_ZONE_INFORMATION, ptzi LPTIME_ZONE_INFORMATION) bool + +// TODO: Unknown type(s): PZZWSTR +// func GetUILanguageInfo(dwFlags DWORD, pwmszLanguage /*const*/ PCZZWSTR, pwszFallbackLanguages PZZWSTR, pcchFallbackLanguages *DWORD, pAttributes *DWORD) bool + +func GetUserDefaultLCID() LCID { + ret1 := syscall3(getUserDefaultLCID, 0, + 0, + 0, + 0) + return LCID(ret1) +} + +func GetUserDefaultLangID() LANGID { + ret1 := syscall3(getUserDefaultLangID, 0, + 0, + 0, + 0) + return LANGID(ret1) +} + +func GetUserDefaultLocaleName(lpLocaleName LPWSTR, cchLocaleName int32) int32 { + ret1 := syscall3(getUserDefaultLocaleName, 2, + uintptr(unsafe.Pointer(lpLocaleName)), + uintptr(cchLocaleName), + 0) + return int32(ret1) +} + +func GetUserDefaultUILanguage() LANGID { + ret1 := syscall3(getUserDefaultUILanguage, 0, + 0, + 0, + 0) + return LANGID(ret1) +} + +// TODO: Unknown type(s): GEOCLASS +// func GetUserGeoID(geoClass GEOCLASS) GEOID + +// TODO: Unknown type(s): PZZWSTR +// func GetUserPreferredUILanguages(dwFlags DWORD, pulNumLanguages *uint32, pwszLanguagesBuffer PZZWSTR, pcchLanguagesBuffer *uint32) bool + +func GetVersion() DWORD { + ret1 := syscall3(getVersion, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): LPOSVERSIONINFOW +// func GetVersionEx(lpVersionInformation LPOSVERSIONINFOW) bool + +func GetVolumeInformationByHandleW(hFile HANDLE, lpVolumeNameBuffer LPWSTR, nVolumeNameSize DWORD, lpVolumeSerialNumber *uint32, lpMaximumComponentLength *uint32, lpFileSystemFlags *uint32, lpFileSystemNameBuffer LPWSTR, nFileSystemNameSize DWORD) bool { + ret1 := syscall9(getVolumeInformationByHandleW, 8, + uintptr(hFile), + uintptr(unsafe.Pointer(lpVolumeNameBuffer)), + uintptr(nVolumeNameSize), + uintptr(unsafe.Pointer(lpVolumeSerialNumber)), + uintptr(unsafe.Pointer(lpMaximumComponentLength)), + uintptr(unsafe.Pointer(lpFileSystemFlags)), + uintptr(unsafe.Pointer(lpFileSystemNameBuffer)), + uintptr(nFileSystemNameSize), + 0) + return ret1 != 0 +} + +func GetVolumeInformation(lpRootPathName string, lpVolumeNameBuffer LPWSTR, nVolumeNameSize DWORD, lpVolumeSerialNumber *uint32, lpMaximumComponentLength *uint32, lpFileSystemFlags *uint32, lpFileSystemNameBuffer LPWSTR, nFileSystemNameSize DWORD) bool { + lpRootPathNameStr := unicode16FromString(lpRootPathName) + ret1 := syscall9(getVolumeInformation, 8, + uintptr(unsafe.Pointer(&lpRootPathNameStr[0])), + uintptr(unsafe.Pointer(lpVolumeNameBuffer)), + uintptr(nVolumeNameSize), + uintptr(unsafe.Pointer(lpVolumeSerialNumber)), + uintptr(unsafe.Pointer(lpMaximumComponentLength)), + uintptr(unsafe.Pointer(lpFileSystemFlags)), + uintptr(unsafe.Pointer(lpFileSystemNameBuffer)), + uintptr(nFileSystemNameSize), + 0) + return ret1 != 0 +} + +func GetVolumeNameForVolumeMountPoint(lpszVolumeMountPoint string, lpszVolumeName LPWSTR, cchBufferLength DWORD) bool { + lpszVolumeMountPointStr := unicode16FromString(lpszVolumeMountPoint) + ret1 := syscall3(getVolumeNameForVolumeMountPoint, 3, + uintptr(unsafe.Pointer(&lpszVolumeMountPointStr[0])), + uintptr(unsafe.Pointer(lpszVolumeName)), + uintptr(cchBufferLength)) + return ret1 != 0 +} + +func GetVolumePathName(lpszFileName string, lpszVolumePathName LPWSTR, cchBufferLength DWORD) bool { + lpszFileNameStr := unicode16FromString(lpszFileName) + ret1 := syscall3(getVolumePathName, 3, + uintptr(unsafe.Pointer(&lpszFileNameStr[0])), + uintptr(unsafe.Pointer(lpszVolumePathName)), + uintptr(cchBufferLength)) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPWCH +// func GetVolumePathNamesForVolumeName(lpszVolumeName string, lpszVolumePathNames LPWCH, cchBufferLength DWORD, lpcchReturnLength *DWORD) bool + +func GetWindowsDirectory(lpBuffer LPWSTR, uSize UINT) UINT { + ret1 := syscall3(getWindowsDirectory, 2, + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(uSize), + 0) + return UINT(ret1) +} + +func GetWriteWatch(dwFlags DWORD, lpBaseAddress uintptr, dwRegionSize SIZE_T, lpAddresses *PVOID, lpdwCount *ULONG_PTR, lpdwGranularity *uint32) UINT { + ret1 := syscall6(getWriteWatch, 6, + uintptr(dwFlags), + lpBaseAddress, + uintptr(dwRegionSize), + uintptr(unsafe.Pointer(lpAddresses)), + uintptr(unsafe.Pointer(lpdwCount)), + uintptr(unsafe.Pointer(lpdwGranularity))) + return UINT(ret1) +} + +func GlobalAddAtom(lpString string) ATOM { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(globalAddAtom, 1, + uintptr(unsafe.Pointer(&lpStringStr[0])), + 0, + 0) + return ATOM(ret1) +} + +func GlobalAlloc(uFlags UINT, dwBytes SIZE_T) HGLOBAL { + ret1 := syscall3(globalAlloc, 2, + uintptr(uFlags), + uintptr(dwBytes), + 0) + return HGLOBAL(ret1) +} + +func GlobalCompact(dwMinFree DWORD) SIZE_T { + ret1 := syscall3(globalCompact, 1, + uintptr(dwMinFree), + 0, + 0) + return SIZE_T(ret1) +} + +func GlobalDeleteAtom(nAtom ATOM) ATOM { + ret1 := syscall3(globalDeleteAtom, 1, + uintptr(nAtom), + 0, + 0) + return ATOM(ret1) +} + +func GlobalFindAtom(lpString string) ATOM { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(globalFindAtom, 1, + uintptr(unsafe.Pointer(&lpStringStr[0])), + 0, + 0) + return ATOM(ret1) +} + +func GlobalFix(hMem HGLOBAL) { + syscall3(globalFix, 1, + uintptr(hMem), + 0, + 0) +} + +func GlobalFlags(hMem HGLOBAL) UINT { + ret1 := syscall3(globalFlags, 1, + uintptr(hMem), + 0, + 0) + return UINT(ret1) +} + +func GlobalFree(hMem HGLOBAL) HGLOBAL { + ret1 := syscall3(globalFree, 1, + uintptr(hMem), + 0, + 0) + return HGLOBAL(ret1) +} + +func GlobalGetAtomName(nAtom ATOM, lpBuffer LPWSTR, nSize int32) UINT { + ret1 := syscall3(globalGetAtomName, 3, + uintptr(nAtom), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(nSize)) + return UINT(ret1) +} + +func GlobalHandle(pMem /*const*/ uintptr) HGLOBAL { + ret1 := syscall3(globalHandle, 1, + pMem, + 0, + 0) + return HGLOBAL(ret1) +} + +func GlobalLock(hMem HGLOBAL) LPVOID { + ret1 := syscall3(globalLock, 1, + uintptr(hMem), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): LPMEMORYSTATUS +// func GlobalMemoryStatus(lpBuffer LPMEMORYSTATUS) + +// TODO: Unknown type(s): LPMEMORYSTATUSEX +func GlobalMemoryStatusEx(lpBuffer *MEMORYSTATUSEX) bool { + ret1 := syscall3(globalMemoryStatusEx, 1, + uintptr(unsafe.Pointer(lpBuffer)), + 0, + 0) + return ret1 != 0 +} + +func GlobalReAlloc(hMem HGLOBAL, dwBytes SIZE_T, uFlags UINT) HGLOBAL { + ret1 := syscall3(globalReAlloc, 3, + uintptr(hMem), + uintptr(dwBytes), + uintptr(uFlags)) + return HGLOBAL(ret1) +} + +func GlobalSize(hMem HGLOBAL) SIZE_T { + ret1 := syscall3(globalSize, 1, + uintptr(hMem), + 0, + 0) + return SIZE_T(ret1) +} + +func GlobalUnWire(hMem HGLOBAL) bool { + ret1 := syscall3(globalUnWire, 1, + uintptr(hMem), + 0, + 0) + return ret1 != 0 +} + +func GlobalUnfix(hMem HGLOBAL) { + syscall3(globalUnfix, 1, + uintptr(hMem), + 0, + 0) +} + +func GlobalUnlock(hMem HGLOBAL) bool { + ret1 := syscall3(globalUnlock, 1, + uintptr(hMem), + 0, + 0) + return ret1 != 0 +} + +func GlobalWire(hMem HGLOBAL) LPVOID { + ret1 := syscall3(globalWire, 1, + uintptr(hMem), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): LPHEAPENTRY32 +// func Heap32First(lphe LPHEAPENTRY32, th32ProcessID DWORD, th32HeapID *uint32) bool + +// TODO: Unknown type(s): LPHEAPLIST32 +// func Heap32ListFirst(hSnapshot HANDLE, lphl LPHEAPLIST32) bool + +// TODO: Unknown type(s): LPHEAPLIST32 +// func Heap32ListNext(hSnapshot HANDLE, lphl LPHEAPLIST32) bool + +// TODO: Unknown type(s): LPHEAPENTRY32 +// func Heap32Next(lphe LPHEAPENTRY32) bool + +func HeapAlloc(hHeap HANDLE, dwFlags DWORD, dwBytes SIZE_T) LPVOID { + ret1 := syscall3(heapAlloc, 3, + uintptr(hHeap), + uintptr(dwFlags), + uintptr(dwBytes)) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func HeapCompact(hHeap HANDLE, dwFlags DWORD) SIZE_T { + ret1 := syscall3(heapCompact, 2, + uintptr(hHeap), + uintptr(dwFlags), + 0) + return SIZE_T(ret1) +} + +func HeapCreate(flOptions DWORD, dwInitialSize SIZE_T, dwMaximumSize SIZE_T) HANDLE { + ret1 := syscall3(heapCreate, 3, + uintptr(flOptions), + uintptr(dwInitialSize), + uintptr(dwMaximumSize)) + return HANDLE(ret1) +} + +func HeapDestroy(hHeap HANDLE) bool { + ret1 := syscall3(heapDestroy, 1, + uintptr(hHeap), + 0, + 0) + return ret1 != 0 +} + +func HeapFree(hHeap HANDLE, dwFlags DWORD, lpMem LPVOID) bool { + ret1 := syscall3(heapFree, 3, + uintptr(hHeap), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpMem))) + return ret1 != 0 +} + +func HeapLock(hHeap HANDLE) bool { + ret1 := syscall3(heapLock, 1, + uintptr(hHeap), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): HEAP_INFORMATION_CLASS, PSIZE_T +// func HeapQueryInformation(heapHandle HANDLE, heapInformationClass HEAP_INFORMATION_CLASS, heapInformation uintptr, heapInformationLength SIZE_T, returnLength PSIZE_T) bool + +func HeapReAlloc(hHeap HANDLE, dwFlags DWORD, lpMem LPVOID, dwBytes SIZE_T) LPVOID { + ret1 := syscall6(heapReAlloc, 4, + uintptr(hHeap), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpMem)), + uintptr(dwBytes), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): HEAP_INFORMATION_CLASS +// func HeapSetInformation(heapHandle HANDLE, heapInformationClass HEAP_INFORMATION_CLASS, heapInformation uintptr, heapInformationLength SIZE_T) bool + +func HeapSize(hHeap HANDLE, dwFlags DWORD, lpMem /*const*/ uintptr) SIZE_T { + ret1 := syscall3(heapSize, 3, + uintptr(hHeap), + uintptr(dwFlags), + lpMem) + return SIZE_T(ret1) +} + +// TODO: Unknown type(s): LPHEAP_SUMMARY +// func HeapSummary(hHeap HANDLE, dwFlags DWORD, lpSummary LPHEAP_SUMMARY) bool + +func HeapUnlock(hHeap HANDLE) bool { + ret1 := syscall3(heapUnlock, 1, + uintptr(hHeap), + 0, + 0) + return ret1 != 0 +} + +func HeapValidate(hHeap HANDLE, dwFlags DWORD, lpMem /*const*/ uintptr) bool { + ret1 := syscall3(heapValidate, 3, + uintptr(hHeap), + uintptr(dwFlags), + lpMem) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPPROCESS_HEAP_ENTRY +// func HeapWalk(hHeap HANDLE, lpEntry LPPROCESS_HEAP_ENTRY) bool + +func IdnToAscii(dwFlags DWORD, lpUnicodeCharStr string, cchUnicodeChar int32, lpASCIICharStr LPWSTR, cchASCIIChar int32) int32 { + lpUnicodeCharStrStr := unicode16FromString(lpUnicodeCharStr) + ret1 := syscall6(idnToAscii, 5, + uintptr(dwFlags), + uintptr(unsafe.Pointer(&lpUnicodeCharStrStr[0])), + uintptr(cchUnicodeChar), + uintptr(unsafe.Pointer(lpASCIICharStr)), + uintptr(cchASCIIChar), + 0) + return int32(ret1) +} + +func IdnToNameprepUnicode(dwFlags DWORD, lpUnicodeCharStr string, cchUnicodeChar int32, lpNameprepCharStr LPWSTR, cchNameprepChar int32) int32 { + lpUnicodeCharStrStr := unicode16FromString(lpUnicodeCharStr) + ret1 := syscall6(idnToNameprepUnicode, 5, + uintptr(dwFlags), + uintptr(unsafe.Pointer(&lpUnicodeCharStrStr[0])), + uintptr(cchUnicodeChar), + uintptr(unsafe.Pointer(lpNameprepCharStr)), + uintptr(cchNameprepChar), + 0) + return int32(ret1) +} + +func IdnToUnicode(dwFlags DWORD, lpASCIICharStr string, cchASCIIChar int32, lpUnicodeCharStr LPWSTR, cchUnicodeChar int32) int32 { + lpASCIICharStrStr := unicode16FromString(lpASCIICharStr) + ret1 := syscall6(idnToUnicode, 5, + uintptr(dwFlags), + uintptr(unsafe.Pointer(&lpASCIICharStrStr[0])), + uintptr(cchASCIIChar), + uintptr(unsafe.Pointer(lpUnicodeCharStr)), + uintptr(cchUnicodeChar), + 0) + return int32(ret1) +} + +func InitAtomTable(nSize DWORD) bool { + ret1 := syscall3(initAtomTable, 1, + uintptr(nSize), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPINIT_ONCE +// func InitOnceBeginInitialize(lpInitOnce LPINIT_ONCE, dwFlags DWORD, fPending *BOOL, lpContext *LPVOID) bool + +// TODO: Unknown type(s): LPINIT_ONCE +// func InitOnceComplete(lpInitOnce LPINIT_ONCE, dwFlags DWORD, lpContext LPVOID) bool + +// TODO: Unknown type(s): PINIT_ONCE, PINIT_ONCE_FN +// func InitOnceExecuteOnce(initOnce PINIT_ONCE, initFn PINIT_ONCE_FN, parameter uintptr, context *LPVOID) bool + +// TODO: Unknown type(s): PINIT_ONCE +// func InitOnceInitialize(initOnce PINIT_ONCE) + +// TODO: Unknown type(s): PCONDITION_VARIABLE +// func InitializeConditionVariable(conditionVariable PCONDITION_VARIABLE) + +// TODO: Unknown type(s): LPCRITICAL_SECTION +// func InitializeCriticalSection(lpCriticalSection LPCRITICAL_SECTION) + +// TODO: Unknown type(s): LPCRITICAL_SECTION +// func InitializeCriticalSectionAndSpinCount(lpCriticalSection LPCRITICAL_SECTION, dwSpinCount DWORD) bool + +// TODO: Unknown type(s): LPCRITICAL_SECTION +// func InitializeCriticalSectionEx(lpCriticalSection LPCRITICAL_SECTION, dwSpinCount DWORD, flags DWORD) bool + +// TODO: Unknown type(s): LPPROC_THREAD_ATTRIBUTE_LIST, PSIZE_T +// func InitializeProcThreadAttributeList(lpAttributeList LPPROC_THREAD_ATTRIBUTE_LIST, dwAttributeCount DWORD, dwFlags DWORD, lpSize PSIZE_T) bool + +// TODO: Unknown type(s): PSLIST_HEADER +// func InitializeSListHead(listHead PSLIST_HEADER) + +func InitializeSRWLock(sRWLock PSRWLOCK) { + syscall3(initializeSRWLock, 1, + uintptr(unsafe.Pointer(sRWLock)), + 0, + 0) +} + +// TODO: Unknown type(s): PSLIST_ENTRY, PSLIST_HEADER +// func InterlockedFlushSList(listHead PSLIST_HEADER) PSLIST_ENTRY + +// TODO: Unknown type(s): PSLIST_ENTRY, PSLIST_HEADER +// func InterlockedPopEntrySList(listHead PSLIST_HEADER) PSLIST_ENTRY + +// TODO: Unknown type(s): PSLIST_ENTRY, PSLIST_HEADER +// func InterlockedPushEntrySList(listHead PSLIST_HEADER, listEntry PSLIST_ENTRY) PSLIST_ENTRY + +func IsBadCodePtr(lpfn FARPROC) bool { + lpfnCallback := syscall.NewCallback(func() uintptr { + ret := lpfn() + return uintptr(unsafe.Pointer(ret)) + }) + ret1 := syscall3(isBadCodePtr, 1, + lpfnCallback, + 0, + 0) + return ret1 != 0 +} + +func IsBadHugeReadPtr(lp /*const*/ uintptr, ucb *uint32) bool { + ret1 := syscall3(isBadHugeReadPtr, 2, + lp, + uintptr(unsafe.Pointer(ucb)), + 0) + return ret1 != 0 +} + +func IsBadHugeWritePtr(lp LPVOID, ucb *uint32) bool { + ret1 := syscall3(isBadHugeWritePtr, 2, + uintptr(unsafe.Pointer(lp)), + uintptr(unsafe.Pointer(ucb)), + 0) + return ret1 != 0 +} + +func IsBadReadPtr(lp /*const*/ uintptr, ucb *uint32) bool { + ret1 := syscall3(isBadReadPtr, 2, + lp, + uintptr(unsafe.Pointer(ucb)), + 0) + return ret1 != 0 +} + +func IsBadStringPtr(lpsz string, ucchMax *uint32) bool { + lpszStr := unicode16FromString(lpsz) + ret1 := syscall3(isBadStringPtr, 2, + uintptr(unsafe.Pointer(&lpszStr[0])), + uintptr(unsafe.Pointer(ucchMax)), + 0) + return ret1 != 0 +} + +func IsBadWritePtr(lp LPVOID, ucb *uint32) bool { + ret1 := syscall3(isBadWritePtr, 2, + uintptr(unsafe.Pointer(lp)), + uintptr(unsafe.Pointer(ucb)), + 0) + return ret1 != 0 +} + +func IsDBCSLeadByte(testChar BYTE) bool { + ret1 := syscall3(isDBCSLeadByte, 1, + uintptr(testChar), + 0, + 0) + return ret1 != 0 +} + +func IsDBCSLeadByteEx(codePage UINT, testChar BYTE) bool { + ret1 := syscall3(isDBCSLeadByteEx, 2, + uintptr(codePage), + uintptr(testChar), + 0) + return ret1 != 0 +} + +func IsDebuggerPresent() bool { + ret1 := syscall3(isDebuggerPresent, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPNLSVERSIONINFO, NLS_FUNCTION +// func IsNLSDefinedString(function NLS_FUNCTION, dwFlags DWORD, lpVersionInformation LPNLSVERSIONINFO, lpString string, cchStr INT) bool + +// TODO: Unknown type(s): NORM_FORM +// func IsNormalizedString(normForm NORM_FORM, lpString string, cwLength int32) bool + +func IsProcessInJob(processHandle HANDLE, jobHandle HANDLE, result *BOOL) bool { + ret1 := syscall3(isProcessInJob, 3, + uintptr(processHandle), + uintptr(jobHandle), + uintptr(unsafe.Pointer(result))) + return ret1 != 0 +} + +func IsProcessorFeaturePresent(processorFeature DWORD) bool { + ret1 := syscall3(isProcessorFeaturePresent, 1, + uintptr(processorFeature), + 0, + 0) + return ret1 != 0 +} + +func IsSystemResumeAutomatic() bool { + ret1 := syscall3(isSystemResumeAutomatic, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func IsThreadAFiber() bool { + ret1 := syscall3(isThreadAFiber, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PTP_TIMER +// func IsThreadpoolTimerSet(pti PTP_TIMER) bool + +func IsValidCodePage(codePage UINT) bool { + ret1 := syscall3(isValidCodePage, 1, + uintptr(codePage), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LGRPID +// func IsValidLanguageGroup(languageGroup LGRPID, dwFlags DWORD) bool + +func IsValidLocale(locale LCID, dwFlags DWORD) bool { + ret1 := syscall3(isValidLocale, 2, + uintptr(locale), + uintptr(dwFlags), + 0) + return ret1 != 0 +} + +func IsValidLocaleName(lpLocaleName string) bool { + lpLocaleNameStr := unicode16FromString(lpLocaleName) + ret1 := syscall3(isValidLocaleName, 1, + uintptr(unsafe.Pointer(&lpLocaleNameStr[0])), + 0, + 0) + return ret1 != 0 +} + +func IsWow64Process(hProcess HANDLE, wow64Process *BOOL) bool { + ret1 := syscall3(isWow64Process, 2, + uintptr(hProcess), + uintptr(unsafe.Pointer(wow64Process)), + 0) + return ret1 != 0 +} + +func LCIDToLocaleName(locale LCID, lpName LPWSTR, cchName int32, dwFlags DWORD) int32 { + ret1 := syscall6(lCIDToLocaleName, 4, + uintptr(locale), + uintptr(unsafe.Pointer(lpName)), + uintptr(cchName), + uintptr(dwFlags), + 0, + 0) + return int32(ret1) +} + +// TODO: Unknown type(s): LPNLSVERSIONINFO +// func LCMapStringEx(lpLocaleName string, dwMapFlags DWORD, lpSrcStr string, cchSrc int32, lpDestStr LPWSTR, cchDest int32, lpVersionInformation LPNLSVERSIONINFO, lpReserved LPVOID, sortHandle LPARAM) int32 + +func LCMapString(locale LCID, dwMapFlags DWORD, lpSrcStr string, cchSrc int32, lpDestStr LPWSTR, cchDest int32) int32 { + lpSrcStrStr := unicode16FromString(lpSrcStr) + ret1 := syscall6(lCMapString, 6, + uintptr(locale), + uintptr(dwMapFlags), + uintptr(unsafe.Pointer(&lpSrcStrStr[0])), + uintptr(cchSrc), + uintptr(unsafe.Pointer(lpDestStr)), + uintptr(cchDest)) + return int32(ret1) +} + +func LZClose(unnamed0 INT) { + syscall3(lZClose, 1, + uintptr(unnamed0), + 0, + 0) +} + +func LZCopy(unnamed0 INT, unnamed1 INT) LONG { + ret1 := syscall3(lZCopy, 2, + uintptr(unnamed0), + uintptr(unnamed1), + 0) + return LONG(ret1) +} + +func LZDone() { + syscall3(lZDone, 0, + 0, + 0, + 0) +} + +func LZInit(unnamed0 INT) INT { + ret1 := syscall3(lZInit, 1, + uintptr(unnamed0), + 0, + 0) + return INT(ret1) +} + +// TODO: Unknown type(s): LPOFSTRUCT +// func LZOpenFile(unnamed0 LPWSTR, unnamed1 LPOFSTRUCT, unnamed2 WORD) INT + +func LZRead(unnamed0 INT, unnamed1 LPSTR, unnamed2 INT) INT { + ret1 := syscall3(lZRead, 3, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + uintptr(unnamed2)) + return INT(ret1) +} + +func LZSeek(unnamed0 INT, unnamed1 LONG, unnamed2 INT) LONG { + ret1 := syscall3(lZSeek, 3, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2)) + return LONG(ret1) +} + +func LZStart() INT { + ret1 := syscall3(lZStart, 0, + 0, + 0, + 0) + return INT(ret1) +} + +// TODO: Unknown type(s): LPCRITICAL_SECTION +// func LeaveCriticalSection(lpCriticalSection LPCRITICAL_SECTION) + +// TODO: Unknown type(s): PCRITICAL_SECTION, PTP_CALLBACK_INSTANCE +// func LeaveCriticalSectionWhenCallbackReturns(pci PTP_CALLBACK_INSTANCE, pcs PCRITICAL_SECTION) + +func LoadLibraryEx(lpLibFileName string, hFile HANDLE, dwFlags DWORD) HMODULE { + lpLibFileNameStr := unicode16FromString(lpLibFileName) + ret1 := syscall3(loadLibraryEx, 3, + uintptr(unsafe.Pointer(&lpLibFileNameStr[0])), + uintptr(hFile), + uintptr(dwFlags)) + return HMODULE(ret1) +} + +func LoadLibrary(lpLibFileName string) HMODULE { + lpLibFileNameStr := unicode16FromString(lpLibFileName) + ret1 := syscall3(loadLibrary, 1, + uintptr(unsafe.Pointer(&lpLibFileNameStr[0])), + 0, + 0) + return HMODULE(ret1) +} + +func LoadModule(lpModuleName /*const*/ LPCSTR, lpParameterBlock LPVOID) DWORD { + ret1 := syscall3(loadModule, 2, + uintptr(unsafe.Pointer(lpModuleName)), + uintptr(unsafe.Pointer(lpParameterBlock)), + 0) + return DWORD(ret1) +} + +func LoadPackagedLibrary(lpwLibFileName string, reserved DWORD) HMODULE { + lpwLibFileNameStr := unicode16FromString(lpwLibFileName) + ret1 := syscall3(loadPackagedLibrary, 2, + uintptr(unsafe.Pointer(&lpwLibFileNameStr[0])), + uintptr(reserved), + 0) + return HMODULE(ret1) +} + +func LoadResource(hModule HMODULE, hResInfo HRSRC) HGLOBAL { + ret1 := syscall3(loadResource, 2, + uintptr(hModule), + uintptr(hResInfo), + 0) + return HGLOBAL(ret1) +} + +func LocalAlloc(uFlags UINT, uBytes SIZE_T) HLOCAL { + ret1 := syscall3(localAlloc, 2, + uintptr(uFlags), + uintptr(uBytes), + 0) + return HLOCAL(ret1) +} + +func LocalCompact(uMinFree UINT) SIZE_T { + ret1 := syscall3(localCompact, 1, + uintptr(uMinFree), + 0, + 0) + return SIZE_T(ret1) +} + +func LocalFileTimeToFileTime(lpLocalFileTime /*const*/ *FILETIME, lpFileTime *FILETIME) bool { + ret1 := syscall3(localFileTimeToFileTime, 2, + uintptr(unsafe.Pointer(lpLocalFileTime)), + uintptr(unsafe.Pointer(lpFileTime)), + 0) + return ret1 != 0 +} + +func LocalFlags(hMem HLOCAL) UINT { + ret1 := syscall3(localFlags, 1, + uintptr(hMem), + 0, + 0) + return UINT(ret1) +} + +func LocalFree(hMem HLOCAL) HLOCAL { + ret1 := syscall3(localFree, 1, + uintptr(hMem), + 0, + 0) + return HLOCAL(ret1) +} + +func LocalHandle(pMem /*const*/ uintptr) HLOCAL { + ret1 := syscall3(localHandle, 1, + pMem, + 0, + 0) + return HLOCAL(ret1) +} + +func LocalLock(hMem HLOCAL) LPVOID { + ret1 := syscall3(localLock, 1, + uintptr(hMem), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func LocalReAlloc(hMem HLOCAL, uBytes SIZE_T, uFlags UINT) HLOCAL { + ret1 := syscall3(localReAlloc, 3, + uintptr(hMem), + uintptr(uBytes), + uintptr(uFlags)) + return HLOCAL(ret1) +} + +func LocalShrink(hMem HLOCAL, cbNewSize UINT) SIZE_T { + ret1 := syscall3(localShrink, 2, + uintptr(hMem), + uintptr(cbNewSize), + 0) + return SIZE_T(ret1) +} + +func LocalSize(hMem HLOCAL) SIZE_T { + ret1 := syscall3(localSize, 1, + uintptr(hMem), + 0, + 0) + return SIZE_T(ret1) +} + +func LocalUnlock(hMem HLOCAL) bool { + ret1 := syscall3(localUnlock, 1, + uintptr(hMem), + 0, + 0) + return ret1 != 0 +} + +func LocaleNameToLCID(lpName string, dwFlags DWORD) LCID { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall3(localeNameToLCID, 2, + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(dwFlags), + 0) + return LCID(ret1) +} + +func LockFile(hFile HANDLE, dwFileOffsetLow DWORD, dwFileOffsetHigh DWORD, nNumberOfBytesToLockLow DWORD, nNumberOfBytesToLockHigh DWORD) bool { + ret1 := syscall6(lockFile, 5, + uintptr(hFile), + uintptr(dwFileOffsetLow), + uintptr(dwFileOffsetHigh), + uintptr(nNumberOfBytesToLockLow), + uintptr(nNumberOfBytesToLockHigh), + 0) + return ret1 != 0 +} + +func LockFileEx(hFile HANDLE, dwFlags DWORD, dwReserved DWORD, nNumberOfBytesToLockLow DWORD, nNumberOfBytesToLockHigh DWORD, lpOverlapped *OVERLAPPED) bool { + ret1 := syscall6(lockFileEx, 6, + uintptr(hFile), + uintptr(dwFlags), + uintptr(dwReserved), + uintptr(nNumberOfBytesToLockLow), + uintptr(nNumberOfBytesToLockHigh), + uintptr(unsafe.Pointer(lpOverlapped))) + return ret1 != 0 +} + +func LockResource(hResData HGLOBAL) LPVOID { + ret1 := syscall3(lockResource, 1, + uintptr(hResData), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): PULONG_PTR +// func MapUserPhysicalPages(virtualAddress uintptr, numberOfPages *uint32, pageArray PULONG_PTR) bool + +// TODO: Unknown type(s): PULONG_PTR +// func MapUserPhysicalPagesScatter(virtualAddresses *PVOID, numberOfPages *uint32, pageArray PULONG_PTR) bool + +func MapViewOfFile(hFileMappingObject HANDLE, dwDesiredAccess DWORD, dwFileOffsetHigh DWORD, dwFileOffsetLow DWORD, dwNumberOfBytesToMap SIZE_T) LPVOID { + ret1 := syscall6(mapViewOfFile, 5, + uintptr(hFileMappingObject), + uintptr(dwDesiredAccess), + uintptr(dwFileOffsetHigh), + uintptr(dwFileOffsetLow), + uintptr(dwNumberOfBytesToMap), + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func MapViewOfFileEx(hFileMappingObject HANDLE, dwDesiredAccess DWORD, dwFileOffsetHigh DWORD, dwFileOffsetLow DWORD, dwNumberOfBytesToMap SIZE_T, lpBaseAddress LPVOID) LPVOID { + ret1 := syscall6(mapViewOfFileEx, 6, + uintptr(hFileMappingObject), + uintptr(dwDesiredAccess), + uintptr(dwFileOffsetHigh), + uintptr(dwFileOffsetLow), + uintptr(dwNumberOfBytesToMap), + uintptr(unsafe.Pointer(lpBaseAddress))) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func MapViewOfFileExNuma(hFileMappingObject HANDLE, dwDesiredAccess DWORD, dwFileOffsetHigh DWORD, dwFileOffsetLow DWORD, dwNumberOfBytesToMap SIZE_T, lpBaseAddress LPVOID, nndPreferred DWORD) LPVOID { + ret1 := syscall9(mapViewOfFileExNuma, 7, + uintptr(hFileMappingObject), + uintptr(dwDesiredAccess), + uintptr(dwFileOffsetHigh), + uintptr(dwFileOffsetLow), + uintptr(dwNumberOfBytesToMap), + uintptr(unsafe.Pointer(lpBaseAddress)), + uintptr(nndPreferred), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): LPMODULEENTRY32W +// func Module32FirstW(hSnapshot HANDLE, lpme LPMODULEENTRY32W) bool + +// TODO: Unknown type(s): LPMODULEENTRY32W +// func Module32NextW(hSnapshot HANDLE, lpme LPMODULEENTRY32W) bool + +func MoveFileEx(lpExistingFileName string, lpNewFileName string, dwFlags DWORD) bool { + lpExistingFileNameStr := unicode16FromString(lpExistingFileName) + lpNewFileNameStr := unicode16FromString(lpNewFileName) + ret1 := syscall3(moveFileEx, 3, + uintptr(unsafe.Pointer(&lpExistingFileNameStr[0])), + uintptr(unsafe.Pointer(&lpNewFileNameStr[0])), + uintptr(dwFlags)) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPPROGRESS_ROUTINE +// func MoveFileTransacted(lpExistingFileName string, lpNewFileName string, lpProgressRoutine LPPROGRESS_ROUTINE, lpData LPVOID, dwFlags DWORD, hTransaction HANDLE) bool + +func MoveFile(lpExistingFileName string, lpNewFileName string) bool { + lpExistingFileNameStr := unicode16FromString(lpExistingFileName) + lpNewFileNameStr := unicode16FromString(lpNewFileName) + ret1 := syscall3(moveFile, 2, + uintptr(unsafe.Pointer(&lpExistingFileNameStr[0])), + uintptr(unsafe.Pointer(&lpNewFileNameStr[0])), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPPROGRESS_ROUTINE +// func MoveFileWithProgress(lpExistingFileName string, lpNewFileName string, lpProgressRoutine LPPROGRESS_ROUTINE, lpData LPVOID, dwFlags DWORD) bool + +func MulDiv(nNumber int32, nNumerator int32, nDenominator int32) int32 { + ret1 := syscall3(mulDiv, 3, + uintptr(nNumber), + uintptr(nNumerator), + uintptr(nDenominator)) + return int32(ret1) +} + +// TODO: Unknown type(s): LPCCH +// func MultiByteToWideChar(codePage UINT, dwFlags DWORD, lpMultiByteStr LPCCH, cbMultiByte int32, lpWideCharStr LPWSTR, cchWideChar int32) int32 + +func NeedCurrentDirectoryForExePath(exeName string) bool { + exeNameStr := unicode16FromString(exeName) + ret1 := syscall3(needCurrentDirectoryForExePath, 1, + uintptr(unsafe.Pointer(&exeNameStr[0])), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): NORM_FORM +// func NormalizeString(normForm NORM_FORM, lpSrcString string, cwSrcLength int32, lpDstString LPWSTR, cwDstLength int32) int32 + +func NotifyUILanguageChange(dwFlags DWORD, pcwstrNewLanguage string, pcwstrPreviousLanguage string, dwReserved DWORD, pdwStatusRtrn *DWORD) bool { + pcwstrNewLanguageStr := unicode16FromString(pcwstrNewLanguage) + pcwstrPreviousLanguageStr := unicode16FromString(pcwstrPreviousLanguage) + ret1 := syscall6(notifyUILanguageChange, 5, + uintptr(dwFlags), + uintptr(unsafe.Pointer(&pcwstrNewLanguageStr[0])), + uintptr(unsafe.Pointer(&pcwstrPreviousLanguageStr[0])), + uintptr(dwReserved), + uintptr(unsafe.Pointer(pdwStatusRtrn)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): OFFER_PRIORITY +// func OfferVirtualMemory(virtualAddress uintptr, size SIZE_T, priority OFFER_PRIORITY) DWORD + +func OpenEvent(dwDesiredAccess DWORD, bInheritHandle bool, lpName string) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall3(openEvent, 3, + uintptr(dwDesiredAccess), + getUintptrFromBool(bInheritHandle), + uintptr(unsafe.Pointer(&lpNameStr[0]))) + return HANDLE(ret1) +} + +// TODO: Unknown type(s): LPOFSTRUCT +// func OpenFile(lpFileName /*const*/ LPCSTR, lpReOpenBuff LPOFSTRUCT, uStyle UINT) HFILE + +// TODO: Unknown type(s): LPFILE_ID_DESCRIPTOR +// func OpenFileById(hVolumeHint HANDLE, lpFileId LPFILE_ID_DESCRIPTOR, dwDesiredAccess DWORD, dwShareMode DWORD, lpSecurityAttributes *SECURITY_ATTRIBUTES, dwFlagsAndAttributes DWORD) HANDLE + +func OpenFileMapping(dwDesiredAccess DWORD, bInheritHandle bool, lpName string) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall3(openFileMapping, 3, + uintptr(dwDesiredAccess), + getUintptrFromBool(bInheritHandle), + uintptr(unsafe.Pointer(&lpNameStr[0]))) + return HANDLE(ret1) +} + +func OpenJobObject(dwDesiredAccess DWORD, bInheritHandle bool, lpName string) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall3(openJobObject, 3, + uintptr(dwDesiredAccess), + getUintptrFromBool(bInheritHandle), + uintptr(unsafe.Pointer(&lpNameStr[0]))) + return HANDLE(ret1) +} + +func OpenMutex(dwDesiredAccess DWORD, bInheritHandle bool, lpName string) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall3(openMutex, 3, + uintptr(dwDesiredAccess), + getUintptrFromBool(bInheritHandle), + uintptr(unsafe.Pointer(&lpNameStr[0]))) + return HANDLE(ret1) +} + +func OpenPrivateNamespace(lpBoundaryDescriptor LPVOID, lpAliasPrefix string) HANDLE { + lpAliasPrefixStr := unicode16FromString(lpAliasPrefix) + ret1 := syscall3(openPrivateNamespace, 2, + uintptr(unsafe.Pointer(lpBoundaryDescriptor)), + uintptr(unsafe.Pointer(&lpAliasPrefixStr[0])), + 0) + return HANDLE(ret1) +} + +func OpenProcess(dwDesiredAccess DWORD, bInheritHandle bool, dwProcessId DWORD) HANDLE { + ret1 := syscall3(openProcess, 3, + uintptr(dwDesiredAccess), + getUintptrFromBool(bInheritHandle), + uintptr(dwProcessId)) + return HANDLE(ret1) +} + +func OpenSemaphore(dwDesiredAccess DWORD, bInheritHandle bool, lpName string) HANDLE { + lpNameStr := unicode16FromString(lpName) + ret1 := syscall3(openSemaphore, 3, + uintptr(dwDesiredAccess), + getUintptrFromBool(bInheritHandle), + uintptr(unsafe.Pointer(&lpNameStr[0]))) + return HANDLE(ret1) +} + +func OpenThread(dwDesiredAccess DWORD, bInheritHandle bool, dwThreadId DWORD) HANDLE { + ret1 := syscall3(openThread, 3, + uintptr(dwDesiredAccess), + getUintptrFromBool(bInheritHandle), + uintptr(dwThreadId)) + return HANDLE(ret1) +} + +func OpenWaitableTimer(dwDesiredAccess DWORD, bInheritHandle bool, lpTimerName string) HANDLE { + lpTimerNameStr := unicode16FromString(lpTimerName) + ret1 := syscall3(openWaitableTimer, 3, + uintptr(dwDesiredAccess), + getUintptrFromBool(bInheritHandle), + uintptr(unsafe.Pointer(&lpTimerNameStr[0]))) + return HANDLE(ret1) +} + +func OutputDebugString(lpOutputString string) { + lpOutputStringStr := unicode16FromString(lpOutputString) + syscall3(outputDebugString, 1, + uintptr(unsafe.Pointer(&lpOutputStringStr[0])), + 0, + 0) +} + +// TODO: Unknown type(s): PINPUT_RECORD +// func PeekConsoleInput(hConsoleInput HANDLE, lpBuffer PINPUT_RECORD, nLength DWORD, lpNumberOfEventsRead *uint32) bool + +func PeekNamedPipe(hNamedPipe HANDLE, lpBuffer LPVOID, nBufferSize DWORD, lpBytesRead *uint32, lpTotalBytesAvail *uint32, lpBytesLeftThisMessage *uint32) bool { + ret1 := syscall6(peekNamedPipe, 6, + uintptr(hNamedPipe), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(nBufferSize), + uintptr(unsafe.Pointer(lpBytesRead)), + uintptr(unsafe.Pointer(lpTotalBytesAvail)), + uintptr(unsafe.Pointer(lpBytesLeftThisMessage))) + return ret1 != 0 +} + +func PostQueuedCompletionStatus(completionPort HANDLE, dwNumberOfBytesTransferred DWORD, dwCompletionKey *uint32, lpOverlapped *OVERLAPPED) bool { + ret1 := syscall6(postQueuedCompletionStatus, 4, + uintptr(completionPort), + uintptr(dwNumberOfBytesTransferred), + uintptr(unsafe.Pointer(dwCompletionKey)), + uintptr(unsafe.Pointer(lpOverlapped)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): POWER_REQUEST_TYPE +// func PowerClearRequest(powerRequest HANDLE, requestType POWER_REQUEST_TYPE) bool + +// TODO: Unknown type(s): PREASON_CONTEXT +// func PowerCreateRequest(context PREASON_CONTEXT) HANDLE + +// TODO: Unknown type(s): POWER_REQUEST_TYPE +// func PowerSetRequest(powerRequest HANDLE, requestType POWER_REQUEST_TYPE) bool + +// TODO: Unknown type(s): PWIN32_MEMORY_RANGE_ENTRY +// func PrefetchVirtualMemory(hProcess HANDLE, numberOfEntries *uint32, virtualAddresses PWIN32_MEMORY_RANGE_ENTRY, flags ULONG) bool + +func PrepareTape(hDevice HANDLE, dwOperation DWORD, bImmediate bool) DWORD { + ret1 := syscall3(prepareTape, 3, + uintptr(hDevice), + uintptr(dwOperation), + getUintptrFromBool(bImmediate)) + return DWORD(ret1) +} + +// TODO: Unknown type(s): LPPROCESSENTRY32W +// func Process32FirstW(hSnapshot HANDLE, lppe LPPROCESSENTRY32W) bool + +// TODO: Unknown type(s): LPPROCESSENTRY32W +func Process32Next(hSnapshot HANDLE, lppe *LPPROCESSENTRY32) bool { + ret1 := syscall3(process32Next, 2, + uintptr(hSnapshot), + uintptr(unsafe.Pointer(lppe)), + 0) + return ret1 != 0 +} + +func ProcessIdToSessionId(dwProcessId DWORD, pSessionId *uint32) bool { + ret1 := syscall3(processIdToSessionId, 2, + uintptr(dwProcessId), + uintptr(unsafe.Pointer(pSessionId)), + 0) + return ret1 != 0 +} + +func PulseEvent(hEvent HANDLE) bool { + ret1 := syscall3(pulseEvent, 1, + uintptr(hEvent), + 0, + 0) + return ret1 != 0 +} + +func PurgeComm(hFile HANDLE, dwFlags DWORD) bool { + ret1 := syscall3(purgeComm, 2, + uintptr(hFile), + uintptr(dwFlags), + 0) + return ret1 != 0 +} + +func QueryActCtxSettingsW(dwFlags DWORD, hActCtx HANDLE, settingsNameSpace string, settingName string, pvBuffer PWSTR, dwBuffer SIZE_T, pdwWrittenOrRequired *SIZE_T) bool { + settingsNameSpaceStr := unicode16FromString(settingsNameSpace) + settingNameStr := unicode16FromString(settingName) + ret1 := syscall9(queryActCtxSettingsW, 7, + uintptr(dwFlags), + uintptr(hActCtx), + uintptr(unsafe.Pointer(&settingsNameSpaceStr[0])), + uintptr(unsafe.Pointer(&settingNameStr[0])), + uintptr(unsafe.Pointer(pvBuffer)), + uintptr(dwBuffer), + uintptr(unsafe.Pointer(pdwWrittenOrRequired)), + 0, + 0) + return ret1 != 0 +} + +func QueryActCtxW(dwFlags DWORD, hActCtx HANDLE, pvSubInstance uintptr, ulInfoClass ULONG, pvBuffer uintptr, cbBuffer SIZE_T, pcbWrittenOrRequired *SIZE_T) bool { + ret1 := syscall9(queryActCtxW, 7, + uintptr(dwFlags), + uintptr(hActCtx), + pvSubInstance, + uintptr(ulInfoClass), + pvBuffer, + uintptr(cbBuffer), + uintptr(unsafe.Pointer(pcbWrittenOrRequired)), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PSLIST_HEADER +// func QueryDepthSList(listHead PSLIST_HEADER) USHORT + +func QueryDosDevice(lpDeviceName string, lpTargetPath LPWSTR, ucchMax DWORD) DWORD { + lpDeviceNameStr := unicode16FromString(lpDeviceName) + ret1 := syscall3(queryDosDevice, 3, + uintptr(unsafe.Pointer(&lpDeviceNameStr[0])), + uintptr(unsafe.Pointer(lpTargetPath)), + uintptr(ucchMax)) + return DWORD(ret1) +} + +func QueryFullProcessImageName(hProcess HANDLE, dwFlags DWORD, lpExeName LPWSTR, lpdwSize *DWORD) bool { + ret1 := syscall6(queryFullProcessImageName, 4, + uintptr(hProcess), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpExeName)), + uintptr(unsafe.Pointer(lpdwSize)), + 0, + 0) + return ret1 != 0 +} + +func QueryIdleProcessorCycleTime(bufferLength *uint32, processorIdleCycleTime PULONG64) bool { + ret1 := syscall3(queryIdleProcessorCycleTime, 2, + uintptr(unsafe.Pointer(bufferLength)), + uintptr(unsafe.Pointer(processorIdleCycleTime)), + 0) + return ret1 != 0 +} + +func QueryIdleProcessorCycleTimeEx(group USHORT, bufferLength *uint32, processorIdleCycleTime PULONG64) bool { + ret1 := syscall3(queryIdleProcessorCycleTimeEx, 3, + uintptr(group), + uintptr(unsafe.Pointer(bufferLength)), + uintptr(unsafe.Pointer(processorIdleCycleTime))) + return ret1 != 0 +} + +// TODO: Unknown type(s): JOBOBJECTINFOCLASS +// func QueryInformationJobObject(hJob HANDLE, jobObjectInformationClass JOBOBJECTINFOCLASS, lpJobObjectInformation LPVOID, cbJobObjectInformationLength DWORD, lpReturnLength *uint32) bool + +func QueryMemoryResourceNotification(resourceNotificationHandle HANDLE, resourceState *BOOL) bool { + ret1 := syscall3(queryMemoryResourceNotification, 2, + uintptr(resourceNotificationHandle), + uintptr(unsafe.Pointer(resourceState)), + 0) + return ret1 != 0 +} + +func QueryPerformanceCounter(lpPerformanceCount *LARGE_INTEGER) bool { + ret1 := syscall3(queryPerformanceCounter, 1, + uintptr(unsafe.Pointer(lpPerformanceCount)), + 0, + 0) + return ret1 != 0 +} + +func QueryPerformanceFrequency(lpFrequency *LARGE_INTEGER) bool { + ret1 := syscall3(queryPerformanceFrequency, 1, + uintptr(unsafe.Pointer(lpFrequency)), + 0, + 0) + return ret1 != 0 +} + +func QueryProcessAffinityUpdateMode(hProcess HANDLE, lpdwFlags *uint32) bool { + ret1 := syscall3(queryProcessAffinityUpdateMode, 2, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpdwFlags)), + 0) + return ret1 != 0 +} + +func QueryProcessCycleTime(processHandle HANDLE, cycleTime PULONG64) bool { + ret1 := syscall3(queryProcessCycleTime, 2, + uintptr(processHandle), + uintptr(unsafe.Pointer(cycleTime)), + 0) + return ret1 != 0 +} + +func QueryThreadCycleTime(threadHandle HANDLE, cycleTime PULONG64) bool { + ret1 := syscall3(queryThreadCycleTime, 2, + uintptr(threadHandle), + uintptr(unsafe.Pointer(cycleTime)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PBOOLEAN +// func QueryThreadProfiling(threadHandle HANDLE, enabled PBOOLEAN) DWORD + +// TODO: Unknown type(s): PTP_POOL, PTP_POOL_STACK_INFORMATION +// func QueryThreadpoolStackInformation(ptpp PTP_POOL, ptpsi PTP_POOL_STACK_INFORMATION) bool + +// TODO: Unknown type(s): PULONGLONG +// func QueryUnbiasedInterruptTime(unbiasedTime PULONGLONG) bool + +// TODO: Unknown type(s): PAPCFUNC +// func QueueUserAPC(pfnAPC PAPCFUNC, hThread HANDLE, dwData *uint32) DWORD + +func QueueUserWorkItem(function THREAD_START_ROUTINE, context uintptr, flags ULONG) bool { + functionCallback := syscall.NewCallback(func(lpThreadParameterRawArg LPVOID) uintptr { + ret := function(lpThreadParameterRawArg) + return uintptr(ret) + }) + ret1 := syscall3(queueUserWorkItem, 3, + functionCallback, + context, + uintptr(flags)) + return ret1 != 0 +} + +func RaiseException(dwExceptionCode DWORD, dwExceptionFlags DWORD, nNumberOfArguments DWORD, lpArguments /*const*/ *ULONG_PTR) { + syscall6(raiseException, 4, + uintptr(dwExceptionCode), + uintptr(dwExceptionFlags), + uintptr(nNumberOfArguments), + uintptr(unsafe.Pointer(lpArguments)), + 0, + 0) +} + +// TODO: Unknown type(s): PCONTEXT, PEXCEPTION_RECORD +// func RaiseFailFastException(pExceptionRecord PEXCEPTION_RECORD, pContextRecord PCONTEXT, dwFlags DWORD) + +func ReOpenFile(hOriginalFile HANDLE, dwDesiredAccess DWORD, dwShareMode DWORD, dwFlagsAndAttributes DWORD) HANDLE { + ret1 := syscall6(reOpenFile, 4, + uintptr(hOriginalFile), + uintptr(dwDesiredAccess), + uintptr(dwShareMode), + uintptr(dwFlagsAndAttributes), + 0, + 0) + return HANDLE(ret1) +} + +// TODO: Unknown type(s): PINPUT_RECORD +// func ReadConsoleInput(hConsoleInput HANDLE, lpBuffer PINPUT_RECORD, nLength DWORD, lpNumberOfEventsRead *uint32) bool + +func ReadConsoleOutputAttribute(hConsoleOutput HANDLE, lpAttribute *uint16, nLength DWORD, dwReadCoord COORD, lpNumberOfAttrsRead *uint32) bool { + ret1 := syscall6(readConsoleOutputAttribute, 5, + uintptr(hConsoleOutput), + uintptr(unsafe.Pointer(lpAttribute)), + uintptr(nLength), + getUintptrFromCOORD(dwReadCoord), + uintptr(unsafe.Pointer(lpNumberOfAttrsRead)), + 0) + return ret1 != 0 +} + +func ReadConsoleOutputCharacter(hConsoleOutput HANDLE, lpCharacter LPWSTR, nLength DWORD, dwReadCoord COORD, lpNumberOfCharsRead *uint32) bool { + ret1 := syscall6(readConsoleOutputCharacter, 5, + uintptr(hConsoleOutput), + uintptr(unsafe.Pointer(lpCharacter)), + uintptr(nLength), + getUintptrFromCOORD(dwReadCoord), + uintptr(unsafe.Pointer(lpNumberOfCharsRead)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCHAR_INFO, PSMALL_RECT +// func ReadConsoleOutput(hConsoleOutput HANDLE, lpBuffer PCHAR_INFO, dwBufferSize COORD, dwBufferCoord COORD, lpReadRegion PSMALL_RECT) bool + +func ReadConsole(hConsoleInput HANDLE, lpBuffer LPVOID, nNumberOfCharsToRead DWORD, lpNumberOfCharsRead *uint32, lpReserved LPVOID) bool { + ret1 := syscall6(readConsole, 5, + uintptr(hConsoleInput), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(nNumberOfCharsToRead), + uintptr(unsafe.Pointer(lpNumberOfCharsRead)), + uintptr(unsafe.Pointer(lpReserved)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPOVERLAPPED_COMPLETION_ROUTINE +// func ReadDirectoryChangesW(hDirectory HANDLE, lpBuffer LPVOID, nBufferLength DWORD, bWatchSubtree bool, dwNotifyFilter DWORD, lpBytesReturned *uint32, lpOverlapped *OVERLAPPED, lpCompletionRoutine LPOVERLAPPED_COMPLETION_ROUTINE) bool + +func ReadFile(hFile HANDLE, lpBuffer LPVOID, nNumberOfBytesToRead DWORD, lpNumberOfBytesRead *uint32, lpOverlapped *OVERLAPPED) bool { + ret1 := syscall6(readFile, 5, + uintptr(hFile), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(nNumberOfBytesToRead), + uintptr(unsafe.Pointer(lpNumberOfBytesRead)), + uintptr(unsafe.Pointer(lpOverlapped)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPOVERLAPPED_COMPLETION_ROUTINE +// func ReadFileEx(hFile HANDLE, lpBuffer LPVOID, nNumberOfBytesToRead DWORD, lpOverlapped *OVERLAPPED, lpCompletionRoutine LPOVERLAPPED_COMPLETION_ROUTINE) bool + +// TODO: Unknown type(s): FILE_SEGMENT_ELEMENT* +// func ReadFileScatter(hFile HANDLE, aSegmentArray FILE_SEGMENT_ELEMENT*, nNumberOfBytesToRead DWORD, lpReserved *uint32, lpOverlapped *OVERLAPPED) bool + +func ReadProcessMemory(hProcess HANDLE, lpBaseAddress /*const*/ uintptr, lpBuffer LPVOID, nSize SIZE_T, lpNumberOfBytesRead *SIZE_T) bool { + ret1 := syscall6(readProcessMemory, 5, + uintptr(hProcess), + lpBaseAddress, + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(nSize), + uintptr(unsafe.Pointer(lpNumberOfBytesRead)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PPERFORMANCE_DATA +// func ReadThreadProfilingData(performanceDataHandle HANDLE, flags DWORD, performanceData PPERFORMANCE_DATA) DWORD + +func ReclaimVirtualMemory(virtualAddress uintptr, size SIZE_T) DWORD { + ret1 := syscall3(reclaimVirtualMemory, 2, + virtualAddress, + uintptr(size), + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): APPLICATION_RECOVERY_CALLBACK +// func RegisterApplicationRecoveryCallback(pRecoveyCallback APPLICATION_RECOVERY_CALLBACK, pvParameter uintptr, dwPingInterval DWORD, dwFlags DWORD) HRESULT + +func RegisterApplicationRestart(pwzCommandline string, dwFlags DWORD) HRESULT { + pwzCommandlineStr := unicode16FromString(pwzCommandline) + ret1 := syscall3(registerApplicationRestart, 2, + uintptr(unsafe.Pointer(&pwzCommandlineStr[0])), + uintptr(dwFlags), + 0) + return HRESULT(ret1) +} + +// TODO: Unknown type(s): WAITORTIMERCALLBACK +// func RegisterWaitForSingleObject(phNewWaitObject *HANDLE, hObject HANDLE, callback WAITORTIMERCALLBACK, context uintptr, dwMilliseconds ULONG, dwFlags ULONG) bool + +func ReleaseActCtx(hActCtx HANDLE) { + syscall3(releaseActCtx, 1, + uintptr(hActCtx), + 0, + 0) +} + +func ReleaseMutex(hMutex HANDLE) bool { + ret1 := syscall3(releaseMutex, 1, + uintptr(hMutex), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PTP_CALLBACK_INSTANCE +// func ReleaseMutexWhenCallbackReturns(pci PTP_CALLBACK_INSTANCE, mut HANDLE) + +func ReleaseSRWLockExclusive(sRWLock PSRWLOCK) { + syscall3(releaseSRWLockExclusive, 1, + uintptr(unsafe.Pointer(sRWLock)), + 0, + 0) +} + +func ReleaseSRWLockShared(sRWLock PSRWLOCK) { + syscall3(releaseSRWLockShared, 1, + uintptr(unsafe.Pointer(sRWLock)), + 0, + 0) +} + +func ReleaseSemaphore(hSemaphore HANDLE, lReleaseCount LONG, lpPreviousCount *LONG) bool { + ret1 := syscall3(releaseSemaphore, 3, + uintptr(hSemaphore), + uintptr(lReleaseCount), + uintptr(unsafe.Pointer(lpPreviousCount))) + return ret1 != 0 +} + +// TODO: Unknown type(s): PTP_CALLBACK_INSTANCE +// func ReleaseSemaphoreWhenCallbackReturns(pci PTP_CALLBACK_INSTANCE, sem HANDLE, crel DWORD) + +func RemoveDirectoryTransacted(lpPathName string, hTransaction HANDLE) bool { + lpPathNameStr := unicode16FromString(lpPathName) + ret1 := syscall3(removeDirectoryTransacted, 2, + uintptr(unsafe.Pointer(&lpPathNameStr[0])), + uintptr(hTransaction), + 0) + return ret1 != 0 +} + +func RemoveDirectory(lpPathName string) bool { + lpPathNameStr := unicode16FromString(lpPathName) + ret1 := syscall3(removeDirectory, 1, + uintptr(unsafe.Pointer(&lpPathNameStr[0])), + 0, + 0) + return ret1 != 0 +} + +func RemoveSecureMemoryCacheCallback(pfnCallBack PSECURE_MEMORY_CACHE_CALLBACK) bool { + pfnCallBackCallback := syscall.NewCallback(func(AddrRawArg PVOID, RangeRawArg SIZE_T) uintptr { + ret := pfnCallBack(AddrRawArg, RangeRawArg) + return uintptr(ret) + }) + ret1 := syscall3(removeSecureMemoryCacheCallback, 1, + pfnCallBackCallback, + 0, + 0) + return ret1 != 0 +} + +func RemoveVectoredContinueHandler(handle uintptr) ULONG { + ret1 := syscall3(removeVectoredContinueHandler, 1, + handle, + 0, + 0) + return ULONG(ret1) +} + +func RemoveVectoredExceptionHandler(handle uintptr) ULONG { + ret1 := syscall3(removeVectoredExceptionHandler, 1, + handle, + 0, + 0) + return ULONG(ret1) +} + +func ReplaceFile(lpReplacedFileName string, lpReplacementFileName string, lpBackupFileName string, dwReplaceFlags DWORD, lpExclude LPVOID, lpReserved LPVOID) bool { + lpReplacedFileNameStr := unicode16FromString(lpReplacedFileName) + lpReplacementFileNameStr := unicode16FromString(lpReplacementFileName) + lpBackupFileNameStr := unicode16FromString(lpBackupFileName) + ret1 := syscall6(replaceFile, 6, + uintptr(unsafe.Pointer(&lpReplacedFileNameStr[0])), + uintptr(unsafe.Pointer(&lpReplacementFileNameStr[0])), + uintptr(unsafe.Pointer(&lpBackupFileNameStr[0])), + uintptr(dwReplaceFlags), + uintptr(unsafe.Pointer(lpExclude)), + uintptr(unsafe.Pointer(lpReserved))) + return ret1 != 0 +} + +func ReplacePartitionUnit(targetPartition PWSTR, sparePartition PWSTR, flags ULONG) bool { + ret1 := syscall3(replacePartitionUnit, 3, + uintptr(unsafe.Pointer(targetPartition)), + uintptr(unsafe.Pointer(sparePartition)), + uintptr(flags)) + return ret1 != 0 +} + +func RequestDeviceWakeup(hDevice HANDLE) bool { + ret1 := syscall3(requestDeviceWakeup, 1, + uintptr(hDevice), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LATENCY_TIME +// func RequestWakeupLatency(latency LATENCY_TIME) bool + +func ResetEvent(hEvent HANDLE) bool { + ret1 := syscall3(resetEvent, 1, + uintptr(hEvent), + 0, + 0) + return ret1 != 0 +} + +func ResetWriteWatch(lpBaseAddress LPVOID, dwRegionSize SIZE_T) UINT { + ret1 := syscall3(resetWriteWatch, 2, + uintptr(unsafe.Pointer(lpBaseAddress)), + uintptr(dwRegionSize), + 0) + return UINT(ret1) +} + +func ResolveLocaleName(lpNameToResolve string, lpLocaleName LPWSTR, cchLocaleName int32) int32 { + lpNameToResolveStr := unicode16FromString(lpNameToResolve) + ret1 := syscall3(resolveLocaleName, 3, + uintptr(unsafe.Pointer(&lpNameToResolveStr[0])), + uintptr(unsafe.Pointer(lpLocaleName)), + uintptr(cchLocaleName)) + return int32(ret1) +} + +func RestoreLastError(dwErrCode DWORD) { + syscall3(restoreLastError, 1, + uintptr(dwErrCode), + 0, + 0) +} + +func ResumeThread(hThread HANDLE) DWORD { + ret1 := syscall3(resumeThread, 1, + uintptr(hThread), + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): CONST CHAR_INFO * +// func ScrollConsoleScreenBuffer(hConsoleOutput HANDLE, lpScrollRectangle /*const*/ *SMALL_RECT, lpClipRectangle /*const*/ *SMALL_RECT, dwDestinationOrigin COORD, lpFill /*const*/ CONST CHAR_INFO *) bool + +func SearchPath(lpPath string, lpFileName string, lpExtension string, nBufferLength DWORD, lpBuffer LPWSTR, lpFilePart *LPWSTR) DWORD { + lpPathStr := unicode16FromString(lpPath) + lpFileNameStr := unicode16FromString(lpFileName) + lpExtensionStr := unicode16FromString(lpExtension) + ret1 := syscall6(searchPath, 6, + uintptr(unsafe.Pointer(&lpPathStr[0])), + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(unsafe.Pointer(&lpExtensionStr[0])), + uintptr(nBufferLength), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(unsafe.Pointer(lpFilePart))) + return DWORD(ret1) +} + +func SetCalendarInfo(locale LCID, calendar CALID, calType CALTYPE, lpCalData string) bool { + lpCalDataStr := unicode16FromString(lpCalData) + ret1 := syscall6(setCalendarInfo, 4, + uintptr(locale), + uintptr(calendar), + uintptr(calType), + uintptr(unsafe.Pointer(&lpCalDataStr[0])), + 0, + 0) + return ret1 != 0 +} + +func SetCommBreak(hFile HANDLE) bool { + ret1 := syscall3(setCommBreak, 1, + uintptr(hFile), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPCOMMCONFIG +// func SetCommConfig(hCommDev HANDLE, lpCC LPCOMMCONFIG, dwSize DWORD) bool + +func SetCommMask(hFile HANDLE, dwEvtMask DWORD) bool { + ret1 := syscall3(setCommMask, 2, + uintptr(hFile), + uintptr(dwEvtMask), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPDCB +// func SetCommState(hFile HANDLE, lpDCB LPDCB) bool + +// TODO: Unknown type(s): LPCOMMTIMEOUTS +// func SetCommTimeouts(hFile HANDLE, lpCommTimeouts LPCOMMTIMEOUTS) bool + +// TODO: Unknown type(s): COMPUTER_NAME_FORMAT +// func SetComputerNameEx(nameType COMPUTER_NAME_FORMAT, lpBuffer string) bool + +func SetComputerName(lpComputerName string) bool { + lpComputerNameStr := unicode16FromString(lpComputerName) + ret1 := syscall3(setComputerName, 1, + uintptr(unsafe.Pointer(&lpComputerNameStr[0])), + 0, + 0) + return ret1 != 0 +} + +func SetConsoleActiveScreenBuffer(hConsoleOutput HANDLE) bool { + ret1 := syscall3(setConsoleActiveScreenBuffer, 1, + uintptr(hConsoleOutput), + 0, + 0) + return ret1 != 0 +} + +func SetConsoleCP(wCodePageID UINT) bool { + ret1 := syscall3(setConsoleCP, 1, + uintptr(wCodePageID), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PHANDLER_ROUTINE +// func SetConsoleCtrlHandler(handlerRoutine PHANDLER_ROUTINE, add bool) bool + +// TODO: Unknown type(s): CONST CONSOLE_CURSOR_INFO * +// func SetConsoleCursorInfo(hConsoleOutput HANDLE, lpConsoleCursorInfo /*const*/ CONST CONSOLE_CURSOR_INFO *) bool + +func SetConsoleCursorPosition(hConsoleOutput HANDLE, dwCursorPosition COORD) bool { + ret1 := syscall3(setConsoleCursorPosition, 2, + uintptr(hConsoleOutput), + getUintptrFromCOORD(dwCursorPosition), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCOORD +// func SetConsoleDisplayMode(hConsoleOutput HANDLE, dwFlags DWORD, lpNewScreenBufferDimensions PCOORD) bool + +// TODO: Unknown type(s): PCONSOLE_HISTORY_INFO +// func SetConsoleHistoryInfo(lpConsoleHistoryInfo PCONSOLE_HISTORY_INFO) bool + +func SetConsoleMode(hConsoleHandle HANDLE, dwMode DWORD) bool { + ret1 := syscall3(setConsoleMode, 2, + uintptr(hConsoleHandle), + uintptr(dwMode), + 0) + return ret1 != 0 +} + +func SetConsoleOutputCP(wCodePageID UINT) bool { + ret1 := syscall3(setConsoleOutputCP, 1, + uintptr(wCodePageID), + 0, + 0) + return ret1 != 0 +} + +func SetConsoleScreenBufferInfoEx(hConsoleOutput HANDLE, lpConsoleScreenBufferInfoEx PCONSOLE_SCREEN_BUFFER_INFOEX) bool { + ret1 := syscall3(setConsoleScreenBufferInfoEx, 2, + uintptr(hConsoleOutput), + uintptr(unsafe.Pointer(lpConsoleScreenBufferInfoEx)), + 0) + return ret1 != 0 +} + +func SetConsoleScreenBufferSize(hConsoleOutput HANDLE, dwSize COORD) bool { + ret1 := syscall3(setConsoleScreenBufferSize, 2, + uintptr(hConsoleOutput), + getUintptrFromCOORD(dwSize), + 0) + return ret1 != 0 +} + +func SetConsoleTextAttribute(hConsoleOutput HANDLE, wAttributes WORD) bool { + ret1 := syscall3(setConsoleTextAttribute, 2, + uintptr(hConsoleOutput), + uintptr(wAttributes), + 0) + return ret1 != 0 +} + +func SetConsoleTitle(lpConsoleTitle string) bool { + lpConsoleTitleStr := unicode16FromString(lpConsoleTitle) + ret1 := syscall3(setConsoleTitle, 1, + uintptr(unsafe.Pointer(&lpConsoleTitleStr[0])), + 0, + 0) + return ret1 != 0 +} + +func SetConsoleWindowInfo(hConsoleOutput HANDLE, bAbsolute bool, lpConsoleWindow /*const*/ *SMALL_RECT) bool { + ret1 := syscall3(setConsoleWindowInfo, 3, + uintptr(hConsoleOutput), + getUintptrFromBool(bAbsolute), + uintptr(unsafe.Pointer(lpConsoleWindow))) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPCRITICAL_SECTION +// func SetCriticalSectionSpinCount(lpCriticalSection LPCRITICAL_SECTION, dwSpinCount DWORD) DWORD + +// TODO: Unknown type(s): PCONSOLE_FONT_INFOEX +// func SetCurrentConsoleFontEx(hConsoleOutput HANDLE, bMaximumWindow bool, lpConsoleCurrentFontEx PCONSOLE_FONT_INFOEX) bool + +func SetCurrentDirectory(lpPathName string) bool { + lpPathNameStr := unicode16FromString(lpPathName) + ret1 := syscall3(setCurrentDirectory, 1, + uintptr(unsafe.Pointer(&lpPathNameStr[0])), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPCOMMCONFIG +// func SetDefaultCommConfig(lpszName string, lpCC LPCOMMCONFIG, dwSize DWORD) bool + +func SetDllDirectory(lpPathName string) bool { + lpPathNameStr := unicode16FromString(lpPathName) + ret1 := syscall3(setDllDirectory, 1, + uintptr(unsafe.Pointer(&lpPathNameStr[0])), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): CONST DYNAMIC_TIME_ZONE_INFORMATION * +// func SetDynamicTimeZoneInformation(lpTimeZoneInformation /*const*/ CONST DYNAMIC_TIME_ZONE_INFORMATION *) bool + +func SetEndOfFile(hFile HANDLE) bool { + ret1 := syscall3(setEndOfFile, 1, + uintptr(hFile), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPWCH +// func SetEnvironmentStrings(newEnvironment LPWCH) bool + +func SetEnvironmentVariable(lpName string, lpValue string) bool { + lpNameStr := unicode16FromString(lpName) + lpValueStr := unicode16FromString(lpValue) + ret1 := syscall3(setEnvironmentVariable, 2, + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(unsafe.Pointer(&lpValueStr[0])), + 0) + return ret1 != 0 +} + +func SetErrorMode(uMode UINT) UINT { + ret1 := syscall3(setErrorMode, 1, + uintptr(uMode), + 0, + 0) + return UINT(ret1) +} + +func SetEvent(hEvent HANDLE) bool { + ret1 := syscall3(setEvent, 1, + uintptr(hEvent), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PTP_CALLBACK_INSTANCE +// func SetEventWhenCallbackReturns(pci PTP_CALLBACK_INSTANCE, evt HANDLE) + +func SetFileApisToANSI() { + syscall3(setFileApisToANSI, 0, + 0, + 0, + 0) +} + +func SetFileApisToOEM() { + syscall3(setFileApisToOEM, 0, + 0, + 0, + 0) +} + +func SetFileAttributesTransacted(lpFileName string, dwFileAttributes DWORD, hTransaction HANDLE) bool { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(setFileAttributesTransacted, 3, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(dwFileAttributes), + uintptr(hTransaction)) + return ret1 != 0 +} + +func SetFileAttributes(lpFileName string, dwFileAttributes DWORD) bool { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(setFileAttributes, 2, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + uintptr(dwFileAttributes), + 0) + return ret1 != 0 +} + +func SetFileBandwidthReservation(hFile HANDLE, nPeriodMilliseconds DWORD, nBytesPerPeriod DWORD, bDiscardable bool, lpTransferSize *uint32, lpNumOutstandingRequests *uint32) bool { + ret1 := syscall6(setFileBandwidthReservation, 6, + uintptr(hFile), + uintptr(nPeriodMilliseconds), + uintptr(nBytesPerPeriod), + getUintptrFromBool(bDiscardable), + uintptr(unsafe.Pointer(lpTransferSize)), + uintptr(unsafe.Pointer(lpNumOutstandingRequests))) + return ret1 != 0 +} + +func SetFileCompletionNotificationModes(fileHandle HANDLE, flags UCHAR) bool { + ret1 := syscall3(setFileCompletionNotificationModes, 2, + uintptr(fileHandle), + uintptr(flags), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): FILE_INFO_BY_HANDLE_CLASS +// func SetFileInformationByHandle(hFile HANDLE, fileInformationClass FILE_INFO_BY_HANDLE_CLASS, lpFileInformation LPVOID, dwBufferSize DWORD) bool + +func SetFileIoOverlappedRange(fileHandle HANDLE, overlappedRangeStart PUCHAR, length ULONG) bool { + ret1 := syscall3(setFileIoOverlappedRange, 3, + uintptr(fileHandle), + uintptr(unsafe.Pointer(overlappedRangeStart)), + uintptr(length)) + return ret1 != 0 +} + +func SetFilePointer(hFile HANDLE, lDistanceToMove LONG, lpDistanceToMoveHigh *int32, dwMoveMethod DWORD) DWORD { + ret1 := syscall6(setFilePointer, 4, + uintptr(hFile), + uintptr(lDistanceToMove), + uintptr(unsafe.Pointer(lpDistanceToMoveHigh)), + uintptr(dwMoveMethod), + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PLARGE_INTEGER +// func SetFilePointerEx(hFile HANDLE, liDistanceToMove LARGE_INTEGER, lpNewFilePointer PLARGE_INTEGER, dwMoveMethod DWORD) bool + +func SetFileShortName(hFile HANDLE, lpShortName string) bool { + lpShortNameStr := unicode16FromString(lpShortName) + ret1 := syscall3(setFileShortName, 2, + uintptr(hFile), + uintptr(unsafe.Pointer(&lpShortNameStr[0])), + 0) + return ret1 != 0 +} + +func SetFileTime(hFile HANDLE, lpCreationTime /*const*/ *FILETIME, lpLastAccessTime /*const*/ *FILETIME, lpLastWriteTime /*const*/ *FILETIME) bool { + ret1 := syscall6(setFileTime, 4, + uintptr(hFile), + uintptr(unsafe.Pointer(lpCreationTime)), + uintptr(unsafe.Pointer(lpLastAccessTime)), + uintptr(unsafe.Pointer(lpLastWriteTime)), + 0, + 0) + return ret1 != 0 +} + +func SetFileValidData(hFile HANDLE, validDataLength LONGLONG) bool { + ret1 := syscall3(setFileValidData, 2, + uintptr(hFile), + uintptr(validDataLength), + 0) + return ret1 != 0 +} + +func SetFirmwareEnvironmentVariable(lpName string, lpGuid string, pValue uintptr, nSize DWORD) bool { + lpNameStr := unicode16FromString(lpName) + lpGuidStr := unicode16FromString(lpGuid) + ret1 := syscall6(setFirmwareEnvironmentVariable, 4, + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(unsafe.Pointer(&lpGuidStr[0])), + pValue, + uintptr(nSize), + 0, + 0) + return ret1 != 0 +} + +func SetHandleCount(uNumber UINT) UINT { + ret1 := syscall3(setHandleCount, 1, + uintptr(uNumber), + 0, + 0) + return UINT(ret1) +} + +func SetHandleInformation(hObject HANDLE, dwMask DWORD, dwFlags DWORD) bool { + ret1 := syscall3(setHandleInformation, 3, + uintptr(hObject), + uintptr(dwMask), + uintptr(dwFlags)) + return ret1 != 0 +} + +// TODO: Unknown type(s): JOBOBJECTINFOCLASS +// func SetInformationJobObject(hJob HANDLE, jobObjectInformationClass JOBOBJECTINFOCLASS, lpJobObjectInformation LPVOID, cbJobObjectInformationLength DWORD) bool + +func SetLastError(dwErrCode DWORD) { + syscall3(setLastError, 1, + uintptr(dwErrCode), + 0, + 0) +} + +func SetLocalTime(lpSystemTime /*const*/ *SYSTEMTIME) bool { + ret1 := syscall3(setLocalTime, 1, + uintptr(unsafe.Pointer(lpSystemTime)), + 0, + 0) + return ret1 != 0 +} + +func SetLocaleInfo(locale LCID, lCType LCTYPE, lpLCData string) bool { + lpLCDataStr := unicode16FromString(lpLCData) + ret1 := syscall3(setLocaleInfo, 3, + uintptr(locale), + uintptr(lCType), + uintptr(unsafe.Pointer(&lpLCDataStr[0]))) + return ret1 != 0 +} + +func SetMailslotInfo(hMailslot HANDLE, lReadTimeout DWORD) bool { + ret1 := syscall3(setMailslotInfo, 2, + uintptr(hMailslot), + uintptr(lReadTimeout), + 0) + return ret1 != 0 +} + +func SetMessageWaitingIndicator(hMsgIndicator HANDLE, ulMsgCount ULONG) bool { + ret1 := syscall3(setMessageWaitingIndicator, 2, + uintptr(hMsgIndicator), + uintptr(ulMsgCount), + 0) + return ret1 != 0 +} + +func SetNamedPipeHandleState(hNamedPipe HANDLE, lpMode *uint32, lpMaxCollectionCount *uint32, lpCollectDataTimeout *uint32) bool { + ret1 := syscall6(setNamedPipeHandleState, 4, + uintptr(hNamedPipe), + uintptr(unsafe.Pointer(lpMode)), + uintptr(unsafe.Pointer(lpMaxCollectionCount)), + uintptr(unsafe.Pointer(lpCollectDataTimeout)), + 0, + 0) + return ret1 != 0 +} + +func SetPriorityClass(hProcess HANDLE, dwPriorityClass DWORD) bool { + ret1 := syscall3(setPriorityClass, 2, + uintptr(hProcess), + uintptr(dwPriorityClass), + 0) + return ret1 != 0 +} + +func SetProcessAffinityMask(hProcess HANDLE, dwProcessAffinityMask *uint32) bool { + ret1 := syscall3(setProcessAffinityMask, 2, + uintptr(hProcess), + uintptr(unsafe.Pointer(dwProcessAffinityMask)), + 0) + return ret1 != 0 +} + +func SetProcessAffinityUpdateMode(hProcess HANDLE, dwFlags DWORD) bool { + ret1 := syscall3(setProcessAffinityUpdateMode, 2, + uintptr(hProcess), + uintptr(dwFlags), + 0) + return ret1 != 0 +} + +func SetProcessDEPPolicy(dwFlags DWORD) bool { + ret1 := syscall3(setProcessDEPPolicy, 1, + uintptr(dwFlags), + 0, + 0) + return ret1 != 0 +} + +func SetProcessPreferredUILanguages(dwFlags DWORD, pwszLanguagesBuffer /*const*/ PCZZWSTR, pulNumLanguages *uint32) bool { + ret1 := syscall3(setProcessPreferredUILanguages, 3, + uintptr(dwFlags), + uintptr(unsafe.Pointer(pwszLanguagesBuffer)), + uintptr(unsafe.Pointer(pulNumLanguages))) + return ret1 != 0 +} + +func SetProcessPriorityBoost(hProcess HANDLE, bDisablePriorityBoost bool) bool { + ret1 := syscall3(setProcessPriorityBoost, 2, + uintptr(hProcess), + getUintptrFromBool(bDisablePriorityBoost), + 0) + return ret1 != 0 +} + +func SetProcessShutdownParameters(dwLevel DWORD, dwFlags DWORD) bool { + ret1 := syscall3(setProcessShutdownParameters, 2, + uintptr(dwLevel), + uintptr(dwFlags), + 0) + return ret1 != 0 +} + +func SetProcessWorkingSetSize(hProcess HANDLE, dwMinimumWorkingSetSize SIZE_T, dwMaximumWorkingSetSize SIZE_T) bool { + ret1 := syscall3(setProcessWorkingSetSize, 3, + uintptr(hProcess), + uintptr(dwMinimumWorkingSetSize), + uintptr(dwMaximumWorkingSetSize)) + return ret1 != 0 +} + +func SetProcessWorkingSetSizeEx(hProcess HANDLE, dwMinimumWorkingSetSize SIZE_T, dwMaximumWorkingSetSize SIZE_T, flags DWORD) bool { + ret1 := syscall6(setProcessWorkingSetSizeEx, 4, + uintptr(hProcess), + uintptr(dwMinimumWorkingSetSize), + uintptr(dwMaximumWorkingSetSize), + uintptr(flags), + 0, + 0) + return ret1 != 0 +} + +func SetSearchPathMode(flags DWORD) bool { + ret1 := syscall3(setSearchPathMode, 1, + uintptr(flags), + 0, + 0) + return ret1 != 0 +} + +func SetStdHandle(nStdHandle DWORD, hHandle HANDLE) bool { + ret1 := syscall3(setStdHandle, 2, + uintptr(nStdHandle), + uintptr(hHandle), + 0) + return ret1 != 0 +} + +func SetStdHandleEx(nStdHandle DWORD, hHandle HANDLE, phPrevValue *HANDLE) bool { + ret1 := syscall3(setStdHandleEx, 3, + uintptr(nStdHandle), + uintptr(hHandle), + uintptr(unsafe.Pointer(phPrevValue))) + return ret1 != 0 +} + +func SetSystemFileCacheSize(minimumFileCacheSize SIZE_T, maximumFileCacheSize SIZE_T, flags DWORD) bool { + ret1 := syscall3(setSystemFileCacheSize, 3, + uintptr(minimumFileCacheSize), + uintptr(maximumFileCacheSize), + uintptr(flags)) + return ret1 != 0 +} + +func SetSystemPowerState(fSuspend bool, fForce bool) bool { + ret1 := syscall3(setSystemPowerState, 2, + getUintptrFromBool(fSuspend), + getUintptrFromBool(fForce), + 0) + return ret1 != 0 +} + +func SetSystemTime(lpSystemTime /*const*/ *SYSTEMTIME) bool { + ret1 := syscall3(setSystemTime, 1, + uintptr(unsafe.Pointer(lpSystemTime)), + 0, + 0) + return ret1 != 0 +} + +func SetSystemTimeAdjustment(dwTimeAdjustment DWORD, bTimeAdjustmentDisabled bool) bool { + ret1 := syscall3(setSystemTimeAdjustment, 2, + uintptr(dwTimeAdjustment), + getUintptrFromBool(bTimeAdjustmentDisabled), + 0) + return ret1 != 0 +} + +func SetTapeParameters(hDevice HANDLE, dwOperation DWORD, lpTapeInformation LPVOID) DWORD { + ret1 := syscall3(setTapeParameters, 3, + uintptr(hDevice), + uintptr(dwOperation), + uintptr(unsafe.Pointer(lpTapeInformation))) + return DWORD(ret1) +} + +func SetTapePosition(hDevice HANDLE, dwPositionMethod DWORD, dwPartition DWORD, dwOffsetLow DWORD, dwOffsetHigh DWORD, bImmediate bool) DWORD { + ret1 := syscall6(setTapePosition, 6, + uintptr(hDevice), + uintptr(dwPositionMethod), + uintptr(dwPartition), + uintptr(dwOffsetLow), + uintptr(dwOffsetHigh), + getUintptrFromBool(bImmediate)) + return DWORD(ret1) +} + +func SetThreadAffinityMask(hThread HANDLE, dwThreadAffinityMask *uint32) *uint32 { + ret1 := syscall3(setThreadAffinityMask, 2, + uintptr(hThread), + uintptr(unsafe.Pointer(dwThreadAffinityMask)), + 0) + return (*uint32)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): CONST CONTEXT * +// func SetThreadContext(hThread HANDLE, lpContext /*const*/ CONST CONTEXT *) bool + +func SetThreadErrorMode(dwNewMode DWORD, lpOldMode *uint32) bool { + ret1 := syscall3(setThreadErrorMode, 2, + uintptr(dwNewMode), + uintptr(unsafe.Pointer(lpOldMode)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): EXECUTION_STATE +// func SetThreadExecutionState(esFlags EXECUTION_STATE) EXECUTION_STATE + +// TODO: Unknown type(s): CONST GROUP_AFFINITY *, PGROUP_AFFINITY +// func SetThreadGroupAffinity(hThread HANDLE, groupAffinity /*const*/ CONST GROUP_AFFINITY *, previousGroupAffinity PGROUP_AFFINITY) bool + +func SetThreadIdealProcessor(hThread HANDLE, dwIdealProcessor DWORD) DWORD { + ret1 := syscall3(setThreadIdealProcessor, 2, + uintptr(hThread), + uintptr(dwIdealProcessor), + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PPROCESSOR_NUMBER +// func SetThreadIdealProcessorEx(hThread HANDLE, lpIdealProcessor PPROCESSOR_NUMBER, lpPreviousIdealProcessor PPROCESSOR_NUMBER) bool + +func SetThreadLocale(locale LCID) bool { + ret1 := syscall3(setThreadLocale, 1, + uintptr(locale), + 0, + 0) + return ret1 != 0 +} + +func SetThreadPreferredUILanguages(dwFlags DWORD, pwszLanguagesBuffer /*const*/ PCZZWSTR, pulNumLanguages *uint32) bool { + ret1 := syscall3(setThreadPreferredUILanguages, 3, + uintptr(dwFlags), + uintptr(unsafe.Pointer(pwszLanguagesBuffer)), + uintptr(unsafe.Pointer(pulNumLanguages))) + return ret1 != 0 +} + +func SetThreadPriority(hThread HANDLE, nPriority int32) bool { + ret1 := syscall3(setThreadPriority, 2, + uintptr(hThread), + uintptr(nPriority), + 0) + return ret1 != 0 +} + +func SetThreadPriorityBoost(hThread HANDLE, bDisablePriorityBoost bool) bool { + ret1 := syscall3(setThreadPriorityBoost, 2, + uintptr(hThread), + getUintptrFromBool(bDisablePriorityBoost), + 0) + return ret1 != 0 +} + +func SetThreadStackGuarantee(stackSizeInBytes *uint32) bool { + ret1 := syscall3(setThreadStackGuarantee, 1, + uintptr(unsafe.Pointer(stackSizeInBytes)), + 0, + 0) + return ret1 != 0 +} + +func SetThreadUILanguage(langId LANGID) LANGID { + ret1 := syscall3(setThreadUILanguage, 1, + uintptr(langId), + 0, + 0) + return LANGID(ret1) +} + +// TODO: Unknown type(s): PTP_POOL, PTP_POOL_STACK_INFORMATION +// func SetThreadpoolStackInformation(ptpp PTP_POOL, ptpsi PTP_POOL_STACK_INFORMATION) bool + +// TODO: Unknown type(s): PTP_POOL +// func SetThreadpoolThreadMaximum(ptpp PTP_POOL, cthrdMost DWORD) + +// TODO: Unknown type(s): PTP_POOL +// func SetThreadpoolThreadMinimum(ptpp PTP_POOL, cthrdMic DWORD) bool + +// TODO: Unknown type(s): PFILETIME, PTP_TIMER +// func SetThreadpoolTimer(pti PTP_TIMER, pftDueTime PFILETIME, msPeriod DWORD, msWindowLength DWORD) + +// TODO: Unknown type(s): PFILETIME, PTP_WAIT +// func SetThreadpoolWait(pwa PTP_WAIT, h HANDLE, pftTimeout PFILETIME) + +// TODO: Unknown type(s): CONST TIME_ZONE_INFORMATION * +// func SetTimeZoneInformation(lpTimeZoneInformation /*const*/ CONST TIME_ZONE_INFORMATION *) bool + +// TODO: Unknown type(s): WAITORTIMERCALLBACK +// func SetTimerQueueTimer(timerQueue HANDLE, callback WAITORTIMERCALLBACK, parameter uintptr, dueTime DWORD, period DWORD, preferIo bool) HANDLE + +// TODO: Unknown type(s): LPTOP_LEVEL_EXCEPTION_FILTER +// func SetUnhandledExceptionFilter(lpTopLevelExceptionFilter LPTOP_LEVEL_EXCEPTION_FILTER) LPTOP_LEVEL_EXCEPTION_FILTER + +func SetUserGeoID(geoId GEOID) bool { + ret1 := syscall3(setUserGeoID, 1, + uintptr(geoId), + 0, + 0) + return ret1 != 0 +} + +func SetVolumeLabel(lpRootPathName string, lpVolumeName string) bool { + lpRootPathNameStr := unicode16FromString(lpRootPathName) + lpVolumeNameStr := unicode16FromString(lpVolumeName) + ret1 := syscall3(setVolumeLabel, 2, + uintptr(unsafe.Pointer(&lpRootPathNameStr[0])), + uintptr(unsafe.Pointer(&lpVolumeNameStr[0])), + 0) + return ret1 != 0 +} + +func SetVolumeMountPoint(lpszVolumeMountPoint string, lpszVolumeName string) bool { + lpszVolumeMountPointStr := unicode16FromString(lpszVolumeMountPoint) + lpszVolumeNameStr := unicode16FromString(lpszVolumeName) + ret1 := syscall3(setVolumeMountPoint, 2, + uintptr(unsafe.Pointer(&lpszVolumeMountPointStr[0])), + uintptr(unsafe.Pointer(&lpszVolumeNameStr[0])), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PTIMERAPCROUTINE +// func SetWaitableTimer(hTimer HANDLE, lpDueTime /*const*/ *LARGE_INTEGER, lPeriod LONG, pfnCompletionRoutine PTIMERAPCROUTINE, lpArgToCompletionRoutine LPVOID, fResume bool) bool + +// TODO: Unknown type(s): PREASON_CONTEXT, PTIMERAPCROUTINE +// func SetWaitableTimerEx(hTimer HANDLE, lpDueTime /*const*/ *LARGE_INTEGER, lPeriod LONG, pfnCompletionRoutine PTIMERAPCROUTINE, lpArgToCompletionRoutine LPVOID, wakeContext PREASON_CONTEXT, tolerableDelay ULONG) bool + +func SetupComm(hFile HANDLE, dwInQueue DWORD, dwOutQueue DWORD) bool { + ret1 := syscall3(setupComm, 3, + uintptr(hFile), + uintptr(dwInQueue), + uintptr(dwOutQueue)) + return ret1 != 0 +} + +func SignalObjectAndWait(hObjectToSignal HANDLE, hObjectToWaitOn HANDLE, dwMilliseconds DWORD, bAlertable bool) DWORD { + ret1 := syscall6(signalObjectAndWait, 4, + uintptr(hObjectToSignal), + uintptr(hObjectToWaitOn), + uintptr(dwMilliseconds), + getUintptrFromBool(bAlertable), + 0, + 0) + return DWORD(ret1) +} + +func SizeofResource(hModule HMODULE, hResInfo HRSRC) DWORD { + ret1 := syscall3(sizeofResource, 2, + uintptr(hModule), + uintptr(hResInfo), + 0) + return DWORD(ret1) +} + +func Sleep(dwMilliseconds DWORD) { + syscall3(sleep, 1, + uintptr(dwMilliseconds), + 0, + 0) +} + +// TODO: Unknown type(s): PCONDITION_VARIABLE, PCRITICAL_SECTION +// func SleepConditionVariableCS(conditionVariable PCONDITION_VARIABLE, criticalSection PCRITICAL_SECTION, dwMilliseconds DWORD) bool + +// TODO: Unknown type(s): PCONDITION_VARIABLE +// func SleepConditionVariableSRW(conditionVariable PCONDITION_VARIABLE, sRWLock PSRWLOCK, dwMilliseconds DWORD, flags ULONG) bool + +func SleepEx(dwMilliseconds DWORD, bAlertable bool) DWORD { + ret1 := syscall3(sleepEx, 2, + uintptr(dwMilliseconds), + getUintptrFromBool(bAlertable), + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PTP_IO +// func StartThreadpoolIo(pio PTP_IO) + +// TODO: Unknown type(s): PTP_WORK +// func SubmitThreadpoolWork(pwk PTP_WORK) + +func SuspendThread(hThread HANDLE) DWORD { + ret1 := syscall3(suspendThread, 1, + uintptr(hThread), + 0, + 0) + return DWORD(ret1) +} + +func SwitchToFiber(lpFiber LPVOID) { + syscall3(switchToFiber, 1, + uintptr(unsafe.Pointer(lpFiber)), + 0, + 0) +} + +func SwitchToThread() bool { + ret1 := syscall3(switchToThread, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func SystemTimeToFileTime(lpSystemTime /*const*/ *SYSTEMTIME, lpFileTime *FILETIME) bool { + ret1 := syscall3(systemTimeToFileTime, 2, + uintptr(unsafe.Pointer(lpSystemTime)), + uintptr(unsafe.Pointer(lpFileTime)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): CONST TIME_ZONE_INFORMATION * +// func SystemTimeToTzSpecificLocalTime(lpTimeZoneInformation /*const*/ CONST TIME_ZONE_INFORMATION *, lpUniversalTime /*const*/ *SYSTEMTIME, lpLocalTime *SYSTEMTIME) bool + +func TerminateJobObject(hJob HANDLE, uExitCode UINT) bool { + ret1 := syscall3(terminateJobObject, 2, + uintptr(hJob), + uintptr(uExitCode), + 0) + return ret1 != 0 +} + +func TerminateProcess(hProcess HANDLE, uExitCode UINT) bool { + ret1 := syscall3(terminateProcess, 2, + uintptr(hProcess), + uintptr(uExitCode), + 0) + return ret1 != 0 +} + +func TerminateThread(hThread HANDLE, dwExitCode DWORD) bool { + ret1 := syscall3(terminateThread, 2, + uintptr(hThread), + uintptr(dwExitCode), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPTHREADENTRY32 +// func Thread32First(hSnapshot HANDLE, lpte LPTHREADENTRY32) bool + +// TODO: Unknown type(s): LPTHREADENTRY32 +// func Thread32Next(hSnapshot HANDLE, lpte LPTHREADENTRY32) bool + +func TlsAlloc() DWORD { + ret1 := syscall3(tlsAlloc, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func TlsFree(dwTlsIndex DWORD) bool { + ret1 := syscall3(tlsFree, 1, + uintptr(dwTlsIndex), + 0, + 0) + return ret1 != 0 +} + +func TlsGetValue(dwTlsIndex DWORD) LPVOID { + ret1 := syscall3(tlsGetValue, 1, + uintptr(dwTlsIndex), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func TlsSetValue(dwTlsIndex DWORD, lpTlsValue LPVOID) bool { + ret1 := syscall3(tlsSetValue, 2, + uintptr(dwTlsIndex), + uintptr(unsafe.Pointer(lpTlsValue)), + 0) + return ret1 != 0 +} + +func Toolhelp32ReadProcessMemory(th32ProcessID DWORD, lpBaseAddress /*const*/ uintptr, lpBuffer LPVOID, cbRead SIZE_T, lpNumberOfBytesRead *SIZE_T) bool { + ret1 := syscall6(toolhelp32ReadProcessMemory, 5, + uintptr(th32ProcessID), + lpBaseAddress, + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(cbRead), + uintptr(unsafe.Pointer(lpNumberOfBytesRead)), + 0) + return ret1 != 0 +} + +func TransactNamedPipe(hNamedPipe HANDLE, lpInBuffer LPVOID, nInBufferSize DWORD, lpOutBuffer LPVOID, nOutBufferSize DWORD, lpBytesRead *uint32, lpOverlapped *OVERLAPPED) bool { + ret1 := syscall9(transactNamedPipe, 7, + uintptr(hNamedPipe), + uintptr(unsafe.Pointer(lpInBuffer)), + uintptr(nInBufferSize), + uintptr(unsafe.Pointer(lpOutBuffer)), + uintptr(nOutBufferSize), + uintptr(unsafe.Pointer(lpBytesRead)), + uintptr(unsafe.Pointer(lpOverlapped)), + 0, + 0) + return ret1 != 0 +} + +func TransmitCommChar(hFile HANDLE, cChar byte) bool { + ret1 := syscall3(transmitCommChar, 2, + uintptr(hFile), + uintptr(cChar), + 0) + return ret1 != 0 +} + +func TryAcquireSRWLockExclusive(sRWLock PSRWLOCK) BOOLEAN { + ret1 := syscall3(tryAcquireSRWLockExclusive, 1, + uintptr(unsafe.Pointer(sRWLock)), + 0, + 0) + return BOOLEAN(ret1) +} + +func TryAcquireSRWLockShared(sRWLock PSRWLOCK) BOOLEAN { + ret1 := syscall3(tryAcquireSRWLockShared, 1, + uintptr(unsafe.Pointer(sRWLock)), + 0, + 0) + return BOOLEAN(ret1) +} + +// TODO: Unknown type(s): LPCRITICAL_SECTION +// func TryEnterCriticalSection(lpCriticalSection LPCRITICAL_SECTION) bool + +// TODO: Unknown type(s): PTP_CALLBACK_ENVIRON, PTP_SIMPLE_CALLBACK +// func TrySubmitThreadpoolCallback(pfns PTP_SIMPLE_CALLBACK, pv uintptr, pcbe PTP_CALLBACK_ENVIRON) bool + +// TODO: Unknown type(s): CONST TIME_ZONE_INFORMATION * +// func TzSpecificLocalTimeToSystemTime(lpTimeZoneInformation /*const*/ CONST TIME_ZONE_INFORMATION *, lpLocalTime /*const*/ *SYSTEMTIME, lpUniversalTime *SYSTEMTIME) bool + +// TODO: Unknown type(s): struct _EXCEPTION_POINTERS * +// func UnhandledExceptionFilter(exceptionInfo struct _EXCEPTION_POINTERS *) LONG + +func UnlockFile(hFile HANDLE, dwFileOffsetLow DWORD, dwFileOffsetHigh DWORD, nNumberOfBytesToUnlockLow DWORD, nNumberOfBytesToUnlockHigh DWORD) bool { + ret1 := syscall6(unlockFile, 5, + uintptr(hFile), + uintptr(dwFileOffsetLow), + uintptr(dwFileOffsetHigh), + uintptr(nNumberOfBytesToUnlockLow), + uintptr(nNumberOfBytesToUnlockHigh), + 0) + return ret1 != 0 +} + +func UnlockFileEx(hFile HANDLE, dwReserved DWORD, nNumberOfBytesToUnlockLow DWORD, nNumberOfBytesToUnlockHigh DWORD, lpOverlapped *OVERLAPPED) bool { + ret1 := syscall6(unlockFileEx, 5, + uintptr(hFile), + uintptr(dwReserved), + uintptr(nNumberOfBytesToUnlockLow), + uintptr(nNumberOfBytesToUnlockHigh), + uintptr(unsafe.Pointer(lpOverlapped)), + 0) + return ret1 != 0 +} + +func UnmapViewOfFile(lpBaseAddress /*const*/ uintptr) bool { + ret1 := syscall3(unmapViewOfFile, 1, + lpBaseAddress, + 0, + 0) + return ret1 != 0 +} + +func UnregisterApplicationRecoveryCallback() HRESULT { + ret1 := syscall3(unregisterApplicationRecoveryCallback, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func UnregisterApplicationRestart() HRESULT { + ret1 := syscall3(unregisterApplicationRestart, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func UnregisterWait(waitHandle HANDLE) bool { + ret1 := syscall3(unregisterWait, 1, + uintptr(waitHandle), + 0, + 0) + return ret1 != 0 +} + +func UnregisterWaitEx(waitHandle HANDLE, completionEvent HANDLE) bool { + ret1 := syscall3(unregisterWaitEx, 2, + uintptr(waitHandle), + uintptr(completionEvent), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPPROC_THREAD_ATTRIBUTE_LIST, PSIZE_T +// func UpdateProcThreadAttribute(lpAttributeList LPPROC_THREAD_ATTRIBUTE_LIST, dwFlags DWORD, attribute *uint32, lpValue uintptr, cbSize SIZE_T, lpPreviousValue uintptr, lpReturnSize PSIZE_T) bool + +func UpdateResource(hUpdate HANDLE, lpType string, lpName string, wLanguage WORD, lpData LPVOID, cb DWORD) bool { + lpTypeStr := unicode16FromString(lpType) + lpNameStr := unicode16FromString(lpName) + ret1 := syscall6(updateResource, 6, + uintptr(hUpdate), + uintptr(unsafe.Pointer(&lpTypeStr[0])), + uintptr(unsafe.Pointer(&lpNameStr[0])), + uintptr(wLanguage), + uintptr(unsafe.Pointer(lpData)), + uintptr(cb)) + return ret1 != 0 +} + +func VerLanguageName(wLang DWORD, szLang LPWSTR, nSize DWORD) DWORD { + ret1 := syscall3(verLanguageName, 3, + uintptr(wLang), + uintptr(unsafe.Pointer(szLang)), + uintptr(nSize)) + return DWORD(ret1) +} + +func VerifyScripts(dwFlags DWORD, lpLocaleScripts string, cchLocaleScripts int32, lpTestScripts string, cchTestScripts int32) bool { + lpLocaleScriptsStr := unicode16FromString(lpLocaleScripts) + lpTestScriptsStr := unicode16FromString(lpTestScripts) + ret1 := syscall6(verifyScripts, 5, + uintptr(dwFlags), + uintptr(unsafe.Pointer(&lpLocaleScriptsStr[0])), + uintptr(cchLocaleScripts), + uintptr(unsafe.Pointer(&lpTestScriptsStr[0])), + uintptr(cchTestScripts), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): DWORDLONG, LPOSVERSIONINFOEXW +// func VerifyVersionInfo(lpVersionInformation LPOSVERSIONINFOEXW, dwTypeMask DWORD, dwlConditionMask DWORDLONG) bool + +func VirtualAlloc(lpAddress LPVOID, dwSize SIZE_T, flAllocationType DWORD, flProtect DWORD) LPVOID { + ret1 := syscall6(virtualAlloc, 4, + uintptr(unsafe.Pointer(lpAddress)), + uintptr(dwSize), + uintptr(flAllocationType), + uintptr(flProtect), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func VirtualAllocEx(hProcess HANDLE, lpAddress LPVOID, dwSize SIZE_T, flAllocationType DWORD, flProtect DWORD) LPVOID { + ret1 := syscall6(virtualAllocEx, 5, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpAddress)), + uintptr(dwSize), + uintptr(flAllocationType), + uintptr(flProtect), + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func VirtualAllocExNuma(hProcess HANDLE, lpAddress LPVOID, dwSize SIZE_T, flAllocationType DWORD, flProtect DWORD, nndPreferred DWORD) LPVOID { + ret1 := syscall6(virtualAllocExNuma, 6, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpAddress)), + uintptr(dwSize), + uintptr(flAllocationType), + uintptr(flProtect), + uintptr(nndPreferred)) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func VirtualFree(lpAddress LPVOID, dwSize SIZE_T, dwFreeType DWORD) bool { + ret1 := syscall3(virtualFree, 3, + uintptr(unsafe.Pointer(lpAddress)), + uintptr(dwSize), + uintptr(dwFreeType)) + return ret1 != 0 +} + +func VirtualFreeEx(hProcess HANDLE, lpAddress LPVOID, dwSize SIZE_T, dwFreeType DWORD) bool { + ret1 := syscall6(virtualFreeEx, 4, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpAddress)), + uintptr(dwSize), + uintptr(dwFreeType), + 0, + 0) + return ret1 != 0 +} + +func VirtualLock(lpAddress LPVOID, dwSize SIZE_T) bool { + ret1 := syscall3(virtualLock, 2, + uintptr(unsafe.Pointer(lpAddress)), + uintptr(dwSize), + 0) + return ret1 != 0 +} + +func VirtualProtect(lpAddress LPVOID, dwSize SIZE_T, flNewProtect DWORD, lpflOldProtect *DWORD) bool { + ret1 := syscall6(virtualProtect, 4, + uintptr(unsafe.Pointer(lpAddress)), + uintptr(dwSize), + uintptr(flNewProtect), + uintptr(unsafe.Pointer(lpflOldProtect)), + 0, + 0) + return ret1 != 0 +} + +func VirtualProtectEx(hProcess HANDLE, lpAddress LPVOID, dwSize SIZE_T, flNewProtect DWORD, lpflOldProtect *DWORD) bool { + ret1 := syscall6(virtualProtectEx, 5, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpAddress)), + uintptr(dwSize), + uintptr(flNewProtect), + uintptr(unsafe.Pointer(lpflOldProtect)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PMEMORY_BASIC_INFORMATION +// func VirtualQuery(lpAddress /*const*/ uintptr, lpBuffer PMEMORY_BASIC_INFORMATION, dwLength SIZE_T) SIZE_T + +// TODO: Unknown type(s): PMEMORY_BASIC_INFORMATION +// func VirtualQueryEx(hProcess HANDLE, lpAddress /*const*/ uintptr, lpBuffer PMEMORY_BASIC_INFORMATION, dwLength SIZE_T) SIZE_T + +func VirtualUnlock(lpAddress LPVOID, dwSize SIZE_T) bool { + ret1 := syscall3(virtualUnlock, 2, + uintptr(unsafe.Pointer(lpAddress)), + uintptr(dwSize), + 0) + return ret1 != 0 +} + +func WTSGetActiveConsoleSessionId() DWORD { + ret1 := syscall3(wTSGetActiveConsoleSessionId, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func WaitCommEvent(hFile HANDLE, lpEvtMask *uint32, lpOverlapped *OVERLAPPED) bool { + ret1 := syscall3(waitCommEvent, 3, + uintptr(hFile), + uintptr(unsafe.Pointer(lpEvtMask)), + uintptr(unsafe.Pointer(lpOverlapped))) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPDEBUG_EVENT +// func WaitForDebugEvent(lpDebugEvent LPDEBUG_EVENT, dwMilliseconds DWORD) bool + +func WaitForMultipleObjects(nCount DWORD, lpHandles /*const*/ *HANDLE, bWaitAll bool, dwMilliseconds DWORD) DWORD { + ret1 := syscall6(waitForMultipleObjects, 4, + uintptr(nCount), + uintptr(unsafe.Pointer(lpHandles)), + getUintptrFromBool(bWaitAll), + uintptr(dwMilliseconds), + 0, + 0) + return DWORD(ret1) +} + +func WaitForMultipleObjectsEx(nCount DWORD, lpHandles /*const*/ *HANDLE, bWaitAll bool, dwMilliseconds DWORD, bAlertable bool) DWORD { + ret1 := syscall6(waitForMultipleObjectsEx, 5, + uintptr(nCount), + uintptr(unsafe.Pointer(lpHandles)), + getUintptrFromBool(bWaitAll), + uintptr(dwMilliseconds), + getUintptrFromBool(bAlertable), + 0) + return DWORD(ret1) +} + +func WaitForSingleObject(hHandle HANDLE, dwMilliseconds DWORD) DWORD { + ret1 := syscall3(waitForSingleObject, 2, + uintptr(hHandle), + uintptr(dwMilliseconds), + 0) + return DWORD(ret1) +} + +func WaitForSingleObjectEx(hHandle HANDLE, dwMilliseconds DWORD, bAlertable bool) DWORD { + ret1 := syscall3(waitForSingleObjectEx, 3, + uintptr(hHandle), + uintptr(dwMilliseconds), + getUintptrFromBool(bAlertable)) + return DWORD(ret1) +} + +// TODO: Unknown type(s): PTP_IO +// func WaitForThreadpoolIoCallbacks(pio PTP_IO, fCancelPendingCallbacks bool) + +// TODO: Unknown type(s): PTP_TIMER +// func WaitForThreadpoolTimerCallbacks(pti PTP_TIMER, fCancelPendingCallbacks bool) + +// TODO: Unknown type(s): PTP_WAIT +// func WaitForThreadpoolWaitCallbacks(pwa PTP_WAIT, fCancelPendingCallbacks bool) + +// TODO: Unknown type(s): PTP_WORK +// func WaitForThreadpoolWorkCallbacks(pwk PTP_WORK, fCancelPendingCallbacks bool) + +func WaitNamedPipe(lpNamedPipeName string, nTimeOut DWORD) bool { + lpNamedPipeNameStr := unicode16FromString(lpNamedPipeName) + ret1 := syscall3(waitNamedPipe, 2, + uintptr(unsafe.Pointer(&lpNamedPipeNameStr[0])), + uintptr(nTimeOut), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PCONDITION_VARIABLE +// func WakeAllConditionVariable(conditionVariable PCONDITION_VARIABLE) + +// TODO: Unknown type(s): PCONDITION_VARIABLE +// func WakeConditionVariable(conditionVariable PCONDITION_VARIABLE) + +func WerGetFlags(hProcess HANDLE, pdwFlags *DWORD) HRESULT { + ret1 := syscall3(werGetFlags, 2, + uintptr(hProcess), + uintptr(unsafe.Pointer(pdwFlags)), + 0) + return HRESULT(ret1) +} + +// TODO: Unknown type(s): WER_REGISTER_FILE_TYPE +// func WerRegisterFile(pwzFile string, regFileType WER_REGISTER_FILE_TYPE, dwFlags DWORD) HRESULT + +func WerRegisterMemoryBlock(pvAddress uintptr, dwSize DWORD) HRESULT { + ret1 := syscall3(werRegisterMemoryBlock, 2, + pvAddress, + uintptr(dwSize), + 0) + return HRESULT(ret1) +} + +func WerRegisterRuntimeExceptionModule(pwszOutOfProcessCallbackDll string, pContext uintptr) HRESULT { + pwszOutOfProcessCallbackDllStr := unicode16FromString(pwszOutOfProcessCallbackDll) + ret1 := syscall3(werRegisterRuntimeExceptionModule, 2, + uintptr(unsafe.Pointer(&pwszOutOfProcessCallbackDllStr[0])), + pContext, + 0) + return HRESULT(ret1) +} + +func WerSetFlags(dwFlags DWORD) HRESULT { + ret1 := syscall3(werSetFlags, 1, + uintptr(dwFlags), + 0, + 0) + return HRESULT(ret1) +} + +func WerUnregisterFile(pwzFilePath string) HRESULT { + pwzFilePathStr := unicode16FromString(pwzFilePath) + ret1 := syscall3(werUnregisterFile, 1, + uintptr(unsafe.Pointer(&pwzFilePathStr[0])), + 0, + 0) + return HRESULT(ret1) +} + +func WerUnregisterMemoryBlock(pvAddress uintptr) HRESULT { + ret1 := syscall3(werUnregisterMemoryBlock, 1, + pvAddress, + 0, + 0) + return HRESULT(ret1) +} + +func WerUnregisterRuntimeExceptionModule(pwszOutOfProcessCallbackDll string, pContext uintptr) HRESULT { + pwszOutOfProcessCallbackDllStr := unicode16FromString(pwszOutOfProcessCallbackDll) + ret1 := syscall3(werUnregisterRuntimeExceptionModule, 2, + uintptr(unsafe.Pointer(&pwszOutOfProcessCallbackDllStr[0])), + pContext, + 0) + return HRESULT(ret1) +} + +// TODO: Unknown type(s): LPCCH, LPCWCH +// func WideCharToMultiByte(codePage UINT, dwFlags DWORD, lpWideCharStr LPCWCH, cchWideChar int32, lpMultiByteStr LPSTR, cbMultiByte int32, lpDefaultChar LPCCH, lpUsedDefaultChar *BOOL) int32 + +func WinExec(lpCmdLine /*const*/ LPCSTR, uCmdShow UINT) UINT { + ret1 := syscall3(winExec, 2, + uintptr(unsafe.Pointer(lpCmdLine)), + uintptr(uCmdShow), + 0) + return UINT(ret1) +} + +func Wow64DisableWow64FsRedirection(oldValue *PVOID) bool { + ret1 := syscall3(wow64DisableWow64FsRedirection, 1, + uintptr(unsafe.Pointer(oldValue)), + 0, + 0) + return ret1 != 0 +} + +func Wow64EnableWow64FsRedirection(wow64FsEnableRedirection BOOLEAN) BOOLEAN { + ret1 := syscall3(wow64EnableWow64FsRedirection, 1, + uintptr(wow64FsEnableRedirection), + 0, + 0) + return BOOLEAN(ret1) +} + +// TODO: Unknown type(s): PWOW64_CONTEXT +// func Wow64GetThreadContext(hThread HANDLE, lpContext PWOW64_CONTEXT) bool + +// TODO: Unknown type(s): PWOW64_LDT_ENTRY +// func Wow64GetThreadSelectorEntry(hThread HANDLE, dwSelector DWORD, lpSelectorEntry PWOW64_LDT_ENTRY) bool + +func Wow64RevertWow64FsRedirection(olValue uintptr) bool { + ret1 := syscall3(wow64RevertWow64FsRedirection, 1, + olValue, + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): CONST WOW64_CONTEXT * +// func Wow64SetThreadContext(hThread HANDLE, lpContext /*const*/ CONST WOW64_CONTEXT *) bool + +func Wow64SuspendThread(hThread HANDLE) DWORD { + ret1 := syscall3(wow64SuspendThread, 1, + uintptr(hThread), + 0, + 0) + return DWORD(ret1) +} + +// TODO: Unknown type(s): CONST INPUT_RECORD * +// func WriteConsoleInput(hConsoleInput HANDLE, lpBuffer /*const*/ CONST INPUT_RECORD *, nLength DWORD, lpNumberOfEventsWritten *uint32) bool + +func WriteConsoleOutputAttribute(hConsoleOutput HANDLE, lpAttribute /*const*/ *WORD, nLength DWORD, dwWriteCoord COORD, lpNumberOfAttrsWritten *uint32) bool { + ret1 := syscall6(writeConsoleOutputAttribute, 5, + uintptr(hConsoleOutput), + uintptr(unsafe.Pointer(lpAttribute)), + uintptr(nLength), + getUintptrFromCOORD(dwWriteCoord), + uintptr(unsafe.Pointer(lpNumberOfAttrsWritten)), + 0) + return ret1 != 0 +} + +func WriteConsoleOutputCharacter(hConsoleOutput HANDLE, lpCharacter string, nLength DWORD, dwWriteCoord COORD, lpNumberOfCharsWritten *uint32) bool { + lpCharacterStr := unicode16FromString(lpCharacter) + ret1 := syscall6(writeConsoleOutputCharacter, 5, + uintptr(hConsoleOutput), + uintptr(unsafe.Pointer(&lpCharacterStr[0])), + uintptr(nLength), + getUintptrFromCOORD(dwWriteCoord), + uintptr(unsafe.Pointer(lpNumberOfCharsWritten)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): CONST CHAR_INFO *, PSMALL_RECT +// func WriteConsoleOutput(hConsoleOutput HANDLE, lpBuffer /*const*/ CONST CHAR_INFO *, dwBufferSize COORD, dwBufferCoord COORD, lpWriteRegion PSMALL_RECT) bool + +func WriteConsole(hConsoleOutput HANDLE, lpBuffer /*const*/ uintptr, nNumberOfCharsToWrite DWORD, lpNumberOfCharsWritten *uint32, lpReserved LPVOID) bool { + ret1 := syscall6(writeConsole, 5, + uintptr(hConsoleOutput), + lpBuffer, + uintptr(nNumberOfCharsToWrite), + uintptr(unsafe.Pointer(lpNumberOfCharsWritten)), + uintptr(unsafe.Pointer(lpReserved)), + 0) + return ret1 != 0 +} + +func WriteFile(hFile HANDLE, lpBuffer /*const*/ uintptr, nNumberOfBytesToWrite DWORD, lpNumberOfBytesWritten *uint32, lpOverlapped *OVERLAPPED) bool { + ret1 := syscall6(writeFile, 5, + uintptr(hFile), + lpBuffer, + uintptr(nNumberOfBytesToWrite), + uintptr(unsafe.Pointer(lpNumberOfBytesWritten)), + uintptr(unsafe.Pointer(lpOverlapped)), + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): LPOVERLAPPED_COMPLETION_ROUTINE +// func WriteFileEx(hFile HANDLE, lpBuffer /*const*/ uintptr, nNumberOfBytesToWrite DWORD, lpOverlapped *OVERLAPPED, lpCompletionRoutine LPOVERLAPPED_COMPLETION_ROUTINE) bool + +// TODO: Unknown type(s): FILE_SEGMENT_ELEMENT* +// func WriteFileGather(hFile HANDLE, aSegmentArray FILE_SEGMENT_ELEMENT*, nNumberOfBytesToWrite DWORD, lpReserved *uint32, lpOverlapped *OVERLAPPED) bool + +func WritePrivateProfileSection(lpAppName string, lpString string, lpFileName string) bool { + lpAppNameStr := unicode16FromString(lpAppName) + lpStringStr := unicode16FromString(lpString) + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(writePrivateProfileSection, 3, + uintptr(unsafe.Pointer(&lpAppNameStr[0])), + uintptr(unsafe.Pointer(&lpStringStr[0])), + uintptr(unsafe.Pointer(&lpFileNameStr[0]))) + return ret1 != 0 +} + +func WritePrivateProfileString(lpAppName string, lpKeyName string, lpString string, lpFileName string) bool { + lpAppNameStr := unicode16FromString(lpAppName) + lpKeyNameStr := unicode16FromString(lpKeyName) + lpStringStr := unicode16FromString(lpString) + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall6(writePrivateProfileString, 4, + uintptr(unsafe.Pointer(&lpAppNameStr[0])), + uintptr(unsafe.Pointer(&lpKeyNameStr[0])), + uintptr(unsafe.Pointer(&lpStringStr[0])), + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + 0, + 0) + return ret1 != 0 +} + +func WritePrivateProfileStruct(lpszSection string, lpszKey string, lpStruct LPVOID, uSizeStruct UINT, szFile string) bool { + lpszSectionStr := unicode16FromString(lpszSection) + lpszKeyStr := unicode16FromString(lpszKey) + szFileStr := unicode16FromString(szFile) + ret1 := syscall6(writePrivateProfileStruct, 5, + uintptr(unsafe.Pointer(&lpszSectionStr[0])), + uintptr(unsafe.Pointer(&lpszKeyStr[0])), + uintptr(unsafe.Pointer(lpStruct)), + uintptr(uSizeStruct), + uintptr(unsafe.Pointer(&szFileStr[0])), + 0) + return ret1 != 0 +} + +func WriteProcessMemory(hProcess HANDLE, lpBaseAddress LPVOID, lpBuffer /*const*/ uintptr, nSize SIZE_T, lpNumberOfBytesWritten *SIZE_T) bool { + ret1 := syscall6(writeProcessMemory, 5, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpBaseAddress)), + lpBuffer, + uintptr(nSize), + uintptr(unsafe.Pointer(lpNumberOfBytesWritten)), + 0) + return ret1 != 0 +} + +func WriteProfileSection(lpAppName string, lpString string) bool { + lpAppNameStr := unicode16FromString(lpAppName) + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(writeProfileSection, 2, + uintptr(unsafe.Pointer(&lpAppNameStr[0])), + uintptr(unsafe.Pointer(&lpStringStr[0])), + 0) + return ret1 != 0 +} + +func WriteProfileString(lpAppName string, lpKeyName string, lpString string) bool { + lpAppNameStr := unicode16FromString(lpAppName) + lpKeyNameStr := unicode16FromString(lpKeyName) + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(writeProfileString, 3, + uintptr(unsafe.Pointer(&lpAppNameStr[0])), + uintptr(unsafe.Pointer(&lpKeyNameStr[0])), + uintptr(unsafe.Pointer(&lpStringStr[0]))) + return ret1 != 0 +} + +func WriteTapemark(hDevice HANDLE, dwTapemarkType DWORD, dwTapemarkCount DWORD, bImmediate bool) DWORD { + ret1 := syscall6(writeTapemark, 4, + uintptr(hDevice), + uintptr(dwTapemarkType), + uintptr(dwTapemarkCount), + getUintptrFromBool(bImmediate), + 0, + 0) + return DWORD(ret1) +} + +func ZombifyActCtx(hActCtx HANDLE) bool { + ret1 := syscall3(zombifyActCtx, 1, + uintptr(hActCtx), + 0, + 0) + return ret1 != 0 +} + +func Lstrcat(lpString1 LPWSTR, lpString2 string) LPWSTR { + lpString2Str := unicode16FromString(lpString2) + ret1 := syscall3(lstrcat, 2, + uintptr(unsafe.Pointer(lpString1)), + uintptr(unsafe.Pointer(&lpString2Str[0])), + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func Lstrcmp(lpString1 string, lpString2 string) int32 { + lpString1Str := unicode16FromString(lpString1) + lpString2Str := unicode16FromString(lpString2) + ret1 := syscall3(lstrcmp, 2, + uintptr(unsafe.Pointer(&lpString1Str[0])), + uintptr(unsafe.Pointer(&lpString2Str[0])), + 0) + return int32(ret1) +} + +func Lstrcmpi(lpString1 string, lpString2 string) int32 { + lpString1Str := unicode16FromString(lpString1) + lpString2Str := unicode16FromString(lpString2) + ret1 := syscall3(lstrcmpi, 2, + uintptr(unsafe.Pointer(&lpString1Str[0])), + uintptr(unsafe.Pointer(&lpString2Str[0])), + 0) + return int32(ret1) +} + +func Lstrcpy(lpString1 LPWSTR, lpString2 string) LPWSTR { + lpString2Str := unicode16FromString(lpString2) + ret1 := syscall3(lstrcpy, 2, + uintptr(unsafe.Pointer(lpString1)), + uintptr(unsafe.Pointer(&lpString2Str[0])), + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func Lstrcpyn(lpString1 LPWSTR, lpString2 string, iMaxLength int32) LPWSTR { + lpString2Str := unicode16FromString(lpString2) + ret1 := syscall3(lstrcpyn, 3, + uintptr(unsafe.Pointer(lpString1)), + uintptr(unsafe.Pointer(&lpString2Str[0])), + uintptr(iMaxLength)) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func Lstrlen(lpString string) int32 { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(lstrlen, 1, + uintptr(unsafe.Pointer(&lpStringStr[0])), + 0, + 0) + return int32(ret1) +} + +// TODO: Unknown type(s): PCUWSTR +// func Uaw_lstrcmpW(string1 PCUWSTR, string2 PCUWSTR) int32 + +// TODO: Unknown type(s): PCUWSTR +// func Uaw_lstrcmpiW(string1 PCUWSTR, string2 PCUWSTR) int32 + +// TODO: Unknown type(s): LPCUWSTR +// func Uaw_lstrlenW(string LPCUWSTR) int32 + +func CloseConsoleHandle(handle HANDLE) bool { + ret1 := syscall3(closeConsoleHandle, 1, + uintptr(handle), + 0, + 0) + return ret1 != 0 +} + +func CloseProfileUserMapping() bool { + ret1 := syscall3(closeProfileUserMapping, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func CmdBatNotification(bBatchRunning bool) bool { + ret1 := syscall3(cmdBatNotification, 1, + getUintptrFromBool(bBatchRunning), + 0, + 0) + return ret1 != 0 +} + +func DelayLoadFailureHook(name /*const*/ LPCSTR, function /*const*/ LPCSTR) FARPROC { + ret1 := syscall3(delayLoadFailureHook, 2, + uintptr(unsafe.Pointer(name)), + uintptr(unsafe.Pointer(function)), + 0) + return func() INT_PTR { + ret2 := syscall3(ret1, 0, + 0, + 0, + 0) + return (INT_PTR)(unsafe.Pointer(ret2)) + } +} + +func DuplicateConsoleHandle(handle HANDLE, access DWORD, inherit bool, options DWORD) HANDLE { + ret1 := syscall6(duplicateConsoleHandle, 4, + uintptr(handle), + uintptr(access), + getUintptrFromBool(inherit), + uintptr(options), + 0, + 0) + return HANDLE(ret1) +} + +func ExpungeConsoleCommandHistory(unknown string) { + unknownStr := unicode16FromString(unknown) + syscall3(expungeConsoleCommandHistory, 1, + uintptr(unsafe.Pointer(&unknownStr[0])), + 0, + 0) +} + +func GetConsoleCommandHistoryLength(unknown string) DWORD { + unknownStr := unicode16FromString(unknown) + ret1 := syscall3(getConsoleCommandHistoryLength, 1, + uintptr(unsafe.Pointer(&unknownStr[0])), + 0, + 0) + return DWORD(ret1) +} + +func GetConsoleCommandHistory(unknown1 DWORD, unknown2 DWORD, unknown3 DWORD) DWORD { + ret1 := syscall3(getConsoleCommandHistory, 3, + uintptr(unknown1), + uintptr(unknown2), + uintptr(unknown3)) + return DWORD(ret1) +} + +// TODO: Unknown type(s): CONSOLE_FONT_INFO * +// func GetConsoleFontInfo(hConsole HANDLE, maximize bool, numfonts DWORD, info CONSOLE_FONT_INFO *) bool + +func GetConsoleInputExeName(buflen DWORD, buffer LPWSTR) bool { + ret1 := syscall3(getConsoleInputExeName, 2, + uintptr(buflen), + uintptr(unsafe.Pointer(buffer)), + 0) + return ret1 != 0 +} + +func GetConsoleInputWaitHandle() HANDLE { + ret1 := syscall3(getConsoleInputWaitHandle, 0, + 0, + 0, + 0) + return HANDLE(ret1) +} + +func GetConsoleKeyboardLayoutName(layoutName LPWSTR) bool { + ret1 := syscall3(getConsoleKeyboardLayoutName, 1, + uintptr(unsafe.Pointer(layoutName)), + 0, + 0) + return ret1 != 0 +} + +func GetNumberOfConsoleFonts() DWORD { + ret1 := syscall3(getNumberOfConsoleFonts, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func K32EmptyWorkingSet(hProcess HANDLE) bool { + ret1 := syscall3(k32EmptyWorkingSet, 1, + uintptr(hProcess), + 0, + 0) + return ret1 != 0 +} + +func K32EnumDeviceDrivers(image_base uintptr, cb DWORD, needed *uint32) bool { + ret1 := syscall3(k32EnumDeviceDrivers, 3, + image_base, + uintptr(cb), + uintptr(unsafe.Pointer(needed))) + return ret1 != 0 +} + +func K32EnumPageFiles(callback PENUM_PAGE_FILE_CALLBACK, context LPVOID) bool { + callbackCallback := syscall.NewCallback(func(pContextRawArg LPVOID, pPageFileInfoRawArg PENUM_PAGE_FILE_INFORMATION, lpFilenameRawArg /*const*/ *uint16) uintptr { + lpFilename := stringFromUnicode16(lpFilenameRawArg) + ret := callback(pContextRawArg, pPageFileInfoRawArg, lpFilename) + return uintptr(ret) + }) + ret1 := syscall3(k32EnumPageFiles, 2, + callbackCallback, + uintptr(unsafe.Pointer(context)), + 0) + return ret1 != 0 +} + +func K32EnumProcessModules(process HANDLE, lphModule *HMODULE, cb DWORD, needed *uint32) bool { + ret1 := syscall6(k32EnumProcessModules, 4, + uintptr(process), + uintptr(unsafe.Pointer(lphModule)), + uintptr(cb), + uintptr(unsafe.Pointer(needed)), + 0, + 0) + return ret1 != 0 +} + +func K32EnumProcessModulesEx(process HANDLE, lphModule *HMODULE, cb DWORD, needed *uint32, filter DWORD) bool { + ret1 := syscall6(k32EnumProcessModulesEx, 5, + uintptr(process), + uintptr(unsafe.Pointer(lphModule)), + uintptr(cb), + uintptr(unsafe.Pointer(needed)), + uintptr(filter), + 0) + return ret1 != 0 +} + +func K32EnumProcesses(lpdwProcessIDs *uint32, cb DWORD, lpcbUsed *uint32) bool { + ret1 := syscall3(k32EnumProcesses, 3, + uintptr(unsafe.Pointer(lpdwProcessIDs)), + uintptr(cb), + uintptr(unsafe.Pointer(lpcbUsed))) + return ret1 != 0 +} + +func K32GetDeviceDriverBaseName(image_base uintptr, base_name LPWSTR, size DWORD) DWORD { + ret1 := syscall3(k32GetDeviceDriverBaseName, 3, + image_base, + uintptr(unsafe.Pointer(base_name)), + uintptr(size)) + return DWORD(ret1) +} + +func K32GetDeviceDriverFileName(image_base uintptr, file_name LPWSTR, size DWORD) DWORD { + ret1 := syscall3(k32GetDeviceDriverFileName, 3, + image_base, + uintptr(unsafe.Pointer(file_name)), + uintptr(size)) + return DWORD(ret1) +} + +func K32GetMappedFileName(process HANDLE, lpv LPVOID, file_name LPWSTR, size DWORD) DWORD { + ret1 := syscall6(k32GetMappedFileName, 4, + uintptr(process), + uintptr(unsafe.Pointer(lpv)), + uintptr(unsafe.Pointer(file_name)), + uintptr(size), + 0, + 0) + return DWORD(ret1) +} + +func K32GetModuleBaseName(process HANDLE, module HMODULE, base_name LPWSTR, size DWORD) DWORD { + ret1 := syscall6(k32GetModuleBaseName, 4, + uintptr(process), + uintptr(module), + uintptr(unsafe.Pointer(base_name)), + uintptr(size), + 0, + 0) + return DWORD(ret1) +} + +func K32GetModuleFileNameEx(process HANDLE, module HMODULE, file_name LPWSTR, size DWORD) DWORD { + ret1 := syscall6(k32GetModuleFileNameEx, 4, + uintptr(process), + uintptr(module), + uintptr(unsafe.Pointer(file_name)), + uintptr(size), + 0, + 0) + return DWORD(ret1) +} + +func K32GetModuleInformation(process HANDLE, module HMODULE, modinfo *MODULEINFO, cb DWORD) bool { + ret1 := syscall6(k32GetModuleInformation, 4, + uintptr(process), + uintptr(module), + uintptr(unsafe.Pointer(modinfo)), + uintptr(cb), + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): PPERFORMANCE_INFORMATION +// func K32GetPerformanceInfo(info PPERFORMANCE_INFORMATION, size DWORD) bool + +func K32GetProcessImageFileName(process HANDLE, file LPWSTR, size DWORD) DWORD { + ret1 := syscall3(k32GetProcessImageFileName, 3, + uintptr(process), + uintptr(unsafe.Pointer(file)), + uintptr(size)) + return DWORD(ret1) +} + +func K32GetProcessMemoryInfo(process HANDLE, pmc PPROCESS_MEMORY_COUNTERS, cb DWORD) bool { + ret1 := syscall3(k32GetProcessMemoryInfo, 3, + uintptr(process), + uintptr(unsafe.Pointer(pmc)), + uintptr(cb)) + return ret1 != 0 +} + +func K32GetWsChanges(process HANDLE, watchinfo PPSAPI_WS_WATCH_INFORMATION, size DWORD) bool { + ret1 := syscall3(k32GetWsChanges, 3, + uintptr(process), + uintptr(unsafe.Pointer(watchinfo)), + uintptr(size)) + return ret1 != 0 +} + +func K32InitializeProcessForWsWatch(process HANDLE) bool { + ret1 := syscall3(k32InitializeProcessForWsWatch, 1, + uintptr(process), + 0, + 0) + return ret1 != 0 +} + +func K32QueryWorkingSet(process HANDLE, buffer LPVOID, size DWORD) bool { + ret1 := syscall3(k32QueryWorkingSet, 3, + uintptr(process), + uintptr(unsafe.Pointer(buffer)), + uintptr(size)) + return ret1 != 0 +} + +func K32QueryWorkingSetEx(process HANDLE, buffer LPVOID, size DWORD) bool { + ret1 := syscall3(k32QueryWorkingSetEx, 3, + uintptr(process), + uintptr(unsafe.Pointer(buffer)), + uintptr(size)) + return ret1 != 0 +} + +func OpenConsoleW(name string, access DWORD, inherit bool, creation DWORD) HANDLE { + nameStr := unicode16FromString(name) + ret1 := syscall6(openConsoleW, 4, + uintptr(unsafe.Pointer(&nameStr[0])), + uintptr(access), + getUintptrFromBool(inherit), + uintptr(creation), + 0, + 0) + return HANDLE(ret1) +} + +func OpenProfileUserMapping() bool { + ret1 := syscall3(openProfileUserMapping, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +// TODO: Unknown type(s): WAITORTIMERCALLBACK +// func RegisterWaitForSingleObjectEx(hObject HANDLE, callback WAITORTIMERCALLBACK, context uintptr, dwMilliseconds ULONG, dwFlags ULONG) HANDLE + +// TODO: Unknown type(s): CONTEXT * +// func RtlCaptureContext(context CONTEXT *) + +func RtlCaptureStackBackTrace(skip ULONG, count ULONG, buffer *PVOID, hash *ULONG) USHORT { + ret1 := syscall6(rtlCaptureStackBackTrace, 4, + uintptr(skip), + uintptr(count), + uintptr(unsafe.Pointer(buffer)), + uintptr(unsafe.Pointer(hash)), + 0, + 0) + return USHORT(ret1) +} + +func RtlCompareMemory(source1 /*const*/ uintptr, source2 /*const*/ uintptr, length SIZE_T) SIZE_T { + ret1 := syscall3(rtlCompareMemory, 3, + source1, + source2, + uintptr(length)) + return SIZE_T(ret1) +} + +func RtlCopyMemory(dest uintptr, src /*const*/ uintptr, aLen SIZE_T) { + syscall3(rtlCopyMemory, 3, + dest, + src, + uintptr(aLen)) +} + +func RtlFillMemory(destination uintptr, length SIZE_T, fill BYTE) { + syscall3(rtlFillMemory, 3, + destination, + uintptr(length), + uintptr(fill)) +} + +// TODO: Unknown type(s): PRUNTIME_FUNCTION, UNWIND_HISTORY_TABLE * +// func RtlLookupFunctionEntry(pc *uint32, base *uint32, table UNWIND_HISTORY_TABLE *) PRUNTIME_FUNCTION + +func RtlMoveMemory(destination uintptr, source /*const*/ uintptr, length SIZE_T) { + syscall3(rtlMoveMemory, 3, + destination, + source, + uintptr(length)) +} + +func RtlPcToFileHeader(pc uintptr, address *PVOID) uintptr { + ret1 := syscall3(rtlPcToFileHeader, 2, + pc, + uintptr(unsafe.Pointer(address)), + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +// TODO: Unknown type(s): EXCEPTION_RECORD * +// func RtlRaiseException(rec EXCEPTION_RECORD *) + +// TODO: Unknown type(s): CONTEXT *, EXCEPTION_RECORD * +// func RtlRestoreContext(context CONTEXT *, rec EXCEPTION_RECORD *) + +// TODO: Unknown type(s): EXCEPTION_RECORD * +// func RtlUnwind(endframe uintptr, target_ip uintptr, rec EXCEPTION_RECORD *, retval uintptr) + +// TODO: Unknown type(s): CONTEXT *, EXCEPTION_RECORD *, UNWIND_HISTORY_TABLE * +// func RtlUnwindEx(end_frame uintptr, target_ip uintptr, rec EXCEPTION_RECORD *, retval uintptr, context CONTEXT *, table UNWIND_HISTORY_TABLE *) + +// TODO: Unknown type(s): CONTEXT *, KNONVOLATILE_CONTEXT_POINTERS *, RUNTIME_FUNCTION * +// func RtlVirtualUnwind(aType ULONG, base ULONG64, pc ULONG64, function RUNTIME_FUNCTION *, context CONTEXT *, data *PVOID, frame_ret *ULONG64, ctx_ptr KNONVOLATILE_CONTEXT_POINTERS *) uintptr + +func RtlZeroMemory(destination uintptr, length SIZE_T) { + syscall3(rtlZeroMemory, 2, + destination, + uintptr(length), + 0) +} + +func SetCPGlobal(acp UINT) UINT { + ret1 := syscall3(setCPGlobal, 1, + uintptr(acp), + 0, + 0) + return UINT(ret1) +} + +func SetConsoleFont(hConsole HANDLE, index DWORD) bool { + ret1 := syscall3(setConsoleFont, 2, + uintptr(hConsole), + uintptr(index), + 0) + return ret1 != 0 +} + +func SetConsoleIcon(icon HICON) bool { + ret1 := syscall3(setConsoleIcon, 1, + uintptr(icon), + 0, + 0) + return ret1 != 0 +} + +func SetConsoleInputExeName(name string) bool { + nameStr := unicode16FromString(name) + ret1 := syscall3(setConsoleInputExeName, 1, + uintptr(unsafe.Pointer(&nameStr[0])), + 0, + 0) + return ret1 != 0 +} + +func SetConsoleKeyShortcuts(set bool, keys BYTE, a uintptr, b DWORD) bool { + ret1 := syscall6(setConsoleKeyShortcuts, 4, + getUintptrFromBool(set), + uintptr(keys), + a, + uintptr(b), + 0, + 0) + return ret1 != 0 +} + +func SetTermsrvAppInstallMode(bInstallMode bool) DWORD { + ret1 := syscall3(setTermsrvAppInstallMode, 1, + getUintptrFromBool(bInstallMode), + 0, + 0) + return DWORD(ret1) +} + +func TermsrvAppInstallMode() bool { + ret1 := syscall3(termsrvAppInstallMode, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func UTRegister(hModule HMODULE, lpsz16BITDLL LPSTR, lpszInitName LPSTR, lpszProcName LPSTR, ppfn32Thunk *FARPROC, pfnUT32CallBack FARPROC, lpBuff LPVOID) bool { + pfnUT32CallBackCallback := syscall.NewCallback(func() uintptr { + ret := pfnUT32CallBack() + return uintptr(unsafe.Pointer(ret)) + }) + ret1 := syscall9(uTRegister, 7, + uintptr(hModule), + uintptr(unsafe.Pointer(lpsz16BITDLL)), + uintptr(unsafe.Pointer(lpszInitName)), + uintptr(unsafe.Pointer(lpszProcName)), + uintptr(unsafe.Pointer(ppfn32Thunk)), + pfnUT32CallBackCallback, + uintptr(unsafe.Pointer(lpBuff)), + 0, + 0) + return ret1 != 0 +} + +func UTUnRegister(hModule HMODULE) { + syscall3(uTUnRegister, 1, + uintptr(hModule), + 0, + 0) +} + +func VerSetConditionMask(dwlConditionMask ULONGLONG, dwTypeBitMask DWORD, dwConditionMask BYTE) ULONGLONG { + ret1 := syscall3(verSetConditionMask, 3, + uintptr(dwlConditionMask), + uintptr(dwTypeBitMask), + uintptr(dwConditionMask)) + return ULONGLONG(ret1) +} + +func VerifyConsoleIoHandle(handle HANDLE) bool { + ret1 := syscall3(verifyConsoleIoHandle, 1, + uintptr(handle), + 0, + 0) + return ret1 != 0 +} diff --git a/grdp/win/ole32.go b/grdp/win/ole32.go new file mode 100644 index 0000000..4c4587c --- /dev/null +++ b/grdp/win/ole32.go @@ -0,0 +1,1893 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "unsafe" +) + +var ( + // Library + libole32 uintptr + + // Functions + coGetInterceptor uintptr + coGetInterceptorFromTypeInfo uintptr + propVariantChangeType uintptr + bindMoniker uintptr + cLSIDFromProgIDEx uintptr + cLSIDFromString uintptr + coAddRefServerProcess uintptr + coAllowSetForegroundWindow uintptr + coBuildVersion uintptr + coCopyProxy uintptr + coCreateFreeThreadedMarshaler uintptr + coCreateGuid uintptr + coDisconnectObject uintptr + coFileTimeNow uintptr + coFreeAllLibraries uintptr + coFreeLibrary uintptr + coGetActivationState uintptr + coGetApartmentType uintptr + coGetCallContext uintptr + coGetCallState uintptr + coGetCallerTID uintptr + coGetContextToken uintptr + coGetCurrentLogicalThreadId uintptr + coGetCurrentProcess uintptr + coGetDefaultContext uintptr + coGetInstanceFromIStorage uintptr + coGetInterfaceAndReleaseStream uintptr + coGetMalloc uintptr + coGetMarshalSizeMax uintptr + coGetObject uintptr + coGetObjectContext uintptr + coGetPSClsid uintptr + coGetStandardMarshal uintptr + coGetState uintptr + coGetTreatAsClass uintptr + coImpersonateClient uintptr + coInitialize uintptr + coInitializeSecurity uintptr + coInitializeWOW uintptr + coIsHandlerConnected uintptr + coIsOle1Class uintptr + coLoadLibrary uintptr + coLockObjectExternal uintptr + coMarshalHresult uintptr + coMarshalInterThreadInterfaceInStream uintptr + coMarshalInterface uintptr + coQueryClientBlanket uintptr + coQueryProxyBlanket uintptr + coRegisterChannelHook uintptr + coRegisterClassObject uintptr + coRegisterInitializeSpy uintptr + coRegisterMallocSpy uintptr + coRegisterMessageFilter uintptr + coRegisterPSClsid uintptr + coReleaseMarshalData uintptr + coReleaseServerProcess uintptr + coResumeClassObjects uintptr + coRevertToSelf uintptr + coRevokeInitializeSpy uintptr + coRevokeMallocSpy uintptr + coSetProxyBlanket uintptr + coSetState uintptr + coSuspendClassObjects uintptr + coSwitchCallContext uintptr + coTaskMemAlloc uintptr + coTaskMemFree uintptr + coTaskMemRealloc uintptr + coTreatAsClass uintptr + coUnmarshalHresult uintptr + coUnmarshalInterface uintptr + coWaitForMultipleHandles uintptr + createAntiMoniker uintptr + createBindCtx uintptr + createClassMoniker uintptr + createDataAdviseHolder uintptr + createDataCache uintptr + createFileMoniker uintptr + createGenericComposite uintptr + createILockBytesOnHGlobal uintptr + createItemMoniker uintptr + createOleAdviseHolder uintptr + createPointerMoniker uintptr + createStreamOnHGlobal uintptr + dllDebugObjectRPCHook uintptr + doDragDrop uintptr + fmtIdToPropStgName uintptr + freePropVariantArray uintptr + getClassFile uintptr + getConvertStg uintptr + getHGlobalFromILockBytes uintptr + getHGlobalFromStream uintptr + getRunningObjectTable uintptr + iIDFromString uintptr + isAccelerator uintptr + isEqualGUID uintptr + isValidInterface uintptr + mkParseDisplayName uintptr + monikerCommonPrefixWith uintptr + oleBuildVersion uintptr + oleConvertIStorageToOLESTREAM uintptr + oleConvertOLESTREAMToIStorage uintptr + oleCreate uintptr + oleCreateDefaultHandler uintptr + oleCreateEmbeddingHelper uintptr + oleCreateFromData uintptr + oleCreateFromDataEx uintptr + oleCreateFromFile uintptr + oleCreateFromFileEx uintptr + oleCreateLink uintptr + oleCreateLinkFromData uintptr + oleCreateLinkToFile uintptr + oleCreateMenuDescriptor uintptr + oleCreateStaticFromData uintptr + oleDestroyMenuDescriptor uintptr + oleDoAutoConvert uintptr + oleDraw uintptr + oleDuplicateData uintptr + oleFlushClipboard uintptr + oleGetAutoConvert uintptr + oleGetClipboard uintptr + oleGetIconOfClass uintptr + oleInitialize uintptr + oleUninitialize uintptr + oleInitializeWOW uintptr + oleIsCurrentClipboard uintptr + oleIsRunning uintptr + oleLoad uintptr + oleLoadFromStream uintptr + oleLockRunning uintptr + oleMetafilePictFromIconAndLabel uintptr + oleNoteObjectVisible uintptr + oleQueryCreateFromData uintptr + oleQueryLinkFromData uintptr + oleRegEnumVerbs uintptr + oleRegGetMiscStatus uintptr + oleRegGetUserType uintptr + oleSave uintptr + oleSaveToStream uintptr + oleSetAutoConvert uintptr + oleSetClipboard uintptr + oleSetContainedObject uintptr + oleSetMenuDescriptor uintptr + oleTranslateAccelerator uintptr + propStgNameToFmtId uintptr + propSysAllocString uintptr + propSysFreeString uintptr + propVariantClear uintptr + propVariantCopy uintptr + readClassStg uintptr + readClassStm uintptr + readFmtUserTypeStg uintptr + registerDragDrop uintptr + releaseStgMedium uintptr + revokeDragDrop uintptr + setConvertStg uintptr + stgCreateDocfile uintptr + stgCreateDocfileOnILockBytes uintptr + stgCreatePropSetStg uintptr + stgCreatePropStg uintptr + stgIsStorageFile uintptr + stgIsStorageILockBytes uintptr + stgOpenPropStg uintptr + stgSetTimes uintptr + stringFromCLSID uintptr + stringFromGUID2 uintptr + wdtpInterfacePointer_UserFree uintptr + writeClassStg uintptr + writeClassStm uintptr + writeFmtUserTypeStg uintptr +) + +func init() { + // Library + libole32 = doLoadLibrary("ole32.dll") + + // Functions + coGetInterceptor = doGetProcAddress(libole32, "CoGetInterceptor") + coGetInterceptorFromTypeInfo = doGetProcAddress(libole32, "CoGetInterceptorFromTypeInfo") + propVariantChangeType = doGetProcAddress(libole32, "PropVariantChangeType") + bindMoniker = doGetProcAddress(libole32, "BindMoniker") + cLSIDFromProgIDEx = doGetProcAddress(libole32, "CLSIDFromProgIDEx") + cLSIDFromString = doGetProcAddress(libole32, "CLSIDFromString") + coAddRefServerProcess = doGetProcAddress(libole32, "CoAddRefServerProcess") + coAllowSetForegroundWindow = doGetProcAddress(libole32, "CoAllowSetForegroundWindow") + coBuildVersion = doGetProcAddress(libole32, "CoBuildVersion") + coCopyProxy = doGetProcAddress(libole32, "CoCopyProxy") + coCreateFreeThreadedMarshaler = doGetProcAddress(libole32, "CoCreateFreeThreadedMarshaler") + coCreateGuid = doGetProcAddress(libole32, "CoCreateGuid") + coDisconnectObject = doGetProcAddress(libole32, "CoDisconnectObject") + coFileTimeNow = doGetProcAddress(libole32, "CoFileTimeNow") + coFreeAllLibraries = doGetProcAddress(libole32, "CoFreeAllLibraries") + coFreeLibrary = doGetProcAddress(libole32, "CoFreeLibrary") + coGetActivationState = doGetProcAddress(libole32, "CoGetActivationState") + coGetApartmentType = doGetProcAddress(libole32, "CoGetApartmentType") + coGetCallContext = doGetProcAddress(libole32, "CoGetCallContext") + coGetCallState = doGetProcAddress(libole32, "CoGetCallState") + coGetCallerTID = doGetProcAddress(libole32, "CoGetCallerTID") + coGetContextToken = doGetProcAddress(libole32, "CoGetContextToken") + coGetCurrentLogicalThreadId = doGetProcAddress(libole32, "CoGetCurrentLogicalThreadId") + coGetCurrentProcess = doGetProcAddress(libole32, "CoGetCurrentProcess") + coGetDefaultContext = doGetProcAddress(libole32, "CoGetDefaultContext") + coGetInstanceFromIStorage = doGetProcAddress(libole32, "CoGetInstanceFromIStorage") + coGetInterfaceAndReleaseStream = doGetProcAddress(libole32, "CoGetInterfaceAndReleaseStream") + coGetMalloc = doGetProcAddress(libole32, "CoGetMalloc") + coGetMarshalSizeMax = doGetProcAddress(libole32, "CoGetMarshalSizeMax") + coGetObject = doGetProcAddress(libole32, "CoGetObject") + coGetObjectContext = doGetProcAddress(libole32, "CoGetObjectContext") + coGetPSClsid = doGetProcAddress(libole32, "CoGetPSClsid") + coGetStandardMarshal = doGetProcAddress(libole32, "CoGetStandardMarshal") + coGetState = doGetProcAddress(libole32, "CoGetState") + coGetTreatAsClass = doGetProcAddress(libole32, "CoGetTreatAsClass") + coImpersonateClient = doGetProcAddress(libole32, "CoImpersonateClient") + coInitialize = doGetProcAddress(libole32, "CoInitialize") + coInitializeSecurity = doGetProcAddress(libole32, "CoInitializeSecurity") + coInitializeWOW = doGetProcAddress(libole32, "CoInitializeWOW") + coIsHandlerConnected = doGetProcAddress(libole32, "CoIsHandlerConnected") + coIsOle1Class = doGetProcAddress(libole32, "CoIsOle1Class") + coLoadLibrary = doGetProcAddress(libole32, "CoLoadLibrary") + coLockObjectExternal = doGetProcAddress(libole32, "CoLockObjectExternal") + coMarshalHresult = doGetProcAddress(libole32, "CoMarshalHresult") + coMarshalInterThreadInterfaceInStream = doGetProcAddress(libole32, "CoMarshalInterThreadInterfaceInStream") + coMarshalInterface = doGetProcAddress(libole32, "CoMarshalInterface") + coQueryClientBlanket = doGetProcAddress(libole32, "CoQueryClientBlanket") + coQueryProxyBlanket = doGetProcAddress(libole32, "CoQueryProxyBlanket") + coRegisterChannelHook = doGetProcAddress(libole32, "CoRegisterChannelHook") + coRegisterClassObject = doGetProcAddress(libole32, "CoRegisterClassObject") + coRegisterInitializeSpy = doGetProcAddress(libole32, "CoRegisterInitializeSpy") + coRegisterMallocSpy = doGetProcAddress(libole32, "CoRegisterMallocSpy") + coRegisterMessageFilter = doGetProcAddress(libole32, "CoRegisterMessageFilter") + coRegisterPSClsid = doGetProcAddress(libole32, "CoRegisterPSClsid") + coReleaseMarshalData = doGetProcAddress(libole32, "CoReleaseMarshalData") + coReleaseServerProcess = doGetProcAddress(libole32, "CoReleaseServerProcess") + coResumeClassObjects = doGetProcAddress(libole32, "CoResumeClassObjects") + coRevertToSelf = doGetProcAddress(libole32, "CoRevertToSelf") + coRevokeInitializeSpy = doGetProcAddress(libole32, "CoRevokeInitializeSpy") + coRevokeMallocSpy = doGetProcAddress(libole32, "CoRevokeMallocSpy") + coSetProxyBlanket = doGetProcAddress(libole32, "CoSetProxyBlanket") + coSetState = doGetProcAddress(libole32, "CoSetState") + coSuspendClassObjects = doGetProcAddress(libole32, "CoSuspendClassObjects") + coSwitchCallContext = doGetProcAddress(libole32, "CoSwitchCallContext") + coTaskMemAlloc = doGetProcAddress(libole32, "CoTaskMemAlloc") + coTaskMemFree = doGetProcAddress(libole32, "CoTaskMemFree") + coTaskMemRealloc = doGetProcAddress(libole32, "CoTaskMemRealloc") + coTreatAsClass = doGetProcAddress(libole32, "CoTreatAsClass") + coUnmarshalHresult = doGetProcAddress(libole32, "CoUnmarshalHresult") + coUnmarshalInterface = doGetProcAddress(libole32, "CoUnmarshalInterface") + coWaitForMultipleHandles = doGetProcAddress(libole32, "CoWaitForMultipleHandles") + createAntiMoniker = doGetProcAddress(libole32, "CreateAntiMoniker") + createBindCtx = doGetProcAddress(libole32, "CreateBindCtx") + createClassMoniker = doGetProcAddress(libole32, "CreateClassMoniker") + createDataAdviseHolder = doGetProcAddress(libole32, "CreateDataAdviseHolder") + createDataCache = doGetProcAddress(libole32, "CreateDataCache") + createFileMoniker = doGetProcAddress(libole32, "CreateFileMoniker") + createGenericComposite = doGetProcAddress(libole32, "CreateGenericComposite") + createILockBytesOnHGlobal = doGetProcAddress(libole32, "CreateILockBytesOnHGlobal") + createItemMoniker = doGetProcAddress(libole32, "CreateItemMoniker") + createOleAdviseHolder = doGetProcAddress(libole32, "CreateOleAdviseHolder") + createPointerMoniker = doGetProcAddress(libole32, "CreatePointerMoniker") + createStreamOnHGlobal = doGetProcAddress(libole32, "CreateStreamOnHGlobal") + dllDebugObjectRPCHook = doGetProcAddress(libole32, "DllDebugObjectRPCHook") + doDragDrop = doGetProcAddress(libole32, "DoDragDrop") + fmtIdToPropStgName = doGetProcAddress(libole32, "FmtIdToPropStgName") + freePropVariantArray = doGetProcAddress(libole32, "FreePropVariantArray") + getClassFile = doGetProcAddress(libole32, "GetClassFile") + getConvertStg = doGetProcAddress(libole32, "GetConvertStg") + getHGlobalFromILockBytes = doGetProcAddress(libole32, "GetHGlobalFromILockBytes") + getHGlobalFromStream = doGetProcAddress(libole32, "GetHGlobalFromStream") + getRunningObjectTable = doGetProcAddress(libole32, "GetRunningObjectTable") + iIDFromString = doGetProcAddress(libole32, "IIDFromString") + isAccelerator = doGetProcAddress(libole32, "IsAccelerator") + isEqualGUID = doGetProcAddress(libole32, "IsEqualGUID") + isValidInterface = doGetProcAddress(libole32, "IsValidInterface") + mkParseDisplayName = doGetProcAddress(libole32, "MkParseDisplayName") + monikerCommonPrefixWith = doGetProcAddress(libole32, "MonikerCommonPrefixWith") + oleBuildVersion = doGetProcAddress(libole32, "OleBuildVersion") + oleConvertIStorageToOLESTREAM = doGetProcAddress(libole32, "OleConvertIStorageToOLESTREAM") + oleConvertOLESTREAMToIStorage = doGetProcAddress(libole32, "OleConvertOLESTREAMToIStorage") + oleCreate = doGetProcAddress(libole32, "OleCreate") + oleCreateDefaultHandler = doGetProcAddress(libole32, "OleCreateDefaultHandler") + oleCreateEmbeddingHelper = doGetProcAddress(libole32, "OleCreateEmbeddingHelper") + oleCreateFromData = doGetProcAddress(libole32, "OleCreateFromData") + oleCreateFromDataEx = doGetProcAddress(libole32, "OleCreateFromDataEx") + oleCreateFromFile = doGetProcAddress(libole32, "OleCreateFromFile") + oleCreateFromFileEx = doGetProcAddress(libole32, "OleCreateFromFileEx") + oleCreateLink = doGetProcAddress(libole32, "OleCreateLink") + oleCreateLinkFromData = doGetProcAddress(libole32, "OleCreateLinkFromData") + oleCreateLinkToFile = doGetProcAddress(libole32, "OleCreateLinkToFile") + oleCreateMenuDescriptor = doGetProcAddress(libole32, "OleCreateMenuDescriptor") + oleCreateStaticFromData = doGetProcAddress(libole32, "OleCreateStaticFromData") + oleDestroyMenuDescriptor = doGetProcAddress(libole32, "OleDestroyMenuDescriptor") + oleDoAutoConvert = doGetProcAddress(libole32, "OleDoAutoConvert") + oleDraw = doGetProcAddress(libole32, "OleDraw") + oleDuplicateData = doGetProcAddress(libole32, "OleDuplicateData") + oleFlushClipboard = doGetProcAddress(libole32, "OleFlushClipboard") + oleGetAutoConvert = doGetProcAddress(libole32, "OleGetAutoConvert") + oleGetClipboard = doGetProcAddress(libole32, "OleGetClipboard") + oleGetIconOfClass = doGetProcAddress(libole32, "OleGetIconOfClass") + oleInitialize = doGetProcAddress(libole32, "OleInitialize") + oleUninitialize = doGetProcAddress(libole32, "OleUninitialize") + oleInitializeWOW = doGetProcAddress(libole32, "OleInitializeWOW") + oleIsCurrentClipboard = doGetProcAddress(libole32, "OleIsCurrentClipboard") + oleIsRunning = doGetProcAddress(libole32, "OleIsRunning") + oleLoad = doGetProcAddress(libole32, "OleLoad") + oleLoadFromStream = doGetProcAddress(libole32, "OleLoadFromStream") + oleLockRunning = doGetProcAddress(libole32, "OleLockRunning") + oleMetafilePictFromIconAndLabel = doGetProcAddress(libole32, "OleMetafilePictFromIconAndLabel") + oleNoteObjectVisible = doGetProcAddress(libole32, "OleNoteObjectVisible") + oleQueryCreateFromData = doGetProcAddress(libole32, "OleQueryCreateFromData") + oleQueryLinkFromData = doGetProcAddress(libole32, "OleQueryLinkFromData") + oleRegEnumVerbs = doGetProcAddress(libole32, "OleRegEnumVerbs") + oleRegGetMiscStatus = doGetProcAddress(libole32, "OleRegGetMiscStatus") + oleRegGetUserType = doGetProcAddress(libole32, "OleRegGetUserType") + oleSave = doGetProcAddress(libole32, "OleSave") + oleSaveToStream = doGetProcAddress(libole32, "OleSaveToStream") + oleSetAutoConvert = doGetProcAddress(libole32, "OleSetAutoConvert") + oleSetClipboard = doGetProcAddress(libole32, "OleSetClipboard") + oleSetContainedObject = doGetProcAddress(libole32, "OleSetContainedObject") + oleSetMenuDescriptor = doGetProcAddress(libole32, "OleSetMenuDescriptor") + oleTranslateAccelerator = doGetProcAddress(libole32, "OleTranslateAccelerator") + propStgNameToFmtId = doGetProcAddress(libole32, "PropStgNameToFmtId") + propSysAllocString = doGetProcAddress(libole32, "PropSysAllocString") + propSysFreeString = doGetProcAddress(libole32, "PropSysFreeString") + propVariantClear = doGetProcAddress(libole32, "PropVariantClear") + propVariantCopy = doGetProcAddress(libole32, "PropVariantCopy") + readClassStg = doGetProcAddress(libole32, "ReadClassStg") + readClassStm = doGetProcAddress(libole32, "ReadClassStm") + readFmtUserTypeStg = doGetProcAddress(libole32, "ReadFmtUserTypeStg") + registerDragDrop = doGetProcAddress(libole32, "RegisterDragDrop") + releaseStgMedium = doGetProcAddress(libole32, "ReleaseStgMedium") + revokeDragDrop = doGetProcAddress(libole32, "RevokeDragDrop") + setConvertStg = doGetProcAddress(libole32, "SetConvertStg") + stgCreateDocfile = doGetProcAddress(libole32, "StgCreateDocfile") + stgCreateDocfileOnILockBytes = doGetProcAddress(libole32, "StgCreateDocfileOnILockBytes") + stgCreatePropSetStg = doGetProcAddress(libole32, "StgCreatePropSetStg") + stgCreatePropStg = doGetProcAddress(libole32, "StgCreatePropStg") + stgIsStorageFile = doGetProcAddress(libole32, "StgIsStorageFile") + stgIsStorageILockBytes = doGetProcAddress(libole32, "StgIsStorageILockBytes") + stgOpenPropStg = doGetProcAddress(libole32, "StgOpenPropStg") + stgSetTimes = doGetProcAddress(libole32, "StgSetTimes") + stringFromCLSID = doGetProcAddress(libole32, "StringFromCLSID") + stringFromGUID2 = doGetProcAddress(libole32, "StringFromGUID2") + wdtpInterfacePointer_UserFree = doGetProcAddress(libole32, "WdtpInterfacePointer_UserFree") + writeClassStg = doGetProcAddress(libole32, "WriteClassStg") + writeClassStm = doGetProcAddress(libole32, "WriteClassStm") + writeFmtUserTypeStg = doGetProcAddress(libole32, "WriteFmtUserTypeStg") +} + +func CoGetInterceptor(iidIntercepted REFIID, punkOuter *IUnknown, iid REFIID, ppv uintptr) HRESULT { + ret1 := syscall6(coGetInterceptor, 4, + uintptr(unsafe.Pointer(iidIntercepted)), + uintptr(unsafe.Pointer(punkOuter)), + uintptr(unsafe.Pointer(iid)), + ppv, + 0, + 0) + return HRESULT(ret1) +} + +func CoGetInterceptorFromTypeInfo(iidIntercepted REFIID, punkOuter *IUnknown, typeInfo *ITypeInfo, iid REFIID, ppv uintptr) HRESULT { + ret1 := syscall6(coGetInterceptorFromTypeInfo, 5, + uintptr(unsafe.Pointer(iidIntercepted)), + uintptr(unsafe.Pointer(punkOuter)), + uintptr(unsafe.Pointer(typeInfo)), + uintptr(unsafe.Pointer(iid)), + ppv, + 0) + return HRESULT(ret1) +} + +func PropVariantChangeType(ppropvarDest *PROPVARIANT, propvarSrc REFPROPVARIANT, flags PROPVAR_CHANGE_FLAGS, vt VARTYPE) HRESULT { + ret1 := syscall6(propVariantChangeType, 4, + uintptr(unsafe.Pointer(ppropvarDest)), + uintptr(unsafe.Pointer(propvarSrc)), + uintptr(flags), + uintptr(vt), + 0, + 0) + return HRESULT(ret1) +} + +func BindMoniker(pmk LPMONIKER, grfOpt DWORD, riid REFIID, ppvResult *LPVOID) HRESULT { + ret1 := syscall6(bindMoniker, 4, + uintptr(unsafe.Pointer(pmk)), + uintptr(grfOpt), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(ppvResult)), + 0, + 0) + return HRESULT(ret1) +} + +func CLSIDFromProgIDEx(progid /*const*/ LPCOLESTR, clsid *CLSID) HRESULT { + ret1 := syscall3(cLSIDFromProgIDEx, 2, + uintptr(unsafe.Pointer(progid)), + uintptr(unsafe.Pointer(clsid)), + 0) + return HRESULT(ret1) +} + +func CLSIDFromString(idstr /*const*/ LPCOLESTR, id *CLSID) HRESULT { + ret1 := syscall3(cLSIDFromString, 2, + uintptr(unsafe.Pointer(idstr)), + uintptr(unsafe.Pointer(id)), + 0) + return HRESULT(ret1) +} + +func CoAddRefServerProcess() ULONG { + ret1 := syscall3(coAddRefServerProcess, 0, + 0, + 0, + 0) + return ULONG(ret1) +} + +func CoAllowSetForegroundWindow(pUnk *IUnknown, pvReserved uintptr) HRESULT { + ret1 := syscall3(coAllowSetForegroundWindow, 2, + uintptr(unsafe.Pointer(pUnk)), + pvReserved, + 0) + return HRESULT(ret1) +} + +func CoBuildVersion() DWORD { + ret1 := syscall3(coBuildVersion, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func CoCopyProxy(pProxy *IUnknown, ppCopy **IUnknown) HRESULT { + ret1 := syscall3(coCopyProxy, 2, + uintptr(unsafe.Pointer(pProxy)), + uintptr(unsafe.Pointer(ppCopy)), + 0) + return HRESULT(ret1) +} + +func CoCreateFreeThreadedMarshaler(punkOuter LPUNKNOWN, ppunkMarshal *LPUNKNOWN) HRESULT { + ret1 := syscall3(coCreateFreeThreadedMarshaler, 2, + uintptr(unsafe.Pointer(punkOuter)), + uintptr(unsafe.Pointer(ppunkMarshal)), + 0) + return HRESULT(ret1) +} + +func CoCreateGuid(pguid *GUID) HRESULT { + ret1 := syscall3(coCreateGuid, 1, + uintptr(unsafe.Pointer(pguid)), + 0, + 0) + return HRESULT(ret1) +} + +func CoDisconnectObject(lpUnk LPUNKNOWN, reserved DWORD) HRESULT { + ret1 := syscall3(coDisconnectObject, 2, + uintptr(unsafe.Pointer(lpUnk)), + uintptr(reserved), + 0) + return HRESULT(ret1) +} + +func CoFileTimeNow(lpFileTime *FILETIME) HRESULT { + ret1 := syscall3(coFileTimeNow, 1, + uintptr(unsafe.Pointer(lpFileTime)), + 0, + 0) + return HRESULT(ret1) +} + +func CoFreeAllLibraries() { + syscall3(coFreeAllLibraries, 0, + 0, + 0, + 0) +} + +func CoFreeLibrary(hLibrary HINSTANCE) { + syscall3(coFreeLibrary, 1, + uintptr(hLibrary), + 0, + 0) +} + +func CoGetActivationState(guid GUID, unknown DWORD, unknown2 *uint32) HRESULT { + ret1 := syscall6(coGetActivationState, 6, + uintptr(guid.Data1), + uintptr((uint32(guid.Data2)<<16)|uint32(guid.Data3)), + uintptr((uint32(guid.Data4[0])<<24)|(uint32(guid.Data4[1]<<16))|(uint32(guid.Data4[2]<<8))|uint32(guid.Data4[3])), + uintptr((uint32(guid.Data4[4])<<24)|(uint32(guid.Data4[5]<<16))|(uint32(guid.Data4[6]<<8))|uint32(guid.Data4[7])), + uintptr(unknown), + uintptr(unsafe.Pointer(unknown2))) + return HRESULT(ret1) +} + +func CoGetApartmentType(aType *APTTYPE, qualifier *APTTYPEQUALIFIER) HRESULT { + ret1 := syscall3(coGetApartmentType, 2, + uintptr(unsafe.Pointer(aType)), + uintptr(unsafe.Pointer(qualifier)), + 0) + return HRESULT(ret1) +} + +func CoGetCallContext(riid REFIID, ppv uintptr) HRESULT { + ret1 := syscall3(coGetCallContext, 2, + uintptr(unsafe.Pointer(riid)), + ppv, + 0) + return HRESULT(ret1) +} + +func CoGetCallState(unknown int32, unknown2 *uint32) HRESULT { + ret1 := syscall3(coGetCallState, 2, + uintptr(unknown), + uintptr(unsafe.Pointer(unknown2)), + 0) + return HRESULT(ret1) +} + +func CoGetCallerTID(lpdwTID *uint32) HRESULT { + ret1 := syscall3(coGetCallerTID, 1, + uintptr(unsafe.Pointer(lpdwTID)), + 0, + 0) + return HRESULT(ret1) +} + +func CoGetContextToken(token *ULONG_PTR) HRESULT { + ret1 := syscall3(coGetContextToken, 1, + uintptr(unsafe.Pointer(token)), + 0, + 0) + return HRESULT(ret1) +} + +func CoGetCurrentLogicalThreadId(id *GUID) HRESULT { + ret1 := syscall3(coGetCurrentLogicalThreadId, 1, + uintptr(unsafe.Pointer(id)), + 0, + 0) + return HRESULT(ret1) +} + +func CoGetCurrentProcess() DWORD { + ret1 := syscall3(coGetCurrentProcess, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func CoGetDefaultContext(aType APTTYPE, riid REFIID, ppv *LPVOID) HRESULT { + ret1 := syscall3(coGetDefaultContext, 3, + uintptr(aType), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(ppv))) + return HRESULT(ret1) +} + +func CoGetInstanceFromIStorage(server_info *COSERVERINFO, rclsid *CLSID, outer *IUnknown, cls_context DWORD, storage *IStorage, count DWORD, results *MULTI_QI) HRESULT { + ret1 := syscall9(coGetInstanceFromIStorage, 7, + uintptr(unsafe.Pointer(server_info)), + uintptr(unsafe.Pointer(rclsid)), + uintptr(unsafe.Pointer(outer)), + uintptr(cls_context), + uintptr(unsafe.Pointer(storage)), + uintptr(count), + uintptr(unsafe.Pointer(results)), + 0, + 0) + return HRESULT(ret1) +} + +func CoGetInterfaceAndReleaseStream(pStm LPSTREAM, riid REFIID, ppv *LPVOID) HRESULT { + ret1 := syscall3(coGetInterfaceAndReleaseStream, 3, + uintptr(unsafe.Pointer(pStm)), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(ppv))) + return HRESULT(ret1) +} + +func CoGetMalloc(context DWORD, imalloc **IMalloc) HRESULT { + ret1 := syscall3(coGetMalloc, 2, + uintptr(context), + uintptr(unsafe.Pointer(imalloc)), + 0) + return HRESULT(ret1) +} + +func CoGetMarshalSizeMax(pulSize *ULONG, riid REFIID, pUnk *IUnknown, dwDestContext DWORD, pvDestContext uintptr, mshlFlags DWORD) HRESULT { + ret1 := syscall6(coGetMarshalSizeMax, 6, + uintptr(unsafe.Pointer(pulSize)), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(pUnk)), + uintptr(dwDestContext), + pvDestContext, + uintptr(mshlFlags)) + return HRESULT(ret1) +} + +func CoGetObject(pszName string, pBindOptions *BIND_OPTS, riid REFIID, ppv uintptr) HRESULT { + pszNameStr := unicode16FromString(pszName) + ret1 := syscall6(coGetObject, 4, + uintptr(unsafe.Pointer(&pszNameStr[0])), + uintptr(unsafe.Pointer(pBindOptions)), + uintptr(unsafe.Pointer(riid)), + ppv, + 0, + 0) + return HRESULT(ret1) +} + +func CoGetObjectContext(riid REFIID, ppv uintptr) HRESULT { + ret1 := syscall3(coGetObjectContext, 2, + uintptr(unsafe.Pointer(riid)), + ppv, + 0) + return HRESULT(ret1) +} + +func CoGetPSClsid(riid REFIID, pclsid *CLSID) HRESULT { + ret1 := syscall3(coGetPSClsid, 2, + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(pclsid)), + 0) + return HRESULT(ret1) +} + +func CoGetStandardMarshal(riid REFIID, pUnk *IUnknown, dwDestContext DWORD, pvDestContext LPVOID, mshlflags DWORD, ppMarshal *LPMARSHAL) HRESULT { + ret1 := syscall6(coGetStandardMarshal, 6, + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(pUnk)), + uintptr(dwDestContext), + uintptr(unsafe.Pointer(pvDestContext)), + uintptr(mshlflags), + uintptr(unsafe.Pointer(ppMarshal))) + return HRESULT(ret1) +} + +func CoGetState(ppv **IUnknown) HRESULT { + ret1 := syscall3(coGetState, 1, + uintptr(unsafe.Pointer(ppv)), + 0, + 0) + return HRESULT(ret1) +} + +func CoGetTreatAsClass(clsidOld /*const*/ REFCLSID, clsidNew *CLSID) HRESULT { + ret1 := syscall3(coGetTreatAsClass, 2, + uintptr(unsafe.Pointer(clsidOld)), + uintptr(unsafe.Pointer(clsidNew)), + 0) + return HRESULT(ret1) +} + +func CoImpersonateClient() HRESULT { + ret1 := syscall3(coImpersonateClient, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func CoInitialize(lpReserved LPVOID) HRESULT { + ret1 := syscall3(coInitialize, 1, + uintptr(unsafe.Pointer(lpReserved)), + 0, + 0) + return HRESULT(ret1) +} + +func CoInitializeSecurity(pSecDesc PSECURITY_DESCRIPTOR, cAuthSvc LONG, asAuthSvc *SOLE_AUTHENTICATION_SERVICE, pReserved1 uintptr, dwAuthnLevel DWORD, dwImpLevel DWORD, pReserved2 uintptr, dwCapabilities DWORD, pReserved3 uintptr) HRESULT { + ret1 := syscall9(coInitializeSecurity, 9, + uintptr(unsafe.Pointer(pSecDesc)), + uintptr(cAuthSvc), + uintptr(unsafe.Pointer(asAuthSvc)), + pReserved1, + uintptr(dwAuthnLevel), + uintptr(dwImpLevel), + pReserved2, + uintptr(dwCapabilities), + pReserved3) + return HRESULT(ret1) +} + +func CoInitializeWOW(x DWORD, y DWORD) HRESULT { + ret1 := syscall3(coInitializeWOW, 2, + uintptr(x), + uintptr(y), + 0) + return HRESULT(ret1) +} + +func CoIsHandlerConnected(pUnk *IUnknown) bool { + ret1 := syscall3(coIsHandlerConnected, 1, + uintptr(unsafe.Pointer(pUnk)), + 0, + 0) + return ret1 != 0 +} + +func CoIsOle1Class(clsid /*const*/ REFCLSID) bool { + ret1 := syscall3(coIsOle1Class, 1, + uintptr(unsafe.Pointer(clsid)), + 0, + 0) + return ret1 != 0 +} + +func CoLoadLibrary(lpszLibName LPOLESTR, bAutoFree bool) HINSTANCE { + ret1 := syscall3(coLoadLibrary, 2, + uintptr(unsafe.Pointer(lpszLibName)), + getUintptrFromBool(bAutoFree), + 0) + return HINSTANCE(ret1) +} + +func CoLockObjectExternal(pUnk LPUNKNOWN, fLock bool, fLastUnlockReleases bool) HRESULT { + ret1 := syscall3(coLockObjectExternal, 3, + uintptr(unsafe.Pointer(pUnk)), + getUintptrFromBool(fLock), + getUintptrFromBool(fLastUnlockReleases)) + return HRESULT(ret1) +} + +func CoMarshalHresult(pStm LPSTREAM, hresult HRESULT) HRESULT { + ret1 := syscall3(coMarshalHresult, 2, + uintptr(unsafe.Pointer(pStm)), + uintptr(hresult), + 0) + return HRESULT(ret1) +} + +func CoMarshalInterThreadInterfaceInStream(riid REFIID, pUnk LPUNKNOWN, ppStm *LPSTREAM) HRESULT { + ret1 := syscall3(coMarshalInterThreadInterfaceInStream, 3, + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(pUnk)), + uintptr(unsafe.Pointer(ppStm))) + return HRESULT(ret1) +} + +func CoMarshalInterface(pStream *IStream, riid REFIID, pUnk *IUnknown, dwDestContext DWORD, pvDestContext uintptr, mshlFlags DWORD) HRESULT { + ret1 := syscall6(coMarshalInterface, 6, + uintptr(unsafe.Pointer(pStream)), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(pUnk)), + uintptr(dwDestContext), + pvDestContext, + uintptr(mshlFlags)) + return HRESULT(ret1) +} + +func CoQueryClientBlanket(pAuthnSvc *uint32, pAuthzSvc *uint32, pServerPrincName **OLECHAR, pAuthnLevel *uint32, pImpLevel *uint32, pPrivs *RPC_AUTHZ_HANDLE, pCapabilities *uint32) HRESULT { + ret1 := syscall9(coQueryClientBlanket, 7, + uintptr(unsafe.Pointer(pAuthnSvc)), + uintptr(unsafe.Pointer(pAuthzSvc)), + uintptr(unsafe.Pointer(pServerPrincName)), + uintptr(unsafe.Pointer(pAuthnLevel)), + uintptr(unsafe.Pointer(pImpLevel)), + uintptr(unsafe.Pointer(pPrivs)), + uintptr(unsafe.Pointer(pCapabilities)), + 0, + 0) + return HRESULT(ret1) +} + +func CoQueryProxyBlanket(pProxy *IUnknown, pAuthnSvc *uint32, pAuthzSvc *uint32, ppServerPrincName **OLECHAR, pAuthnLevel *uint32, pImpLevel *uint32, ppAuthInfo uintptr, pCapabilities *uint32) HRESULT { + ret1 := syscall9(coQueryProxyBlanket, 8, + uintptr(unsafe.Pointer(pProxy)), + uintptr(unsafe.Pointer(pAuthnSvc)), + uintptr(unsafe.Pointer(pAuthzSvc)), + uintptr(unsafe.Pointer(ppServerPrincName)), + uintptr(unsafe.Pointer(pAuthnLevel)), + uintptr(unsafe.Pointer(pImpLevel)), + ppAuthInfo, + uintptr(unsafe.Pointer(pCapabilities)), + 0) + return HRESULT(ret1) +} + +func CoRegisterChannelHook(guidExtension REFGUID, pChannelHook *IChannelHook) HRESULT { + ret1 := syscall3(coRegisterChannelHook, 2, + uintptr(unsafe.Pointer(guidExtension)), + uintptr(unsafe.Pointer(pChannelHook)), + 0) + return HRESULT(ret1) +} + +func CoRegisterClassObject(rclsid /*const*/ REFCLSID, pUnk LPUNKNOWN, dwClsContext DWORD, flags DWORD, lpdwRegister *uint32) HRESULT { + ret1 := syscall6(coRegisterClassObject, 5, + uintptr(unsafe.Pointer(rclsid)), + uintptr(unsafe.Pointer(pUnk)), + uintptr(dwClsContext), + uintptr(flags), + uintptr(unsafe.Pointer(lpdwRegister)), + 0) + return HRESULT(ret1) +} + +func CoRegisterInitializeSpy(spy *IInitializeSpy, cookie *ULARGE_INTEGER) HRESULT { + ret1 := syscall3(coRegisterInitializeSpy, 2, + uintptr(unsafe.Pointer(spy)), + uintptr(unsafe.Pointer(cookie)), + 0) + return HRESULT(ret1) +} + +func CoRegisterMallocSpy(pMallocSpy LPMALLOCSPY) HRESULT { + ret1 := syscall3(coRegisterMallocSpy, 1, + uintptr(unsafe.Pointer(pMallocSpy)), + 0, + 0) + return HRESULT(ret1) +} + +func CoRegisterMessageFilter(lpMessageFilter LPMESSAGEFILTER, lplpMessageFilter *LPMESSAGEFILTER) HRESULT { + ret1 := syscall3(coRegisterMessageFilter, 2, + uintptr(unsafe.Pointer(lpMessageFilter)), + uintptr(unsafe.Pointer(lplpMessageFilter)), + 0) + return HRESULT(ret1) +} + +func CoRegisterPSClsid(riid REFIID, rclsid /*const*/ REFCLSID) HRESULT { + ret1 := syscall3(coRegisterPSClsid, 2, + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(rclsid)), + 0) + return HRESULT(ret1) +} + +func CoReleaseMarshalData(pStream *IStream) HRESULT { + ret1 := syscall3(coReleaseMarshalData, 1, + uintptr(unsafe.Pointer(pStream)), + 0, + 0) + return HRESULT(ret1) +} + +func CoReleaseServerProcess() ULONG { + ret1 := syscall3(coReleaseServerProcess, 0, + 0, + 0, + 0) + return ULONG(ret1) +} + +func CoResumeClassObjects() HRESULT { + ret1 := syscall3(coResumeClassObjects, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func CoRevertToSelf() HRESULT { + ret1 := syscall3(coRevertToSelf, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func CoRevokeInitializeSpy(cookie ULARGE_INTEGER) HRESULT { + ret1 := syscall3(coRevokeInitializeSpy, 2, + uintptr(*(*uint32)(unsafe.Pointer(&cookie))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cookie)) + uintptr(4)))), + 0) + return HRESULT(ret1) +} + +func CoRevokeMallocSpy() HRESULT { + ret1 := syscall3(coRevokeMallocSpy, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func CoSetProxyBlanket(pProxy *IUnknown, authnSvc DWORD, authzSvc DWORD, pServerPrincName *OLECHAR, authnLevel DWORD, impLevel DWORD, pAuthInfo uintptr, capabilities DWORD) HRESULT { + ret1 := syscall9(coSetProxyBlanket, 8, + uintptr(unsafe.Pointer(pProxy)), + uintptr(authnSvc), + uintptr(authzSvc), + uintptr(unsafe.Pointer(pServerPrincName)), + uintptr(authnLevel), + uintptr(impLevel), + pAuthInfo, + uintptr(capabilities), + 0) + return HRESULT(ret1) +} + +func CoSetState(pv *IUnknown) HRESULT { + ret1 := syscall3(coSetState, 1, + uintptr(unsafe.Pointer(pv)), + 0, + 0) + return HRESULT(ret1) +} + +func CoSuspendClassObjects() HRESULT { + ret1 := syscall3(coSuspendClassObjects, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func CoSwitchCallContext(pObject *IUnknown, ppOldObject **IUnknown) HRESULT { + ret1 := syscall3(coSwitchCallContext, 2, + uintptr(unsafe.Pointer(pObject)), + uintptr(unsafe.Pointer(ppOldObject)), + 0) + return HRESULT(ret1) +} + +func CoTaskMemAlloc(size SIZE_T) LPVOID { + ret1 := syscall3(coTaskMemAlloc, 1, + uintptr(size), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func CoTaskMemFree(ptr LPVOID) { + syscall3(coTaskMemFree, 1, + uintptr(unsafe.Pointer(ptr)), + 0, + 0) +} + +func CoTaskMemRealloc(pvOld LPVOID, size SIZE_T) LPVOID { + ret1 := syscall3(coTaskMemRealloc, 2, + uintptr(unsafe.Pointer(pvOld)), + uintptr(size), + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func CoTreatAsClass(clsidOld /*const*/ REFCLSID, clsidNew /*const*/ REFCLSID) HRESULT { + ret1 := syscall3(coTreatAsClass, 2, + uintptr(unsafe.Pointer(clsidOld)), + uintptr(unsafe.Pointer(clsidNew)), + 0) + return HRESULT(ret1) +} + +func CoUnmarshalHresult(pStm LPSTREAM, phresult *HRESULT) HRESULT { + ret1 := syscall3(coUnmarshalHresult, 2, + uintptr(unsafe.Pointer(pStm)), + uintptr(unsafe.Pointer(phresult)), + 0) + return HRESULT(ret1) +} + +func CoUnmarshalInterface(pStream *IStream, riid REFIID, ppv *LPVOID) HRESULT { + ret1 := syscall3(coUnmarshalInterface, 3, + uintptr(unsafe.Pointer(pStream)), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(ppv))) + return HRESULT(ret1) +} + +func CoWaitForMultipleHandles(dwFlags DWORD, dwTimeout DWORD, cHandles ULONG, pHandles *HANDLE, lpdwindex *uint32) HRESULT { + ret1 := syscall6(coWaitForMultipleHandles, 5, + uintptr(dwFlags), + uintptr(dwTimeout), + uintptr(cHandles), + uintptr(unsafe.Pointer(pHandles)), + uintptr(unsafe.Pointer(lpdwindex)), + 0) + return HRESULT(ret1) +} + +func CreateAntiMoniker(ppmk **IMoniker) HRESULT { + ret1 := syscall3(createAntiMoniker, 1, + uintptr(unsafe.Pointer(ppmk)), + 0, + 0) + return HRESULT(ret1) +} + +func CreateBindCtx(reserved DWORD, ppbc *LPBC) HRESULT { + ret1 := syscall3(createBindCtx, 2, + uintptr(reserved), + uintptr(unsafe.Pointer(ppbc)), + 0) + return HRESULT(ret1) +} + +func CreateClassMoniker(rclsid /*const*/ REFCLSID, ppmk **IMoniker) HRESULT { + ret1 := syscall3(createClassMoniker, 2, + uintptr(unsafe.Pointer(rclsid)), + uintptr(unsafe.Pointer(ppmk)), + 0) + return HRESULT(ret1) +} + +func CreateDataAdviseHolder(ppDAHolder **IDataAdviseHolder) HRESULT { + ret1 := syscall3(createDataAdviseHolder, 1, + uintptr(unsafe.Pointer(ppDAHolder)), + 0, + 0) + return HRESULT(ret1) +} + +func CreateDataCache(pUnkOuter LPUNKNOWN, rclsid /*const*/ REFCLSID, riid REFIID, ppvObj *LPVOID) HRESULT { + ret1 := syscall6(createDataCache, 4, + uintptr(unsafe.Pointer(pUnkOuter)), + uintptr(unsafe.Pointer(rclsid)), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(ppvObj)), + 0, + 0) + return HRESULT(ret1) +} + +func CreateFileMoniker(lpszPathName /*const*/ LPCOLESTR, ppmk **IMoniker) HRESULT { + ret1 := syscall3(createFileMoniker, 2, + uintptr(unsafe.Pointer(lpszPathName)), + uintptr(unsafe.Pointer(ppmk)), + 0) + return HRESULT(ret1) +} + +func CreateGenericComposite(pmkFirst *IMoniker, pmkRest *IMoniker, ppmkComposite **IMoniker) HRESULT { + ret1 := syscall3(createGenericComposite, 3, + uintptr(unsafe.Pointer(pmkFirst)), + uintptr(unsafe.Pointer(pmkRest)), + uintptr(unsafe.Pointer(ppmkComposite))) + return HRESULT(ret1) +} + +func CreateILockBytesOnHGlobal(global HGLOBAL, delete_on_release bool, ret **ILockBytes) HRESULT { + ret1 := syscall3(createILockBytesOnHGlobal, 3, + uintptr(global), + getUintptrFromBool(delete_on_release), + uintptr(unsafe.Pointer(ret))) + return HRESULT(ret1) +} + +func CreateItemMoniker(lpszDelim /*const*/ LPCOLESTR, lpszItem /*const*/ LPCOLESTR, ppmk **IMoniker) HRESULT { + ret1 := syscall3(createItemMoniker, 3, + uintptr(unsafe.Pointer(lpszDelim)), + uintptr(unsafe.Pointer(lpszItem)), + uintptr(unsafe.Pointer(ppmk))) + return HRESULT(ret1) +} + +func CreateOleAdviseHolder(ppOAHolder **IOleAdviseHolder) HRESULT { + ret1 := syscall3(createOleAdviseHolder, 1, + uintptr(unsafe.Pointer(ppOAHolder)), + 0, + 0) + return HRESULT(ret1) +} + +func CreatePointerMoniker(punk LPUNKNOWN, ppmk *LPMONIKER) HRESULT { + ret1 := syscall3(createPointerMoniker, 2, + uintptr(unsafe.Pointer(punk)), + uintptr(unsafe.Pointer(ppmk)), + 0) + return HRESULT(ret1) +} + +func CreateStreamOnHGlobal(hGlobal HGLOBAL, fDeleteOnRelease bool, ppstm *LPSTREAM) HRESULT { + ret1 := syscall3(createStreamOnHGlobal, 3, + uintptr(hGlobal), + getUintptrFromBool(fDeleteOnRelease), + uintptr(unsafe.Pointer(ppstm))) + return HRESULT(ret1) +} + +func DllDebugObjectRPCHook(b bool, dummy uintptr) bool { + ret1 := syscall3(dllDebugObjectRPCHook, 2, + getUintptrFromBool(b), + dummy, + 0) + return ret1 != 0 +} + +func DoDragDrop(pDataObject *IDataObject, pDropSource *IDropSource, dwOKEffect DWORD, pdwEffect *uint32) HRESULT { + ret1 := syscall6(doDragDrop, 4, + uintptr(unsafe.Pointer(pDataObject)), + uintptr(unsafe.Pointer(pDropSource)), + uintptr(dwOKEffect), + uintptr(unsafe.Pointer(pdwEffect)), + 0, + 0) + return HRESULT(ret1) +} + +func FmtIdToPropStgName(rfmtid /*const*/ *FMTID, str LPOLESTR) HRESULT { + ret1 := syscall3(fmtIdToPropStgName, 2, + uintptr(unsafe.Pointer(rfmtid)), + uintptr(unsafe.Pointer(str)), + 0) + return HRESULT(ret1) +} + +func FreePropVariantArray(cVariants ULONG, rgvars *PROPVARIANT) HRESULT { + ret1 := syscall3(freePropVariantArray, 2, + uintptr(cVariants), + uintptr(unsafe.Pointer(rgvars)), + 0) + return HRESULT(ret1) +} + +func GetClassFile(filePathName /*const*/ LPCOLESTR, pclsid *CLSID) HRESULT { + ret1 := syscall3(getClassFile, 2, + uintptr(unsafe.Pointer(filePathName)), + uintptr(unsafe.Pointer(pclsid)), + 0) + return HRESULT(ret1) +} + +func GetConvertStg(stg *IStorage) HRESULT { + ret1 := syscall3(getConvertStg, 1, + uintptr(unsafe.Pointer(stg)), + 0, + 0) + return HRESULT(ret1) +} + +func GetHGlobalFromILockBytes(iface *ILockBytes, phglobal *HGLOBAL) HRESULT { + ret1 := syscall3(getHGlobalFromILockBytes, 2, + uintptr(unsafe.Pointer(iface)), + uintptr(unsafe.Pointer(phglobal)), + 0) + return HRESULT(ret1) +} + +func GetHGlobalFromStream(pstm *IStream, phglobal *HGLOBAL) HRESULT { + ret1 := syscall3(getHGlobalFromStream, 2, + uintptr(unsafe.Pointer(pstm)), + uintptr(unsafe.Pointer(phglobal)), + 0) + return HRESULT(ret1) +} + +func GetRunningObjectTable(reserved DWORD, pprot *LPRUNNINGOBJECTTABLE) HRESULT { + ret1 := syscall3(getRunningObjectTable, 2, + uintptr(reserved), + uintptr(unsafe.Pointer(pprot)), + 0) + return HRESULT(ret1) +} + +func IIDFromString(s /*const*/ LPCOLESTR, iid *IID) HRESULT { + ret1 := syscall3(iIDFromString, 2, + uintptr(unsafe.Pointer(s)), + uintptr(unsafe.Pointer(iid)), + 0) + return HRESULT(ret1) +} + +func IsAccelerator(hAccel HACCEL, cAccelEntries int32, lpMsg *MSG, lpwCmd *WORD) bool { + ret1 := syscall6(isAccelerator, 4, + uintptr(hAccel), + uintptr(cAccelEntries), + uintptr(unsafe.Pointer(lpMsg)), + uintptr(unsafe.Pointer(lpwCmd)), + 0, + 0) + return ret1 != 0 +} + +func IsEqualGUID(rguid1 REFGUID, rguid2 REFGUID) bool { + ret1 := syscall3(isEqualGUID, 2, + uintptr(unsafe.Pointer(rguid1)), + uintptr(unsafe.Pointer(rguid2)), + 0) + return ret1 != 0 +} + +func IsValidInterface(punk LPUNKNOWN) bool { + ret1 := syscall3(isValidInterface, 1, + uintptr(unsafe.Pointer(punk)), + 0, + 0) + return ret1 != 0 +} + +func MkParseDisplayName(pbc LPBC, szDisplayName /*const*/ LPCOLESTR, pchEaten *uint32, ppmk *LPMONIKER) HRESULT { + ret1 := syscall6(mkParseDisplayName, 4, + uintptr(unsafe.Pointer(pbc)), + uintptr(unsafe.Pointer(szDisplayName)), + uintptr(unsafe.Pointer(pchEaten)), + uintptr(unsafe.Pointer(ppmk)), + 0, + 0) + return HRESULT(ret1) +} + +func MonikerCommonPrefixWith(pmkThis *IMoniker, pmkOther *IMoniker, ppmkCommon **IMoniker) HRESULT { + ret1 := syscall3(monikerCommonPrefixWith, 3, + uintptr(unsafe.Pointer(pmkThis)), + uintptr(unsafe.Pointer(pmkOther)), + uintptr(unsafe.Pointer(ppmkCommon))) + return HRESULT(ret1) +} + +func OleBuildVersion() DWORD { + ret1 := syscall3(oleBuildVersion, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func OleConvertIStorageToOLESTREAM(pstg LPSTORAGE, pOleStream LPOLESTREAM) HRESULT { + ret1 := syscall3(oleConvertIStorageToOLESTREAM, 2, + uintptr(unsafe.Pointer(pstg)), + uintptr(unsafe.Pointer(pOleStream)), + 0) + return HRESULT(ret1) +} + +func OleConvertOLESTREAMToIStorage(pOleStream LPOLESTREAM, pstg LPSTORAGE, ptd /*const*/ *DVTARGETDEVICE) HRESULT { + ret1 := syscall3(oleConvertOLESTREAMToIStorage, 3, + uintptr(unsafe.Pointer(pOleStream)), + uintptr(unsafe.Pointer(pstg)), + uintptr(unsafe.Pointer(ptd))) + return HRESULT(ret1) +} + +func OleCreate(rclsid /*const*/ REFCLSID, riid REFIID, renderopt DWORD, pFormatEtc *FORMATETC, pClientSite LPOLECLIENTSITE, pStg LPSTORAGE, ppvObj *LPVOID) HRESULT { + ret1 := syscall9(oleCreate, 7, + uintptr(unsafe.Pointer(rclsid)), + uintptr(unsafe.Pointer(riid)), + uintptr(renderopt), + uintptr(unsafe.Pointer(pFormatEtc)), + uintptr(unsafe.Pointer(pClientSite)), + uintptr(unsafe.Pointer(pStg)), + uintptr(unsafe.Pointer(ppvObj)), + 0, + 0) + return HRESULT(ret1) +} + +func OleCreateDefaultHandler(clsid /*const*/ REFCLSID, pUnkOuter LPUNKNOWN, riid REFIID, ppvObj *LPVOID) HRESULT { + ret1 := syscall6(oleCreateDefaultHandler, 4, + uintptr(unsafe.Pointer(clsid)), + uintptr(unsafe.Pointer(pUnkOuter)), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(ppvObj)), + 0, + 0) + return HRESULT(ret1) +} + +func OleCreateEmbeddingHelper(clsid /*const*/ REFCLSID, pUnkOuter LPUNKNOWN, flags DWORD, pCF *IClassFactory, riid REFIID, ppvObj *LPVOID) HRESULT { + ret1 := syscall6(oleCreateEmbeddingHelper, 6, + uintptr(unsafe.Pointer(clsid)), + uintptr(unsafe.Pointer(pUnkOuter)), + uintptr(flags), + uintptr(unsafe.Pointer(pCF)), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(ppvObj))) + return HRESULT(ret1) +} + +func OleCreateFromData(data LPDATAOBJECT, iid REFIID, renderopt DWORD, fmt *FORMATETC, client_site LPOLECLIENTSITE, stg LPSTORAGE, obj *LPVOID) HRESULT { + ret1 := syscall9(oleCreateFromData, 7, + uintptr(unsafe.Pointer(data)), + uintptr(unsafe.Pointer(iid)), + uintptr(renderopt), + uintptr(unsafe.Pointer(fmt)), + uintptr(unsafe.Pointer(client_site)), + uintptr(unsafe.Pointer(stg)), + uintptr(unsafe.Pointer(obj)), + 0, + 0) + return HRESULT(ret1) +} + +func OleCreateFromDataEx(data *IDataObject, iid REFIID, flags DWORD, renderopt DWORD, num_cache_fmts ULONG, adv_flags *uint32, cache_fmts *FORMATETC, sink *IAdviseSink, conns *uint32, client_site *IOleClientSite, stg *IStorage, obj uintptr) HRESULT { + ret1 := syscall12(oleCreateFromDataEx, 12, + uintptr(unsafe.Pointer(data)), + uintptr(unsafe.Pointer(iid)), + uintptr(flags), + uintptr(renderopt), + uintptr(num_cache_fmts), + uintptr(unsafe.Pointer(adv_flags)), + uintptr(unsafe.Pointer(cache_fmts)), + uintptr(unsafe.Pointer(sink)), + uintptr(unsafe.Pointer(conns)), + uintptr(unsafe.Pointer(client_site)), + uintptr(unsafe.Pointer(stg)), + obj) + return HRESULT(ret1) +} + +func OleCreateFromFile(clsid /*const*/ REFCLSID, filename /*const*/ *OLECHAR, iid REFIID, renderopt DWORD, fmt *FORMATETC, client_site *IOleClientSite, storage *IStorage, obj uintptr) HRESULT { + ret1 := syscall9(oleCreateFromFile, 8, + uintptr(unsafe.Pointer(clsid)), + uintptr(unsafe.Pointer(filename)), + uintptr(unsafe.Pointer(iid)), + uintptr(renderopt), + uintptr(unsafe.Pointer(fmt)), + uintptr(unsafe.Pointer(client_site)), + uintptr(unsafe.Pointer(storage)), + obj, + 0) + return HRESULT(ret1) +} + +func OleCreateFromFileEx(clsid /*const*/ REFCLSID, filename /*const*/ *OLECHAR, iid REFIID, flags DWORD, renderopt DWORD, num_fmts ULONG, adv_flags *uint32, fmts *FORMATETC, sink *IAdviseSink, conns *uint32, client_site *IOleClientSite, stg *IStorage, obj uintptr) HRESULT { + ret1 := syscall15(oleCreateFromFileEx, 13, + uintptr(unsafe.Pointer(clsid)), + uintptr(unsafe.Pointer(filename)), + uintptr(unsafe.Pointer(iid)), + uintptr(flags), + uintptr(renderopt), + uintptr(num_fmts), + uintptr(unsafe.Pointer(adv_flags)), + uintptr(unsafe.Pointer(fmts)), + uintptr(unsafe.Pointer(sink)), + uintptr(unsafe.Pointer(conns)), + uintptr(unsafe.Pointer(client_site)), + uintptr(unsafe.Pointer(stg)), + obj, + 0, + 0) + return HRESULT(ret1) +} + +func OleCreateLink(pmkLinkSrc LPMONIKER, riid REFIID, renderopt DWORD, lpFormatEtc *FORMATETC, pClientSite LPOLECLIENTSITE, pStg LPSTORAGE, ppvObj *LPVOID) HRESULT { + ret1 := syscall9(oleCreateLink, 7, + uintptr(unsafe.Pointer(pmkLinkSrc)), + uintptr(unsafe.Pointer(riid)), + uintptr(renderopt), + uintptr(unsafe.Pointer(lpFormatEtc)), + uintptr(unsafe.Pointer(pClientSite)), + uintptr(unsafe.Pointer(pStg)), + uintptr(unsafe.Pointer(ppvObj)), + 0, + 0) + return HRESULT(ret1) +} + +func OleCreateLinkFromData(data *IDataObject, iid REFIID, renderopt DWORD, fmt *FORMATETC, client_site *IOleClientSite, stg *IStorage, obj uintptr) HRESULT { + ret1 := syscall9(oleCreateLinkFromData, 7, + uintptr(unsafe.Pointer(data)), + uintptr(unsafe.Pointer(iid)), + uintptr(renderopt), + uintptr(unsafe.Pointer(fmt)), + uintptr(unsafe.Pointer(client_site)), + uintptr(unsafe.Pointer(stg)), + obj, + 0, + 0) + return HRESULT(ret1) +} + +func OleCreateLinkToFile(lpszFileName /*const*/ LPCOLESTR, riid REFIID, renderopt DWORD, lpFormatEtc *FORMATETC, pClientSite LPOLECLIENTSITE, pStg LPSTORAGE, ppvObj *LPVOID) HRESULT { + ret1 := syscall9(oleCreateLinkToFile, 7, + uintptr(unsafe.Pointer(lpszFileName)), + uintptr(unsafe.Pointer(riid)), + uintptr(renderopt), + uintptr(unsafe.Pointer(lpFormatEtc)), + uintptr(unsafe.Pointer(pClientSite)), + uintptr(unsafe.Pointer(pStg)), + uintptr(unsafe.Pointer(ppvObj)), + 0, + 0) + return HRESULT(ret1) +} + +func OleCreateMenuDescriptor(hmenuCombined HMENU, lpMenuWidths LPOLEMENUGROUPWIDTHS) HOLEMENU { + ret1 := syscall3(oleCreateMenuDescriptor, 2, + uintptr(hmenuCombined), + uintptr(unsafe.Pointer(lpMenuWidths)), + 0) + return HOLEMENU(ret1) +} + +func OleCreateStaticFromData(data *IDataObject, iid REFIID, renderopt DWORD, fmt *FORMATETC, client_site *IOleClientSite, stg *IStorage, obj uintptr) HRESULT { + ret1 := syscall9(oleCreateStaticFromData, 7, + uintptr(unsafe.Pointer(data)), + uintptr(unsafe.Pointer(iid)), + uintptr(renderopt), + uintptr(unsafe.Pointer(fmt)), + uintptr(unsafe.Pointer(client_site)), + uintptr(unsafe.Pointer(stg)), + obj, + 0, + 0) + return HRESULT(ret1) +} + +func OleDestroyMenuDescriptor(hmenuDescriptor HOLEMENU) HRESULT { + ret1 := syscall3(oleDestroyMenuDescriptor, 1, + uintptr(hmenuDescriptor), + 0, + 0) + return HRESULT(ret1) +} + +func OleDoAutoConvert(pStg LPSTORAGE, pClsidNew *CLSID) HRESULT { + ret1 := syscall3(oleDoAutoConvert, 2, + uintptr(unsafe.Pointer(pStg)), + uintptr(unsafe.Pointer(pClsidNew)), + 0) + return HRESULT(ret1) +} + +func OleDraw(pUnk *IUnknown, dwAspect DWORD, hdcDraw HDC, rect /*const*/ *RECT) HRESULT { + ret1 := syscall6(oleDraw, 4, + uintptr(unsafe.Pointer(pUnk)), + uintptr(dwAspect), + uintptr(hdcDraw), + uintptr(unsafe.Pointer(rect)), + 0, + 0) + return HRESULT(ret1) +} + +func OleDuplicateData(hSrc HANDLE, cfFormat CLIPFORMAT, uiFlags UINT) HANDLE { + ret1 := syscall3(oleDuplicateData, 3, + uintptr(hSrc), + uintptr(cfFormat), + uintptr(uiFlags)) + return HANDLE(ret1) +} + +func OleFlushClipboard() HRESULT { + ret1 := syscall3(oleFlushClipboard, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func OleGetAutoConvert(clsidOld /*const*/ REFCLSID, pClsidNew *CLSID) HRESULT { + ret1 := syscall3(oleGetAutoConvert, 2, + uintptr(unsafe.Pointer(clsidOld)), + uintptr(unsafe.Pointer(pClsidNew)), + 0) + return HRESULT(ret1) +} + +func OleGetClipboard(obj **IDataObject) HRESULT { + ret1 := syscall3(oleGetClipboard, 1, + uintptr(unsafe.Pointer(obj)), + 0, + 0) + return HRESULT(ret1) +} + +func OleGetIconOfClass(rclsid /*const*/ REFCLSID, lpszLabel LPOLESTR, fUseTypeAsLabel bool) HGLOBAL { + ret1 := syscall3(oleGetIconOfClass, 3, + uintptr(unsafe.Pointer(rclsid)), + uintptr(unsafe.Pointer(lpszLabel)), + getUintptrFromBool(fUseTypeAsLabel)) + return HGLOBAL(ret1) +} + +func OleInitialize(x DWORD) HRESULT { + ret1 := syscall3(oleInitialize, 1, + uintptr(x), + 0, + 0) + return HRESULT(ret1) +} +func OleUninitialize() HRESULT { + ret1 := syscall3(oleUninitialize, 1, + 0, + 0, + 0) + return HRESULT(ret1) +} +func OleInitializeWOW(x DWORD, y DWORD) HRESULT { + ret1 := syscall3(oleInitializeWOW, 2, + uintptr(x), + uintptr(y), + 0) + return HRESULT(ret1) +} +func OleIsCurrentClipboard(data *IDataObject) HRESULT { + ret1 := syscall3(oleIsCurrentClipboard, 1, + uintptr(unsafe.Pointer(data)), + 0, + 0) + return HRESULT(ret1) +} + +func OleIsRunning(object LPOLEOBJECT) bool { + ret1 := syscall3(oleIsRunning, 1, + uintptr(unsafe.Pointer(object)), + 0, + 0) + return ret1 != 0 +} + +func OleLoad(pStg LPSTORAGE, riid REFIID, pClientSite LPOLECLIENTSITE, ppvObj *LPVOID) HRESULT { + ret1 := syscall6(oleLoad, 4, + uintptr(unsafe.Pointer(pStg)), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(pClientSite)), + uintptr(unsafe.Pointer(ppvObj)), + 0, + 0) + return HRESULT(ret1) +} + +func OleLoadFromStream(pStm *IStream, iidInterface REFIID, ppvObj uintptr) HRESULT { + ret1 := syscall3(oleLoadFromStream, 3, + uintptr(unsafe.Pointer(pStm)), + uintptr(unsafe.Pointer(iidInterface)), + ppvObj) + return HRESULT(ret1) +} + +func OleLockRunning(pUnknown LPUNKNOWN, fLock bool, fLastUnlockCloses bool) HRESULT { + ret1 := syscall3(oleLockRunning, 3, + uintptr(unsafe.Pointer(pUnknown)), + getUintptrFromBool(fLock), + getUintptrFromBool(fLastUnlockCloses)) + return HRESULT(ret1) +} + +func OleMetafilePictFromIconAndLabel(hIcon HICON, lpszLabel LPOLESTR, lpszSourceFile LPOLESTR, iIconIndex UINT) HGLOBAL { + ret1 := syscall6(oleMetafilePictFromIconAndLabel, 4, + uintptr(hIcon), + uintptr(unsafe.Pointer(lpszLabel)), + uintptr(unsafe.Pointer(lpszSourceFile)), + uintptr(iIconIndex), + 0, + 0) + return HGLOBAL(ret1) +} + +func OleNoteObjectVisible(pUnknown LPUNKNOWN, bVisible bool) HRESULT { + ret1 := syscall3(oleNoteObjectVisible, 2, + uintptr(unsafe.Pointer(pUnknown)), + getUintptrFromBool(bVisible), + 0) + return HRESULT(ret1) +} + +func OleQueryCreateFromData(data *IDataObject) HRESULT { + ret1 := syscall3(oleQueryCreateFromData, 1, + uintptr(unsafe.Pointer(data)), + 0, + 0) + return HRESULT(ret1) +} + +func OleQueryLinkFromData(pSrcDataObject *IDataObject) HRESULT { + ret1 := syscall3(oleQueryLinkFromData, 1, + uintptr(unsafe.Pointer(pSrcDataObject)), + 0, + 0) + return HRESULT(ret1) +} + +func OleRegEnumVerbs(clsid /*const*/ REFCLSID, ppenum *LPENUMOLEVERB) HRESULT { + ret1 := syscall3(oleRegEnumVerbs, 2, + uintptr(unsafe.Pointer(clsid)), + uintptr(unsafe.Pointer(ppenum)), + 0) + return HRESULT(ret1) +} + +func OleRegGetMiscStatus(clsid /*const*/ REFCLSID, dwAspect DWORD, pdwStatus *uint32) HRESULT { + ret1 := syscall3(oleRegGetMiscStatus, 3, + uintptr(unsafe.Pointer(clsid)), + uintptr(dwAspect), + uintptr(unsafe.Pointer(pdwStatus))) + return HRESULT(ret1) +} + +func OleRegGetUserType(clsid /*const*/ REFCLSID, form DWORD, usertype *LPOLESTR) HRESULT { + ret1 := syscall3(oleRegGetUserType, 3, + uintptr(unsafe.Pointer(clsid)), + uintptr(form), + uintptr(unsafe.Pointer(usertype))) + return HRESULT(ret1) +} + +func OleSave(pPS LPPERSISTSTORAGE, pStg LPSTORAGE, fSameAsLoad bool) HRESULT { + ret1 := syscall3(oleSave, 3, + uintptr(unsafe.Pointer(pPS)), + uintptr(unsafe.Pointer(pStg)), + getUintptrFromBool(fSameAsLoad)) + return HRESULT(ret1) +} + +func OleSaveToStream(pPStm *IPersistStream, pStm *IStream) HRESULT { + ret1 := syscall3(oleSaveToStream, 2, + uintptr(unsafe.Pointer(pPStm)), + uintptr(unsafe.Pointer(pStm)), + 0) + return HRESULT(ret1) +} + +func OleSetAutoConvert(clsidOld /*const*/ REFCLSID, clsidNew /*const*/ REFCLSID) HRESULT { + ret1 := syscall3(oleSetAutoConvert, 2, + uintptr(unsafe.Pointer(clsidOld)), + uintptr(unsafe.Pointer(clsidNew)), + 0) + return HRESULT(ret1) +} + +func OleSetClipboard(data *IDataObject) UINT { + ret1 := syscall3(oleSetClipboard, 1, + uintptr(unsafe.Pointer(data)), + 0, + 0) + + return UINT(ret1) +} + +func OleSetContainedObject(pUnknown LPUNKNOWN, fContained bool) HRESULT { + ret1 := syscall3(oleSetContainedObject, 2, + uintptr(unsafe.Pointer(pUnknown)), + getUintptrFromBool(fContained), + 0) + return HRESULT(ret1) +} + +func OleSetMenuDescriptor(hOleMenu HOLEMENU, hwndFrame HWND, hwndActiveObject HWND, lpFrame LPOLEINPLACEFRAME, lpActiveObject LPOLEINPLACEACTIVEOBJECT) HRESULT { + ret1 := syscall6(oleSetMenuDescriptor, 5, + uintptr(hOleMenu), + uintptr(hwndFrame), + uintptr(hwndActiveObject), + uintptr(unsafe.Pointer(lpFrame)), + uintptr(unsafe.Pointer(lpActiveObject)), + 0) + return HRESULT(ret1) +} + +func OleTranslateAccelerator(lpFrame LPOLEINPLACEFRAME, lpFrameInfo LPOLEINPLACEFRAMEINFO, lpmsg *MSG) HRESULT { + ret1 := syscall3(oleTranslateAccelerator, 3, + uintptr(unsafe.Pointer(lpFrame)), + uintptr(unsafe.Pointer(lpFrameInfo)), + uintptr(unsafe.Pointer(lpmsg))) + return HRESULT(ret1) +} + +func PropStgNameToFmtId(str /*const*/ LPOLESTR, rfmtid *FMTID) HRESULT { + ret1 := syscall3(propStgNameToFmtId, 2, + uintptr(unsafe.Pointer(str)), + uintptr(unsafe.Pointer(rfmtid)), + 0) + return HRESULT(ret1) +} + +func PropSysAllocString(str /*const*/ LPCOLESTR) BSTR { + ret1 := syscall3(propSysAllocString, 1, + uintptr(unsafe.Pointer(str)), + 0, + 0) + return (BSTR)(unsafe.Pointer(ret1)) +} + +func PropSysFreeString(str LPOLESTR) { + syscall3(propSysFreeString, 1, + uintptr(unsafe.Pointer(str)), + 0, + 0) +} + +func PropVariantClear(pvar *PROPVARIANT) HRESULT { + ret1 := syscall3(propVariantClear, 1, + uintptr(unsafe.Pointer(pvar)), + 0, + 0) + return HRESULT(ret1) +} + +func PropVariantCopy(pvarDest *PROPVARIANT, pvarSrc /*const*/ *PROPVARIANT) HRESULT { + ret1 := syscall3(propVariantCopy, 2, + uintptr(unsafe.Pointer(pvarDest)), + uintptr(unsafe.Pointer(pvarSrc)), + 0) + return HRESULT(ret1) +} + +func ReadClassStg(pstg *IStorage, pclsid *CLSID) HRESULT { + ret1 := syscall3(readClassStg, 2, + uintptr(unsafe.Pointer(pstg)), + uintptr(unsafe.Pointer(pclsid)), + 0) + return HRESULT(ret1) +} + +func ReadClassStm(pStm *IStream, pclsid *CLSID) HRESULT { + ret1 := syscall3(readClassStm, 2, + uintptr(unsafe.Pointer(pStm)), + uintptr(unsafe.Pointer(pclsid)), + 0) + return HRESULT(ret1) +} + +func ReadFmtUserTypeStg(pstg LPSTORAGE, pcf *CLIPFORMAT, lplpszUserType *LPOLESTR) HRESULT { + ret1 := syscall3(readFmtUserTypeStg, 3, + uintptr(unsafe.Pointer(pstg)), + uintptr(unsafe.Pointer(pcf)), + uintptr(unsafe.Pointer(lplpszUserType))) + return HRESULT(ret1) +} + +func RegisterDragDrop(hwnd HWND, pDropTarget LPDROPTARGET) HRESULT { + ret1 := syscall3(registerDragDrop, 2, + uintptr(hwnd), + uintptr(unsafe.Pointer(pDropTarget)), + 0) + return HRESULT(ret1) +} + +func ReleaseStgMedium(pmedium *STGMEDIUM) { + syscall3(releaseStgMedium, 1, + uintptr(unsafe.Pointer(pmedium)), + 0, + 0) +} + +func RevokeDragDrop(hwnd HWND) HRESULT { + ret1 := syscall3(revokeDragDrop, 1, + uintptr(hwnd), + 0, + 0) + return HRESULT(ret1) +} + +func SetConvertStg(storage *IStorage, convert bool) HRESULT { + ret1 := syscall3(setConvertStg, 2, + uintptr(unsafe.Pointer(storage)), + getUintptrFromBool(convert), + 0) + return HRESULT(ret1) +} + +// TODO: Unknown type(s): const SERIALIZEDPROPERTYVALUE * +// func StgConvertPropertyToVariant(prop /*const*/ const SERIALIZEDPROPERTYVALUE *, codePage USHORT, pvar *PROPVARIANT, pma uintptr) BOOLEAN + +func StgCreateDocfile(pwcsName /*const*/ LPCOLESTR, grfMode DWORD, reserved DWORD, ppstgOpen **IStorage) HRESULT { + ret1 := syscall6(stgCreateDocfile, 4, + uintptr(unsafe.Pointer(pwcsName)), + uintptr(grfMode), + uintptr(reserved), + uintptr(unsafe.Pointer(ppstgOpen)), + 0, + 0) + return HRESULT(ret1) +} + +func StgCreateDocfileOnILockBytes(plkbyt *ILockBytes, grfMode DWORD, reserved DWORD, ppstgOpen **IStorage) HRESULT { + ret1 := syscall6(stgCreateDocfileOnILockBytes, 4, + uintptr(unsafe.Pointer(plkbyt)), + uintptr(grfMode), + uintptr(reserved), + uintptr(unsafe.Pointer(ppstgOpen)), + 0, + 0) + return HRESULT(ret1) +} + +func StgCreatePropSetStg(pstg *IStorage, reserved DWORD, propset **IPropertySetStorage) HRESULT { + ret1 := syscall3(stgCreatePropSetStg, 3, + uintptr(unsafe.Pointer(pstg)), + uintptr(reserved), + uintptr(unsafe.Pointer(propset))) + return HRESULT(ret1) +} + +func StgCreatePropStg(unk *IUnknown, fmt REFFMTID, clsid /*const*/ *CLSID, flags DWORD, reserved DWORD, prop_stg **IPropertyStorage) HRESULT { + ret1 := syscall6(stgCreatePropStg, 6, + uintptr(unsafe.Pointer(unk)), + uintptr(unsafe.Pointer(fmt)), + uintptr(unsafe.Pointer(clsid)), + uintptr(flags), + uintptr(reserved), + uintptr(unsafe.Pointer(prop_stg))) + return HRESULT(ret1) +} + +// TODO: Unknown type(s): STGOPTIONS * +// func StgCreateStorageEx(pwcsName /*const*/ *WCHAR, grfMode DWORD, stgfmt DWORD, grfAttrs DWORD, pStgOptions STGOPTIONS *, reserved uintptr, riid REFIID, ppObjectOpen uintptr) HRESULT + +func StgIsStorageFile(fn /*const*/ LPCOLESTR) HRESULT { + ret1 := syscall3(stgIsStorageFile, 1, + uintptr(unsafe.Pointer(fn)), + 0, + 0) + return HRESULT(ret1) +} + +func StgIsStorageILockBytes(plkbyt *ILockBytes) HRESULT { + ret1 := syscall3(stgIsStorageILockBytes, 1, + uintptr(unsafe.Pointer(plkbyt)), + 0, + 0) + return HRESULT(ret1) +} + +func StgOpenPropStg(unk *IUnknown, fmt REFFMTID, flags DWORD, reserved DWORD, prop_stg **IPropertyStorage) HRESULT { + ret1 := syscall6(stgOpenPropStg, 5, + uintptr(unsafe.Pointer(unk)), + uintptr(unsafe.Pointer(fmt)), + uintptr(flags), + uintptr(reserved), + uintptr(unsafe.Pointer(prop_stg)), + 0) + return HRESULT(ret1) +} + +// TODO: Unknown type(s): SNB +// func StgOpenStorage(pwcsName /*const*/ *OLECHAR, pstgPriority *IStorage, grfMode DWORD, snbExclude SNB, reserved DWORD, ppstgOpen **IStorage) HRESULT + +// TODO: Unknown type(s): STGOPTIONS * +// func StgOpenStorageEx(pwcsName /*const*/ *WCHAR, grfMode DWORD, stgfmt DWORD, grfAttrs DWORD, pStgOptions STGOPTIONS *, reserved uintptr, riid REFIID, ppObjectOpen uintptr) HRESULT + +// TODO: Unknown type(s): SNB +// func StgOpenStorageOnILockBytes(plkbyt *ILockBytes, pstgPriority *IStorage, grfMode DWORD, snbExclude SNB, reserved DWORD, ppstgOpen **IStorage) HRESULT + +func StgSetTimes(str /*const*/ *OLECHAR, pctime /*const*/ *FILETIME, patime /*const*/ *FILETIME, pmtime /*const*/ *FILETIME) HRESULT { + ret1 := syscall6(stgSetTimes, 4, + uintptr(unsafe.Pointer(str)), + uintptr(unsafe.Pointer(pctime)), + uintptr(unsafe.Pointer(patime)), + uintptr(unsafe.Pointer(pmtime)), + 0, + 0) + return HRESULT(ret1) +} + +func StringFromCLSID(id /*const*/ REFCLSID, idstr *LPOLESTR) HRESULT { + ret1 := syscall3(stringFromCLSID, 2, + uintptr(unsafe.Pointer(id)), + uintptr(unsafe.Pointer(idstr)), + 0) + return HRESULT(ret1) +} + +func StringFromGUID2(id REFGUID, str LPOLESTR, cmax INT) INT { + ret1 := syscall3(stringFromGUID2, 3, + uintptr(unsafe.Pointer(id)), + uintptr(unsafe.Pointer(str)), + uintptr(cmax)) + return INT(ret1) +} + +func WdtpInterfacePointer_UserFree(punk *IUnknown) { + syscall3(wdtpInterfacePointer_UserFree, 1, + uintptr(unsafe.Pointer(punk)), + 0, + 0) +} + +func WriteClassStg(pStg *IStorage, rclsid /*const*/ REFCLSID) HRESULT { + ret1 := syscall3(writeClassStg, 2, + uintptr(unsafe.Pointer(pStg)), + uintptr(unsafe.Pointer(rclsid)), + 0) + return HRESULT(ret1) +} + +func WriteClassStm(pStm *IStream, rclsid /*const*/ REFCLSID) HRESULT { + ret1 := syscall3(writeClassStm, 2, + uintptr(unsafe.Pointer(pStm)), + uintptr(unsafe.Pointer(rclsid)), + 0) + return HRESULT(ret1) +} + +func WriteFmtUserTypeStg(pstg LPSTORAGE, cf CLIPFORMAT, lpszUserType LPOLESTR) HRESULT { + ret1 := syscall3(writeFmtUserTypeStg, 3, + uintptr(unsafe.Pointer(pstg)), + uintptr(cf), + uintptr(unsafe.Pointer(lpszUserType))) + return HRESULT(ret1) +} diff --git a/grdp/win/oleaut32.go b/grdp/win/oleaut32.go new file mode 100644 index 0000000..70dc998 --- /dev/null +++ b/grdp/win/oleaut32.go @@ -0,0 +1,3964 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "unsafe" +) + +var ( + // Library + liboleaut32 uintptr + + // Functions + bSTR_UserFree uintptr + bSTR_UserSize uintptr + bstrFromVector uintptr + clearCustData uintptr + createDispTypeInfo uintptr + createErrorInfo uintptr + createStdDispatch uintptr + createTypeLib uintptr + createTypeLib2 uintptr + dispCallFunc uintptr + dispGetIDsOfNames uintptr + dispGetParam uintptr + dispInvoke uintptr + dosDateTimeToVariantTime uintptr + getErrorInfo uintptr + getRecordInfoFromGuids uintptr + getRecordInfoFromTypeInfo uintptr + lHashValOfNameSysA uintptr + lPSAFEARRAY_UserFree uintptr + lPSAFEARRAY_UserSize uintptr + loadRegTypeLib uintptr + loadTypeLib uintptr + loadTypeLibEx uintptr + oaBuildVersion uintptr + oleCreateFontIndirect uintptr + oleCreatePictureIndirect uintptr + oleCreatePropertyFrame uintptr + oleCreatePropertyFrameIndirect uintptr + oleIconToCursor uintptr + oleLoadPicture uintptr + oleLoadPictureEx uintptr + oleLoadPictureFile uintptr + oleLoadPicturePath uintptr + oleSavePictureFile uintptr + oleTranslateColor uintptr + queryPathOfRegTypeLib uintptr + registerTypeLib uintptr + registerTypeLibForUser uintptr + safeArrayAccessData uintptr + safeArrayAllocData uintptr + safeArrayAllocDescriptor uintptr + safeArrayAllocDescriptorEx uintptr + safeArrayCopy uintptr + safeArrayCopyData uintptr + safeArrayDestroy uintptr + safeArrayDestroyData uintptr + safeArrayDestroyDescriptor uintptr + safeArrayGetDim uintptr + safeArrayGetElement uintptr + safeArrayGetElemsize uintptr + safeArrayGetIID uintptr + safeArrayGetLBound uintptr + safeArrayGetRecordInfo uintptr + safeArrayGetUBound uintptr + safeArrayGetVartype uintptr + safeArrayLock uintptr + safeArrayPtrOfIndex uintptr + safeArrayPutElement uintptr + safeArrayRedim uintptr + safeArraySetIID uintptr + safeArraySetRecordInfo uintptr + safeArrayUnaccessData uintptr + safeArrayUnlock uintptr + setErrorInfo uintptr + setOaNoCache uintptr + sysAllocString uintptr + sysAllocStringByteLen uintptr + sysAllocStringLen uintptr + sysFreeString uintptr + sysReAllocString uintptr + sysReAllocStringLen uintptr + sysStringByteLen uintptr + sysStringLen uintptr + systemTimeToVariantTime uintptr + unRegisterTypeLib uintptr + unRegisterTypeLibForUser uintptr + vARIANT_UserFree uintptr + vARIANT_UserSize uintptr + varAbs uintptr + varAdd uintptr + varAnd uintptr + varBoolFromCy uintptr + varBoolFromDate uintptr + varBoolFromDec uintptr + varBoolFromDisp uintptr + varBoolFromI1 uintptr + varBoolFromI2 uintptr + varBoolFromI4 uintptr + varBoolFromI8 uintptr + varBoolFromR4 uintptr + varBoolFromR8 uintptr + varBoolFromStr uintptr + varBoolFromUI1 uintptr + varBoolFromUI2 uintptr + varBoolFromUI4 uintptr + varBoolFromUI8 uintptr + varBstrCat uintptr + varBstrCmp uintptr + varBstrFromBool uintptr + varBstrFromCy uintptr + varBstrFromDate uintptr + varBstrFromDec uintptr + varBstrFromDisp uintptr + varBstrFromI1 uintptr + varBstrFromI2 uintptr + varBstrFromI4 uintptr + varBstrFromI8 uintptr + varBstrFromR4 uintptr + varBstrFromR8 uintptr + varBstrFromUI1 uintptr + varBstrFromUI2 uintptr + varBstrFromUI4 uintptr + varBstrFromUI8 uintptr + varCat uintptr + varCmp uintptr + varCyAbs uintptr + varCyAdd uintptr + varCyCmp uintptr + varCyCmpR8 uintptr + varCyFix uintptr + varCyFromBool uintptr + varCyFromDate uintptr + varCyFromDec uintptr + varCyFromDisp uintptr + varCyFromI1 uintptr + varCyFromI2 uintptr + varCyFromI4 uintptr + varCyFromI8 uintptr + varCyFromR4 uintptr + varCyFromR8 uintptr + varCyFromStr uintptr + varCyFromUI1 uintptr + varCyFromUI2 uintptr + varCyFromUI4 uintptr + varCyFromUI8 uintptr + varCyInt uintptr + varCyMul uintptr + varCyMulI4 uintptr + varCyMulI8 uintptr + varCyNeg uintptr + varCyRound uintptr + varCySub uintptr + varDateFromBool uintptr + varDateFromCy uintptr + varDateFromDec uintptr + varDateFromDisp uintptr + varDateFromI1 uintptr + varDateFromI2 uintptr + varDateFromI4 uintptr + varDateFromI8 uintptr + varDateFromR4 uintptr + varDateFromR8 uintptr + varDateFromStr uintptr + varDateFromUI1 uintptr + varDateFromUI2 uintptr + varDateFromUI4 uintptr + varDateFromUI8 uintptr + varDateFromUdate uintptr + varDateFromUdateEx uintptr + varDecAbs uintptr + varDecAdd uintptr + varDecCmp uintptr + varDecCmpR8 uintptr + varDecDiv uintptr + varDecFix uintptr + varDecFromBool uintptr + varDecFromCy uintptr + varDecFromDate uintptr + varDecFromDisp uintptr + varDecFromI1 uintptr + varDecFromI2 uintptr + varDecFromI4 uintptr + varDecFromI8 uintptr + varDecFromR4 uintptr + varDecFromR8 uintptr + varDecFromStr uintptr + varDecFromUI1 uintptr + varDecFromUI2 uintptr + varDecFromUI4 uintptr + varDecFromUI8 uintptr + varDecInt uintptr + varDecMul uintptr + varDecNeg uintptr + varDecRound uintptr + varDecSub uintptr + varDiv uintptr + varEqv uintptr + varFix uintptr + varFormat uintptr + varFormatCurrency uintptr + varFormatDateTime uintptr + varFormatFromTokens uintptr + varFormatNumber uintptr + varFormatPercent uintptr + varI1FromBool uintptr + varI1FromCy uintptr + varI1FromDate uintptr + varI1FromDec uintptr + varI1FromDisp uintptr + varI1FromI2 uintptr + varI1FromI4 uintptr + varI1FromI8 uintptr + varI1FromR4 uintptr + varI1FromR8 uintptr + varI1FromStr uintptr + varI1FromUI1 uintptr + varI1FromUI2 uintptr + varI1FromUI4 uintptr + varI1FromUI8 uintptr + varI2FromBool uintptr + varI2FromCy uintptr + varI2FromDate uintptr + varI2FromDec uintptr + varI2FromDisp uintptr + varI2FromI1 uintptr + varI2FromI4 uintptr + varI2FromI8 uintptr + varI2FromR4 uintptr + varI2FromR8 uintptr + varI2FromStr uintptr + varI2FromUI1 uintptr + varI2FromUI2 uintptr + varI2FromUI4 uintptr + varI2FromUI8 uintptr + varI4FromBool uintptr + varI4FromCy uintptr + varI4FromDate uintptr + varI4FromDec uintptr + varI4FromDisp uintptr + varI4FromI1 uintptr + varI4FromI2 uintptr + varI4FromI8 uintptr + varI4FromR4 uintptr + varI4FromR8 uintptr + varI4FromStr uintptr + varI4FromUI1 uintptr + varI4FromUI2 uintptr + varI4FromUI4 uintptr + varI4FromUI8 uintptr + varI8FromBool uintptr + varI8FromCy uintptr + varI8FromDate uintptr + varI8FromDec uintptr + varI8FromDisp uintptr + varI8FromI1 uintptr + varI8FromI2 uintptr + varI8FromR4 uintptr + varI8FromR8 uintptr + varI8FromStr uintptr + varI8FromUI1 uintptr + varI8FromUI2 uintptr + varI8FromUI4 uintptr + varI8FromUI8 uintptr + varIdiv uintptr + varImp uintptr + varInt uintptr + varMod uintptr + varMonthName uintptr + varMul uintptr + varNeg uintptr + varNot uintptr + varNumFromParseNum uintptr + varOr uintptr + varParseNumFromStr uintptr + varPow uintptr + varR4CmpR8 uintptr + varR4FromBool uintptr + varR4FromCy uintptr + varR4FromDate uintptr + varR4FromDec uintptr + varR4FromDisp uintptr + varR4FromI1 uintptr + varR4FromI2 uintptr + varR4FromI4 uintptr + varR4FromI8 uintptr + varR4FromR8 uintptr + varR4FromStr uintptr + varR4FromUI1 uintptr + varR4FromUI2 uintptr + varR4FromUI4 uintptr + varR4FromUI8 uintptr + varR8FromBool uintptr + varR8FromCy uintptr + varR8FromDate uintptr + varR8FromDec uintptr + varR8FromDisp uintptr + varR8FromI1 uintptr + varR8FromI2 uintptr + varR8FromI4 uintptr + varR8FromI8 uintptr + varR8FromR4 uintptr + varR8FromStr uintptr + varR8FromUI1 uintptr + varR8FromUI2 uintptr + varR8FromUI4 uintptr + varR8FromUI8 uintptr + varR8Pow uintptr + varR8Round uintptr + varRound uintptr + varSub uintptr + varTokenizeFormatString uintptr + varUI1FromBool uintptr + varUI1FromCy uintptr + varUI1FromDate uintptr + varUI1FromDec uintptr + varUI1FromDisp uintptr + varUI1FromI1 uintptr + varUI1FromI2 uintptr + varUI1FromI4 uintptr + varUI1FromI8 uintptr + varUI1FromR4 uintptr + varUI1FromR8 uintptr + varUI1FromStr uintptr + varUI1FromUI2 uintptr + varUI1FromUI4 uintptr + varUI1FromUI8 uintptr + varUI2FromBool uintptr + varUI2FromCy uintptr + varUI2FromDate uintptr + varUI2FromDec uintptr + varUI2FromDisp uintptr + varUI2FromI1 uintptr + varUI2FromI2 uintptr + varUI2FromI4 uintptr + varUI2FromI8 uintptr + varUI2FromR4 uintptr + varUI2FromR8 uintptr + varUI2FromStr uintptr + varUI2FromUI1 uintptr + varUI2FromUI4 uintptr + varUI2FromUI8 uintptr + varUI4FromBool uintptr + varUI4FromCy uintptr + varUI4FromDate uintptr + varUI4FromDec uintptr + varUI4FromDisp uintptr + varUI4FromI1 uintptr + varUI4FromI2 uintptr + varUI4FromI4 uintptr + varUI4FromI8 uintptr + varUI4FromR4 uintptr + varUI4FromR8 uintptr + varUI4FromStr uintptr + varUI4FromUI1 uintptr + varUI4FromUI2 uintptr + varUI4FromUI8 uintptr + varUI8FromBool uintptr + varUI8FromCy uintptr + varUI8FromDate uintptr + varUI8FromDec uintptr + varUI8FromDisp uintptr + varUI8FromI1 uintptr + varUI8FromI2 uintptr + varUI8FromI8 uintptr + varUI8FromR4 uintptr + varUI8FromR8 uintptr + varUI8FromStr uintptr + varUI8FromUI1 uintptr + varUI8FromUI2 uintptr + varUI8FromUI4 uintptr + varUdateFromDate uintptr + varWeekdayName uintptr + varXor uintptr + variantChangeType uintptr + variantChangeTypeEx uintptr + variantClear uintptr + variantCopy uintptr + variantCopyInd uintptr + variantInit uintptr + variantTimeToDosDateTime uintptr + variantTimeToSystemTime uintptr + vectorFromBstr uintptr +) + +func init() { + // Library + liboleaut32 = doLoadLibrary("oleaut32.dll") + + // Functions + bSTR_UserFree = doGetProcAddress(liboleaut32, "BSTR_UserFree") + bSTR_UserSize = doGetProcAddress(liboleaut32, "BSTR_UserSize") + bstrFromVector = doGetProcAddress(liboleaut32, "BstrFromVector") + clearCustData = doGetProcAddress(liboleaut32, "ClearCustData") + createDispTypeInfo = doGetProcAddress(liboleaut32, "CreateDispTypeInfo") + createErrorInfo = doGetProcAddress(liboleaut32, "CreateErrorInfo") + createStdDispatch = doGetProcAddress(liboleaut32, "CreateStdDispatch") + createTypeLib = doGetProcAddress(liboleaut32, "CreateTypeLib") + createTypeLib2 = doGetProcAddress(liboleaut32, "CreateTypeLib2") + dispCallFunc = doGetProcAddress(liboleaut32, "DispCallFunc") + dispGetIDsOfNames = doGetProcAddress(liboleaut32, "DispGetIDsOfNames") + dispGetParam = doGetProcAddress(liboleaut32, "DispGetParam") + dispInvoke = doGetProcAddress(liboleaut32, "DispInvoke") + dosDateTimeToVariantTime = doGetProcAddress(liboleaut32, "DosDateTimeToVariantTime") + getErrorInfo = doGetProcAddress(liboleaut32, "GetErrorInfo") + getRecordInfoFromGuids = doGetProcAddress(liboleaut32, "GetRecordInfoFromGuids") + getRecordInfoFromTypeInfo = doGetProcAddress(liboleaut32, "GetRecordInfoFromTypeInfo") + lHashValOfNameSysA = doGetProcAddress(liboleaut32, "LHashValOfNameSysA") + lPSAFEARRAY_UserFree = doGetProcAddress(liboleaut32, "LPSAFEARRAY_UserFree") + lPSAFEARRAY_UserSize = doGetProcAddress(liboleaut32, "LPSAFEARRAY_UserSize") + loadRegTypeLib = doGetProcAddress(liboleaut32, "LoadRegTypeLib") + loadTypeLib = doGetProcAddress(liboleaut32, "LoadTypeLib") + loadTypeLibEx = doGetProcAddress(liboleaut32, "LoadTypeLibEx") + oaBuildVersion = doGetProcAddress(liboleaut32, "OaBuildVersion") + oleCreateFontIndirect = doGetProcAddress(liboleaut32, "OleCreateFontIndirect") + oleCreatePictureIndirect = doGetProcAddress(liboleaut32, "OleCreatePictureIndirect") + oleCreatePropertyFrame = doGetProcAddress(liboleaut32, "OleCreatePropertyFrame") + oleCreatePropertyFrameIndirect = doGetProcAddress(liboleaut32, "OleCreatePropertyFrameIndirect") + oleIconToCursor = doGetProcAddress(liboleaut32, "OleIconToCursor") + oleLoadPicture = doGetProcAddress(liboleaut32, "OleLoadPicture") + oleLoadPictureEx = doGetProcAddress(liboleaut32, "OleLoadPictureEx") + oleLoadPictureFile = doGetProcAddress(liboleaut32, "OleLoadPictureFile") + oleLoadPicturePath = doGetProcAddress(liboleaut32, "OleLoadPicturePath") + oleSavePictureFile = doGetProcAddress(liboleaut32, "OleSavePictureFile") + oleTranslateColor = doGetProcAddress(liboleaut32, "OleTranslateColor") + queryPathOfRegTypeLib = doGetProcAddress(liboleaut32, "QueryPathOfRegTypeLib") + registerTypeLib = doGetProcAddress(liboleaut32, "RegisterTypeLib") + registerTypeLibForUser = doGetProcAddress(liboleaut32, "RegisterTypeLibForUser") + safeArrayAccessData = doGetProcAddress(liboleaut32, "SafeArrayAccessData") + safeArrayAllocData = doGetProcAddress(liboleaut32, "SafeArrayAllocData") + safeArrayAllocDescriptor = doGetProcAddress(liboleaut32, "SafeArrayAllocDescriptor") + safeArrayAllocDescriptorEx = doGetProcAddress(liboleaut32, "SafeArrayAllocDescriptorEx") + safeArrayCopy = doGetProcAddress(liboleaut32, "SafeArrayCopy") + safeArrayCopyData = doGetProcAddress(liboleaut32, "SafeArrayCopyData") + safeArrayDestroy = doGetProcAddress(liboleaut32, "SafeArrayDestroy") + safeArrayDestroyData = doGetProcAddress(liboleaut32, "SafeArrayDestroyData") + safeArrayDestroyDescriptor = doGetProcAddress(liboleaut32, "SafeArrayDestroyDescriptor") + safeArrayGetDim = doGetProcAddress(liboleaut32, "SafeArrayGetDim") + safeArrayGetElement = doGetProcAddress(liboleaut32, "SafeArrayGetElement") + safeArrayGetElemsize = doGetProcAddress(liboleaut32, "SafeArrayGetElemsize") + safeArrayGetIID = doGetProcAddress(liboleaut32, "SafeArrayGetIID") + safeArrayGetLBound = doGetProcAddress(liboleaut32, "SafeArrayGetLBound") + safeArrayGetRecordInfo = doGetProcAddress(liboleaut32, "SafeArrayGetRecordInfo") + safeArrayGetUBound = doGetProcAddress(liboleaut32, "SafeArrayGetUBound") + safeArrayGetVartype = doGetProcAddress(liboleaut32, "SafeArrayGetVartype") + safeArrayLock = doGetProcAddress(liboleaut32, "SafeArrayLock") + safeArrayPtrOfIndex = doGetProcAddress(liboleaut32, "SafeArrayPtrOfIndex") + safeArrayPutElement = doGetProcAddress(liboleaut32, "SafeArrayPutElement") + safeArrayRedim = doGetProcAddress(liboleaut32, "SafeArrayRedim") + safeArraySetIID = doGetProcAddress(liboleaut32, "SafeArraySetIID") + safeArraySetRecordInfo = doGetProcAddress(liboleaut32, "SafeArraySetRecordInfo") + safeArrayUnaccessData = doGetProcAddress(liboleaut32, "SafeArrayUnaccessData") + safeArrayUnlock = doGetProcAddress(liboleaut32, "SafeArrayUnlock") + setErrorInfo = doGetProcAddress(liboleaut32, "SetErrorInfo") + setOaNoCache = doGetProcAddress(liboleaut32, "SetOaNoCache") + sysAllocString = doGetProcAddress(liboleaut32, "SysAllocString") + sysAllocStringByteLen = doGetProcAddress(liboleaut32, "SysAllocStringByteLen") + sysAllocStringLen = doGetProcAddress(liboleaut32, "SysAllocStringLen") + sysFreeString = doGetProcAddress(liboleaut32, "SysFreeString") + sysReAllocString = doGetProcAddress(liboleaut32, "SysReAllocString") + sysReAllocStringLen = doGetProcAddress(liboleaut32, "SysReAllocStringLen") + sysStringByteLen = doGetProcAddress(liboleaut32, "SysStringByteLen") + sysStringLen = doGetProcAddress(liboleaut32, "SysStringLen") + systemTimeToVariantTime = doGetProcAddress(liboleaut32, "SystemTimeToVariantTime") + unRegisterTypeLib = doGetProcAddress(liboleaut32, "UnRegisterTypeLib") + unRegisterTypeLibForUser = doGetProcAddress(liboleaut32, "UnRegisterTypeLibForUser") + vARIANT_UserFree = doGetProcAddress(liboleaut32, "VARIANT_UserFree") + vARIANT_UserSize = doGetProcAddress(liboleaut32, "VARIANT_UserSize") + varAbs = doGetProcAddress(liboleaut32, "VarAbs") + varAdd = doGetProcAddress(liboleaut32, "VarAdd") + varAnd = doGetProcAddress(liboleaut32, "VarAnd") + varBoolFromCy = doGetProcAddress(liboleaut32, "VarBoolFromCy") + varBoolFromDate = doGetProcAddress(liboleaut32, "VarBoolFromDate") + varBoolFromDec = doGetProcAddress(liboleaut32, "VarBoolFromDec") + varBoolFromDisp = doGetProcAddress(liboleaut32, "VarBoolFromDisp") + varBoolFromI1 = doGetProcAddress(liboleaut32, "VarBoolFromI1") + varBoolFromI2 = doGetProcAddress(liboleaut32, "VarBoolFromI2") + varBoolFromI4 = doGetProcAddress(liboleaut32, "VarBoolFromI4") + varBoolFromI8 = doGetProcAddress(liboleaut32, "VarBoolFromI8") + varBoolFromR4 = doGetProcAddress(liboleaut32, "VarBoolFromR4") + varBoolFromR8 = doGetProcAddress(liboleaut32, "VarBoolFromR8") + varBoolFromStr = doGetProcAddress(liboleaut32, "VarBoolFromStr") + varBoolFromUI1 = doGetProcAddress(liboleaut32, "VarBoolFromUI1") + varBoolFromUI2 = doGetProcAddress(liboleaut32, "VarBoolFromUI2") + varBoolFromUI4 = doGetProcAddress(liboleaut32, "VarBoolFromUI4") + varBoolFromUI8 = doGetProcAddress(liboleaut32, "VarBoolFromUI8") + varBstrCat = doGetProcAddress(liboleaut32, "VarBstrCat") + varBstrCmp = doGetProcAddress(liboleaut32, "VarBstrCmp") + varBstrFromBool = doGetProcAddress(liboleaut32, "VarBstrFromBool") + varBstrFromCy = doGetProcAddress(liboleaut32, "VarBstrFromCy") + varBstrFromDate = doGetProcAddress(liboleaut32, "VarBstrFromDate") + varBstrFromDec = doGetProcAddress(liboleaut32, "VarBstrFromDec") + varBstrFromDisp = doGetProcAddress(liboleaut32, "VarBstrFromDisp") + varBstrFromI1 = doGetProcAddress(liboleaut32, "VarBstrFromI1") + varBstrFromI2 = doGetProcAddress(liboleaut32, "VarBstrFromI2") + varBstrFromI4 = doGetProcAddress(liboleaut32, "VarBstrFromI4") + varBstrFromI8 = doGetProcAddress(liboleaut32, "VarBstrFromI8") + varBstrFromR4 = doGetProcAddress(liboleaut32, "VarBstrFromR4") + varBstrFromR8 = doGetProcAddress(liboleaut32, "VarBstrFromR8") + varBstrFromUI1 = doGetProcAddress(liboleaut32, "VarBstrFromUI1") + varBstrFromUI2 = doGetProcAddress(liboleaut32, "VarBstrFromUI2") + varBstrFromUI4 = doGetProcAddress(liboleaut32, "VarBstrFromUI4") + varBstrFromUI8 = doGetProcAddress(liboleaut32, "VarBstrFromUI8") + varCat = doGetProcAddress(liboleaut32, "VarCat") + varCmp = doGetProcAddress(liboleaut32, "VarCmp") + varCyAbs = doGetProcAddress(liboleaut32, "VarCyAbs") + varCyAdd = doGetProcAddress(liboleaut32, "VarCyAdd") + varCyCmp = doGetProcAddress(liboleaut32, "VarCyCmp") + varCyCmpR8 = doGetProcAddress(liboleaut32, "VarCyCmpR8") + varCyFix = doGetProcAddress(liboleaut32, "VarCyFix") + varCyFromBool = doGetProcAddress(liboleaut32, "VarCyFromBool") + varCyFromDate = doGetProcAddress(liboleaut32, "VarCyFromDate") + varCyFromDec = doGetProcAddress(liboleaut32, "VarCyFromDec") + varCyFromDisp = doGetProcAddress(liboleaut32, "VarCyFromDisp") + varCyFromI1 = doGetProcAddress(liboleaut32, "VarCyFromI1") + varCyFromI2 = doGetProcAddress(liboleaut32, "VarCyFromI2") + varCyFromI4 = doGetProcAddress(liboleaut32, "VarCyFromI4") + varCyFromI8 = doGetProcAddress(liboleaut32, "VarCyFromI8") + varCyFromR4 = doGetProcAddress(liboleaut32, "VarCyFromR4") + varCyFromR8 = doGetProcAddress(liboleaut32, "VarCyFromR8") + varCyFromStr = doGetProcAddress(liboleaut32, "VarCyFromStr") + varCyFromUI1 = doGetProcAddress(liboleaut32, "VarCyFromUI1") + varCyFromUI2 = doGetProcAddress(liboleaut32, "VarCyFromUI2") + varCyFromUI4 = doGetProcAddress(liboleaut32, "VarCyFromUI4") + varCyFromUI8 = doGetProcAddress(liboleaut32, "VarCyFromUI8") + varCyInt = doGetProcAddress(liboleaut32, "VarCyInt") + varCyMul = doGetProcAddress(liboleaut32, "VarCyMul") + varCyMulI4 = doGetProcAddress(liboleaut32, "VarCyMulI4") + varCyMulI8 = doGetProcAddress(liboleaut32, "VarCyMulI8") + varCyNeg = doGetProcAddress(liboleaut32, "VarCyNeg") + varCyRound = doGetProcAddress(liboleaut32, "VarCyRound") + varCySub = doGetProcAddress(liboleaut32, "VarCySub") + varDateFromBool = doGetProcAddress(liboleaut32, "VarDateFromBool") + varDateFromCy = doGetProcAddress(liboleaut32, "VarDateFromCy") + varDateFromDec = doGetProcAddress(liboleaut32, "VarDateFromDec") + varDateFromDisp = doGetProcAddress(liboleaut32, "VarDateFromDisp") + varDateFromI1 = doGetProcAddress(liboleaut32, "VarDateFromI1") + varDateFromI2 = doGetProcAddress(liboleaut32, "VarDateFromI2") + varDateFromI4 = doGetProcAddress(liboleaut32, "VarDateFromI4") + varDateFromI8 = doGetProcAddress(liboleaut32, "VarDateFromI8") + varDateFromR4 = doGetProcAddress(liboleaut32, "VarDateFromR4") + varDateFromR8 = doGetProcAddress(liboleaut32, "VarDateFromR8") + varDateFromStr = doGetProcAddress(liboleaut32, "VarDateFromStr") + varDateFromUI1 = doGetProcAddress(liboleaut32, "VarDateFromUI1") + varDateFromUI2 = doGetProcAddress(liboleaut32, "VarDateFromUI2") + varDateFromUI4 = doGetProcAddress(liboleaut32, "VarDateFromUI4") + varDateFromUI8 = doGetProcAddress(liboleaut32, "VarDateFromUI8") + varDateFromUdate = doGetProcAddress(liboleaut32, "VarDateFromUdate") + varDateFromUdateEx = doGetProcAddress(liboleaut32, "VarDateFromUdateEx") + varDecAbs = doGetProcAddress(liboleaut32, "VarDecAbs") + varDecAdd = doGetProcAddress(liboleaut32, "VarDecAdd") + varDecCmp = doGetProcAddress(liboleaut32, "VarDecCmp") + varDecCmpR8 = doGetProcAddress(liboleaut32, "VarDecCmpR8") + varDecDiv = doGetProcAddress(liboleaut32, "VarDecDiv") + varDecFix = doGetProcAddress(liboleaut32, "VarDecFix") + varDecFromBool = doGetProcAddress(liboleaut32, "VarDecFromBool") + varDecFromCy = doGetProcAddress(liboleaut32, "VarDecFromCy") + varDecFromDate = doGetProcAddress(liboleaut32, "VarDecFromDate") + varDecFromDisp = doGetProcAddress(liboleaut32, "VarDecFromDisp") + varDecFromI1 = doGetProcAddress(liboleaut32, "VarDecFromI1") + varDecFromI2 = doGetProcAddress(liboleaut32, "VarDecFromI2") + varDecFromI4 = doGetProcAddress(liboleaut32, "VarDecFromI4") + varDecFromI8 = doGetProcAddress(liboleaut32, "VarDecFromI8") + varDecFromR4 = doGetProcAddress(liboleaut32, "VarDecFromR4") + varDecFromR8 = doGetProcAddress(liboleaut32, "VarDecFromR8") + varDecFromStr = doGetProcAddress(liboleaut32, "VarDecFromStr") + varDecFromUI1 = doGetProcAddress(liboleaut32, "VarDecFromUI1") + varDecFromUI2 = doGetProcAddress(liboleaut32, "VarDecFromUI2") + varDecFromUI4 = doGetProcAddress(liboleaut32, "VarDecFromUI4") + varDecFromUI8 = doGetProcAddress(liboleaut32, "VarDecFromUI8") + varDecInt = doGetProcAddress(liboleaut32, "VarDecInt") + varDecMul = doGetProcAddress(liboleaut32, "VarDecMul") + varDecNeg = doGetProcAddress(liboleaut32, "VarDecNeg") + varDecRound = doGetProcAddress(liboleaut32, "VarDecRound") + varDecSub = doGetProcAddress(liboleaut32, "VarDecSub") + varDiv = doGetProcAddress(liboleaut32, "VarDiv") + varEqv = doGetProcAddress(liboleaut32, "VarEqv") + varFix = doGetProcAddress(liboleaut32, "VarFix") + varFormat = doGetProcAddress(liboleaut32, "VarFormat") + varFormatCurrency = doGetProcAddress(liboleaut32, "VarFormatCurrency") + varFormatDateTime = doGetProcAddress(liboleaut32, "VarFormatDateTime") + varFormatFromTokens = doGetProcAddress(liboleaut32, "VarFormatFromTokens") + varFormatNumber = doGetProcAddress(liboleaut32, "VarFormatNumber") + varFormatPercent = doGetProcAddress(liboleaut32, "VarFormatPercent") + varI1FromBool = doGetProcAddress(liboleaut32, "VarI1FromBool") + varI1FromCy = doGetProcAddress(liboleaut32, "VarI1FromCy") + varI1FromDate = doGetProcAddress(liboleaut32, "VarI1FromDate") + varI1FromDec = doGetProcAddress(liboleaut32, "VarI1FromDec") + varI1FromDisp = doGetProcAddress(liboleaut32, "VarI1FromDisp") + varI1FromI2 = doGetProcAddress(liboleaut32, "VarI1FromI2") + varI1FromI4 = doGetProcAddress(liboleaut32, "VarI1FromI4") + varI1FromI8 = doGetProcAddress(liboleaut32, "VarI1FromI8") + varI1FromR4 = doGetProcAddress(liboleaut32, "VarI1FromR4") + varI1FromR8 = doGetProcAddress(liboleaut32, "VarI1FromR8") + varI1FromStr = doGetProcAddress(liboleaut32, "VarI1FromStr") + varI1FromUI1 = doGetProcAddress(liboleaut32, "VarI1FromUI1") + varI1FromUI2 = doGetProcAddress(liboleaut32, "VarI1FromUI2") + varI1FromUI4 = doGetProcAddress(liboleaut32, "VarI1FromUI4") + varI1FromUI8 = doGetProcAddress(liboleaut32, "VarI1FromUI8") + varI2FromBool = doGetProcAddress(liboleaut32, "VarI2FromBool") + varI2FromCy = doGetProcAddress(liboleaut32, "VarI2FromCy") + varI2FromDate = doGetProcAddress(liboleaut32, "VarI2FromDate") + varI2FromDec = doGetProcAddress(liboleaut32, "VarI2FromDec") + varI2FromDisp = doGetProcAddress(liboleaut32, "VarI2FromDisp") + varI2FromI1 = doGetProcAddress(liboleaut32, "VarI2FromI1") + varI2FromI4 = doGetProcAddress(liboleaut32, "VarI2FromI4") + varI2FromI8 = doGetProcAddress(liboleaut32, "VarI2FromI8") + varI2FromR4 = doGetProcAddress(liboleaut32, "VarI2FromR4") + varI2FromR8 = doGetProcAddress(liboleaut32, "VarI2FromR8") + varI2FromStr = doGetProcAddress(liboleaut32, "VarI2FromStr") + varI2FromUI1 = doGetProcAddress(liboleaut32, "VarI2FromUI1") + varI2FromUI2 = doGetProcAddress(liboleaut32, "VarI2FromUI2") + varI2FromUI4 = doGetProcAddress(liboleaut32, "VarI2FromUI4") + varI2FromUI8 = doGetProcAddress(liboleaut32, "VarI2FromUI8") + varI4FromBool = doGetProcAddress(liboleaut32, "VarI4FromBool") + varI4FromCy = doGetProcAddress(liboleaut32, "VarI4FromCy") + varI4FromDate = doGetProcAddress(liboleaut32, "VarI4FromDate") + varI4FromDec = doGetProcAddress(liboleaut32, "VarI4FromDec") + varI4FromDisp = doGetProcAddress(liboleaut32, "VarI4FromDisp") + varI4FromI1 = doGetProcAddress(liboleaut32, "VarI4FromI1") + varI4FromI2 = doGetProcAddress(liboleaut32, "VarI4FromI2") + varI4FromI8 = doGetProcAddress(liboleaut32, "VarI4FromI8") + varI4FromR4 = doGetProcAddress(liboleaut32, "VarI4FromR4") + varI4FromR8 = doGetProcAddress(liboleaut32, "VarI4FromR8") + varI4FromStr = doGetProcAddress(liboleaut32, "VarI4FromStr") + varI4FromUI1 = doGetProcAddress(liboleaut32, "VarI4FromUI1") + varI4FromUI2 = doGetProcAddress(liboleaut32, "VarI4FromUI2") + varI4FromUI4 = doGetProcAddress(liboleaut32, "VarI4FromUI4") + varI4FromUI8 = doGetProcAddress(liboleaut32, "VarI4FromUI8") + varI8FromBool = doGetProcAddress(liboleaut32, "VarI8FromBool") + varI8FromCy = doGetProcAddress(liboleaut32, "VarI8FromCy") + varI8FromDate = doGetProcAddress(liboleaut32, "VarI8FromDate") + varI8FromDec = doGetProcAddress(liboleaut32, "VarI8FromDec") + varI8FromDisp = doGetProcAddress(liboleaut32, "VarI8FromDisp") + varI8FromI1 = doGetProcAddress(liboleaut32, "VarI8FromI1") + varI8FromI2 = doGetProcAddress(liboleaut32, "VarI8FromI2") + varI8FromR4 = doGetProcAddress(liboleaut32, "VarI8FromR4") + varI8FromR8 = doGetProcAddress(liboleaut32, "VarI8FromR8") + varI8FromStr = doGetProcAddress(liboleaut32, "VarI8FromStr") + varI8FromUI1 = doGetProcAddress(liboleaut32, "VarI8FromUI1") + varI8FromUI2 = doGetProcAddress(liboleaut32, "VarI8FromUI2") + varI8FromUI4 = doGetProcAddress(liboleaut32, "VarI8FromUI4") + varI8FromUI8 = doGetProcAddress(liboleaut32, "VarI8FromUI8") + varIdiv = doGetProcAddress(liboleaut32, "VarIdiv") + varImp = doGetProcAddress(liboleaut32, "VarImp") + varInt = doGetProcAddress(liboleaut32, "VarInt") + varMod = doGetProcAddress(liboleaut32, "VarMod") + varMonthName = doGetProcAddress(liboleaut32, "VarMonthName") + varMul = doGetProcAddress(liboleaut32, "VarMul") + varNeg = doGetProcAddress(liboleaut32, "VarNeg") + varNot = doGetProcAddress(liboleaut32, "VarNot") + varNumFromParseNum = doGetProcAddress(liboleaut32, "VarNumFromParseNum") + varOr = doGetProcAddress(liboleaut32, "VarOr") + varParseNumFromStr = doGetProcAddress(liboleaut32, "VarParseNumFromStr") + varPow = doGetProcAddress(liboleaut32, "VarPow") + varR4CmpR8 = doGetProcAddress(liboleaut32, "VarR4CmpR8") + varR4FromBool = doGetProcAddress(liboleaut32, "VarR4FromBool") + varR4FromCy = doGetProcAddress(liboleaut32, "VarR4FromCy") + varR4FromDate = doGetProcAddress(liboleaut32, "VarR4FromDate") + varR4FromDec = doGetProcAddress(liboleaut32, "VarR4FromDec") + varR4FromDisp = doGetProcAddress(liboleaut32, "VarR4FromDisp") + varR4FromI1 = doGetProcAddress(liboleaut32, "VarR4FromI1") + varR4FromI2 = doGetProcAddress(liboleaut32, "VarR4FromI2") + varR4FromI4 = doGetProcAddress(liboleaut32, "VarR4FromI4") + varR4FromI8 = doGetProcAddress(liboleaut32, "VarR4FromI8") + varR4FromR8 = doGetProcAddress(liboleaut32, "VarR4FromR8") + varR4FromStr = doGetProcAddress(liboleaut32, "VarR4FromStr") + varR4FromUI1 = doGetProcAddress(liboleaut32, "VarR4FromUI1") + varR4FromUI2 = doGetProcAddress(liboleaut32, "VarR4FromUI2") + varR4FromUI4 = doGetProcAddress(liboleaut32, "VarR4FromUI4") + varR4FromUI8 = doGetProcAddress(liboleaut32, "VarR4FromUI8") + varR8FromBool = doGetProcAddress(liboleaut32, "VarR8FromBool") + varR8FromCy = doGetProcAddress(liboleaut32, "VarR8FromCy") + varR8FromDate = doGetProcAddress(liboleaut32, "VarR8FromDate") + varR8FromDec = doGetProcAddress(liboleaut32, "VarR8FromDec") + varR8FromDisp = doGetProcAddress(liboleaut32, "VarR8FromDisp") + varR8FromI1 = doGetProcAddress(liboleaut32, "VarR8FromI1") + varR8FromI2 = doGetProcAddress(liboleaut32, "VarR8FromI2") + varR8FromI4 = doGetProcAddress(liboleaut32, "VarR8FromI4") + varR8FromI8 = doGetProcAddress(liboleaut32, "VarR8FromI8") + varR8FromR4 = doGetProcAddress(liboleaut32, "VarR8FromR4") + varR8FromStr = doGetProcAddress(liboleaut32, "VarR8FromStr") + varR8FromUI1 = doGetProcAddress(liboleaut32, "VarR8FromUI1") + varR8FromUI2 = doGetProcAddress(liboleaut32, "VarR8FromUI2") + varR8FromUI4 = doGetProcAddress(liboleaut32, "VarR8FromUI4") + varR8FromUI8 = doGetProcAddress(liboleaut32, "VarR8FromUI8") + varR8Pow = doGetProcAddress(liboleaut32, "VarR8Pow") + varR8Round = doGetProcAddress(liboleaut32, "VarR8Round") + varRound = doGetProcAddress(liboleaut32, "VarRound") + varSub = doGetProcAddress(liboleaut32, "VarSub") + varTokenizeFormatString = doGetProcAddress(liboleaut32, "VarTokenizeFormatString") + varUI1FromBool = doGetProcAddress(liboleaut32, "VarUI1FromBool") + varUI1FromCy = doGetProcAddress(liboleaut32, "VarUI1FromCy") + varUI1FromDate = doGetProcAddress(liboleaut32, "VarUI1FromDate") + varUI1FromDec = doGetProcAddress(liboleaut32, "VarUI1FromDec") + varUI1FromDisp = doGetProcAddress(liboleaut32, "VarUI1FromDisp") + varUI1FromI1 = doGetProcAddress(liboleaut32, "VarUI1FromI1") + varUI1FromI2 = doGetProcAddress(liboleaut32, "VarUI1FromI2") + varUI1FromI4 = doGetProcAddress(liboleaut32, "VarUI1FromI4") + varUI1FromI8 = doGetProcAddress(liboleaut32, "VarUI1FromI8") + varUI1FromR4 = doGetProcAddress(liboleaut32, "VarUI1FromR4") + varUI1FromR8 = doGetProcAddress(liboleaut32, "VarUI1FromR8") + varUI1FromStr = doGetProcAddress(liboleaut32, "VarUI1FromStr") + varUI1FromUI2 = doGetProcAddress(liboleaut32, "VarUI1FromUI2") + varUI1FromUI4 = doGetProcAddress(liboleaut32, "VarUI1FromUI4") + varUI1FromUI8 = doGetProcAddress(liboleaut32, "VarUI1FromUI8") + varUI2FromBool = doGetProcAddress(liboleaut32, "VarUI2FromBool") + varUI2FromCy = doGetProcAddress(liboleaut32, "VarUI2FromCy") + varUI2FromDate = doGetProcAddress(liboleaut32, "VarUI2FromDate") + varUI2FromDec = doGetProcAddress(liboleaut32, "VarUI2FromDec") + varUI2FromDisp = doGetProcAddress(liboleaut32, "VarUI2FromDisp") + varUI2FromI1 = doGetProcAddress(liboleaut32, "VarUI2FromI1") + varUI2FromI2 = doGetProcAddress(liboleaut32, "VarUI2FromI2") + varUI2FromI4 = doGetProcAddress(liboleaut32, "VarUI2FromI4") + varUI2FromI8 = doGetProcAddress(liboleaut32, "VarUI2FromI8") + varUI2FromR4 = doGetProcAddress(liboleaut32, "VarUI2FromR4") + varUI2FromR8 = doGetProcAddress(liboleaut32, "VarUI2FromR8") + varUI2FromStr = doGetProcAddress(liboleaut32, "VarUI2FromStr") + varUI2FromUI1 = doGetProcAddress(liboleaut32, "VarUI2FromUI1") + varUI2FromUI4 = doGetProcAddress(liboleaut32, "VarUI2FromUI4") + varUI2FromUI8 = doGetProcAddress(liboleaut32, "VarUI2FromUI8") + varUI4FromBool = doGetProcAddress(liboleaut32, "VarUI4FromBool") + varUI4FromCy = doGetProcAddress(liboleaut32, "VarUI4FromCy") + varUI4FromDate = doGetProcAddress(liboleaut32, "VarUI4FromDate") + varUI4FromDec = doGetProcAddress(liboleaut32, "VarUI4FromDec") + varUI4FromDisp = doGetProcAddress(liboleaut32, "VarUI4FromDisp") + varUI4FromI1 = doGetProcAddress(liboleaut32, "VarUI4FromI1") + varUI4FromI2 = doGetProcAddress(liboleaut32, "VarUI4FromI2") + varUI4FromI4 = doGetProcAddress(liboleaut32, "VarUI4FromI4") + varUI4FromI8 = doGetProcAddress(liboleaut32, "VarUI4FromI8") + varUI4FromR4 = doGetProcAddress(liboleaut32, "VarUI4FromR4") + varUI4FromR8 = doGetProcAddress(liboleaut32, "VarUI4FromR8") + varUI4FromStr = doGetProcAddress(liboleaut32, "VarUI4FromStr") + varUI4FromUI1 = doGetProcAddress(liboleaut32, "VarUI4FromUI1") + varUI4FromUI2 = doGetProcAddress(liboleaut32, "VarUI4FromUI2") + varUI4FromUI8 = doGetProcAddress(liboleaut32, "VarUI4FromUI8") + varUI8FromBool = doGetProcAddress(liboleaut32, "VarUI8FromBool") + varUI8FromCy = doGetProcAddress(liboleaut32, "VarUI8FromCy") + varUI8FromDate = doGetProcAddress(liboleaut32, "VarUI8FromDate") + varUI8FromDec = doGetProcAddress(liboleaut32, "VarUI8FromDec") + varUI8FromDisp = doGetProcAddress(liboleaut32, "VarUI8FromDisp") + varUI8FromI1 = doGetProcAddress(liboleaut32, "VarUI8FromI1") + varUI8FromI2 = doGetProcAddress(liboleaut32, "VarUI8FromI2") + varUI8FromI8 = doGetProcAddress(liboleaut32, "VarUI8FromI8") + varUI8FromR4 = doGetProcAddress(liboleaut32, "VarUI8FromR4") + varUI8FromR8 = doGetProcAddress(liboleaut32, "VarUI8FromR8") + varUI8FromStr = doGetProcAddress(liboleaut32, "VarUI8FromStr") + varUI8FromUI1 = doGetProcAddress(liboleaut32, "VarUI8FromUI1") + varUI8FromUI2 = doGetProcAddress(liboleaut32, "VarUI8FromUI2") + varUI8FromUI4 = doGetProcAddress(liboleaut32, "VarUI8FromUI4") + varUdateFromDate = doGetProcAddress(liboleaut32, "VarUdateFromDate") + varWeekdayName = doGetProcAddress(liboleaut32, "VarWeekdayName") + varXor = doGetProcAddress(liboleaut32, "VarXor") + variantChangeType = doGetProcAddress(liboleaut32, "VariantChangeType") + variantChangeTypeEx = doGetProcAddress(liboleaut32, "VariantChangeTypeEx") + variantClear = doGetProcAddress(liboleaut32, "VariantClear") + variantCopy = doGetProcAddress(liboleaut32, "VariantCopy") + variantCopyInd = doGetProcAddress(liboleaut32, "VariantCopyInd") + variantInit = doGetProcAddress(liboleaut32, "VariantInit") + variantTimeToDosDateTime = doGetProcAddress(liboleaut32, "VariantTimeToDosDateTime") + variantTimeToSystemTime = doGetProcAddress(liboleaut32, "VariantTimeToSystemTime") + vectorFromBstr = doGetProcAddress(liboleaut32, "VectorFromBstr") +} + +func BSTR_UserFree(pFlags *ULONG, pstr *BSTR) { + syscall3(bSTR_UserFree, 2, + uintptr(unsafe.Pointer(pFlags)), + uintptr(unsafe.Pointer(pstr)), + 0) +} + +func BSTR_UserSize(pFlags *ULONG, start ULONG, pstr *BSTR) ULONG { + ret1 := syscall3(bSTR_UserSize, 3, + uintptr(unsafe.Pointer(pFlags)), + uintptr(start), + uintptr(unsafe.Pointer(pstr))) + return ULONG(ret1) +} + +func BstrFromVector(psa *SAFEARRAY, pbstr *BSTR) HRESULT { + ret1 := syscall3(bstrFromVector, 2, + uintptr(unsafe.Pointer(psa)), + uintptr(unsafe.Pointer(pbstr)), + 0) + return HRESULT(ret1) +} + +func ClearCustData(lpCust *CUSTDATA) { + syscall3(clearCustData, 1, + uintptr(unsafe.Pointer(lpCust)), + 0, + 0) +} + +func CreateDispTypeInfo(pidata *INTERFACEDATA, lcid LCID, pptinfo **ITypeInfo) HRESULT { + ret1 := syscall3(createDispTypeInfo, 3, + uintptr(unsafe.Pointer(pidata)), + uintptr(lcid), + uintptr(unsafe.Pointer(pptinfo))) + return HRESULT(ret1) +} + +func CreateErrorInfo(pperrinfo **ICreateErrorInfo) HRESULT { + ret1 := syscall3(createErrorInfo, 1, + uintptr(unsafe.Pointer(pperrinfo)), + 0, + 0) + return HRESULT(ret1) +} + +func CreateStdDispatch(punkOuter *IUnknown, pvThis uintptr, ptinfo *ITypeInfo, stddisp **IUnknown) HRESULT { + ret1 := syscall6(createStdDispatch, 4, + uintptr(unsafe.Pointer(punkOuter)), + pvThis, + uintptr(unsafe.Pointer(ptinfo)), + uintptr(unsafe.Pointer(stddisp)), + 0, + 0) + return HRESULT(ret1) +} + +func CreateTypeLib(syskind SYSKIND, szFile /*const*/ LPCOLESTR, ppctlib **ICreateTypeLib) HRESULT { + ret1 := syscall3(createTypeLib, 3, + uintptr(syskind), + uintptr(unsafe.Pointer(szFile)), + uintptr(unsafe.Pointer(ppctlib))) + return HRESULT(ret1) +} + +func CreateTypeLib2(syskind SYSKIND, szFile /*const*/ LPCOLESTR, ppctlib **ICreateTypeLib2) HRESULT { + ret1 := syscall3(createTypeLib2, 3, + uintptr(syskind), + uintptr(unsafe.Pointer(szFile)), + uintptr(unsafe.Pointer(ppctlib))) + return HRESULT(ret1) +} + +func DispCallFunc(pvInstance uintptr, oVft *uint32, cc CALLCONV, vtReturn VARTYPE, cActuals UINT, prgvt *VARTYPE, prgpvarg **VARIANTARG, pvargResult *VARIANT) HRESULT { + ret1 := syscall9(dispCallFunc, 8, + pvInstance, + uintptr(unsafe.Pointer(oVft)), + uintptr(cc), + uintptr(vtReturn), + uintptr(cActuals), + uintptr(unsafe.Pointer(prgvt)), + uintptr(unsafe.Pointer(prgpvarg)), + uintptr(unsafe.Pointer(pvargResult)), + 0) + return HRESULT(ret1) +} + +func DispGetIDsOfNames(ptinfo *ITypeInfo, rgszNames **OLECHAR, cNames UINT, rgdispid *DISPID) HRESULT { + ret1 := syscall6(dispGetIDsOfNames, 4, + uintptr(unsafe.Pointer(ptinfo)), + uintptr(unsafe.Pointer(rgszNames)), + uintptr(cNames), + uintptr(unsafe.Pointer(rgdispid)), + 0, + 0) + return HRESULT(ret1) +} + +func DispGetParam(pdispparams *DISPPARAMS, position UINT, vtTarg VARTYPE, pvarResult *VARIANT, puArgErr *UINT) HRESULT { + ret1 := syscall6(dispGetParam, 5, + uintptr(unsafe.Pointer(pdispparams)), + uintptr(position), + uintptr(vtTarg), + uintptr(unsafe.Pointer(pvarResult)), + uintptr(unsafe.Pointer(puArgErr)), + 0) + return HRESULT(ret1) +} + +func DispInvoke(_this uintptr, ptinfo *ITypeInfo, dispidMember DISPID, wFlags USHORT, pparams *DISPPARAMS, pvarResult *VARIANT, pexcepinfo *EXCEPINFO, puArgErr *UINT) HRESULT { + ret1 := syscall9(dispInvoke, 8, + _this, + uintptr(unsafe.Pointer(ptinfo)), + uintptr(dispidMember), + uintptr(wFlags), + uintptr(unsafe.Pointer(pparams)), + uintptr(unsafe.Pointer(pvarResult)), + uintptr(unsafe.Pointer(pexcepinfo)), + uintptr(unsafe.Pointer(puArgErr)), + 0) + return HRESULT(ret1) +} + +func DosDateTimeToVariantTime(wDosDate USHORT, wDosTime USHORT, pDateOut *float64) INT { + ret1 := syscall3(dosDateTimeToVariantTime, 3, + uintptr(wDosDate), + uintptr(wDosTime), + uintptr(unsafe.Pointer(pDateOut))) + return INT(ret1) +} + +func GetErrorInfo(dwReserved ULONG, pperrinfo **IErrorInfo) HRESULT { + ret1 := syscall3(getErrorInfo, 2, + uintptr(dwReserved), + uintptr(unsafe.Pointer(pperrinfo)), + 0) + return HRESULT(ret1) +} + +func GetRecordInfoFromGuids(rGuidTypeLib REFGUID, uVerMajor ULONG, uVerMinor ULONG, lcid LCID, rGuidTypeInfo REFGUID, ppRecInfo **IRecordInfo) HRESULT { + ret1 := syscall6(getRecordInfoFromGuids, 6, + uintptr(unsafe.Pointer(rGuidTypeLib)), + uintptr(uVerMajor), + uintptr(uVerMinor), + uintptr(lcid), + uintptr(unsafe.Pointer(rGuidTypeInfo)), + uintptr(unsafe.Pointer(ppRecInfo))) + return HRESULT(ret1) +} + +func GetRecordInfoFromTypeInfo(pTI *ITypeInfo, ppRecInfo **IRecordInfo) HRESULT { + ret1 := syscall3(getRecordInfoFromTypeInfo, 2, + uintptr(unsafe.Pointer(pTI)), + uintptr(unsafe.Pointer(ppRecInfo)), + 0) + return HRESULT(ret1) +} + +func LHashValOfNameSysA(skind SYSKIND, lcid LCID, lpStr /*const*/ LPCSTR) ULONG { + ret1 := syscall3(lHashValOfNameSysA, 3, + uintptr(skind), + uintptr(lcid), + uintptr(unsafe.Pointer(lpStr))) + return ULONG(ret1) +} + +func LPSAFEARRAY_UserFree(pFlags *ULONG, ppsa *LPSAFEARRAY) { + syscall3(lPSAFEARRAY_UserFree, 2, + uintptr(unsafe.Pointer(pFlags)), + uintptr(unsafe.Pointer(ppsa)), + 0) +} + +func LPSAFEARRAY_UserSize(pFlags *ULONG, startingSize ULONG, ppsa *LPSAFEARRAY) ULONG { + ret1 := syscall3(lPSAFEARRAY_UserSize, 3, + uintptr(unsafe.Pointer(pFlags)), + uintptr(startingSize), + uintptr(unsafe.Pointer(ppsa))) + return ULONG(ret1) +} + +func LoadRegTypeLib(rguid REFGUID, wVerMajor WORD, wVerMinor WORD, lcid LCID, ppTLib **ITypeLib) HRESULT { + ret1 := syscall6(loadRegTypeLib, 5, + uintptr(unsafe.Pointer(rguid)), + uintptr(wVerMajor), + uintptr(wVerMinor), + uintptr(lcid), + uintptr(unsafe.Pointer(ppTLib)), + 0) + return HRESULT(ret1) +} + +func LoadTypeLib(szFile /*const*/ *OLECHAR, pptLib **ITypeLib) HRESULT { + ret1 := syscall3(loadTypeLib, 2, + uintptr(unsafe.Pointer(szFile)), + uintptr(unsafe.Pointer(pptLib)), + 0) + return HRESULT(ret1) +} + +func LoadTypeLibEx(szFile /*const*/ LPCOLESTR, regkind REGKIND, pptLib **ITypeLib) HRESULT { + ret1 := syscall3(loadTypeLibEx, 3, + uintptr(unsafe.Pointer(szFile)), + uintptr(regkind), + uintptr(unsafe.Pointer(pptLib))) + return HRESULT(ret1) +} + +func OaBuildVersion() ULONG { + ret1 := syscall3(oaBuildVersion, 0, + 0, + 0, + 0) + return ULONG(ret1) +} + +func OleCreateFontIndirect(lpFontDesc *FONTDESC, riid REFIID, ppvObj *LPVOID) HRESULT { + ret1 := syscall3(oleCreateFontIndirect, 3, + uintptr(unsafe.Pointer(lpFontDesc)), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(ppvObj))) + return HRESULT(ret1) +} + +func OleCreatePictureIndirect(lpPictDesc *PICTDESC, riid REFIID, own bool, ppvObj uintptr) HRESULT { + ret1 := syscall6(oleCreatePictureIndirect, 4, + uintptr(unsafe.Pointer(lpPictDesc)), + uintptr(unsafe.Pointer(riid)), + getUintptrFromBool(own), + ppvObj, + 0, + 0) + return HRESULT(ret1) +} + +func OleCreatePropertyFrame(hwndOwner HWND, x UINT, y UINT, lpszCaption /*const*/ LPCOLESTR, cObjects ULONG, ppUnk *LPUNKNOWN, cPages ULONG, pPageClsID *CLSID, lcid LCID, dwReserved DWORD, pvReserved LPVOID) HRESULT { + ret1 := syscall12(oleCreatePropertyFrame, 11, + uintptr(hwndOwner), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(lpszCaption)), + uintptr(cObjects), + uintptr(unsafe.Pointer(ppUnk)), + uintptr(cPages), + uintptr(unsafe.Pointer(pPageClsID)), + uintptr(lcid), + uintptr(dwReserved), + uintptr(unsafe.Pointer(pvReserved)), + 0) + return HRESULT(ret1) +} + +func OleCreatePropertyFrameIndirect(lpParams *OCPFIPARAMS) HRESULT { + ret1 := syscall3(oleCreatePropertyFrameIndirect, 1, + uintptr(unsafe.Pointer(lpParams)), + 0, + 0) + return HRESULT(ret1) +} + +func OleIconToCursor(hinstExe HINSTANCE, hIcon HICON) HCURSOR { + ret1 := syscall3(oleIconToCursor, 2, + uintptr(hinstExe), + uintptr(hIcon), + 0) + return HCURSOR(ret1) +} + +func OleLoadPicture(lpstream LPSTREAM, lSize LONG, fRunmode bool, riid REFIID, ppvObj *LPVOID) HRESULT { + ret1 := syscall6(oleLoadPicture, 5, + uintptr(unsafe.Pointer(lpstream)), + uintptr(lSize), + getUintptrFromBool(fRunmode), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(ppvObj)), + 0) + return HRESULT(ret1) +} + +func OleLoadPictureEx(lpstream LPSTREAM, lSize LONG, fRunmode bool, riid REFIID, xsiz DWORD, ysiz DWORD, flags DWORD, ppvObj *LPVOID) HRESULT { + ret1 := syscall9(oleLoadPictureEx, 8, + uintptr(unsafe.Pointer(lpstream)), + uintptr(lSize), + getUintptrFromBool(fRunmode), + uintptr(unsafe.Pointer(riid)), + uintptr(xsiz), + uintptr(ysiz), + uintptr(flags), + uintptr(unsafe.Pointer(ppvObj)), + 0) + return HRESULT(ret1) +} + +func OleLoadPictureFile(file VARIANT, picture *LPDISPATCH) HRESULT { + args := unpackVARIANT(file) + args = append(args, uintptr(unsafe.Pointer(picture))) + ret := syscallN(oleLoadPictureFile, args) + return HRESULT(ret) +} + +func OleLoadPicturePath(szURLorPath LPOLESTR, punkCaller LPUNKNOWN, dwReserved DWORD, clrReserved OLE_COLOR, riid REFIID, ppvRet *LPVOID) HRESULT { + ret1 := syscall6(oleLoadPicturePath, 6, + uintptr(unsafe.Pointer(szURLorPath)), + uintptr(unsafe.Pointer(punkCaller)), + uintptr(dwReserved), + uintptr(clrReserved), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(ppvRet))) + return HRESULT(ret1) +} + +func OleSavePictureFile(picture *IDispatch, filename BSTR) HRESULT { + ret1 := syscall3(oleSavePictureFile, 2, + uintptr(unsafe.Pointer(picture)), + uintptr(unsafe.Pointer(filename)), + 0) + return HRESULT(ret1) +} + +func OleTranslateColor(clr OLE_COLOR, hpal HPALETTE, pColorRef *COLORREF) HRESULT { + ret1 := syscall3(oleTranslateColor, 3, + uintptr(clr), + uintptr(hpal), + uintptr(unsafe.Pointer(pColorRef))) + return HRESULT(ret1) +} + +func QueryPathOfRegTypeLib(guid REFGUID, wMaj WORD, wMin WORD, lcid LCID, path *BSTR) HRESULT { + ret1 := syscall6(queryPathOfRegTypeLib, 5, + uintptr(unsafe.Pointer(guid)), + uintptr(wMaj), + uintptr(wMin), + uintptr(lcid), + uintptr(unsafe.Pointer(path)), + 0) + return HRESULT(ret1) +} + +func RegisterTypeLib(ptlib *ITypeLib, szFullPath *OLECHAR, szHelpDir *OLECHAR) HRESULT { + ret1 := syscall3(registerTypeLib, 3, + uintptr(unsafe.Pointer(ptlib)), + uintptr(unsafe.Pointer(szFullPath)), + uintptr(unsafe.Pointer(szHelpDir))) + return HRESULT(ret1) +} + +func RegisterTypeLibForUser(ptlib *ITypeLib, szFullPath *OLECHAR, szHelpDir *OLECHAR) HRESULT { + ret1 := syscall3(registerTypeLibForUser, 3, + uintptr(unsafe.Pointer(ptlib)), + uintptr(unsafe.Pointer(szFullPath)), + uintptr(unsafe.Pointer(szHelpDir))) + return HRESULT(ret1) +} + +func SafeArrayAccessData(psa *SAFEARRAY, ppvData uintptr) HRESULT { + ret1 := syscall3(safeArrayAccessData, 2, + uintptr(unsafe.Pointer(psa)), + ppvData, + 0) + return HRESULT(ret1) +} + +func SafeArrayAllocData(psa *SAFEARRAY) HRESULT { + ret1 := syscall3(safeArrayAllocData, 1, + uintptr(unsafe.Pointer(psa)), + 0, + 0) + return HRESULT(ret1) +} + +func SafeArrayAllocDescriptor(cDims UINT, ppsaOut **SAFEARRAY) HRESULT { + ret1 := syscall3(safeArrayAllocDescriptor, 2, + uintptr(cDims), + uintptr(unsafe.Pointer(ppsaOut)), + 0) + return HRESULT(ret1) +} + +func SafeArrayAllocDescriptorEx(vt VARTYPE, cDims UINT, ppsaOut **SAFEARRAY) HRESULT { + ret1 := syscall3(safeArrayAllocDescriptorEx, 3, + uintptr(vt), + uintptr(cDims), + uintptr(unsafe.Pointer(ppsaOut))) + return HRESULT(ret1) +} + +func SafeArrayCopy(psa *SAFEARRAY, ppsaOut **SAFEARRAY) HRESULT { + ret1 := syscall3(safeArrayCopy, 2, + uintptr(unsafe.Pointer(psa)), + uintptr(unsafe.Pointer(ppsaOut)), + 0) + return HRESULT(ret1) +} + +func SafeArrayCopyData(psaSource *SAFEARRAY, psaTarget *SAFEARRAY) HRESULT { + ret1 := syscall3(safeArrayCopyData, 2, + uintptr(unsafe.Pointer(psaSource)), + uintptr(unsafe.Pointer(psaTarget)), + 0) + return HRESULT(ret1) +} + +func SafeArrayDestroy(psa *SAFEARRAY) HRESULT { + ret1 := syscall3(safeArrayDestroy, 1, + uintptr(unsafe.Pointer(psa)), + 0, + 0) + return HRESULT(ret1) +} + +func SafeArrayDestroyData(psa *SAFEARRAY) HRESULT { + ret1 := syscall3(safeArrayDestroyData, 1, + uintptr(unsafe.Pointer(psa)), + 0, + 0) + return HRESULT(ret1) +} + +func SafeArrayDestroyDescriptor(psa *SAFEARRAY) HRESULT { + ret1 := syscall3(safeArrayDestroyDescriptor, 1, + uintptr(unsafe.Pointer(psa)), + 0, + 0) + return HRESULT(ret1) +} + +func SafeArrayGetDim(psa *SAFEARRAY) UINT { + ret1 := syscall3(safeArrayGetDim, 1, + uintptr(unsafe.Pointer(psa)), + 0, + 0) + return UINT(ret1) +} + +func SafeArrayGetElement(psa *SAFEARRAY, rgIndices *LONG, pvData uintptr) HRESULT { + ret1 := syscall3(safeArrayGetElement, 3, + uintptr(unsafe.Pointer(psa)), + uintptr(unsafe.Pointer(rgIndices)), + pvData) + return HRESULT(ret1) +} + +func SafeArrayGetElemsize(psa *SAFEARRAY) UINT { + ret1 := syscall3(safeArrayGetElemsize, 1, + uintptr(unsafe.Pointer(psa)), + 0, + 0) + return UINT(ret1) +} + +func SafeArrayGetIID(psa *SAFEARRAY, pGuid *GUID) HRESULT { + ret1 := syscall3(safeArrayGetIID, 2, + uintptr(unsafe.Pointer(psa)), + uintptr(unsafe.Pointer(pGuid)), + 0) + return HRESULT(ret1) +} + +func SafeArrayGetLBound(psa *SAFEARRAY, nDim UINT, plLbound *LONG) HRESULT { + ret1 := syscall3(safeArrayGetLBound, 3, + uintptr(unsafe.Pointer(psa)), + uintptr(nDim), + uintptr(unsafe.Pointer(plLbound))) + return HRESULT(ret1) +} + +func SafeArrayGetRecordInfo(psa *SAFEARRAY, pRinfo **IRecordInfo) HRESULT { + ret1 := syscall3(safeArrayGetRecordInfo, 2, + uintptr(unsafe.Pointer(psa)), + uintptr(unsafe.Pointer(pRinfo)), + 0) + return HRESULT(ret1) +} + +func SafeArrayGetUBound(psa *SAFEARRAY, nDim UINT, plUbound *LONG) HRESULT { + ret1 := syscall3(safeArrayGetUBound, 3, + uintptr(unsafe.Pointer(psa)), + uintptr(nDim), + uintptr(unsafe.Pointer(plUbound))) + return HRESULT(ret1) +} + +func SafeArrayGetVartype(psa *SAFEARRAY, pvt *VARTYPE) HRESULT { + ret1 := syscall3(safeArrayGetVartype, 2, + uintptr(unsafe.Pointer(psa)), + uintptr(unsafe.Pointer(pvt)), + 0) + return HRESULT(ret1) +} + +func SafeArrayLock(psa *SAFEARRAY) HRESULT { + ret1 := syscall3(safeArrayLock, 1, + uintptr(unsafe.Pointer(psa)), + 0, + 0) + return HRESULT(ret1) +} + +func SafeArrayPtrOfIndex(psa *SAFEARRAY, rgIndices *LONG, ppvData uintptr) HRESULT { + ret1 := syscall3(safeArrayPtrOfIndex, 3, + uintptr(unsafe.Pointer(psa)), + uintptr(unsafe.Pointer(rgIndices)), + ppvData) + return HRESULT(ret1) +} + +func SafeArrayPutElement(psa *SAFEARRAY, rgIndices *LONG, pvData uintptr) HRESULT { + ret1 := syscall3(safeArrayPutElement, 3, + uintptr(unsafe.Pointer(psa)), + uintptr(unsafe.Pointer(rgIndices)), + pvData) + return HRESULT(ret1) +} + +func SafeArrayRedim(psa *SAFEARRAY, psabound *SAFEARRAYBOUND) HRESULT { + ret1 := syscall3(safeArrayRedim, 2, + uintptr(unsafe.Pointer(psa)), + uintptr(unsafe.Pointer(psabound)), + 0) + return HRESULT(ret1) +} + +func SafeArraySetIID(psa *SAFEARRAY, guid REFGUID) HRESULT { + ret1 := syscall3(safeArraySetIID, 2, + uintptr(unsafe.Pointer(psa)), + uintptr(unsafe.Pointer(guid)), + 0) + return HRESULT(ret1) +} + +func SafeArraySetRecordInfo(psa *SAFEARRAY, pRinfo *IRecordInfo) HRESULT { + ret1 := syscall3(safeArraySetRecordInfo, 2, + uintptr(unsafe.Pointer(psa)), + uintptr(unsafe.Pointer(pRinfo)), + 0) + return HRESULT(ret1) +} + +func SafeArrayUnaccessData(psa *SAFEARRAY) HRESULT { + ret1 := syscall3(safeArrayUnaccessData, 1, + uintptr(unsafe.Pointer(psa)), + 0, + 0) + return HRESULT(ret1) +} + +func SafeArrayUnlock(psa *SAFEARRAY) HRESULT { + ret1 := syscall3(safeArrayUnlock, 1, + uintptr(unsafe.Pointer(psa)), + 0, + 0) + return HRESULT(ret1) +} + +func SetErrorInfo(dwReserved ULONG, perrinfo *IErrorInfo) HRESULT { + ret1 := syscall3(setErrorInfo, 2, + uintptr(dwReserved), + uintptr(unsafe.Pointer(perrinfo)), + 0) + return HRESULT(ret1) +} + +func SetOaNoCache() { + syscall3(setOaNoCache, 0, + 0, + 0, + 0) +} + +func SysAllocString(str /*const*/ LPCOLESTR) BSTR { + ret1 := syscall3(sysAllocString, 1, + uintptr(unsafe.Pointer(str)), + 0, + 0) + return (BSTR)(unsafe.Pointer(ret1)) +} + +func SysAllocStringByteLen(str /*const*/ LPCSTR, aLen UINT) BSTR { + ret1 := syscall3(sysAllocStringByteLen, 2, + uintptr(unsafe.Pointer(str)), + uintptr(aLen), + 0) + return (BSTR)(unsafe.Pointer(ret1)) +} + +func SysAllocStringLen(str /*const*/ *OLECHAR, aLen uint32) BSTR { + ret1 := syscall3(sysAllocStringLen, 2, + uintptr(unsafe.Pointer(str)), + uintptr(aLen), + 0) + return (BSTR)(unsafe.Pointer(ret1)) +} + +func SysFreeString(str BSTR) { + syscall3(sysFreeString, 1, + uintptr(unsafe.Pointer(str)), + 0, + 0) +} + +func SysReAllocString(old *BSTR, str /*const*/ LPCOLESTR) INT { + ret1 := syscall3(sysReAllocString, 2, + uintptr(unsafe.Pointer(old)), + uintptr(unsafe.Pointer(str)), + 0) + return INT(ret1) +} + +func SysReAllocStringLen(old *BSTR, str /*const*/ *OLECHAR, aLen uint32) int32 { + ret1 := syscall3(sysReAllocStringLen, 3, + uintptr(unsafe.Pointer(old)), + uintptr(unsafe.Pointer(str)), + uintptr(aLen)) + return int32(ret1) +} + +func SysStringByteLen(str BSTR) UINT { + ret1 := syscall3(sysStringByteLen, 1, + uintptr(unsafe.Pointer(str)), + 0, + 0) + return UINT(ret1) +} + +func SysStringLen(str BSTR) UINT { + ret1 := syscall3(sysStringLen, 1, + uintptr(unsafe.Pointer(str)), + 0, + 0) + return UINT(ret1) +} + +func SystemTimeToVariantTime(lpSt *SYSTEMTIME, pDateOut *float64) INT { + ret1 := syscall3(systemTimeToVariantTime, 2, + uintptr(unsafe.Pointer(lpSt)), + uintptr(unsafe.Pointer(pDateOut)), + 0) + return INT(ret1) +} + +func UnRegisterTypeLib(libid REFGUID, wVerMajor WORD, wVerMinor WORD, lcid LCID, syskind SYSKIND) HRESULT { + ret1 := syscall6(unRegisterTypeLib, 5, + uintptr(unsafe.Pointer(libid)), + uintptr(wVerMajor), + uintptr(wVerMinor), + uintptr(lcid), + uintptr(syskind), + 0) + return HRESULT(ret1) +} + +func UnRegisterTypeLibForUser(libid REFGUID, wVerMajor WORD, wVerMinor WORD, lcid LCID, syskind SYSKIND) HRESULT { + ret1 := syscall6(unRegisterTypeLibForUser, 5, + uintptr(unsafe.Pointer(libid)), + uintptr(wVerMajor), + uintptr(wVerMinor), + uintptr(lcid), + uintptr(syskind), + 0) + return HRESULT(ret1) +} + +func VARIANT_UserFree(pFlags *ULONG, pvar *VARIANT) { + syscall3(vARIANT_UserFree, 2, + uintptr(unsafe.Pointer(pFlags)), + uintptr(unsafe.Pointer(pvar)), + 0) +} + +func VARIANT_UserSize(pFlags *ULONG, start ULONG, pvar *VARIANT) ULONG { + ret1 := syscall3(vARIANT_UserSize, 3, + uintptr(unsafe.Pointer(pFlags)), + uintptr(start), + uintptr(unsafe.Pointer(pvar))) + return ULONG(ret1) +} + +func VarAbs(pVarIn *VARIANT, pVarOut *VARIANT) HRESULT { + ret1 := syscall3(varAbs, 2, + uintptr(unsafe.Pointer(pVarIn)), + uintptr(unsafe.Pointer(pVarOut)), + 0) + return HRESULT(ret1) +} + +func VarAdd(left *VARIANT, right *VARIANT, result *VARIANT) HRESULT { + ret1 := syscall3(varAdd, 3, + uintptr(unsafe.Pointer(left)), + uintptr(unsafe.Pointer(right)), + uintptr(unsafe.Pointer(result))) + return HRESULT(ret1) +} + +func VarAnd(left *VARIANT, right *VARIANT, result *VARIANT) HRESULT { + ret1 := syscall3(varAnd, 3, + uintptr(unsafe.Pointer(left)), + uintptr(unsafe.Pointer(right)), + uintptr(unsafe.Pointer(result))) + return HRESULT(ret1) +} + +func VarBoolFromCy(cyIn CY, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromCy, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pBoolOut))) + return HRESULT(ret1) +} + +func VarBoolFromDate(dateIn DATE, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromDate, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(pBoolOut)), + 0) + return HRESULT(ret1) +} + +func VarBoolFromDec(pDecIn *DECIMAL, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromDec, 2, + uintptr(unsafe.Pointer(pDecIn)), + uintptr(unsafe.Pointer(pBoolOut)), + 0) + return HRESULT(ret1) +} + +func VarBoolFromDisp(pdispIn *IDispatch, lcid LCID, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(pBoolOut))) + return HRESULT(ret1) +} + +func VarBoolFromI1(cIn int8, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromI1, 2, + uintptr(cIn), + uintptr(unsafe.Pointer(pBoolOut)), + 0) + return HRESULT(ret1) +} + +func VarBoolFromI2(sIn SHORT, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromI2, 2, + uintptr(sIn), + uintptr(unsafe.Pointer(pBoolOut)), + 0) + return HRESULT(ret1) +} + +func VarBoolFromI4(lIn LONG, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromI4, 2, + uintptr(lIn), + uintptr(unsafe.Pointer(pBoolOut)), + 0) + return HRESULT(ret1) +} + +func VarBoolFromI8(llIn LONG64, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromI8, 2, + uintptr(llIn), + uintptr(unsafe.Pointer(pBoolOut)), + 0) + return HRESULT(ret1) +} + +func VarBoolFromR4(fltIn FLOAT, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromR4, 2, + uintptr(fltIn), + uintptr(unsafe.Pointer(pBoolOut)), + 0) + return HRESULT(ret1) +} + +func VarBoolFromR8(dblIn float64, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromR8, 2, + uintptr(dblIn), + uintptr(unsafe.Pointer(pBoolOut)), + 0) + return HRESULT(ret1) +} + +func VarBoolFromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall6(varBoolFromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pBoolOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBoolFromUI1(bIn BYTE, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromUI1, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(pBoolOut)), + 0) + return HRESULT(ret1) +} + +func VarBoolFromUI2(usIn USHORT, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromUI2, 2, + uintptr(usIn), + uintptr(unsafe.Pointer(pBoolOut)), + 0) + return HRESULT(ret1) +} + +func VarBoolFromUI4(ulIn ULONG, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromUI4, 2, + uintptr(ulIn), + uintptr(unsafe.Pointer(pBoolOut)), + 0) + return HRESULT(ret1) +} + +func VarBoolFromUI8(ullIn ULONG64, pBoolOut *VARIANT_BOOL) HRESULT { + ret1 := syscall3(varBoolFromUI8, 2, + uintptr(ullIn), + uintptr(unsafe.Pointer(pBoolOut)), + 0) + return HRESULT(ret1) +} + +func VarBstrCat(pbstrLeft BSTR, pbstrRight BSTR, pbstrOut *BSTR) HRESULT { + ret1 := syscall3(varBstrCat, 3, + uintptr(unsafe.Pointer(pbstrLeft)), + uintptr(unsafe.Pointer(pbstrRight)), + uintptr(unsafe.Pointer(pbstrOut))) + return HRESULT(ret1) +} + +func VarBstrCmp(pbstrLeft BSTR, pbstrRight BSTR, lcid LCID, dwFlags DWORD) HRESULT { + ret1 := syscall6(varBstrCmp, 4, + uintptr(unsafe.Pointer(pbstrLeft)), + uintptr(unsafe.Pointer(pbstrRight)), + uintptr(lcid), + uintptr(dwFlags), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromBool(boolIn VARIANT_BOOL, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromBool, 4, + uintptr(boolIn), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromCy(cyIn CY, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromCy, 5, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0) + return HRESULT(ret1) +} + +func VarBstrFromDate(dateIn DATE, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromDate, 4, + uintptr(dateIn), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromDec(pDecIn *DECIMAL, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromDec, 4, + uintptr(unsafe.Pointer(pDecIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromDisp(pdispIn *IDispatch, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromDisp, 4, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromI1(cIn int8, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromI1, 4, + uintptr(cIn), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromI2(sIn int16, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromI2, 4, + uintptr(sIn), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromI4(lIn LONG, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromI4, 4, + uintptr(lIn), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromI8(llIn LONG64, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromI8, 4, + uintptr(llIn), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromR4(fltIn FLOAT, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromR4, 4, + uintptr(fltIn), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromR8(dblIn float64, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromR8, 4, + uintptr(dblIn), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromUI1(bIn BYTE, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromUI1, 4, + uintptr(bIn), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromUI2(usIn USHORT, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromUI2, 4, + uintptr(usIn), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromUI4(ulIn ULONG, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromUI4, 4, + uintptr(ulIn), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarBstrFromUI8(ullIn ULONG64, lcid LCID, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varBstrFromUI8, 4, + uintptr(ullIn), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarCat(left *VARIANT, right *VARIANT, out *VARIANT) HRESULT { + ret1 := syscall3(varCat, 3, + uintptr(unsafe.Pointer(left)), + uintptr(unsafe.Pointer(right)), + uintptr(unsafe.Pointer(out))) + return HRESULT(ret1) +} + +func VarCmp(left *VARIANT, right *VARIANT, lcid LCID, flags DWORD) HRESULT { + ret1 := syscall6(varCmp, 4, + uintptr(unsafe.Pointer(left)), + uintptr(unsafe.Pointer(right)), + uintptr(lcid), + uintptr(flags), + 0, + 0) + return HRESULT(ret1) +} + +func VarCyAbs(cyIn /*const*/ CY, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyAbs, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pCyOut))) + return HRESULT(ret1) +} + +func VarCyAdd(cyLeft /*const*/ CY, cyRight /*const*/ CY, pCyOut *CY) HRESULT { + ret1 := syscall6(varCyAdd, 5, + uintptr(*(*uint32)(unsafe.Pointer(&cyLeft))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyLeft)) + uintptr(4)))), + uintptr(*(*uint32)(unsafe.Pointer(&cyRight))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyRight)) + uintptr(4)))), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyCmp(cyLeft /*const*/ CY, cyRight /*const*/ CY) HRESULT { + ret1 := syscall6(varCyCmp, 4, + uintptr(*(*uint32)(unsafe.Pointer(&cyLeft))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyLeft)) + uintptr(4)))), + uintptr(*(*uint32)(unsafe.Pointer(&cyRight))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyRight)) + uintptr(4)))), + 0, + 0) + return HRESULT(ret1) +} + +func VarCyCmpR8(cyLeft /*const*/ CY, dblRight float64) HRESULT { + ret1 := syscall3(varCyCmpR8, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyLeft))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyLeft)) + uintptr(4)))), + uintptr(dblRight)) + return HRESULT(ret1) +} + +func VarCyFix(cyIn /*const*/ CY, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFix, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pCyOut))) + return HRESULT(ret1) +} + +func VarCyFromBool(boolIn VARIANT_BOOL, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromBool, 2, + uintptr(boolIn), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyFromDate(dateIn DATE, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromDate, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyFromDec(pdecIn *DECIMAL, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromDec, 2, + uintptr(unsafe.Pointer(pdecIn)), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyFromDisp(pdispIn *IDispatch, lcid LCID, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(pCyOut))) + return HRESULT(ret1) +} + +func VarCyFromI1(cIn int8, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromI1, 2, + uintptr(cIn), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyFromI2(sIn SHORT, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromI2, 2, + uintptr(sIn), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyFromI4(lIn LONG, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromI4, 2, + uintptr(lIn), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyFromI8(llIn LONG64, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromI8, 2, + uintptr(llIn), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyFromR4(fltIn FLOAT, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromR4, 2, + uintptr(fltIn), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyFromR8(dblIn float64, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromR8, 2, + uintptr(dblIn), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyFromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, pCyOut *CY) HRESULT { + ret1 := syscall6(varCyFromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pCyOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarCyFromUI1(bIn BYTE, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromUI1, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyFromUI2(usIn USHORT, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromUI2, 2, + uintptr(usIn), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyFromUI4(ulIn ULONG, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromUI4, 2, + uintptr(ulIn), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyFromUI8(ullIn ULONG64, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyFromUI8, 2, + uintptr(ullIn), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyInt(cyIn /*const*/ CY, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyInt, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pCyOut))) + return HRESULT(ret1) +} + +func VarCyMul(cyLeft /*const*/ CY, cyRight /*const*/ CY, pCyOut *CY) HRESULT { + ret1 := syscall6(varCyMul, 5, + uintptr(*(*uint32)(unsafe.Pointer(&cyLeft))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyLeft)) + uintptr(4)))), + uintptr(*(*uint32)(unsafe.Pointer(&cyRight))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyRight)) + uintptr(4)))), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarCyMulI4(cyLeft /*const*/ CY, lRight LONG, pCyOut *CY) HRESULT { + ret1 := syscall6(varCyMulI4, 4, + uintptr(*(*uint32)(unsafe.Pointer(&cyLeft))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyLeft)) + uintptr(4)))), + uintptr(lRight), + uintptr(unsafe.Pointer(pCyOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarCyMulI8(cyLeft /*const*/ CY, llRight LONG64, pCyOut *CY) HRESULT { + ret1 := syscall6(varCyMulI8, 4, + uintptr(*(*uint32)(unsafe.Pointer(&cyLeft))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyLeft)) + uintptr(4)))), + uintptr(llRight), + uintptr(unsafe.Pointer(pCyOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarCyNeg(cyIn /*const*/ CY, pCyOut *CY) HRESULT { + ret1 := syscall3(varCyNeg, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pCyOut))) + return HRESULT(ret1) +} + +func VarCyRound(cyIn /*const*/ CY, cDecimals int32, pCyOut *CY) HRESULT { + ret1 := syscall6(varCyRound, 4, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(cDecimals), + uintptr(unsafe.Pointer(pCyOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarCySub(cyLeft /*const*/ CY, cyRight /*const*/ CY, pCyOut *CY) HRESULT { + ret1 := syscall6(varCySub, 5, + uintptr(*(*uint32)(unsafe.Pointer(&cyLeft))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyLeft)) + uintptr(4)))), + uintptr(*(*uint32)(unsafe.Pointer(&cyRight))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyRight)) + uintptr(4)))), + uintptr(unsafe.Pointer(pCyOut)), + 0) + return HRESULT(ret1) +} + +func VarDateFromBool(boolIn VARIANT_BOOL, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromBool, 2, + uintptr(boolIn), + uintptr(unsafe.Pointer(pdateOut)), + 0) + return HRESULT(ret1) +} + +func VarDateFromCy(cyIn CY, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromCy, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pdateOut))) + return HRESULT(ret1) +} + +func VarDateFromDec(pdecIn *DECIMAL, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromDec, 2, + uintptr(unsafe.Pointer(pdecIn)), + uintptr(unsafe.Pointer(pdateOut)), + 0) + return HRESULT(ret1) +} + +func VarDateFromDisp(pdispIn *IDispatch, lcid LCID, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(pdateOut))) + return HRESULT(ret1) +} + +func VarDateFromI1(cIn int8, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromI1, 2, + uintptr(cIn), + uintptr(unsafe.Pointer(pdateOut)), + 0) + return HRESULT(ret1) +} + +func VarDateFromI2(sIn int16, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromI2, 2, + uintptr(sIn), + uintptr(unsafe.Pointer(pdateOut)), + 0) + return HRESULT(ret1) +} + +func VarDateFromI4(lIn LONG, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromI4, 2, + uintptr(lIn), + uintptr(unsafe.Pointer(pdateOut)), + 0) + return HRESULT(ret1) +} + +func VarDateFromI8(llIn LONG64, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromI8, 2, + uintptr(llIn), + uintptr(unsafe.Pointer(pdateOut)), + 0) + return HRESULT(ret1) +} + +func VarDateFromR4(fltIn FLOAT, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromR4, 2, + uintptr(fltIn), + uintptr(unsafe.Pointer(pdateOut)), + 0) + return HRESULT(ret1) +} + +func VarDateFromR8(dblIn float64, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromR8, 2, + uintptr(dblIn), + uintptr(unsafe.Pointer(pdateOut)), + 0) + return HRESULT(ret1) +} + +func VarDateFromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, pdateOut *DATE) HRESULT { + ret1 := syscall6(varDateFromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pdateOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarDateFromUI1(bIn BYTE, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromUI1, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(pdateOut)), + 0) + return HRESULT(ret1) +} + +func VarDateFromUI2(uiIn USHORT, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromUI2, 2, + uintptr(uiIn), + uintptr(unsafe.Pointer(pdateOut)), + 0) + return HRESULT(ret1) +} + +func VarDateFromUI4(ulIn ULONG, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromUI4, 2, + uintptr(ulIn), + uintptr(unsafe.Pointer(pdateOut)), + 0) + return HRESULT(ret1) +} + +func VarDateFromUI8(ullIn ULONG64, pdateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromUI8, 2, + uintptr(ullIn), + uintptr(unsafe.Pointer(pdateOut)), + 0) + return HRESULT(ret1) +} + +func VarDateFromUdate(pUdateIn *UDATE, dwFlags ULONG, pDateOut *DATE) HRESULT { + ret1 := syscall3(varDateFromUdate, 3, + uintptr(unsafe.Pointer(pUdateIn)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pDateOut))) + return HRESULT(ret1) +} + +func VarDateFromUdateEx(pUdateIn *UDATE, lcid LCID, dwFlags ULONG, pDateOut *DATE) HRESULT { + ret1 := syscall6(varDateFromUdateEx, 4, + uintptr(unsafe.Pointer(pUdateIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pDateOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarDecAbs(pDecIn /*const*/ *DECIMAL, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecAbs, 2, + uintptr(unsafe.Pointer(pDecIn)), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecAdd(pDecLeft /*const*/ *DECIMAL, pDecRight /*const*/ *DECIMAL, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecAdd, 3, + uintptr(unsafe.Pointer(pDecLeft)), + uintptr(unsafe.Pointer(pDecRight)), + uintptr(unsafe.Pointer(pDecOut))) + return HRESULT(ret1) +} + +func VarDecCmp(pDecLeft /*const*/ *DECIMAL, pDecRight /*const*/ *DECIMAL) HRESULT { + ret1 := syscall3(varDecCmp, 2, + uintptr(unsafe.Pointer(pDecLeft)), + uintptr(unsafe.Pointer(pDecRight)), + 0) + return HRESULT(ret1) +} + +func VarDecCmpR8(pDecLeft /*const*/ *DECIMAL, dblRight float64) HRESULT { + ret1 := syscall3(varDecCmpR8, 2, + uintptr(unsafe.Pointer(pDecLeft)), + uintptr(dblRight), + 0) + return HRESULT(ret1) +} + +func VarDecDiv(pDecLeft /*const*/ *DECIMAL, pDecRight /*const*/ *DECIMAL, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecDiv, 3, + uintptr(unsafe.Pointer(pDecLeft)), + uintptr(unsafe.Pointer(pDecRight)), + uintptr(unsafe.Pointer(pDecOut))) + return HRESULT(ret1) +} + +func VarDecFix(pDecIn /*const*/ *DECIMAL, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFix, 2, + uintptr(unsafe.Pointer(pDecIn)), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecFromBool(bIn VARIANT_BOOL, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromBool, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecFromCy(cyIn CY, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromCy, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pDecOut))) + return HRESULT(ret1) +} + +func VarDecFromDate(dateIn DATE, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromDate, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecFromDisp(pdispIn *IDispatch, lcid LCID, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(pDecOut))) + return HRESULT(ret1) +} + +func VarDecFromI1(cIn int8, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromI1, 2, + uintptr(cIn), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecFromI2(sIn SHORT, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromI2, 2, + uintptr(sIn), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecFromI4(lIn LONG, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromI4, 2, + uintptr(lIn), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecFromI8(llIn LONG64, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromI8, 2, + uintptr(llIn), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecFromR4(fltIn FLOAT, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromR4, 2, + uintptr(fltIn), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecFromR8(dblIn float64, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromR8, 2, + uintptr(dblIn), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecFromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, pDecOut *DECIMAL) HRESULT { + ret1 := syscall6(varDecFromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pDecOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarDecFromUI1(bIn BYTE, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromUI1, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecFromUI2(usIn USHORT, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromUI2, 2, + uintptr(usIn), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecFromUI4(ulIn ULONG, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromUI4, 2, + uintptr(ulIn), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecFromUI8(ullIn ULONG64, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecFromUI8, 2, + uintptr(ullIn), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecInt(pDecIn /*const*/ *DECIMAL, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecInt, 2, + uintptr(unsafe.Pointer(pDecIn)), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecMul(pDecLeft /*const*/ *DECIMAL, pDecRight /*const*/ *DECIMAL, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecMul, 3, + uintptr(unsafe.Pointer(pDecLeft)), + uintptr(unsafe.Pointer(pDecRight)), + uintptr(unsafe.Pointer(pDecOut))) + return HRESULT(ret1) +} + +func VarDecNeg(pDecIn /*const*/ *DECIMAL, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecNeg, 2, + uintptr(unsafe.Pointer(pDecIn)), + uintptr(unsafe.Pointer(pDecOut)), + 0) + return HRESULT(ret1) +} + +func VarDecRound(pDecIn /*const*/ *DECIMAL, cDecimals int32, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecRound, 3, + uintptr(unsafe.Pointer(pDecIn)), + uintptr(cDecimals), + uintptr(unsafe.Pointer(pDecOut))) + return HRESULT(ret1) +} + +func VarDecSub(pDecLeft /*const*/ *DECIMAL, pDecRight /*const*/ *DECIMAL, pDecOut *DECIMAL) HRESULT { + ret1 := syscall3(varDecSub, 3, + uintptr(unsafe.Pointer(pDecLeft)), + uintptr(unsafe.Pointer(pDecRight)), + uintptr(unsafe.Pointer(pDecOut))) + return HRESULT(ret1) +} + +func VarDiv(left *VARIANT, right *VARIANT, result *VARIANT) HRESULT { + ret1 := syscall3(varDiv, 3, + uintptr(unsafe.Pointer(left)), + uintptr(unsafe.Pointer(right)), + uintptr(unsafe.Pointer(result))) + return HRESULT(ret1) +} + +func VarEqv(pVarLeft *VARIANT, pVarRight *VARIANT, pVarOut *VARIANT) HRESULT { + ret1 := syscall3(varEqv, 3, + uintptr(unsafe.Pointer(pVarLeft)), + uintptr(unsafe.Pointer(pVarRight)), + uintptr(unsafe.Pointer(pVarOut))) + return HRESULT(ret1) +} + +func VarFix(pVarIn *VARIANT, pVarOut *VARIANT) HRESULT { + ret1 := syscall3(varFix, 2, + uintptr(unsafe.Pointer(pVarIn)), + uintptr(unsafe.Pointer(pVarOut)), + 0) + return HRESULT(ret1) +} + +func VarFormat(pVarIn *VARIANT, lpszFormat LPOLESTR, nFirstDay int32, nFirstWeek int32, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varFormat, 6, + uintptr(unsafe.Pointer(pVarIn)), + uintptr(unsafe.Pointer(lpszFormat)), + uintptr(nFirstDay), + uintptr(nFirstWeek), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut))) + return HRESULT(ret1) +} + +func VarFormatCurrency(pVarIn *VARIANT, nDigits INT, nLeading INT, nParens INT, nGrouping INT, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall9(varFormatCurrency, 7, + uintptr(unsafe.Pointer(pVarIn)), + uintptr(nDigits), + uintptr(nLeading), + uintptr(nParens), + uintptr(nGrouping), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarFormatDateTime(pVarIn *VARIANT, nFormat INT, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varFormatDateTime, 4, + uintptr(unsafe.Pointer(pVarIn)), + uintptr(nFormat), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarFormatFromTokens(pVarIn *VARIANT, lpszFormat LPOLESTR, rgbTok *byte, dwFlags ULONG, pbstrOut *BSTR, lcid LCID) HRESULT { + ret1 := syscall6(varFormatFromTokens, 6, + uintptr(unsafe.Pointer(pVarIn)), + uintptr(unsafe.Pointer(lpszFormat)), + uintptr(unsafe.Pointer(rgbTok)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + uintptr(lcid)) + return HRESULT(ret1) +} + +func VarFormatNumber(pVarIn *VARIANT, nDigits INT, nLeading INT, nParens INT, nGrouping INT, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall9(varFormatNumber, 7, + uintptr(unsafe.Pointer(pVarIn)), + uintptr(nDigits), + uintptr(nLeading), + uintptr(nParens), + uintptr(nGrouping), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarFormatPercent(pVarIn *VARIANT, nDigits INT, nLeading INT, nParens INT, nGrouping INT, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall9(varFormatPercent, 7, + uintptr(unsafe.Pointer(pVarIn)), + uintptr(nDigits), + uintptr(nLeading), + uintptr(nParens), + uintptr(nGrouping), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarI1FromBool(boolIn VARIANT_BOOL, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromBool, 2, + uintptr(boolIn), + uintptr(unsafe.Pointer(pcOut)), + 0) + return HRESULT(ret1) +} + +func VarI1FromCy(cyIn CY, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromCy, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pcOut))) + return HRESULT(ret1) +} + +func VarI1FromDate(dateIn DATE, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromDate, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(pcOut)), + 0) + return HRESULT(ret1) +} + +func VarI1FromDec(pdecIn *DECIMAL, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromDec, 2, + uintptr(unsafe.Pointer(pdecIn)), + uintptr(unsafe.Pointer(pcOut)), + 0) + return HRESULT(ret1) +} + +func VarI1FromDisp(pdispIn *IDispatch, lcid LCID, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(pcOut))) + return HRESULT(ret1) +} + +func VarI1FromI2(sIn SHORT, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromI2, 2, + uintptr(sIn), + uintptr(unsafe.Pointer(pcOut)), + 0) + return HRESULT(ret1) +} + +func VarI1FromI4(iIn LONG, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromI4, 2, + uintptr(iIn), + uintptr(unsafe.Pointer(pcOut)), + 0) + return HRESULT(ret1) +} + +func VarI1FromI8(llIn LONG64, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromI8, 2, + uintptr(llIn), + uintptr(unsafe.Pointer(pcOut)), + 0) + return HRESULT(ret1) +} + +func VarI1FromR4(fltIn FLOAT, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromR4, 2, + uintptr(fltIn), + uintptr(unsafe.Pointer(pcOut)), + 0) + return HRESULT(ret1) +} + +func VarI1FromR8(dblIn float64, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromR8, 2, + uintptr(dblIn), + uintptr(unsafe.Pointer(pcOut)), + 0) + return HRESULT(ret1) +} + +func VarI1FromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, pcOut *int8) HRESULT { + ret1 := syscall6(varI1FromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pcOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarI1FromUI1(bIn BYTE, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromUI1, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(pcOut)), + 0) + return HRESULT(ret1) +} + +func VarI1FromUI2(usIn USHORT, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromUI2, 2, + uintptr(usIn), + uintptr(unsafe.Pointer(pcOut)), + 0) + return HRESULT(ret1) +} + +func VarI1FromUI4(ulIn ULONG, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromUI4, 2, + uintptr(ulIn), + uintptr(unsafe.Pointer(pcOut)), + 0) + return HRESULT(ret1) +} + +func VarI1FromUI8(ullIn ULONG64, pcOut *int8) HRESULT { + ret1 := syscall3(varI1FromUI8, 2, + uintptr(ullIn), + uintptr(unsafe.Pointer(pcOut)), + 0) + return HRESULT(ret1) +} + +func VarI2FromBool(boolIn VARIANT_BOOL, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromBool, 2, + uintptr(boolIn), + uintptr(unsafe.Pointer(psOut)), + 0) + return HRESULT(ret1) +} + +func VarI2FromCy(cyIn CY, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromCy, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(psOut))) + return HRESULT(ret1) +} + +func VarI2FromDate(dateIn DATE, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromDate, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(psOut)), + 0) + return HRESULT(ret1) +} + +func VarI2FromDec(pdecIn *DECIMAL, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromDec, 2, + uintptr(unsafe.Pointer(pdecIn)), + uintptr(unsafe.Pointer(psOut)), + 0) + return HRESULT(ret1) +} + +func VarI2FromDisp(pdispIn *IDispatch, lcid LCID, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(psOut))) + return HRESULT(ret1) +} + +func VarI2FromI1(cIn int8, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromI1, 2, + uintptr(cIn), + uintptr(unsafe.Pointer(psOut)), + 0) + return HRESULT(ret1) +} + +func VarI2FromI4(iIn LONG, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromI4, 2, + uintptr(iIn), + uintptr(unsafe.Pointer(psOut)), + 0) + return HRESULT(ret1) +} + +func VarI2FromI8(llIn LONG64, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromI8, 2, + uintptr(llIn), + uintptr(unsafe.Pointer(psOut)), + 0) + return HRESULT(ret1) +} + +func VarI2FromR4(fltIn FLOAT, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromR4, 2, + uintptr(fltIn), + uintptr(unsafe.Pointer(psOut)), + 0) + return HRESULT(ret1) +} + +func VarI2FromR8(dblIn float64, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromR8, 2, + uintptr(dblIn), + uintptr(unsafe.Pointer(psOut)), + 0) + return HRESULT(ret1) +} + +func VarI2FromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, psOut *SHORT) HRESULT { + ret1 := syscall6(varI2FromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(psOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarI2FromUI1(bIn BYTE, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromUI1, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(psOut)), + 0) + return HRESULT(ret1) +} + +func VarI2FromUI2(usIn USHORT, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromUI2, 2, + uintptr(usIn), + uintptr(unsafe.Pointer(psOut)), + 0) + return HRESULT(ret1) +} + +func VarI2FromUI4(ulIn ULONG, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromUI4, 2, + uintptr(ulIn), + uintptr(unsafe.Pointer(psOut)), + 0) + return HRESULT(ret1) +} + +func VarI2FromUI8(ullIn ULONG64, psOut *SHORT) HRESULT { + ret1 := syscall3(varI2FromUI8, 2, + uintptr(ullIn), + uintptr(unsafe.Pointer(psOut)), + 0) + return HRESULT(ret1) +} + +func VarI4FromBool(boolIn VARIANT_BOOL, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromBool, 2, + uintptr(boolIn), + uintptr(unsafe.Pointer(piOut)), + 0) + return HRESULT(ret1) +} + +func VarI4FromCy(cyIn CY, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromCy, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(piOut))) + return HRESULT(ret1) +} + +func VarI4FromDate(dateIn DATE, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromDate, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(piOut)), + 0) + return HRESULT(ret1) +} + +func VarI4FromDec(pdecIn *DECIMAL, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromDec, 2, + uintptr(unsafe.Pointer(pdecIn)), + uintptr(unsafe.Pointer(piOut)), + 0) + return HRESULT(ret1) +} + +func VarI4FromDisp(pdispIn *IDispatch, lcid LCID, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(piOut))) + return HRESULT(ret1) +} + +func VarI4FromI1(cIn int8, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromI1, 2, + uintptr(cIn), + uintptr(unsafe.Pointer(piOut)), + 0) + return HRESULT(ret1) +} + +func VarI4FromI2(sIn SHORT, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromI2, 2, + uintptr(sIn), + uintptr(unsafe.Pointer(piOut)), + 0) + return HRESULT(ret1) +} + +func VarI4FromI8(llIn LONG64, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromI8, 2, + uintptr(llIn), + uintptr(unsafe.Pointer(piOut)), + 0) + return HRESULT(ret1) +} + +func VarI4FromR4(fltIn FLOAT, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromR4, 2, + uintptr(fltIn), + uintptr(unsafe.Pointer(piOut)), + 0) + return HRESULT(ret1) +} + +func VarI4FromR8(dblIn float64, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromR8, 2, + uintptr(dblIn), + uintptr(unsafe.Pointer(piOut)), + 0) + return HRESULT(ret1) +} + +func VarI4FromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, piOut *LONG) HRESULT { + ret1 := syscall6(varI4FromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(piOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarI4FromUI1(bIn BYTE, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromUI1, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(piOut)), + 0) + return HRESULT(ret1) +} + +func VarI4FromUI2(usIn USHORT, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromUI2, 2, + uintptr(usIn), + uintptr(unsafe.Pointer(piOut)), + 0) + return HRESULT(ret1) +} + +func VarI4FromUI4(ulIn ULONG, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromUI4, 2, + uintptr(ulIn), + uintptr(unsafe.Pointer(piOut)), + 0) + return HRESULT(ret1) +} + +func VarI4FromUI8(ullIn ULONG64, piOut *LONG) HRESULT { + ret1 := syscall3(varI4FromUI8, 2, + uintptr(ullIn), + uintptr(unsafe.Pointer(piOut)), + 0) + return HRESULT(ret1) +} + +func VarI8FromBool(boolIn VARIANT_BOOL, pi64Out *LONG64) HRESULT { + ret1 := syscall3(varI8FromBool, 2, + uintptr(boolIn), + uintptr(unsafe.Pointer(pi64Out)), + 0) + return HRESULT(ret1) +} + +func VarI8FromCy(cyIn CY, pi64Out *LONG64) HRESULT { + ret1 := syscall3(varI8FromCy, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pi64Out))) + return HRESULT(ret1) +} + +func VarI8FromDate(dateIn DATE, pi64Out *LONG64) HRESULT { + ret1 := syscall3(varI8FromDate, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(pi64Out)), + 0) + return HRESULT(ret1) +} + +func VarI8FromDec(pdecIn *DECIMAL, pi64Out *LONG64) HRESULT { + ret1 := syscall3(varI8FromDec, 2, + uintptr(unsafe.Pointer(pdecIn)), + uintptr(unsafe.Pointer(pi64Out)), + 0) + return HRESULT(ret1) +} + +func VarI8FromDisp(pdispIn *IDispatch, lcid LCID, pi64Out *LONG64) HRESULT { + ret1 := syscall3(varI8FromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(pi64Out))) + return HRESULT(ret1) +} + +func VarI8FromI1(cIn int8, pi64Out *LONG64) HRESULT { + ret1 := syscall3(varI8FromI1, 2, + uintptr(cIn), + uintptr(unsafe.Pointer(pi64Out)), + 0) + return HRESULT(ret1) +} + +func VarI8FromI2(sIn SHORT, pi64Out *LONG64) HRESULT { + ret1 := syscall3(varI8FromI2, 2, + uintptr(sIn), + uintptr(unsafe.Pointer(pi64Out)), + 0) + return HRESULT(ret1) +} + +func VarI8FromR4(fltIn FLOAT, pi64Out *LONG64) HRESULT { + ret1 := syscall3(varI8FromR4, 2, + uintptr(fltIn), + uintptr(unsafe.Pointer(pi64Out)), + 0) + return HRESULT(ret1) +} + +func VarI8FromR8(dblIn float64, pi64Out *LONG64) HRESULT { + ret1 := syscall3(varI8FromR8, 2, + uintptr(dblIn), + uintptr(unsafe.Pointer(pi64Out)), + 0) + return HRESULT(ret1) +} + +func VarI8FromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, pi64Out *LONG64) HRESULT { + ret1 := syscall6(varI8FromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pi64Out)), + 0, + 0) + return HRESULT(ret1) +} + +func VarI8FromUI1(bIn BYTE, pi64Out *LONG64) HRESULT { + ret1 := syscall3(varI8FromUI1, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(pi64Out)), + 0) + return HRESULT(ret1) +} + +func VarI8FromUI2(usIn USHORT, pi64Out *LONG64) HRESULT { + ret1 := syscall3(varI8FromUI2, 2, + uintptr(usIn), + uintptr(unsafe.Pointer(pi64Out)), + 0) + return HRESULT(ret1) +} + +func VarI8FromUI4(ulIn ULONG, pi64Out *LONG64) HRESULT { + ret1 := syscall3(varI8FromUI4, 2, + uintptr(ulIn), + uintptr(unsafe.Pointer(pi64Out)), + 0) + return HRESULT(ret1) +} + +func VarI8FromUI8(ullIn ULONG64, pi64Out *LONG64) HRESULT { + ret1 := syscall3(varI8FromUI8, 2, + uintptr(ullIn), + uintptr(unsafe.Pointer(pi64Out)), + 0) + return HRESULT(ret1) +} + +func VarIdiv(left *VARIANT, right *VARIANT, result *VARIANT) HRESULT { + ret1 := syscall3(varIdiv, 3, + uintptr(unsafe.Pointer(left)), + uintptr(unsafe.Pointer(right)), + uintptr(unsafe.Pointer(result))) + return HRESULT(ret1) +} + +func VarImp(left *VARIANT, right *VARIANT, result *VARIANT) HRESULT { + ret1 := syscall3(varImp, 3, + uintptr(unsafe.Pointer(left)), + uintptr(unsafe.Pointer(right)), + uintptr(unsafe.Pointer(result))) + return HRESULT(ret1) +} + +func VarInt(pVarIn *VARIANT, pVarOut *VARIANT) HRESULT { + ret1 := syscall3(varInt, 2, + uintptr(unsafe.Pointer(pVarIn)), + uintptr(unsafe.Pointer(pVarOut)), + 0) + return HRESULT(ret1) +} + +func VarMod(left *VARIANT, right *VARIANT, result *VARIANT) HRESULT { + ret1 := syscall3(varMod, 3, + uintptr(unsafe.Pointer(left)), + uintptr(unsafe.Pointer(right)), + uintptr(unsafe.Pointer(result))) + return HRESULT(ret1) +} + +func VarMonthName(iMonth INT, fAbbrev INT, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varMonthName, 4, + uintptr(iMonth), + uintptr(fAbbrev), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarMul(left *VARIANT, right *VARIANT, result *VARIANT) HRESULT { + ret1 := syscall3(varMul, 3, + uintptr(unsafe.Pointer(left)), + uintptr(unsafe.Pointer(right)), + uintptr(unsafe.Pointer(result))) + return HRESULT(ret1) +} + +func VarNeg(pVarIn *VARIANT, pVarOut *VARIANT) HRESULT { + ret1 := syscall3(varNeg, 2, + uintptr(unsafe.Pointer(pVarIn)), + uintptr(unsafe.Pointer(pVarOut)), + 0) + return HRESULT(ret1) +} + +func VarNot(pVarIn *VARIANT, pVarOut *VARIANT) HRESULT { + ret1 := syscall3(varNot, 2, + uintptr(unsafe.Pointer(pVarIn)), + uintptr(unsafe.Pointer(pVarOut)), + 0) + return HRESULT(ret1) +} + +func VarNumFromParseNum(pNumprs *NUMPARSE, rgbDig *byte, dwVtBits ULONG, pVarDst *VARIANT) HRESULT { + ret1 := syscall6(varNumFromParseNum, 4, + uintptr(unsafe.Pointer(pNumprs)), + uintptr(unsafe.Pointer(rgbDig)), + uintptr(dwVtBits), + uintptr(unsafe.Pointer(pVarDst)), + 0, + 0) + return HRESULT(ret1) +} + +func VarOr(pVarLeft *VARIANT, pVarRight *VARIANT, pVarOut *VARIANT) HRESULT { + ret1 := syscall3(varOr, 3, + uintptr(unsafe.Pointer(pVarLeft)), + uintptr(unsafe.Pointer(pVarRight)), + uintptr(unsafe.Pointer(pVarOut))) + return HRESULT(ret1) +} + +func VarParseNumFromStr(lpszStr *OLECHAR, lcid LCID, dwFlags ULONG, pNumprs *NUMPARSE, rgbDig *byte) HRESULT { + ret1 := syscall6(varParseNumFromStr, 5, + uintptr(unsafe.Pointer(lpszStr)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pNumprs)), + uintptr(unsafe.Pointer(rgbDig)), + 0) + return HRESULT(ret1) +} + +func VarPow(left *VARIANT, right *VARIANT, result *VARIANT) HRESULT { + ret1 := syscall3(varPow, 3, + uintptr(unsafe.Pointer(left)), + uintptr(unsafe.Pointer(right)), + uintptr(unsafe.Pointer(result))) + return HRESULT(ret1) +} + +func VarR4CmpR8(fltLeft float32, dblRight float64) HRESULT { + ret1 := syscall3(varR4CmpR8, 2, + uintptr(fltLeft), + uintptr(dblRight), + 0) + return HRESULT(ret1) +} + +func VarR4FromBool(boolIn VARIANT_BOOL, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromBool, 2, + uintptr(boolIn), + uintptr(unsafe.Pointer(pFltOut)), + 0) + return HRESULT(ret1) +} + +func VarR4FromCy(cyIn CY, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromCy, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pFltOut))) + return HRESULT(ret1) +} + +func VarR4FromDate(dateIn DATE, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromDate, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(pFltOut)), + 0) + return HRESULT(ret1) +} + +func VarR4FromDec(pDecIn *DECIMAL, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromDec, 2, + uintptr(unsafe.Pointer(pDecIn)), + uintptr(unsafe.Pointer(pFltOut)), + 0) + return HRESULT(ret1) +} + +func VarR4FromDisp(pdispIn *IDispatch, lcid LCID, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(pFltOut))) + return HRESULT(ret1) +} + +func VarR4FromI1(cIn int8, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromI1, 2, + uintptr(cIn), + uintptr(unsafe.Pointer(pFltOut)), + 0) + return HRESULT(ret1) +} + +func VarR4FromI2(sIn SHORT, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromI2, 2, + uintptr(sIn), + uintptr(unsafe.Pointer(pFltOut)), + 0) + return HRESULT(ret1) +} + +func VarR4FromI4(lIn LONG, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromI4, 2, + uintptr(lIn), + uintptr(unsafe.Pointer(pFltOut)), + 0) + return HRESULT(ret1) +} + +func VarR4FromI8(llIn LONG64, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromI8, 2, + uintptr(llIn), + uintptr(unsafe.Pointer(pFltOut)), + 0) + return HRESULT(ret1) +} + +func VarR4FromR8(dblIn float64, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromR8, 2, + uintptr(dblIn), + uintptr(unsafe.Pointer(pFltOut)), + 0) + return HRESULT(ret1) +} + +func VarR4FromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, pFltOut *float32) HRESULT { + ret1 := syscall6(varR4FromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pFltOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarR4FromUI1(bIn BYTE, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromUI1, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(pFltOut)), + 0) + return HRESULT(ret1) +} + +func VarR4FromUI2(usIn USHORT, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromUI2, 2, + uintptr(usIn), + uintptr(unsafe.Pointer(pFltOut)), + 0) + return HRESULT(ret1) +} + +func VarR4FromUI4(ulIn ULONG, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromUI4, 2, + uintptr(ulIn), + uintptr(unsafe.Pointer(pFltOut)), + 0) + return HRESULT(ret1) +} + +func VarR4FromUI8(ullIn ULONG64, pFltOut *float32) HRESULT { + ret1 := syscall3(varR4FromUI8, 2, + uintptr(ullIn), + uintptr(unsafe.Pointer(pFltOut)), + 0) + return HRESULT(ret1) +} + +func VarR8FromBool(boolIn VARIANT_BOOL, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromBool, 2, + uintptr(boolIn), + uintptr(unsafe.Pointer(pDblOut)), + 0) + return HRESULT(ret1) +} + +func VarR8FromCy(cyIn CY, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromCy, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pDblOut))) + return HRESULT(ret1) +} + +func VarR8FromDate(dateIn DATE, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromDate, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(pDblOut)), + 0) + return HRESULT(ret1) +} + +func VarR8FromDec(pDecIn /*const*/ *DECIMAL, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromDec, 2, + uintptr(unsafe.Pointer(pDecIn)), + uintptr(unsafe.Pointer(pDblOut)), + 0) + return HRESULT(ret1) +} + +func VarR8FromDisp(pdispIn *IDispatch, lcid LCID, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(pDblOut))) + return HRESULT(ret1) +} + +func VarR8FromI1(cIn int8, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromI1, 2, + uintptr(cIn), + uintptr(unsafe.Pointer(pDblOut)), + 0) + return HRESULT(ret1) +} + +func VarR8FromI2(sIn SHORT, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromI2, 2, + uintptr(sIn), + uintptr(unsafe.Pointer(pDblOut)), + 0) + return HRESULT(ret1) +} + +func VarR8FromI4(lIn LONG, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromI4, 2, + uintptr(lIn), + uintptr(unsafe.Pointer(pDblOut)), + 0) + return HRESULT(ret1) +} + +func VarR8FromI8(llIn LONG64, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromI8, 2, + uintptr(llIn), + uintptr(unsafe.Pointer(pDblOut)), + 0) + return HRESULT(ret1) +} + +func VarR8FromR4(fltIn FLOAT, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromR4, 2, + uintptr(fltIn), + uintptr(unsafe.Pointer(pDblOut)), + 0) + return HRESULT(ret1) +} + +func VarR8FromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, pDblOut *float64) HRESULT { + ret1 := syscall6(varR8FromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pDblOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarR8FromUI1(bIn BYTE, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromUI1, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(pDblOut)), + 0) + return HRESULT(ret1) +} + +func VarR8FromUI2(usIn USHORT, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromUI2, 2, + uintptr(usIn), + uintptr(unsafe.Pointer(pDblOut)), + 0) + return HRESULT(ret1) +} + +func VarR8FromUI4(ulIn ULONG, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromUI4, 2, + uintptr(ulIn), + uintptr(unsafe.Pointer(pDblOut)), + 0) + return HRESULT(ret1) +} + +func VarR8FromUI8(ullIn ULONG64, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8FromUI8, 2, + uintptr(ullIn), + uintptr(unsafe.Pointer(pDblOut)), + 0) + return HRESULT(ret1) +} + +func VarR8Pow(dblLeft float64, dblPow float64, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8Pow, 3, + uintptr(dblLeft), + uintptr(dblPow), + uintptr(unsafe.Pointer(pDblOut))) + return HRESULT(ret1) +} + +func VarR8Round(dblIn float64, nDig int32, pDblOut *float64) HRESULT { + ret1 := syscall3(varR8Round, 3, + uintptr(dblIn), + uintptr(nDig), + uintptr(unsafe.Pointer(pDblOut))) + return HRESULT(ret1) +} + +func VarRound(pVarIn *VARIANT, deci int32, pVarOut *VARIANT) HRESULT { + ret1 := syscall3(varRound, 3, + uintptr(unsafe.Pointer(pVarIn)), + uintptr(deci), + uintptr(unsafe.Pointer(pVarOut))) + return HRESULT(ret1) +} + +func VarSub(left *VARIANT, right *VARIANT, result *VARIANT) HRESULT { + ret1 := syscall3(varSub, 3, + uintptr(unsafe.Pointer(left)), + uintptr(unsafe.Pointer(right)), + uintptr(unsafe.Pointer(result))) + return HRESULT(ret1) +} + +func VarTokenizeFormatString(lpszFormat LPOLESTR, rgbTok *byte, cbTok int32, nFirstDay int32, nFirstWeek int32, lcid LCID, pcbActual *int) HRESULT { + ret1 := syscall9(varTokenizeFormatString, 7, + uintptr(unsafe.Pointer(lpszFormat)), + uintptr(unsafe.Pointer(rgbTok)), + uintptr(cbTok), + uintptr(nFirstDay), + uintptr(nFirstWeek), + uintptr(lcid), + uintptr(unsafe.Pointer(pcbActual)), + 0, + 0) + return HRESULT(ret1) +} + +func VarUI1FromBool(boolIn VARIANT_BOOL, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromBool, 2, + uintptr(boolIn), + uintptr(unsafe.Pointer(pbOut)), + 0) + return HRESULT(ret1) +} + +func VarUI1FromCy(cyIn CY, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromCy, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pbOut))) + return HRESULT(ret1) +} + +func VarUI1FromDate(dateIn DATE, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromDate, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(pbOut)), + 0) + return HRESULT(ret1) +} + +func VarUI1FromDec(pdecIn *DECIMAL, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromDec, 2, + uintptr(unsafe.Pointer(pdecIn)), + uintptr(unsafe.Pointer(pbOut)), + 0) + return HRESULT(ret1) +} + +func VarUI1FromDisp(pdispIn *IDispatch, lcid LCID, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(pbOut))) + return HRESULT(ret1) +} + +func VarUI1FromI1(cIn int8, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromI1, 2, + uintptr(cIn), + uintptr(unsafe.Pointer(pbOut)), + 0) + return HRESULT(ret1) +} + +func VarUI1FromI2(sIn SHORT, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromI2, 2, + uintptr(sIn), + uintptr(unsafe.Pointer(pbOut)), + 0) + return HRESULT(ret1) +} + +func VarUI1FromI4(iIn LONG, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromI4, 2, + uintptr(iIn), + uintptr(unsafe.Pointer(pbOut)), + 0) + return HRESULT(ret1) +} + +func VarUI1FromI8(llIn LONG64, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromI8, 2, + uintptr(llIn), + uintptr(unsafe.Pointer(pbOut)), + 0) + return HRESULT(ret1) +} + +func VarUI1FromR4(fltIn FLOAT, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromR4, 2, + uintptr(fltIn), + uintptr(unsafe.Pointer(pbOut)), + 0) + return HRESULT(ret1) +} + +func VarUI1FromR8(dblIn float64, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromR8, 2, + uintptr(dblIn), + uintptr(unsafe.Pointer(pbOut)), + 0) + return HRESULT(ret1) +} + +func VarUI1FromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, pbOut *byte) HRESULT { + ret1 := syscall6(varUI1FromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarUI1FromUI2(usIn USHORT, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromUI2, 2, + uintptr(usIn), + uintptr(unsafe.Pointer(pbOut)), + 0) + return HRESULT(ret1) +} + +func VarUI1FromUI4(ulIn ULONG, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromUI4, 2, + uintptr(ulIn), + uintptr(unsafe.Pointer(pbOut)), + 0) + return HRESULT(ret1) +} + +func VarUI1FromUI8(ullIn ULONG64, pbOut *byte) HRESULT { + ret1 := syscall3(varUI1FromUI8, 2, + uintptr(ullIn), + uintptr(unsafe.Pointer(pbOut)), + 0) + return HRESULT(ret1) +} + +func VarUI2FromBool(boolIn VARIANT_BOOL, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromBool, 2, + uintptr(boolIn), + uintptr(unsafe.Pointer(pusOut)), + 0) + return HRESULT(ret1) +} + +func VarUI2FromCy(cyIn CY, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromCy, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pusOut))) + return HRESULT(ret1) +} + +func VarUI2FromDate(dateIn DATE, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromDate, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(pusOut)), + 0) + return HRESULT(ret1) +} + +func VarUI2FromDec(pdecIn *DECIMAL, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromDec, 2, + uintptr(unsafe.Pointer(pdecIn)), + uintptr(unsafe.Pointer(pusOut)), + 0) + return HRESULT(ret1) +} + +func VarUI2FromDisp(pdispIn *IDispatch, lcid LCID, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(pusOut))) + return HRESULT(ret1) +} + +func VarUI2FromI1(cIn int8, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromI1, 2, + uintptr(cIn), + uintptr(unsafe.Pointer(pusOut)), + 0) + return HRESULT(ret1) +} + +func VarUI2FromI2(sIn SHORT, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromI2, 2, + uintptr(sIn), + uintptr(unsafe.Pointer(pusOut)), + 0) + return HRESULT(ret1) +} + +func VarUI2FromI4(iIn LONG, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromI4, 2, + uintptr(iIn), + uintptr(unsafe.Pointer(pusOut)), + 0) + return HRESULT(ret1) +} + +func VarUI2FromI8(llIn LONG64, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromI8, 2, + uintptr(llIn), + uintptr(unsafe.Pointer(pusOut)), + 0) + return HRESULT(ret1) +} + +func VarUI2FromR4(fltIn FLOAT, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromR4, 2, + uintptr(fltIn), + uintptr(unsafe.Pointer(pusOut)), + 0) + return HRESULT(ret1) +} + +func VarUI2FromR8(dblIn float64, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromR8, 2, + uintptr(dblIn), + uintptr(unsafe.Pointer(pusOut)), + 0) + return HRESULT(ret1) +} + +func VarUI2FromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, pusOut *USHORT) HRESULT { + ret1 := syscall6(varUI2FromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pusOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarUI2FromUI1(bIn BYTE, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromUI1, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(pusOut)), + 0) + return HRESULT(ret1) +} + +func VarUI2FromUI4(ulIn ULONG, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromUI4, 2, + uintptr(ulIn), + uintptr(unsafe.Pointer(pusOut)), + 0) + return HRESULT(ret1) +} + +func VarUI2FromUI8(ullIn ULONG64, pusOut *USHORT) HRESULT { + ret1 := syscall3(varUI2FromUI8, 2, + uintptr(ullIn), + uintptr(unsafe.Pointer(pusOut)), + 0) + return HRESULT(ret1) +} + +func VarUI4FromBool(boolIn VARIANT_BOOL, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromBool, 2, + uintptr(boolIn), + uintptr(unsafe.Pointer(pulOut)), + 0) + return HRESULT(ret1) +} + +func VarUI4FromCy(cyIn CY, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromCy, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pulOut))) + return HRESULT(ret1) +} + +func VarUI4FromDate(dateIn DATE, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromDate, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(pulOut)), + 0) + return HRESULT(ret1) +} + +func VarUI4FromDec(pdecIn *DECIMAL, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromDec, 2, + uintptr(unsafe.Pointer(pdecIn)), + uintptr(unsafe.Pointer(pulOut)), + 0) + return HRESULT(ret1) +} + +func VarUI4FromDisp(pdispIn *IDispatch, lcid LCID, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(pulOut))) + return HRESULT(ret1) +} + +func VarUI4FromI1(cIn int8, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromI1, 2, + uintptr(cIn), + uintptr(unsafe.Pointer(pulOut)), + 0) + return HRESULT(ret1) +} + +func VarUI4FromI2(sIn SHORT, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromI2, 2, + uintptr(sIn), + uintptr(unsafe.Pointer(pulOut)), + 0) + return HRESULT(ret1) +} + +func VarUI4FromI4(iIn LONG, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromI4, 2, + uintptr(iIn), + uintptr(unsafe.Pointer(pulOut)), + 0) + return HRESULT(ret1) +} + +func VarUI4FromI8(llIn LONG64, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromI8, 2, + uintptr(llIn), + uintptr(unsafe.Pointer(pulOut)), + 0) + return HRESULT(ret1) +} + +func VarUI4FromR4(fltIn FLOAT, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromR4, 2, + uintptr(fltIn), + uintptr(unsafe.Pointer(pulOut)), + 0) + return HRESULT(ret1) +} + +func VarUI4FromR8(dblIn float64, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromR8, 2, + uintptr(dblIn), + uintptr(unsafe.Pointer(pulOut)), + 0) + return HRESULT(ret1) +} + +func VarUI4FromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, pulOut *ULONG) HRESULT { + ret1 := syscall6(varUI4FromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pulOut)), + 0, + 0) + return HRESULT(ret1) +} + +func VarUI4FromUI1(bIn BYTE, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromUI1, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(pulOut)), + 0) + return HRESULT(ret1) +} + +func VarUI4FromUI2(usIn USHORT, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromUI2, 2, + uintptr(usIn), + uintptr(unsafe.Pointer(pulOut)), + 0) + return HRESULT(ret1) +} + +func VarUI4FromUI8(ullIn ULONG64, pulOut *ULONG) HRESULT { + ret1 := syscall3(varUI4FromUI8, 2, + uintptr(ullIn), + uintptr(unsafe.Pointer(pulOut)), + 0) + return HRESULT(ret1) +} + +func VarUI8FromBool(boolIn VARIANT_BOOL, pui64Out *ULONG64) HRESULT { + ret1 := syscall3(varUI8FromBool, 2, + uintptr(boolIn), + uintptr(unsafe.Pointer(pui64Out)), + 0) + return HRESULT(ret1) +} + +func VarUI8FromCy(cyIn CY, pui64Out *ULONG64) HRESULT { + ret1 := syscall3(varUI8FromCy, 3, + uintptr(*(*uint32)(unsafe.Pointer(&cyIn))), + uintptr(*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(&cyIn)) + uintptr(4)))), + uintptr(unsafe.Pointer(pui64Out))) + return HRESULT(ret1) +} + +func VarUI8FromDate(dateIn DATE, pui64Out *ULONG64) HRESULT { + ret1 := syscall3(varUI8FromDate, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(pui64Out)), + 0) + return HRESULT(ret1) +} + +func VarUI8FromDec(pdecIn *DECIMAL, pui64Out *ULONG64) HRESULT { + ret1 := syscall3(varUI8FromDec, 2, + uintptr(unsafe.Pointer(pdecIn)), + uintptr(unsafe.Pointer(pui64Out)), + 0) + return HRESULT(ret1) +} + +func VarUI8FromDisp(pdispIn *IDispatch, lcid LCID, pui64Out *ULONG64) HRESULT { + ret1 := syscall3(varUI8FromDisp, 3, + uintptr(unsafe.Pointer(pdispIn)), + uintptr(lcid), + uintptr(unsafe.Pointer(pui64Out))) + return HRESULT(ret1) +} + +func VarUI8FromI1(cIn int8, pui64Out *ULONG64) HRESULT { + ret1 := syscall3(varUI8FromI1, 2, + uintptr(cIn), + uintptr(unsafe.Pointer(pui64Out)), + 0) + return HRESULT(ret1) +} + +func VarUI8FromI2(sIn SHORT, pui64Out *ULONG64) HRESULT { + ret1 := syscall3(varUI8FromI2, 2, + uintptr(sIn), + uintptr(unsafe.Pointer(pui64Out)), + 0) + return HRESULT(ret1) +} + +func VarUI8FromI8(llIn LONG64, pui64Out *ULONG64) HRESULT { + ret1 := syscall3(varUI8FromI8, 2, + uintptr(llIn), + uintptr(unsafe.Pointer(pui64Out)), + 0) + return HRESULT(ret1) +} + +func VarUI8FromR4(fltIn FLOAT, pui64Out *ULONG64) HRESULT { + ret1 := syscall3(varUI8FromR4, 2, + uintptr(fltIn), + uintptr(unsafe.Pointer(pui64Out)), + 0) + return HRESULT(ret1) +} + +func VarUI8FromR8(dblIn float64, pui64Out *ULONG64) HRESULT { + ret1 := syscall3(varUI8FromR8, 2, + uintptr(dblIn), + uintptr(unsafe.Pointer(pui64Out)), + 0) + return HRESULT(ret1) +} + +func VarUI8FromStr(strIn *OLECHAR, lcid LCID, dwFlags ULONG, pui64Out *ULONG64) HRESULT { + ret1 := syscall6(varUI8FromStr, 4, + uintptr(unsafe.Pointer(strIn)), + uintptr(lcid), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pui64Out)), + 0, + 0) + return HRESULT(ret1) +} + +func VarUI8FromUI1(bIn BYTE, pui64Out *ULONG64) HRESULT { + ret1 := syscall3(varUI8FromUI1, 2, + uintptr(bIn), + uintptr(unsafe.Pointer(pui64Out)), + 0) + return HRESULT(ret1) +} + +func VarUI8FromUI2(usIn USHORT, pui64Out *ULONG64) HRESULT { + ret1 := syscall3(varUI8FromUI2, 2, + uintptr(usIn), + uintptr(unsafe.Pointer(pui64Out)), + 0) + return HRESULT(ret1) +} + +func VarUI8FromUI4(ulIn ULONG, pui64Out *ULONG64) HRESULT { + ret1 := syscall3(varUI8FromUI4, 2, + uintptr(ulIn), + uintptr(unsafe.Pointer(pui64Out)), + 0) + return HRESULT(ret1) +} + +func VarUdateFromDate(dateIn DATE, dwFlags ULONG, lpUdate *UDATE) HRESULT { + ret1 := syscall3(varUdateFromDate, 3, + uintptr(dateIn), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpUdate))) + return HRESULT(ret1) +} + +func VarWeekdayName(iWeekday INT, fAbbrev INT, iFirstDay INT, dwFlags ULONG, pbstrOut *BSTR) HRESULT { + ret1 := syscall6(varWeekdayName, 5, + uintptr(iWeekday), + uintptr(fAbbrev), + uintptr(iFirstDay), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pbstrOut)), + 0) + return HRESULT(ret1) +} + +func VarXor(pVarLeft *VARIANT, pVarRight *VARIANT, pVarOut *VARIANT) HRESULT { + ret1 := syscall3(varXor, 3, + uintptr(unsafe.Pointer(pVarLeft)), + uintptr(unsafe.Pointer(pVarRight)), + uintptr(unsafe.Pointer(pVarOut))) + return HRESULT(ret1) +} + +func VariantChangeType(pvargDest *VARIANTARG, pvargSrc *VARIANTARG, wFlags USHORT, vt VARTYPE) HRESULT { + ret1 := syscall6(variantChangeType, 4, + uintptr(unsafe.Pointer(pvargDest)), + uintptr(unsafe.Pointer(pvargSrc)), + uintptr(wFlags), + uintptr(vt), + 0, + 0) + return HRESULT(ret1) +} + +func VariantChangeTypeEx(pvargDest *VARIANTARG, pvargSrc *VARIANTARG, lcid LCID, wFlags USHORT, vt VARTYPE) HRESULT { + ret1 := syscall6(variantChangeTypeEx, 5, + uintptr(unsafe.Pointer(pvargDest)), + uintptr(unsafe.Pointer(pvargSrc)), + uintptr(lcid), + uintptr(wFlags), + uintptr(vt), + 0) + return HRESULT(ret1) +} + +func VariantClear(pVarg *VARIANTARG) HRESULT { + ret1 := syscall3(variantClear, 1, + uintptr(unsafe.Pointer(pVarg)), + 0, + 0) + return HRESULT(ret1) +} + +func VariantCopy(pvargDest *VARIANTARG, pvargSrc *VARIANTARG) HRESULT { + ret1 := syscall3(variantCopy, 2, + uintptr(unsafe.Pointer(pvargDest)), + uintptr(unsafe.Pointer(pvargSrc)), + 0) + return HRESULT(ret1) +} + +func VariantCopyInd(pvargDest *VARIANT, pvargSrc *VARIANTARG) HRESULT { + ret1 := syscall3(variantCopyInd, 2, + uintptr(unsafe.Pointer(pvargDest)), + uintptr(unsafe.Pointer(pvargSrc)), + 0) + return HRESULT(ret1) +} + +func VariantInit(pVarg *VARIANTARG) { + syscall3(variantInit, 1, + uintptr(unsafe.Pointer(pVarg)), + 0, + 0) +} + +func VariantTimeToDosDateTime(dateIn float64, pwDosDate *USHORT, pwDosTime *USHORT) INT { + ret1 := syscall3(variantTimeToDosDateTime, 3, + uintptr(dateIn), + uintptr(unsafe.Pointer(pwDosDate)), + uintptr(unsafe.Pointer(pwDosTime))) + return INT(ret1) +} + +func VariantTimeToSystemTime(dateIn float64, lpSt *SYSTEMTIME) INT { + ret1 := syscall3(variantTimeToSystemTime, 2, + uintptr(dateIn), + uintptr(unsafe.Pointer(lpSt)), + 0) + return INT(ret1) +} + +func VectorFromBstr(bstr BSTR, ppsa **SAFEARRAY) HRESULT { + ret1 := syscall3(vectorFromBstr, 2, + uintptr(unsafe.Pointer(bstr)), + uintptr(unsafe.Pointer(ppsa)), + 0) + return HRESULT(ret1) +} diff --git a/grdp/win/opengl32.go b/grdp/win/opengl32.go new file mode 100644 index 0000000..cc53671 --- /dev/null +++ b/grdp/win/opengl32.go @@ -0,0 +1,3503 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "unsafe" +) + +var ( + // Library + libopengl32 uintptr + + // Functions + glAccum uintptr + glAlphaFunc uintptr + glAreTexturesResident uintptr + glArrayElement uintptr + glBegin uintptr + glBindTexture uintptr + glBitmap uintptr + glBlendFunc uintptr + glCallList uintptr + glCallLists uintptr + glClear uintptr + glClearAccum uintptr + glClearColor uintptr + glClearDepth uintptr + glClearIndex uintptr + glClearStencil uintptr + glClipPlane uintptr + glColor3b uintptr + glColor3bv uintptr + glColor3d uintptr + glColor3dv uintptr + glColor3f uintptr + glColor3fv uintptr + glColor3i uintptr + glColor3iv uintptr + glColor3s uintptr + glColor3sv uintptr + glColor3ub uintptr + glColor3ubv uintptr + glColor3ui uintptr + glColor3uiv uintptr + glColor3us uintptr + glColor3usv uintptr + glColor4b uintptr + glColor4bv uintptr + glColor4d uintptr + glColor4dv uintptr + glColor4f uintptr + glColor4fv uintptr + glColor4i uintptr + glColor4iv uintptr + glColor4s uintptr + glColor4sv uintptr + glColor4ub uintptr + glColor4ubv uintptr + glColor4ui uintptr + glColor4uiv uintptr + glColor4us uintptr + glColor4usv uintptr + glColorMask uintptr + glColorMaterial uintptr + glColorPointer uintptr + glCopyPixels uintptr + glCopyTexImage1D uintptr + glCopyTexImage2D uintptr + glCopyTexSubImage1D uintptr + glCopyTexSubImage2D uintptr + glCullFace uintptr + glDeleteLists uintptr + glDeleteTextures uintptr + glDepthFunc uintptr + glDepthMask uintptr + glDepthRange uintptr + glDisable uintptr + glDisableClientState uintptr + glDrawArrays uintptr + glDrawBuffer uintptr + glDrawElements uintptr + glDrawPixels uintptr + glEdgeFlag uintptr + glEdgeFlagPointer uintptr + glEdgeFlagv uintptr + glEnable uintptr + glEnableClientState uintptr + glEnd uintptr + glEndList uintptr + glEvalCoord1d uintptr + glEvalCoord1dv uintptr + glEvalCoord1f uintptr + glEvalCoord1fv uintptr + glEvalCoord2d uintptr + glEvalCoord2dv uintptr + glEvalCoord2f uintptr + glEvalCoord2fv uintptr + glEvalMesh1 uintptr + glEvalMesh2 uintptr + glEvalPoint1 uintptr + glEvalPoint2 uintptr + glFeedbackBuffer uintptr + glFinish uintptr + glFlush uintptr + glFogf uintptr + glFogfv uintptr + glFogi uintptr + glFogiv uintptr + glFrontFace uintptr + glFrustum uintptr + glGenLists uintptr + glGenTextures uintptr + glGetBooleanv uintptr + glGetClipPlane uintptr + glGetDoublev uintptr + glGetError uintptr + glGetFloatv uintptr + glGetIntegerv uintptr + glGetLightfv uintptr + glGetLightiv uintptr + glGetMapdv uintptr + glGetMapfv uintptr + glGetMapiv uintptr + glGetMaterialfv uintptr + glGetMaterialiv uintptr + glGetPixelMapfv uintptr + glGetPixelMapuiv uintptr + glGetPixelMapusv uintptr + glGetPointerv uintptr + glGetPolygonStipple uintptr + glGetTexEnvfv uintptr + glGetTexEnviv uintptr + glGetTexGendv uintptr + glGetTexGenfv uintptr + glGetTexGeniv uintptr + glGetTexImage uintptr + glGetTexLevelParameterfv uintptr + glGetTexLevelParameteriv uintptr + glGetTexParameterfv uintptr + glGetTexParameteriv uintptr + glHint uintptr + glIndexMask uintptr + glIndexPointer uintptr + glIndexd uintptr + glIndexdv uintptr + glIndexf uintptr + glIndexfv uintptr + glIndexi uintptr + glIndexiv uintptr + glIndexs uintptr + glIndexsv uintptr + glIndexub uintptr + glIndexubv uintptr + glInitNames uintptr + glInterleavedArrays uintptr + glIsEnabled uintptr + glIsList uintptr + glIsTexture uintptr + glLightModelf uintptr + glLightModelfv uintptr + glLightModeli uintptr + glLightModeliv uintptr + glLightf uintptr + glLightfv uintptr + glLighti uintptr + glLightiv uintptr + glLineStipple uintptr + glLineWidth uintptr + glListBase uintptr + glLoadIdentity uintptr + glLoadMatrixd uintptr + glLoadMatrixf uintptr + glLoadName uintptr + glLogicOp uintptr + glMap1d uintptr + glMap1f uintptr + glMap2d uintptr + glMap2f uintptr + glMapGrid1d uintptr + glMapGrid1f uintptr + glMapGrid2d uintptr + glMapGrid2f uintptr + glMaterialf uintptr + glMaterialfv uintptr + glMateriali uintptr + glMaterialiv uintptr + glMatrixMode uintptr + glMultMatrixd uintptr + glMultMatrixf uintptr + glNewList uintptr + glNormal3b uintptr + glNormal3bv uintptr + glNormal3d uintptr + glNormal3dv uintptr + glNormal3f uintptr + glNormal3fv uintptr + glNormal3i uintptr + glNormal3iv uintptr + glNormal3s uintptr + glNormal3sv uintptr + glNormalPointer uintptr + glOrtho uintptr + glPassThrough uintptr + glPixelMapfv uintptr + glPixelMapuiv uintptr + glPixelMapusv uintptr + glPixelStoref uintptr + glPixelStorei uintptr + glPixelTransferf uintptr + glPixelTransferi uintptr + glPixelZoom uintptr + glPointSize uintptr + glPolygonMode uintptr + glPolygonOffset uintptr + glPolygonStipple uintptr + glPopAttrib uintptr + glPopClientAttrib uintptr + glPopMatrix uintptr + glPopName uintptr + glPrioritizeTextures uintptr + glPushAttrib uintptr + glPushClientAttrib uintptr + glPushMatrix uintptr + glPushName uintptr + glRasterPos2d uintptr + glRasterPos2dv uintptr + glRasterPos2f uintptr + glRasterPos2fv uintptr + glRasterPos2i uintptr + glRasterPos2iv uintptr + glRasterPos2s uintptr + glRasterPos2sv uintptr + glRasterPos3d uintptr + glRasterPos3dv uintptr + glRasterPos3f uintptr + glRasterPos3fv uintptr + glRasterPos3i uintptr + glRasterPos3iv uintptr + glRasterPos3s uintptr + glRasterPos3sv uintptr + glRasterPos4d uintptr + glRasterPos4dv uintptr + glRasterPos4f uintptr + glRasterPos4fv uintptr + glRasterPos4i uintptr + glRasterPos4iv uintptr + glRasterPos4s uintptr + glRasterPos4sv uintptr + glReadBuffer uintptr + glReadPixels uintptr + glRectd uintptr + glRectdv uintptr + glRectf uintptr + glRectfv uintptr + glRecti uintptr + glRectiv uintptr + glRects uintptr + glRectsv uintptr + glRenderMode uintptr + glRotated uintptr + glRotatef uintptr + glScaled uintptr + glScalef uintptr + glScissor uintptr + glSelectBuffer uintptr + glShadeModel uintptr + glStencilFunc uintptr + glStencilMask uintptr + glStencilOp uintptr + glTexCoord1d uintptr + glTexCoord1dv uintptr + glTexCoord1f uintptr + glTexCoord1fv uintptr + glTexCoord1i uintptr + glTexCoord1iv uintptr + glTexCoord1s uintptr + glTexCoord1sv uintptr + glTexCoord2d uintptr + glTexCoord2dv uintptr + glTexCoord2f uintptr + glTexCoord2fv uintptr + glTexCoord2i uintptr + glTexCoord2iv uintptr + glTexCoord2s uintptr + glTexCoord2sv uintptr + glTexCoord3d uintptr + glTexCoord3dv uintptr + glTexCoord3f uintptr + glTexCoord3fv uintptr + glTexCoord3i uintptr + glTexCoord3iv uintptr + glTexCoord3s uintptr + glTexCoord3sv uintptr + glTexCoord4d uintptr + glTexCoord4dv uintptr + glTexCoord4f uintptr + glTexCoord4fv uintptr + glTexCoord4i uintptr + glTexCoord4iv uintptr + glTexCoord4s uintptr + glTexCoord4sv uintptr + glTexCoordPointer uintptr + glTexEnvf uintptr + glTexEnvfv uintptr + glTexEnvi uintptr + glTexEnviv uintptr + glTexGend uintptr + glTexGendv uintptr + glTexGenf uintptr + glTexGenfv uintptr + glTexGeni uintptr + glTexGeniv uintptr + glTexImage1D uintptr + glTexImage2D uintptr + glTexParameterf uintptr + glTexParameterfv uintptr + glTexParameteri uintptr + glTexParameteriv uintptr + glTexSubImage1D uintptr + glTexSubImage2D uintptr + glTranslated uintptr + glTranslatef uintptr + glVertex2d uintptr + glVertex2dv uintptr + glVertex2f uintptr + glVertex2fv uintptr + glVertex2i uintptr + glVertex2iv uintptr + glVertex2s uintptr + glVertex2sv uintptr + glVertex3d uintptr + glVertex3dv uintptr + glVertex3f uintptr + glVertex3fv uintptr + glVertex3i uintptr + glVertex3iv uintptr + glVertex3s uintptr + glVertex3sv uintptr + glVertex4d uintptr + glVertex4dv uintptr + glVertex4f uintptr + glVertex4fv uintptr + glVertex4i uintptr + glVertex4iv uintptr + glVertex4s uintptr + glVertex4sv uintptr + glVertexPointer uintptr + glViewport uintptr + wglCopyContext uintptr + wglCreateContext uintptr + wglCreateLayerContext uintptr + wglDeleteContext uintptr + wglDescribeLayerPlane uintptr + wglGetCurrentContext uintptr + wglGetCurrentDC uintptr + wglGetLayerPaletteEntries uintptr + wglGetProcAddress uintptr + wglMakeCurrent uintptr + wglRealizeLayerPalette uintptr + wglSetLayerPaletteEntries uintptr + wglShareLists uintptr + wglSwapLayerBuffers uintptr + wglSwapMultipleBuffers uintptr + wglUseFontBitmaps uintptr + wglUseFontOutlines uintptr + glDebugEntry uintptr + wglChoosePixelFormat uintptr + wglDescribePixelFormat uintptr + wglGetPixelFormat uintptr + wglSetPixelFormat uintptr +) + +func init() { + // Library + libopengl32 = doLoadLibrary("opengl32.dll") + + // Functions + glAccum = doGetProcAddress(libopengl32, "glAccum") + glAlphaFunc = doGetProcAddress(libopengl32, "glAlphaFunc") + glAreTexturesResident = doGetProcAddress(libopengl32, "glAreTexturesResident") + glArrayElement = doGetProcAddress(libopengl32, "glArrayElement") + glBegin = doGetProcAddress(libopengl32, "glBegin") + glBindTexture = doGetProcAddress(libopengl32, "glBindTexture") + glBitmap = doGetProcAddress(libopengl32, "glBitmap") + glBlendFunc = doGetProcAddress(libopengl32, "glBlendFunc") + glCallList = doGetProcAddress(libopengl32, "glCallList") + glCallLists = doGetProcAddress(libopengl32, "glCallLists") + glClear = doGetProcAddress(libopengl32, "glClear") + glClearAccum = doGetProcAddress(libopengl32, "glClearAccum") + glClearColor = doGetProcAddress(libopengl32, "glClearColor") + glClearDepth = doGetProcAddress(libopengl32, "glClearDepth") + glClearIndex = doGetProcAddress(libopengl32, "glClearIndex") + glClearStencil = doGetProcAddress(libopengl32, "glClearStencil") + glClipPlane = doGetProcAddress(libopengl32, "glClipPlane") + glColor3b = doGetProcAddress(libopengl32, "glColor3b") + glColor3bv = doGetProcAddress(libopengl32, "glColor3bv") + glColor3d = doGetProcAddress(libopengl32, "glColor3d") + glColor3dv = doGetProcAddress(libopengl32, "glColor3dv") + glColor3f = doGetProcAddress(libopengl32, "glColor3f") + glColor3fv = doGetProcAddress(libopengl32, "glColor3fv") + glColor3i = doGetProcAddress(libopengl32, "glColor3i") + glColor3iv = doGetProcAddress(libopengl32, "glColor3iv") + glColor3s = doGetProcAddress(libopengl32, "glColor3s") + glColor3sv = doGetProcAddress(libopengl32, "glColor3sv") + glColor3ub = doGetProcAddress(libopengl32, "glColor3ub") + glColor3ubv = doGetProcAddress(libopengl32, "glColor3ubv") + glColor3ui = doGetProcAddress(libopengl32, "glColor3ui") + glColor3uiv = doGetProcAddress(libopengl32, "glColor3uiv") + glColor3us = doGetProcAddress(libopengl32, "glColor3us") + glColor3usv = doGetProcAddress(libopengl32, "glColor3usv") + glColor4b = doGetProcAddress(libopengl32, "glColor4b") + glColor4bv = doGetProcAddress(libopengl32, "glColor4bv") + glColor4d = doGetProcAddress(libopengl32, "glColor4d") + glColor4dv = doGetProcAddress(libopengl32, "glColor4dv") + glColor4f = doGetProcAddress(libopengl32, "glColor4f") + glColor4fv = doGetProcAddress(libopengl32, "glColor4fv") + glColor4i = doGetProcAddress(libopengl32, "glColor4i") + glColor4iv = doGetProcAddress(libopengl32, "glColor4iv") + glColor4s = doGetProcAddress(libopengl32, "glColor4s") + glColor4sv = doGetProcAddress(libopengl32, "glColor4sv") + glColor4ub = doGetProcAddress(libopengl32, "glColor4ub") + glColor4ubv = doGetProcAddress(libopengl32, "glColor4ubv") + glColor4ui = doGetProcAddress(libopengl32, "glColor4ui") + glColor4uiv = doGetProcAddress(libopengl32, "glColor4uiv") + glColor4us = doGetProcAddress(libopengl32, "glColor4us") + glColor4usv = doGetProcAddress(libopengl32, "glColor4usv") + glColorMask = doGetProcAddress(libopengl32, "glColorMask") + glColorMaterial = doGetProcAddress(libopengl32, "glColorMaterial") + glColorPointer = doGetProcAddress(libopengl32, "glColorPointer") + glCopyPixels = doGetProcAddress(libopengl32, "glCopyPixels") + glCopyTexImage1D = doGetProcAddress(libopengl32, "glCopyTexImage1D") + glCopyTexImage2D = doGetProcAddress(libopengl32, "glCopyTexImage2D") + glCopyTexSubImage1D = doGetProcAddress(libopengl32, "glCopyTexSubImage1D") + glCopyTexSubImage2D = doGetProcAddress(libopengl32, "glCopyTexSubImage2D") + glCullFace = doGetProcAddress(libopengl32, "glCullFace") + glDeleteLists = doGetProcAddress(libopengl32, "glDeleteLists") + glDeleteTextures = doGetProcAddress(libopengl32, "glDeleteTextures") + glDepthFunc = doGetProcAddress(libopengl32, "glDepthFunc") + glDepthMask = doGetProcAddress(libopengl32, "glDepthMask") + glDepthRange = doGetProcAddress(libopengl32, "glDepthRange") + glDisable = doGetProcAddress(libopengl32, "glDisable") + glDisableClientState = doGetProcAddress(libopengl32, "glDisableClientState") + glDrawArrays = doGetProcAddress(libopengl32, "glDrawArrays") + glDrawBuffer = doGetProcAddress(libopengl32, "glDrawBuffer") + glDrawElements = doGetProcAddress(libopengl32, "glDrawElements") + glDrawPixels = doGetProcAddress(libopengl32, "glDrawPixels") + glEdgeFlag = doGetProcAddress(libopengl32, "glEdgeFlag") + glEdgeFlagPointer = doGetProcAddress(libopengl32, "glEdgeFlagPointer") + glEdgeFlagv = doGetProcAddress(libopengl32, "glEdgeFlagv") + glEnable = doGetProcAddress(libopengl32, "glEnable") + glEnableClientState = doGetProcAddress(libopengl32, "glEnableClientState") + glEnd = doGetProcAddress(libopengl32, "glEnd") + glEndList = doGetProcAddress(libopengl32, "glEndList") + glEvalCoord1d = doGetProcAddress(libopengl32, "glEvalCoord1d") + glEvalCoord1dv = doGetProcAddress(libopengl32, "glEvalCoord1dv") + glEvalCoord1f = doGetProcAddress(libopengl32, "glEvalCoord1f") + glEvalCoord1fv = doGetProcAddress(libopengl32, "glEvalCoord1fv") + glEvalCoord2d = doGetProcAddress(libopengl32, "glEvalCoord2d") + glEvalCoord2dv = doGetProcAddress(libopengl32, "glEvalCoord2dv") + glEvalCoord2f = doGetProcAddress(libopengl32, "glEvalCoord2f") + glEvalCoord2fv = doGetProcAddress(libopengl32, "glEvalCoord2fv") + glEvalMesh1 = doGetProcAddress(libopengl32, "glEvalMesh1") + glEvalMesh2 = doGetProcAddress(libopengl32, "glEvalMesh2") + glEvalPoint1 = doGetProcAddress(libopengl32, "glEvalPoint1") + glEvalPoint2 = doGetProcAddress(libopengl32, "glEvalPoint2") + glFeedbackBuffer = doGetProcAddress(libopengl32, "glFeedbackBuffer") + glFinish = doGetProcAddress(libopengl32, "glFinish") + glFlush = doGetProcAddress(libopengl32, "glFlush") + glFogf = doGetProcAddress(libopengl32, "glFogf") + glFogfv = doGetProcAddress(libopengl32, "glFogfv") + glFogi = doGetProcAddress(libopengl32, "glFogi") + glFogiv = doGetProcAddress(libopengl32, "glFogiv") + glFrontFace = doGetProcAddress(libopengl32, "glFrontFace") + glFrustum = doGetProcAddress(libopengl32, "glFrustum") + glGenLists = doGetProcAddress(libopengl32, "glGenLists") + glGenTextures = doGetProcAddress(libopengl32, "glGenTextures") + glGetBooleanv = doGetProcAddress(libopengl32, "glGetBooleanv") + glGetClipPlane = doGetProcAddress(libopengl32, "glGetClipPlane") + glGetDoublev = doGetProcAddress(libopengl32, "glGetDoublev") + glGetError = doGetProcAddress(libopengl32, "glGetError") + glGetFloatv = doGetProcAddress(libopengl32, "glGetFloatv") + glGetIntegerv = doGetProcAddress(libopengl32, "glGetIntegerv") + glGetLightfv = doGetProcAddress(libopengl32, "glGetLightfv") + glGetLightiv = doGetProcAddress(libopengl32, "glGetLightiv") + glGetMapdv = doGetProcAddress(libopengl32, "glGetMapdv") + glGetMapfv = doGetProcAddress(libopengl32, "glGetMapfv") + glGetMapiv = doGetProcAddress(libopengl32, "glGetMapiv") + glGetMaterialfv = doGetProcAddress(libopengl32, "glGetMaterialfv") + glGetMaterialiv = doGetProcAddress(libopengl32, "glGetMaterialiv") + glGetPixelMapfv = doGetProcAddress(libopengl32, "glGetPixelMapfv") + glGetPixelMapuiv = doGetProcAddress(libopengl32, "glGetPixelMapuiv") + glGetPixelMapusv = doGetProcAddress(libopengl32, "glGetPixelMapusv") + glGetPointerv = doGetProcAddress(libopengl32, "glGetPointerv") + glGetPolygonStipple = doGetProcAddress(libopengl32, "glGetPolygonStipple") + glGetTexEnvfv = doGetProcAddress(libopengl32, "glGetTexEnvfv") + glGetTexEnviv = doGetProcAddress(libopengl32, "glGetTexEnviv") + glGetTexGendv = doGetProcAddress(libopengl32, "glGetTexGendv") + glGetTexGenfv = doGetProcAddress(libopengl32, "glGetTexGenfv") + glGetTexGeniv = doGetProcAddress(libopengl32, "glGetTexGeniv") + glGetTexImage = doGetProcAddress(libopengl32, "glGetTexImage") + glGetTexLevelParameterfv = doGetProcAddress(libopengl32, "glGetTexLevelParameterfv") + glGetTexLevelParameteriv = doGetProcAddress(libopengl32, "glGetTexLevelParameteriv") + glGetTexParameterfv = doGetProcAddress(libopengl32, "glGetTexParameterfv") + glGetTexParameteriv = doGetProcAddress(libopengl32, "glGetTexParameteriv") + glHint = doGetProcAddress(libopengl32, "glHint") + glIndexMask = doGetProcAddress(libopengl32, "glIndexMask") + glIndexPointer = doGetProcAddress(libopengl32, "glIndexPointer") + glIndexd = doGetProcAddress(libopengl32, "glIndexd") + glIndexdv = doGetProcAddress(libopengl32, "glIndexdv") + glIndexf = doGetProcAddress(libopengl32, "glIndexf") + glIndexfv = doGetProcAddress(libopengl32, "glIndexfv") + glIndexi = doGetProcAddress(libopengl32, "glIndexi") + glIndexiv = doGetProcAddress(libopengl32, "glIndexiv") + glIndexs = doGetProcAddress(libopengl32, "glIndexs") + glIndexsv = doGetProcAddress(libopengl32, "glIndexsv") + glIndexub = doGetProcAddress(libopengl32, "glIndexub") + glIndexubv = doGetProcAddress(libopengl32, "glIndexubv") + glInitNames = doGetProcAddress(libopengl32, "glInitNames") + glInterleavedArrays = doGetProcAddress(libopengl32, "glInterleavedArrays") + glIsEnabled = doGetProcAddress(libopengl32, "glIsEnabled") + glIsList = doGetProcAddress(libopengl32, "glIsList") + glIsTexture = doGetProcAddress(libopengl32, "glIsTexture") + glLightModelf = doGetProcAddress(libopengl32, "glLightModelf") + glLightModelfv = doGetProcAddress(libopengl32, "glLightModelfv") + glLightModeli = doGetProcAddress(libopengl32, "glLightModeli") + glLightModeliv = doGetProcAddress(libopengl32, "glLightModeliv") + glLightf = doGetProcAddress(libopengl32, "glLightf") + glLightfv = doGetProcAddress(libopengl32, "glLightfv") + glLighti = doGetProcAddress(libopengl32, "glLighti") + glLightiv = doGetProcAddress(libopengl32, "glLightiv") + glLineStipple = doGetProcAddress(libopengl32, "glLineStipple") + glLineWidth = doGetProcAddress(libopengl32, "glLineWidth") + glListBase = doGetProcAddress(libopengl32, "glListBase") + glLoadIdentity = doGetProcAddress(libopengl32, "glLoadIdentity") + glLoadMatrixd = doGetProcAddress(libopengl32, "glLoadMatrixd") + glLoadMatrixf = doGetProcAddress(libopengl32, "glLoadMatrixf") + glLoadName = doGetProcAddress(libopengl32, "glLoadName") + glLogicOp = doGetProcAddress(libopengl32, "glLogicOp") + glMap1d = doGetProcAddress(libopengl32, "glMap1d") + glMap1f = doGetProcAddress(libopengl32, "glMap1f") + glMap2d = doGetProcAddress(libopengl32, "glMap2d") + glMap2f = doGetProcAddress(libopengl32, "glMap2f") + glMapGrid1d = doGetProcAddress(libopengl32, "glMapGrid1d") + glMapGrid1f = doGetProcAddress(libopengl32, "glMapGrid1f") + glMapGrid2d = doGetProcAddress(libopengl32, "glMapGrid2d") + glMapGrid2f = doGetProcAddress(libopengl32, "glMapGrid2f") + glMaterialf = doGetProcAddress(libopengl32, "glMaterialf") + glMaterialfv = doGetProcAddress(libopengl32, "glMaterialfv") + glMateriali = doGetProcAddress(libopengl32, "glMateriali") + glMaterialiv = doGetProcAddress(libopengl32, "glMaterialiv") + glMatrixMode = doGetProcAddress(libopengl32, "glMatrixMode") + glMultMatrixd = doGetProcAddress(libopengl32, "glMultMatrixd") + glMultMatrixf = doGetProcAddress(libopengl32, "glMultMatrixf") + glNewList = doGetProcAddress(libopengl32, "glNewList") + glNormal3b = doGetProcAddress(libopengl32, "glNormal3b") + glNormal3bv = doGetProcAddress(libopengl32, "glNormal3bv") + glNormal3d = doGetProcAddress(libopengl32, "glNormal3d") + glNormal3dv = doGetProcAddress(libopengl32, "glNormal3dv") + glNormal3f = doGetProcAddress(libopengl32, "glNormal3f") + glNormal3fv = doGetProcAddress(libopengl32, "glNormal3fv") + glNormal3i = doGetProcAddress(libopengl32, "glNormal3i") + glNormal3iv = doGetProcAddress(libopengl32, "glNormal3iv") + glNormal3s = doGetProcAddress(libopengl32, "glNormal3s") + glNormal3sv = doGetProcAddress(libopengl32, "glNormal3sv") + glNormalPointer = doGetProcAddress(libopengl32, "glNormalPointer") + glOrtho = doGetProcAddress(libopengl32, "glOrtho") + glPassThrough = doGetProcAddress(libopengl32, "glPassThrough") + glPixelMapfv = doGetProcAddress(libopengl32, "glPixelMapfv") + glPixelMapuiv = doGetProcAddress(libopengl32, "glPixelMapuiv") + glPixelMapusv = doGetProcAddress(libopengl32, "glPixelMapusv") + glPixelStoref = doGetProcAddress(libopengl32, "glPixelStoref") + glPixelStorei = doGetProcAddress(libopengl32, "glPixelStorei") + glPixelTransferf = doGetProcAddress(libopengl32, "glPixelTransferf") + glPixelTransferi = doGetProcAddress(libopengl32, "glPixelTransferi") + glPixelZoom = doGetProcAddress(libopengl32, "glPixelZoom") + glPointSize = doGetProcAddress(libopengl32, "glPointSize") + glPolygonMode = doGetProcAddress(libopengl32, "glPolygonMode") + glPolygonOffset = doGetProcAddress(libopengl32, "glPolygonOffset") + glPolygonStipple = doGetProcAddress(libopengl32, "glPolygonStipple") + glPopAttrib = doGetProcAddress(libopengl32, "glPopAttrib") + glPopClientAttrib = doGetProcAddress(libopengl32, "glPopClientAttrib") + glPopMatrix = doGetProcAddress(libopengl32, "glPopMatrix") + glPopName = doGetProcAddress(libopengl32, "glPopName") + glPrioritizeTextures = doGetProcAddress(libopengl32, "glPrioritizeTextures") + glPushAttrib = doGetProcAddress(libopengl32, "glPushAttrib") + glPushClientAttrib = doGetProcAddress(libopengl32, "glPushClientAttrib") + glPushMatrix = doGetProcAddress(libopengl32, "glPushMatrix") + glPushName = doGetProcAddress(libopengl32, "glPushName") + glRasterPos2d = doGetProcAddress(libopengl32, "glRasterPos2d") + glRasterPos2dv = doGetProcAddress(libopengl32, "glRasterPos2dv") + glRasterPos2f = doGetProcAddress(libopengl32, "glRasterPos2f") + glRasterPos2fv = doGetProcAddress(libopengl32, "glRasterPos2fv") + glRasterPos2i = doGetProcAddress(libopengl32, "glRasterPos2i") + glRasterPos2iv = doGetProcAddress(libopengl32, "glRasterPos2iv") + glRasterPos2s = doGetProcAddress(libopengl32, "glRasterPos2s") + glRasterPos2sv = doGetProcAddress(libopengl32, "glRasterPos2sv") + glRasterPos3d = doGetProcAddress(libopengl32, "glRasterPos3d") + glRasterPos3dv = doGetProcAddress(libopengl32, "glRasterPos3dv") + glRasterPos3f = doGetProcAddress(libopengl32, "glRasterPos3f") + glRasterPos3fv = doGetProcAddress(libopengl32, "glRasterPos3fv") + glRasterPos3i = doGetProcAddress(libopengl32, "glRasterPos3i") + glRasterPos3iv = doGetProcAddress(libopengl32, "glRasterPos3iv") + glRasterPos3s = doGetProcAddress(libopengl32, "glRasterPos3s") + glRasterPos3sv = doGetProcAddress(libopengl32, "glRasterPos3sv") + glRasterPos4d = doGetProcAddress(libopengl32, "glRasterPos4d") + glRasterPos4dv = doGetProcAddress(libopengl32, "glRasterPos4dv") + glRasterPos4f = doGetProcAddress(libopengl32, "glRasterPos4f") + glRasterPos4fv = doGetProcAddress(libopengl32, "glRasterPos4fv") + glRasterPos4i = doGetProcAddress(libopengl32, "glRasterPos4i") + glRasterPos4iv = doGetProcAddress(libopengl32, "glRasterPos4iv") + glRasterPos4s = doGetProcAddress(libopengl32, "glRasterPos4s") + glRasterPos4sv = doGetProcAddress(libopengl32, "glRasterPos4sv") + glReadBuffer = doGetProcAddress(libopengl32, "glReadBuffer") + glReadPixels = doGetProcAddress(libopengl32, "glReadPixels") + glRectd = doGetProcAddress(libopengl32, "glRectd") + glRectdv = doGetProcAddress(libopengl32, "glRectdv") + glRectf = doGetProcAddress(libopengl32, "glRectf") + glRectfv = doGetProcAddress(libopengl32, "glRectfv") + glRecti = doGetProcAddress(libopengl32, "glRecti") + glRectiv = doGetProcAddress(libopengl32, "glRectiv") + glRects = doGetProcAddress(libopengl32, "glRects") + glRectsv = doGetProcAddress(libopengl32, "glRectsv") + glRenderMode = doGetProcAddress(libopengl32, "glRenderMode") + glRotated = doGetProcAddress(libopengl32, "glRotated") + glRotatef = doGetProcAddress(libopengl32, "glRotatef") + glScaled = doGetProcAddress(libopengl32, "glScaled") + glScalef = doGetProcAddress(libopengl32, "glScalef") + glScissor = doGetProcAddress(libopengl32, "glScissor") + glSelectBuffer = doGetProcAddress(libopengl32, "glSelectBuffer") + glShadeModel = doGetProcAddress(libopengl32, "glShadeModel") + glStencilFunc = doGetProcAddress(libopengl32, "glStencilFunc") + glStencilMask = doGetProcAddress(libopengl32, "glStencilMask") + glStencilOp = doGetProcAddress(libopengl32, "glStencilOp") + glTexCoord1d = doGetProcAddress(libopengl32, "glTexCoord1d") + glTexCoord1dv = doGetProcAddress(libopengl32, "glTexCoord1dv") + glTexCoord1f = doGetProcAddress(libopengl32, "glTexCoord1f") + glTexCoord1fv = doGetProcAddress(libopengl32, "glTexCoord1fv") + glTexCoord1i = doGetProcAddress(libopengl32, "glTexCoord1i") + glTexCoord1iv = doGetProcAddress(libopengl32, "glTexCoord1iv") + glTexCoord1s = doGetProcAddress(libopengl32, "glTexCoord1s") + glTexCoord1sv = doGetProcAddress(libopengl32, "glTexCoord1sv") + glTexCoord2d = doGetProcAddress(libopengl32, "glTexCoord2d") + glTexCoord2dv = doGetProcAddress(libopengl32, "glTexCoord2dv") + glTexCoord2f = doGetProcAddress(libopengl32, "glTexCoord2f") + glTexCoord2fv = doGetProcAddress(libopengl32, "glTexCoord2fv") + glTexCoord2i = doGetProcAddress(libopengl32, "glTexCoord2i") + glTexCoord2iv = doGetProcAddress(libopengl32, "glTexCoord2iv") + glTexCoord2s = doGetProcAddress(libopengl32, "glTexCoord2s") + glTexCoord2sv = doGetProcAddress(libopengl32, "glTexCoord2sv") + glTexCoord3d = doGetProcAddress(libopengl32, "glTexCoord3d") + glTexCoord3dv = doGetProcAddress(libopengl32, "glTexCoord3dv") + glTexCoord3f = doGetProcAddress(libopengl32, "glTexCoord3f") + glTexCoord3fv = doGetProcAddress(libopengl32, "glTexCoord3fv") + glTexCoord3i = doGetProcAddress(libopengl32, "glTexCoord3i") + glTexCoord3iv = doGetProcAddress(libopengl32, "glTexCoord3iv") + glTexCoord3s = doGetProcAddress(libopengl32, "glTexCoord3s") + glTexCoord3sv = doGetProcAddress(libopengl32, "glTexCoord3sv") + glTexCoord4d = doGetProcAddress(libopengl32, "glTexCoord4d") + glTexCoord4dv = doGetProcAddress(libopengl32, "glTexCoord4dv") + glTexCoord4f = doGetProcAddress(libopengl32, "glTexCoord4f") + glTexCoord4fv = doGetProcAddress(libopengl32, "glTexCoord4fv") + glTexCoord4i = doGetProcAddress(libopengl32, "glTexCoord4i") + glTexCoord4iv = doGetProcAddress(libopengl32, "glTexCoord4iv") + glTexCoord4s = doGetProcAddress(libopengl32, "glTexCoord4s") + glTexCoord4sv = doGetProcAddress(libopengl32, "glTexCoord4sv") + glTexCoordPointer = doGetProcAddress(libopengl32, "glTexCoordPointer") + glTexEnvf = doGetProcAddress(libopengl32, "glTexEnvf") + glTexEnvfv = doGetProcAddress(libopengl32, "glTexEnvfv") + glTexEnvi = doGetProcAddress(libopengl32, "glTexEnvi") + glTexEnviv = doGetProcAddress(libopengl32, "glTexEnviv") + glTexGend = doGetProcAddress(libopengl32, "glTexGend") + glTexGendv = doGetProcAddress(libopengl32, "glTexGendv") + glTexGenf = doGetProcAddress(libopengl32, "glTexGenf") + glTexGenfv = doGetProcAddress(libopengl32, "glTexGenfv") + glTexGeni = doGetProcAddress(libopengl32, "glTexGeni") + glTexGeniv = doGetProcAddress(libopengl32, "glTexGeniv") + glTexImage1D = doGetProcAddress(libopengl32, "glTexImage1D") + glTexImage2D = doGetProcAddress(libopengl32, "glTexImage2D") + glTexParameterf = doGetProcAddress(libopengl32, "glTexParameterf") + glTexParameterfv = doGetProcAddress(libopengl32, "glTexParameterfv") + glTexParameteri = doGetProcAddress(libopengl32, "glTexParameteri") + glTexParameteriv = doGetProcAddress(libopengl32, "glTexParameteriv") + glTexSubImage1D = doGetProcAddress(libopengl32, "glTexSubImage1D") + glTexSubImage2D = doGetProcAddress(libopengl32, "glTexSubImage2D") + glTranslated = doGetProcAddress(libopengl32, "glTranslated") + glTranslatef = doGetProcAddress(libopengl32, "glTranslatef") + glVertex2d = doGetProcAddress(libopengl32, "glVertex2d") + glVertex2dv = doGetProcAddress(libopengl32, "glVertex2dv") + glVertex2f = doGetProcAddress(libopengl32, "glVertex2f") + glVertex2fv = doGetProcAddress(libopengl32, "glVertex2fv") + glVertex2i = doGetProcAddress(libopengl32, "glVertex2i") + glVertex2iv = doGetProcAddress(libopengl32, "glVertex2iv") + glVertex2s = doGetProcAddress(libopengl32, "glVertex2s") + glVertex2sv = doGetProcAddress(libopengl32, "glVertex2sv") + glVertex3d = doGetProcAddress(libopengl32, "glVertex3d") + glVertex3dv = doGetProcAddress(libopengl32, "glVertex3dv") + glVertex3f = doGetProcAddress(libopengl32, "glVertex3f") + glVertex3fv = doGetProcAddress(libopengl32, "glVertex3fv") + glVertex3i = doGetProcAddress(libopengl32, "glVertex3i") + glVertex3iv = doGetProcAddress(libopengl32, "glVertex3iv") + glVertex3s = doGetProcAddress(libopengl32, "glVertex3s") + glVertex3sv = doGetProcAddress(libopengl32, "glVertex3sv") + glVertex4d = doGetProcAddress(libopengl32, "glVertex4d") + glVertex4dv = doGetProcAddress(libopengl32, "glVertex4dv") + glVertex4f = doGetProcAddress(libopengl32, "glVertex4f") + glVertex4fv = doGetProcAddress(libopengl32, "glVertex4fv") + glVertex4i = doGetProcAddress(libopengl32, "glVertex4i") + glVertex4iv = doGetProcAddress(libopengl32, "glVertex4iv") + glVertex4s = doGetProcAddress(libopengl32, "glVertex4s") + glVertex4sv = doGetProcAddress(libopengl32, "glVertex4sv") + glVertexPointer = doGetProcAddress(libopengl32, "glVertexPointer") + glViewport = doGetProcAddress(libopengl32, "glViewport") + wglCopyContext = doGetProcAddress(libopengl32, "wglCopyContext") + wglCreateContext = doGetProcAddress(libopengl32, "wglCreateContext") + wglCreateLayerContext = doGetProcAddress(libopengl32, "wglCreateLayerContext") + wglDeleteContext = doGetProcAddress(libopengl32, "wglDeleteContext") + wglDescribeLayerPlane = doGetProcAddress(libopengl32, "wglDescribeLayerPlane") + wglGetCurrentContext = doGetProcAddress(libopengl32, "wglGetCurrentContext") + wglGetCurrentDC = doGetProcAddress(libopengl32, "wglGetCurrentDC") + wglGetLayerPaletteEntries = doGetProcAddress(libopengl32, "wglGetLayerPaletteEntries") + wglGetProcAddress = doGetProcAddress(libopengl32, "wglGetProcAddress") + wglMakeCurrent = doGetProcAddress(libopengl32, "wglMakeCurrent") + wglRealizeLayerPalette = doGetProcAddress(libopengl32, "wglRealizeLayerPalette") + wglSetLayerPaletteEntries = doGetProcAddress(libopengl32, "wglSetLayerPaletteEntries") + wglShareLists = doGetProcAddress(libopengl32, "wglShareLists") + wglSwapLayerBuffers = doGetProcAddress(libopengl32, "wglSwapLayerBuffers") + wglSwapMultipleBuffers = doGetProcAddress(libopengl32, "wglSwapMultipleBuffers") + wglUseFontBitmaps = doGetProcAddress(libopengl32, "wglUseFontBitmapsW") + wglUseFontOutlines = doGetProcAddress(libopengl32, "wglUseFontOutlinesW") + glDebugEntry = doGetProcAddress(libopengl32, "glDebugEntry") + wglChoosePixelFormat = doGetProcAddress(libopengl32, "wglChoosePixelFormat") + wglDescribePixelFormat = doGetProcAddress(libopengl32, "wglDescribePixelFormat") + wglGetPixelFormat = doGetProcAddress(libopengl32, "wglGetPixelFormat") + wglSetPixelFormat = doGetProcAddress(libopengl32, "wglSetPixelFormat") +} + +func GlAccum(op GLenum, value GLfloat) { + syscall3(glAccum, 2, + uintptr(op), + uintptr(value), + 0) +} + +func GlAlphaFunc(aFunc GLenum, ref GLclampf) { + syscall3(glAlphaFunc, 2, + uintptr(aFunc), + uintptr(ref), + 0) +} + +func GlAreTexturesResident(n GLsizei, textures /*const*/ *GLuint, residences *GLboolean) GLboolean { + ret1 := syscall3(glAreTexturesResident, 3, + uintptr(n), + uintptr(unsafe.Pointer(textures)), + uintptr(unsafe.Pointer(residences))) + return GLboolean(ret1) +} + +func GlArrayElement(i GLint) { + syscall3(glArrayElement, 1, + uintptr(i), + 0, + 0) +} + +func GlBegin(mode GLenum) { + syscall3(glBegin, 1, + uintptr(mode), + 0, + 0) +} + +func GlBindTexture(target GLenum, texture GLuint) { + syscall3(glBindTexture, 2, + uintptr(target), + uintptr(texture), + 0) +} + +func GlBitmap(width GLsizei, height GLsizei, xorig GLfloat, yorig GLfloat, xmove GLfloat, ymove GLfloat, bitmap /*const*/ *GLubyte) { + syscall9(glBitmap, 7, + uintptr(width), + uintptr(height), + uintptr(xorig), + uintptr(yorig), + uintptr(xmove), + uintptr(ymove), + uintptr(unsafe.Pointer(bitmap)), + 0, + 0) +} + +func GlBlendFunc(sfactor GLenum, dfactor GLenum) { + syscall3(glBlendFunc, 2, + uintptr(sfactor), + uintptr(dfactor), + 0) +} + +func GlCallList(list GLuint) { + syscall3(glCallList, 1, + uintptr(list), + 0, + 0) +} + +func GlCallLists(n GLsizei, aType GLenum, lists /*const*/ uintptr) { + syscall3(glCallLists, 3, + uintptr(n), + uintptr(aType), + lists) +} + +func GlClear(mask GLbitfield) { + syscall3(glClear, 1, + uintptr(mask), + 0, + 0) +} + +func GlClearAccum(red GLfloat, green GLfloat, blue GLfloat, alpha GLfloat) { + syscall6(glClearAccum, 4, + uintptr(red), + uintptr(green), + uintptr(blue), + uintptr(alpha), + 0, + 0) +} + +func GlClearColor(red GLclampf, green GLclampf, blue GLclampf, alpha GLclampf) { + syscall6(glClearColor, 4, + uintptr(red), + uintptr(green), + uintptr(blue), + uintptr(alpha), + 0, + 0) +} + +func GlClearDepth(depth GLclampd) { + syscall3(glClearDepth, 1, + uintptr(depth), + 0, + 0) +} + +func GlClearIndex(c GLfloat) { + syscall3(glClearIndex, 1, + uintptr(c), + 0, + 0) +} + +func GlClearStencil(s GLint) { + syscall3(glClearStencil, 1, + uintptr(s), + 0, + 0) +} + +func GlClipPlane(plane GLenum, equation /*const*/ *GLdouble) { + syscall3(glClipPlane, 2, + uintptr(plane), + uintptr(unsafe.Pointer(equation)), + 0) +} + +func GlColor3b(red GLbyte, green GLbyte, blue GLbyte) { + syscall3(glColor3b, 3, + uintptr(red), + uintptr(green), + uintptr(blue)) +} + +func GlColor3bv(v /*const*/ *GLbyte) { + syscall3(glColor3bv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor3d(red GLdouble, green GLdouble, blue GLdouble) { + syscall3(glColor3d, 3, + uintptr(red), + uintptr(green), + uintptr(blue)) +} + +func GlColor3dv(v /*const*/ *GLdouble) { + syscall3(glColor3dv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor3f(red GLfloat, green GLfloat, blue GLfloat) { + syscall3(glColor3f, 3, + uintptr(red), + uintptr(green), + uintptr(blue)) +} + +func GlColor3fv(v /*const*/ *GLfloat) { + syscall3(glColor3fv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor3i(red GLint, green GLint, blue GLint) { + syscall3(glColor3i, 3, + uintptr(red), + uintptr(green), + uintptr(blue)) +} + +func GlColor3iv(v /*const*/ *GLint) { + syscall3(glColor3iv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor3s(red GLshort, green GLshort, blue GLshort) { + syscall3(glColor3s, 3, + uintptr(red), + uintptr(green), + uintptr(blue)) +} + +func GlColor3sv(v /*const*/ *GLshort) { + syscall3(glColor3sv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor3ub(red GLubyte, green GLubyte, blue GLubyte) { + syscall3(glColor3ub, 3, + uintptr(red), + uintptr(green), + uintptr(blue)) +} + +func GlColor3ubv(v /*const*/ *GLubyte) { + syscall3(glColor3ubv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor3ui(red GLuint, green GLuint, blue GLuint) { + syscall3(glColor3ui, 3, + uintptr(red), + uintptr(green), + uintptr(blue)) +} + +func GlColor3uiv(v /*const*/ *GLuint) { + syscall3(glColor3uiv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor3us(red GLushort, green GLushort, blue GLushort) { + syscall3(glColor3us, 3, + uintptr(red), + uintptr(green), + uintptr(blue)) +} + +func GlColor3usv(v /*const*/ *GLushort) { + syscall3(glColor3usv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor4b(red GLbyte, green GLbyte, blue GLbyte, alpha GLbyte) { + syscall6(glColor4b, 4, + uintptr(red), + uintptr(green), + uintptr(blue), + uintptr(alpha), + 0, + 0) +} + +func GlColor4bv(v /*const*/ *GLbyte) { + syscall3(glColor4bv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor4d(red GLdouble, green GLdouble, blue GLdouble, alpha GLdouble) { + syscall6(glColor4d, 4, + uintptr(red), + uintptr(green), + uintptr(blue), + uintptr(alpha), + 0, + 0) +} + +func GlColor4dv(v /*const*/ *GLdouble) { + syscall3(glColor4dv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor4f(red GLfloat, green GLfloat, blue GLfloat, alpha GLfloat) { + syscall6(glColor4f, 4, + uintptr(red), + uintptr(green), + uintptr(blue), + uintptr(alpha), + 0, + 0) +} + +func GlColor4fv(v /*const*/ *GLfloat) { + syscall3(glColor4fv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor4i(red GLint, green GLint, blue GLint, alpha GLint) { + syscall6(glColor4i, 4, + uintptr(red), + uintptr(green), + uintptr(blue), + uintptr(alpha), + 0, + 0) +} + +func GlColor4iv(v /*const*/ *GLint) { + syscall3(glColor4iv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor4s(red GLshort, green GLshort, blue GLshort, alpha GLshort) { + syscall6(glColor4s, 4, + uintptr(red), + uintptr(green), + uintptr(blue), + uintptr(alpha), + 0, + 0) +} + +func GlColor4sv(v /*const*/ *GLshort) { + syscall3(glColor4sv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor4ub(red GLubyte, green GLubyte, blue GLubyte, alpha GLubyte) { + syscall6(glColor4ub, 4, + uintptr(red), + uintptr(green), + uintptr(blue), + uintptr(alpha), + 0, + 0) +} + +func GlColor4ubv(v /*const*/ *GLubyte) { + syscall3(glColor4ubv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor4ui(red GLuint, green GLuint, blue GLuint, alpha GLuint) { + syscall6(glColor4ui, 4, + uintptr(red), + uintptr(green), + uintptr(blue), + uintptr(alpha), + 0, + 0) +} + +func GlColor4uiv(v /*const*/ *GLuint) { + syscall3(glColor4uiv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColor4us(red GLushort, green GLushort, blue GLushort, alpha GLushort) { + syscall6(glColor4us, 4, + uintptr(red), + uintptr(green), + uintptr(blue), + uintptr(alpha), + 0, + 0) +} + +func GlColor4usv(v /*const*/ *GLushort) { + syscall3(glColor4usv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlColorMask(red GLboolean, green GLboolean, blue GLboolean, alpha GLboolean) { + syscall6(glColorMask, 4, + uintptr(red), + uintptr(green), + uintptr(blue), + uintptr(alpha), + 0, + 0) +} + +func GlColorMaterial(face GLenum, mode GLenum) { + syscall3(glColorMaterial, 2, + uintptr(face), + uintptr(mode), + 0) +} + +func GlColorPointer(size GLint, aType GLenum, stride GLsizei, pointer /*const*/ uintptr) { + syscall6(glColorPointer, 4, + uintptr(size), + uintptr(aType), + uintptr(stride), + pointer, + 0, + 0) +} + +func GlCopyPixels(x GLint, y GLint, width GLsizei, height GLsizei, aType GLenum) { + syscall6(glCopyPixels, 5, + uintptr(x), + uintptr(y), + uintptr(width), + uintptr(height), + uintptr(aType), + 0) +} + +func GlCopyTexImage1D(target GLenum, level GLint, internalFormat GLenum, x GLint, y GLint, width GLsizei, border GLint) { + syscall9(glCopyTexImage1D, 7, + uintptr(target), + uintptr(level), + uintptr(internalFormat), + uintptr(x), + uintptr(y), + uintptr(width), + uintptr(border), + 0, + 0) +} + +func GlCopyTexImage2D(target GLenum, level GLint, internalFormat GLenum, x GLint, y GLint, width GLsizei, height GLsizei, border GLint) { + syscall9(glCopyTexImage2D, 8, + uintptr(target), + uintptr(level), + uintptr(internalFormat), + uintptr(x), + uintptr(y), + uintptr(width), + uintptr(height), + uintptr(border), + 0) +} + +func GlCopyTexSubImage1D(target GLenum, level GLint, xoffset GLint, x GLint, y GLint, width GLsizei) { + syscall6(glCopyTexSubImage1D, 6, + uintptr(target), + uintptr(level), + uintptr(xoffset), + uintptr(x), + uintptr(y), + uintptr(width)) +} + +func GlCopyTexSubImage2D(target GLenum, level GLint, xoffset GLint, yoffset GLint, x GLint, y GLint, width GLsizei, height GLsizei) { + syscall9(glCopyTexSubImage2D, 8, + uintptr(target), + uintptr(level), + uintptr(xoffset), + uintptr(yoffset), + uintptr(x), + uintptr(y), + uintptr(width), + uintptr(height), + 0) +} + +func GlCullFace(mode GLenum) { + syscall3(glCullFace, 1, + uintptr(mode), + 0, + 0) +} + +func GlDeleteLists(list GLuint, aRange GLsizei) { + syscall3(glDeleteLists, 2, + uintptr(list), + uintptr(aRange), + 0) +} + +func GlDeleteTextures(n GLsizei, textures /*const*/ *GLuint) { + syscall3(glDeleteTextures, 2, + uintptr(n), + uintptr(unsafe.Pointer(textures)), + 0) +} + +func GlDepthFunc(aFunc GLenum) { + syscall3(glDepthFunc, 1, + uintptr(aFunc), + 0, + 0) +} + +func GlDepthMask(flag GLboolean) { + syscall3(glDepthMask, 1, + uintptr(flag), + 0, + 0) +} + +func GlDepthRange(zNear GLclampd, zFar GLclampd) { + syscall3(glDepthRange, 2, + uintptr(zNear), + uintptr(zFar), + 0) +} + +func GlDisable(cap GLenum) { + syscall3(glDisable, 1, + uintptr(cap), + 0, + 0) +} + +func GlDisableClientState(array GLenum) { + syscall3(glDisableClientState, 1, + uintptr(array), + 0, + 0) +} + +func GlDrawArrays(mode GLenum, first GLint, count GLsizei) { + syscall3(glDrawArrays, 3, + uintptr(mode), + uintptr(first), + uintptr(count)) +} + +func GlDrawBuffer(mode GLenum) { + syscall3(glDrawBuffer, 1, + uintptr(mode), + 0, + 0) +} + +func GlDrawElements(mode GLenum, count GLsizei, aType GLenum, indices /*const*/ uintptr) { + syscall6(glDrawElements, 4, + uintptr(mode), + uintptr(count), + uintptr(aType), + indices, + 0, + 0) +} + +func GlDrawPixels(width GLsizei, height GLsizei, format GLenum, aType GLenum, pixels /*const*/ uintptr) { + syscall6(glDrawPixels, 5, + uintptr(width), + uintptr(height), + uintptr(format), + uintptr(aType), + pixels, + 0) +} + +func GlEdgeFlag(flag GLboolean) { + syscall3(glEdgeFlag, 1, + uintptr(flag), + 0, + 0) +} + +func GlEdgeFlagPointer(stride GLsizei, pointer /*const*/ uintptr) { + syscall3(glEdgeFlagPointer, 2, + uintptr(stride), + pointer, + 0) +} + +func GlEdgeFlagv(flag /*const*/ *GLboolean) { + syscall3(glEdgeFlagv, 1, + uintptr(unsafe.Pointer(flag)), + 0, + 0) +} + +func GlEnable(cap GLenum) { + syscall3(glEnable, 1, + uintptr(cap), + 0, + 0) +} + +func GlEnableClientState(array GLenum) { + syscall3(glEnableClientState, 1, + uintptr(array), + 0, + 0) +} + +func GlEnd() { + syscall3(glEnd, 0, + 0, + 0, + 0) +} + +func GlEndList() { + syscall3(glEndList, 0, + 0, + 0, + 0) +} + +func GlEvalCoord1d(u GLdouble) { + syscall3(glEvalCoord1d, 1, + uintptr(u), + 0, + 0) +} + +func GlEvalCoord1dv(u /*const*/ *GLdouble) { + syscall3(glEvalCoord1dv, 1, + uintptr(unsafe.Pointer(u)), + 0, + 0) +} + +func GlEvalCoord1f(u GLfloat) { + syscall3(glEvalCoord1f, 1, + uintptr(u), + 0, + 0) +} + +func GlEvalCoord1fv(u /*const*/ *GLfloat) { + syscall3(glEvalCoord1fv, 1, + uintptr(unsafe.Pointer(u)), + 0, + 0) +} + +func GlEvalCoord2d(u GLdouble, v GLdouble) { + syscall3(glEvalCoord2d, 2, + uintptr(u), + uintptr(v), + 0) +} + +func GlEvalCoord2dv(u /*const*/ *GLdouble) { + syscall3(glEvalCoord2dv, 1, + uintptr(unsafe.Pointer(u)), + 0, + 0) +} + +func GlEvalCoord2f(u GLfloat, v GLfloat) { + syscall3(glEvalCoord2f, 2, + uintptr(u), + uintptr(v), + 0) +} + +func GlEvalCoord2fv(u /*const*/ *GLfloat) { + syscall3(glEvalCoord2fv, 1, + uintptr(unsafe.Pointer(u)), + 0, + 0) +} + +func GlEvalMesh1(mode GLenum, i1 GLint, i2 GLint) { + syscall3(glEvalMesh1, 3, + uintptr(mode), + uintptr(i1), + uintptr(i2)) +} + +func GlEvalMesh2(mode GLenum, i1 GLint, i2 GLint, j1 GLint, j2 GLint) { + syscall6(glEvalMesh2, 5, + uintptr(mode), + uintptr(i1), + uintptr(i2), + uintptr(j1), + uintptr(j2), + 0) +} + +func GlEvalPoint1(i GLint) { + syscall3(glEvalPoint1, 1, + uintptr(i), + 0, + 0) +} + +func GlEvalPoint2(i GLint, j GLint) { + syscall3(glEvalPoint2, 2, + uintptr(i), + uintptr(j), + 0) +} + +func GlFeedbackBuffer(size GLsizei, aType GLenum, buffer *GLfloat) { + syscall3(glFeedbackBuffer, 3, + uintptr(size), + uintptr(aType), + uintptr(unsafe.Pointer(buffer))) +} + +func GlFinish() { + syscall3(glFinish, 0, + 0, + 0, + 0) +} + +func GlFlush() { + syscall3(glFlush, 0, + 0, + 0, + 0) +} + +func GlFogf(pname GLenum, param GLfloat) { + syscall3(glFogf, 2, + uintptr(pname), + uintptr(param), + 0) +} + +func GlFogfv(pname GLenum, params /*const*/ *GLfloat) { + syscall3(glFogfv, 2, + uintptr(pname), + uintptr(unsafe.Pointer(params)), + 0) +} + +func GlFogi(pname GLenum, param GLint) { + syscall3(glFogi, 2, + uintptr(pname), + uintptr(param), + 0) +} + +func GlFogiv(pname GLenum, params /*const*/ *GLint) { + syscall3(glFogiv, 2, + uintptr(pname), + uintptr(unsafe.Pointer(params)), + 0) +} + +func GlFrontFace(mode GLenum) { + syscall3(glFrontFace, 1, + uintptr(mode), + 0, + 0) +} + +func GlFrustum(left GLdouble, right GLdouble, bottom GLdouble, top GLdouble, zNear GLdouble, zFar GLdouble) { + syscall6(glFrustum, 6, + uintptr(left), + uintptr(right), + uintptr(bottom), + uintptr(top), + uintptr(zNear), + uintptr(zFar)) +} + +func GlGenLists(aRange GLsizei) GLuint { + ret1 := syscall3(glGenLists, 1, + uintptr(aRange), + 0, + 0) + return GLuint(ret1) +} + +func GlGenTextures(n GLsizei, textures *GLuint) { + syscall3(glGenTextures, 2, + uintptr(n), + uintptr(unsafe.Pointer(textures)), + 0) +} + +func GlGetBooleanv(pname GLenum, params *GLboolean) { + syscall3(glGetBooleanv, 2, + uintptr(pname), + uintptr(unsafe.Pointer(params)), + 0) +} + +func GlGetClipPlane(plane GLenum, equation *GLdouble) { + syscall3(glGetClipPlane, 2, + uintptr(plane), + uintptr(unsafe.Pointer(equation)), + 0) +} + +func GlGetDoublev(pname GLenum, params *GLdouble) { + syscall3(glGetDoublev, 2, + uintptr(pname), + uintptr(unsafe.Pointer(params)), + 0) +} + +func GlGetError() GLenum { + ret1 := syscall3(glGetError, 0, + 0, + 0, + 0) + return GLenum(ret1) +} + +func GlGetFloatv(pname GLenum, params *GLfloat) { + syscall3(glGetFloatv, 2, + uintptr(pname), + uintptr(unsafe.Pointer(params)), + 0) +} + +func GlGetIntegerv(pname GLenum, params *GLint) { + syscall3(glGetIntegerv, 2, + uintptr(pname), + uintptr(unsafe.Pointer(params)), + 0) +} + +func GlGetLightfv(light GLenum, pname GLenum, params *GLfloat) { + syscall3(glGetLightfv, 3, + uintptr(light), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlGetLightiv(light GLenum, pname GLenum, params *GLint) { + syscall3(glGetLightiv, 3, + uintptr(light), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlGetMapdv(target GLenum, query GLenum, v *GLdouble) { + syscall3(glGetMapdv, 3, + uintptr(target), + uintptr(query), + uintptr(unsafe.Pointer(v))) +} + +func GlGetMapfv(target GLenum, query GLenum, v *GLfloat) { + syscall3(glGetMapfv, 3, + uintptr(target), + uintptr(query), + uintptr(unsafe.Pointer(v))) +} + +func GlGetMapiv(target GLenum, query GLenum, v *GLint) { + syscall3(glGetMapiv, 3, + uintptr(target), + uintptr(query), + uintptr(unsafe.Pointer(v))) +} + +func GlGetMaterialfv(face GLenum, pname GLenum, params *GLfloat) { + syscall3(glGetMaterialfv, 3, + uintptr(face), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlGetMaterialiv(face GLenum, pname GLenum, params *GLint) { + syscall3(glGetMaterialiv, 3, + uintptr(face), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlGetPixelMapfv(aMap GLenum, values *GLfloat) { + syscall3(glGetPixelMapfv, 2, + uintptr(aMap), + uintptr(unsafe.Pointer(values)), + 0) +} + +func GlGetPixelMapuiv(aMap GLenum, values *GLuint) { + syscall3(glGetPixelMapuiv, 2, + uintptr(aMap), + uintptr(unsafe.Pointer(values)), + 0) +} + +func GlGetPixelMapusv(aMap GLenum, values *GLushort) { + syscall3(glGetPixelMapusv, 2, + uintptr(aMap), + uintptr(unsafe.Pointer(values)), + 0) +} + +func GlGetPointerv(pname GLenum, params uintptr) { + syscall3(glGetPointerv, 2, + uintptr(pname), + params, + 0) +} + +func GlGetPolygonStipple(mask *GLubyte) { + syscall3(glGetPolygonStipple, 1, + uintptr(unsafe.Pointer(mask)), + 0, + 0) +} + +func GlGetTexEnvfv(target GLenum, pname GLenum, params *GLfloat) { + syscall3(glGetTexEnvfv, 3, + uintptr(target), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlGetTexEnviv(target GLenum, pname GLenum, params *GLint) { + syscall3(glGetTexEnviv, 3, + uintptr(target), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlGetTexGendv(coord GLenum, pname GLenum, params *GLdouble) { + syscall3(glGetTexGendv, 3, + uintptr(coord), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlGetTexGenfv(coord GLenum, pname GLenum, params *GLfloat) { + syscall3(glGetTexGenfv, 3, + uintptr(coord), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlGetTexGeniv(coord GLenum, pname GLenum, params *GLint) { + syscall3(glGetTexGeniv, 3, + uintptr(coord), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlGetTexImage(target GLenum, level GLint, format GLenum, aType GLenum, pixels uintptr) { + syscall6(glGetTexImage, 5, + uintptr(target), + uintptr(level), + uintptr(format), + uintptr(aType), + pixels, + 0) +} + +func GlGetTexLevelParameterfv(target GLenum, level GLint, pname GLenum, params *GLfloat) { + syscall6(glGetTexLevelParameterfv, 4, + uintptr(target), + uintptr(level), + uintptr(pname), + uintptr(unsafe.Pointer(params)), + 0, + 0) +} + +func GlGetTexLevelParameteriv(target GLenum, level GLint, pname GLenum, params *GLint) { + syscall6(glGetTexLevelParameteriv, 4, + uintptr(target), + uintptr(level), + uintptr(pname), + uintptr(unsafe.Pointer(params)), + 0, + 0) +} + +func GlGetTexParameterfv(target GLenum, pname GLenum, params *GLfloat) { + syscall3(glGetTexParameterfv, 3, + uintptr(target), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlGetTexParameteriv(target GLenum, pname GLenum, params *GLint) { + syscall3(glGetTexParameteriv, 3, + uintptr(target), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlHint(target GLenum, mode GLenum) { + syscall3(glHint, 2, + uintptr(target), + uintptr(mode), + 0) +} + +func GlIndexMask(mask GLuint) { + syscall3(glIndexMask, 1, + uintptr(mask), + 0, + 0) +} + +func GlIndexPointer(aType GLenum, stride GLsizei, pointer /*const*/ uintptr) { + syscall3(glIndexPointer, 3, + uintptr(aType), + uintptr(stride), + pointer) +} + +func GlIndexd(c GLdouble) { + syscall3(glIndexd, 1, + uintptr(c), + 0, + 0) +} + +func GlIndexdv(c /*const*/ *GLdouble) { + syscall3(glIndexdv, 1, + uintptr(unsafe.Pointer(c)), + 0, + 0) +} + +func GlIndexf(c GLfloat) { + syscall3(glIndexf, 1, + uintptr(c), + 0, + 0) +} + +func GlIndexfv(c /*const*/ *GLfloat) { + syscall3(glIndexfv, 1, + uintptr(unsafe.Pointer(c)), + 0, + 0) +} + +func GlIndexi(c GLint) { + syscall3(glIndexi, 1, + uintptr(c), + 0, + 0) +} + +func GlIndexiv(c /*const*/ *GLint) { + syscall3(glIndexiv, 1, + uintptr(unsafe.Pointer(c)), + 0, + 0) +} + +func GlIndexs(c GLshort) { + syscall3(glIndexs, 1, + uintptr(c), + 0, + 0) +} + +func GlIndexsv(c /*const*/ *GLshort) { + syscall3(glIndexsv, 1, + uintptr(unsafe.Pointer(c)), + 0, + 0) +} + +func GlIndexub(c GLubyte) { + syscall3(glIndexub, 1, + uintptr(c), + 0, + 0) +} + +func GlIndexubv(c /*const*/ *GLubyte) { + syscall3(glIndexubv, 1, + uintptr(unsafe.Pointer(c)), + 0, + 0) +} + +func GlInitNames() { + syscall3(glInitNames, 0, + 0, + 0, + 0) +} + +func GlInterleavedArrays(format GLenum, stride GLsizei, pointer /*const*/ uintptr) { + syscall3(glInterleavedArrays, 3, + uintptr(format), + uintptr(stride), + pointer) +} + +func GlIsEnabled(cap GLenum) GLboolean { + ret1 := syscall3(glIsEnabled, 1, + uintptr(cap), + 0, + 0) + return GLboolean(ret1) +} + +func GlIsList(list GLuint) GLboolean { + ret1 := syscall3(glIsList, 1, + uintptr(list), + 0, + 0) + return GLboolean(ret1) +} + +func GlIsTexture(texture GLuint) GLboolean { + ret1 := syscall3(glIsTexture, 1, + uintptr(texture), + 0, + 0) + return GLboolean(ret1) +} + +func GlLightModelf(pname GLenum, param GLfloat) { + syscall3(glLightModelf, 2, + uintptr(pname), + uintptr(param), + 0) +} + +func GlLightModelfv(pname GLenum, params /*const*/ *GLfloat) { + syscall3(glLightModelfv, 2, + uintptr(pname), + uintptr(unsafe.Pointer(params)), + 0) +} + +func GlLightModeli(pname GLenum, param GLint) { + syscall3(glLightModeli, 2, + uintptr(pname), + uintptr(param), + 0) +} + +func GlLightModeliv(pname GLenum, params /*const*/ *GLint) { + syscall3(glLightModeliv, 2, + uintptr(pname), + uintptr(unsafe.Pointer(params)), + 0) +} + +func GlLightf(light GLenum, pname GLenum, param GLfloat) { + syscall3(glLightf, 3, + uintptr(light), + uintptr(pname), + uintptr(param)) +} + +func GlLightfv(light GLenum, pname GLenum, params /*const*/ *GLfloat) { + syscall3(glLightfv, 3, + uintptr(light), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlLighti(light GLenum, pname GLenum, param GLint) { + syscall3(glLighti, 3, + uintptr(light), + uintptr(pname), + uintptr(param)) +} + +func GlLightiv(light GLenum, pname GLenum, params /*const*/ *GLint) { + syscall3(glLightiv, 3, + uintptr(light), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlLineStipple(factor GLint, pattern GLushort) { + syscall3(glLineStipple, 2, + uintptr(factor), + uintptr(pattern), + 0) +} + +func GlLineWidth(width GLfloat) { + syscall3(glLineWidth, 1, + uintptr(width), + 0, + 0) +} + +func GlListBase(base GLuint) { + syscall3(glListBase, 1, + uintptr(base), + 0, + 0) +} + +func GlLoadIdentity() { + syscall3(glLoadIdentity, 0, + 0, + 0, + 0) +} + +func GlLoadMatrixd(m /*const*/ *GLdouble) { + syscall3(glLoadMatrixd, 1, + uintptr(unsafe.Pointer(m)), + 0, + 0) +} + +func GlLoadMatrixf(m /*const*/ *GLfloat) { + syscall3(glLoadMatrixf, 1, + uintptr(unsafe.Pointer(m)), + 0, + 0) +} + +func GlLoadName(name GLuint) { + syscall3(glLoadName, 1, + uintptr(name), + 0, + 0) +} + +func GlLogicOp(opcode GLenum) { + syscall3(glLogicOp, 1, + uintptr(opcode), + 0, + 0) +} + +func GlMap1d(target GLenum, u1 GLdouble, u2 GLdouble, stride GLint, order GLint, points /*const*/ *GLdouble) { + syscall6(glMap1d, 6, + uintptr(target), + uintptr(u1), + uintptr(u2), + uintptr(stride), + uintptr(order), + uintptr(unsafe.Pointer(points))) +} + +func GlMap1f(target GLenum, u1 GLfloat, u2 GLfloat, stride GLint, order GLint, points /*const*/ *GLfloat) { + syscall6(glMap1f, 6, + uintptr(target), + uintptr(u1), + uintptr(u2), + uintptr(stride), + uintptr(order), + uintptr(unsafe.Pointer(points))) +} + +func GlMap2d(target GLenum, u1 GLdouble, u2 GLdouble, ustride GLint, uorder GLint, v1 GLdouble, v2 GLdouble, vstride GLint, vorder GLint, points /*const*/ *GLdouble) { + syscall12(glMap2d, 10, + uintptr(target), + uintptr(u1), + uintptr(u2), + uintptr(ustride), + uintptr(uorder), + uintptr(v1), + uintptr(v2), + uintptr(vstride), + uintptr(vorder), + uintptr(unsafe.Pointer(points)), + 0, + 0) +} + +func GlMap2f(target GLenum, u1 GLfloat, u2 GLfloat, ustride GLint, uorder GLint, v1 GLfloat, v2 GLfloat, vstride GLint, vorder GLint, points /*const*/ *GLfloat) { + syscall12(glMap2f, 10, + uintptr(target), + uintptr(u1), + uintptr(u2), + uintptr(ustride), + uintptr(uorder), + uintptr(v1), + uintptr(v2), + uintptr(vstride), + uintptr(vorder), + uintptr(unsafe.Pointer(points)), + 0, + 0) +} + +func GlMapGrid1d(un GLint, u1 GLdouble, u2 GLdouble) { + syscall3(glMapGrid1d, 3, + uintptr(un), + uintptr(u1), + uintptr(u2)) +} + +func GlMapGrid1f(un GLint, u1 GLfloat, u2 GLfloat) { + syscall3(glMapGrid1f, 3, + uintptr(un), + uintptr(u1), + uintptr(u2)) +} + +func GlMapGrid2d(un GLint, u1 GLdouble, u2 GLdouble, vn GLint, v1 GLdouble, v2 GLdouble) { + syscall6(glMapGrid2d, 6, + uintptr(un), + uintptr(u1), + uintptr(u2), + uintptr(vn), + uintptr(v1), + uintptr(v2)) +} + +func GlMapGrid2f(un GLint, u1 GLfloat, u2 GLfloat, vn GLint, v1 GLfloat, v2 GLfloat) { + syscall6(glMapGrid2f, 6, + uintptr(un), + uintptr(u1), + uintptr(u2), + uintptr(vn), + uintptr(v1), + uintptr(v2)) +} + +func GlMaterialf(face GLenum, pname GLenum, param GLfloat) { + syscall3(glMaterialf, 3, + uintptr(face), + uintptr(pname), + uintptr(param)) +} + +func GlMaterialfv(face GLenum, pname GLenum, params /*const*/ *GLfloat) { + syscall3(glMaterialfv, 3, + uintptr(face), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlMateriali(face GLenum, pname GLenum, param GLint) { + syscall3(glMateriali, 3, + uintptr(face), + uintptr(pname), + uintptr(param)) +} + +func GlMaterialiv(face GLenum, pname GLenum, params /*const*/ *GLint) { + syscall3(glMaterialiv, 3, + uintptr(face), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlMatrixMode(mode GLenum) { + syscall3(glMatrixMode, 1, + uintptr(mode), + 0, + 0) +} + +func GlMultMatrixd(m /*const*/ *GLdouble) { + syscall3(glMultMatrixd, 1, + uintptr(unsafe.Pointer(m)), + 0, + 0) +} + +func GlMultMatrixf(m /*const*/ *GLfloat) { + syscall3(glMultMatrixf, 1, + uintptr(unsafe.Pointer(m)), + 0, + 0) +} + +func GlNewList(list GLuint, mode GLenum) { + syscall3(glNewList, 2, + uintptr(list), + uintptr(mode), + 0) +} + +func GlNormal3b(nx GLbyte, ny GLbyte, nz GLbyte) { + syscall3(glNormal3b, 3, + uintptr(nx), + uintptr(ny), + uintptr(nz)) +} + +func GlNormal3bv(v /*const*/ *GLbyte) { + syscall3(glNormal3bv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlNormal3d(nx GLdouble, ny GLdouble, nz GLdouble) { + syscall3(glNormal3d, 3, + uintptr(nx), + uintptr(ny), + uintptr(nz)) +} + +func GlNormal3dv(v /*const*/ *GLdouble) { + syscall3(glNormal3dv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlNormal3f(nx GLfloat, ny GLfloat, nz GLfloat) { + syscall3(glNormal3f, 3, + uintptr(nx), + uintptr(ny), + uintptr(nz)) +} + +func GlNormal3fv(v /*const*/ *GLfloat) { + syscall3(glNormal3fv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlNormal3i(nx GLint, ny GLint, nz GLint) { + syscall3(glNormal3i, 3, + uintptr(nx), + uintptr(ny), + uintptr(nz)) +} + +func GlNormal3iv(v /*const*/ *GLint) { + syscall3(glNormal3iv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlNormal3s(nx GLshort, ny GLshort, nz GLshort) { + syscall3(glNormal3s, 3, + uintptr(nx), + uintptr(ny), + uintptr(nz)) +} + +func GlNormal3sv(v /*const*/ *GLshort) { + syscall3(glNormal3sv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlNormalPointer(aType GLenum, stride GLsizei, pointer /*const*/ uintptr) { + syscall3(glNormalPointer, 3, + uintptr(aType), + uintptr(stride), + pointer) +} + +func GlOrtho(left GLdouble, right GLdouble, bottom GLdouble, top GLdouble, zNear GLdouble, zFar GLdouble) { + syscall6(glOrtho, 6, + uintptr(left), + uintptr(right), + uintptr(bottom), + uintptr(top), + uintptr(zNear), + uintptr(zFar)) +} + +func GlPassThrough(token GLfloat) { + syscall3(glPassThrough, 1, + uintptr(token), + 0, + 0) +} + +func GlPixelMapfv(aMap GLenum, mapsize GLsizei, values /*const*/ *GLfloat) { + syscall3(glPixelMapfv, 3, + uintptr(aMap), + uintptr(mapsize), + uintptr(unsafe.Pointer(values))) +} + +func GlPixelMapuiv(aMap GLenum, mapsize GLsizei, values /*const*/ *GLuint) { + syscall3(glPixelMapuiv, 3, + uintptr(aMap), + uintptr(mapsize), + uintptr(unsafe.Pointer(values))) +} + +func GlPixelMapusv(aMap GLenum, mapsize GLsizei, values /*const*/ *GLushort) { + syscall3(glPixelMapusv, 3, + uintptr(aMap), + uintptr(mapsize), + uintptr(unsafe.Pointer(values))) +} + +func GlPixelStoref(pname GLenum, param GLfloat) { + syscall3(glPixelStoref, 2, + uintptr(pname), + uintptr(param), + 0) +} + +func GlPixelStorei(pname GLenum, param GLint) { + syscall3(glPixelStorei, 2, + uintptr(pname), + uintptr(param), + 0) +} + +func GlPixelTransferf(pname GLenum, param GLfloat) { + syscall3(glPixelTransferf, 2, + uintptr(pname), + uintptr(param), + 0) +} + +func GlPixelTransferi(pname GLenum, param GLint) { + syscall3(glPixelTransferi, 2, + uintptr(pname), + uintptr(param), + 0) +} + +func GlPixelZoom(xfactor GLfloat, yfactor GLfloat) { + syscall3(glPixelZoom, 2, + uintptr(xfactor), + uintptr(yfactor), + 0) +} + +func GlPointSize(size GLfloat) { + syscall3(glPointSize, 1, + uintptr(size), + 0, + 0) +} + +func GlPolygonMode(face GLenum, mode GLenum) { + syscall3(glPolygonMode, 2, + uintptr(face), + uintptr(mode), + 0) +} + +func GlPolygonOffset(factor GLfloat, units GLfloat) { + syscall3(glPolygonOffset, 2, + uintptr(factor), + uintptr(units), + 0) +} + +func GlPolygonStipple(mask /*const*/ *GLubyte) { + syscall3(glPolygonStipple, 1, + uintptr(unsafe.Pointer(mask)), + 0, + 0) +} + +func GlPopAttrib() { + syscall3(glPopAttrib, 0, + 0, + 0, + 0) +} + +func GlPopClientAttrib() { + syscall3(glPopClientAttrib, 0, + 0, + 0, + 0) +} + +func GlPopMatrix() { + syscall3(glPopMatrix, 0, + 0, + 0, + 0) +} + +func GlPopName() { + syscall3(glPopName, 0, + 0, + 0, + 0) +} + +func GlPrioritizeTextures(n GLsizei, textures /*const*/ *GLuint, priorities /*const*/ *GLclampf) { + syscall3(glPrioritizeTextures, 3, + uintptr(n), + uintptr(unsafe.Pointer(textures)), + uintptr(unsafe.Pointer(priorities))) +} + +func GlPushAttrib(mask GLbitfield) { + syscall3(glPushAttrib, 1, + uintptr(mask), + 0, + 0) +} + +func GlPushClientAttrib(mask GLbitfield) { + syscall3(glPushClientAttrib, 1, + uintptr(mask), + 0, + 0) +} + +func GlPushMatrix() { + syscall3(glPushMatrix, 0, + 0, + 0, + 0) +} + +func GlPushName(name GLuint) { + syscall3(glPushName, 1, + uintptr(name), + 0, + 0) +} + +func GlRasterPos2d(x GLdouble, y GLdouble) { + syscall3(glRasterPos2d, 2, + uintptr(x), + uintptr(y), + 0) +} + +func GlRasterPos2dv(v /*const*/ *GLdouble) { + syscall3(glRasterPos2dv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlRasterPos2f(x GLfloat, y GLfloat) { + syscall3(glRasterPos2f, 2, + uintptr(x), + uintptr(y), + 0) +} + +func GlRasterPos2fv(v /*const*/ *GLfloat) { + syscall3(glRasterPos2fv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlRasterPos2i(x GLint, y GLint) { + syscall3(glRasterPos2i, 2, + uintptr(x), + uintptr(y), + 0) +} + +func GlRasterPos2iv(v /*const*/ *GLint) { + syscall3(glRasterPos2iv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlRasterPos2s(x GLshort, y GLshort) { + syscall3(glRasterPos2s, 2, + uintptr(x), + uintptr(y), + 0) +} + +func GlRasterPos2sv(v /*const*/ *GLshort) { + syscall3(glRasterPos2sv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlRasterPos3d(x GLdouble, y GLdouble, z GLdouble) { + syscall3(glRasterPos3d, 3, + uintptr(x), + uintptr(y), + uintptr(z)) +} + +func GlRasterPos3dv(v /*const*/ *GLdouble) { + syscall3(glRasterPos3dv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlRasterPos3f(x GLfloat, y GLfloat, z GLfloat) { + syscall3(glRasterPos3f, 3, + uintptr(x), + uintptr(y), + uintptr(z)) +} + +func GlRasterPos3fv(v /*const*/ *GLfloat) { + syscall3(glRasterPos3fv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlRasterPos3i(x GLint, y GLint, z GLint) { + syscall3(glRasterPos3i, 3, + uintptr(x), + uintptr(y), + uintptr(z)) +} + +func GlRasterPos3iv(v /*const*/ *GLint) { + syscall3(glRasterPos3iv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlRasterPos3s(x GLshort, y GLshort, z GLshort) { + syscall3(glRasterPos3s, 3, + uintptr(x), + uintptr(y), + uintptr(z)) +} + +func GlRasterPos3sv(v /*const*/ *GLshort) { + syscall3(glRasterPos3sv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlRasterPos4d(x GLdouble, y GLdouble, z GLdouble, w GLdouble) { + syscall6(glRasterPos4d, 4, + uintptr(x), + uintptr(y), + uintptr(z), + uintptr(w), + 0, + 0) +} + +func GlRasterPos4dv(v /*const*/ *GLdouble) { + syscall3(glRasterPos4dv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlRasterPos4f(x GLfloat, y GLfloat, z GLfloat, w GLfloat) { + syscall6(glRasterPos4f, 4, + uintptr(x), + uintptr(y), + uintptr(z), + uintptr(w), + 0, + 0) +} + +func GlRasterPos4fv(v /*const*/ *GLfloat) { + syscall3(glRasterPos4fv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlRasterPos4i(x GLint, y GLint, z GLint, w GLint) { + syscall6(glRasterPos4i, 4, + uintptr(x), + uintptr(y), + uintptr(z), + uintptr(w), + 0, + 0) +} + +func GlRasterPos4iv(v /*const*/ *GLint) { + syscall3(glRasterPos4iv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlRasterPos4s(x GLshort, y GLshort, z GLshort, w GLshort) { + syscall6(glRasterPos4s, 4, + uintptr(x), + uintptr(y), + uintptr(z), + uintptr(w), + 0, + 0) +} + +func GlRasterPos4sv(v /*const*/ *GLshort) { + syscall3(glRasterPos4sv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlReadBuffer(mode GLenum) { + syscall3(glReadBuffer, 1, + uintptr(mode), + 0, + 0) +} + +func GlReadPixels(x GLint, y GLint, width GLsizei, height GLsizei, format GLenum, aType GLenum, pixels uintptr) { + syscall9(glReadPixels, 7, + uintptr(x), + uintptr(y), + uintptr(width), + uintptr(height), + uintptr(format), + uintptr(aType), + pixels, + 0, + 0) +} + +func GlRectd(x1 GLdouble, y1 GLdouble, x2 GLdouble, y2 GLdouble) { + syscall6(glRectd, 4, + uintptr(x1), + uintptr(y1), + uintptr(x2), + uintptr(y2), + 0, + 0) +} + +func GlRectdv(v1 /*const*/ *GLdouble, v2 /*const*/ *GLdouble) { + syscall3(glRectdv, 2, + uintptr(unsafe.Pointer(v1)), + uintptr(unsafe.Pointer(v2)), + 0) +} + +func GlRectf(x1 GLfloat, y1 GLfloat, x2 GLfloat, y2 GLfloat) { + syscall6(glRectf, 4, + uintptr(x1), + uintptr(y1), + uintptr(x2), + uintptr(y2), + 0, + 0) +} + +func GlRectfv(v1 /*const*/ *GLfloat, v2 /*const*/ *GLfloat) { + syscall3(glRectfv, 2, + uintptr(unsafe.Pointer(v1)), + uintptr(unsafe.Pointer(v2)), + 0) +} + +func GlRecti(x1 GLint, y1 GLint, x2 GLint, y2 GLint) { + syscall6(glRecti, 4, + uintptr(x1), + uintptr(y1), + uintptr(x2), + uintptr(y2), + 0, + 0) +} + +func GlRectiv(v1 /*const*/ *GLint, v2 /*const*/ *GLint) { + syscall3(glRectiv, 2, + uintptr(unsafe.Pointer(v1)), + uintptr(unsafe.Pointer(v2)), + 0) +} + +func GlRects(x1 GLshort, y1 GLshort, x2 GLshort, y2 GLshort) { + syscall6(glRects, 4, + uintptr(x1), + uintptr(y1), + uintptr(x2), + uintptr(y2), + 0, + 0) +} + +func GlRectsv(v1 /*const*/ *GLshort, v2 /*const*/ *GLshort) { + syscall3(glRectsv, 2, + uintptr(unsafe.Pointer(v1)), + uintptr(unsafe.Pointer(v2)), + 0) +} + +func GlRenderMode(mode GLenum) GLint { + ret1 := syscall3(glRenderMode, 1, + uintptr(mode), + 0, + 0) + return GLint(ret1) +} + +func GlRotated(angle GLdouble, x GLdouble, y GLdouble, z GLdouble) { + syscall6(glRotated, 4, + uintptr(angle), + uintptr(x), + uintptr(y), + uintptr(z), + 0, + 0) +} + +func GlRotatef(angle GLfloat, x GLfloat, y GLfloat, z GLfloat) { + syscall6(glRotatef, 4, + uintptr(angle), + uintptr(x), + uintptr(y), + uintptr(z), + 0, + 0) +} + +func GlScaled(x GLdouble, y GLdouble, z GLdouble) { + syscall3(glScaled, 3, + uintptr(x), + uintptr(y), + uintptr(z)) +} + +func GlScalef(x GLfloat, y GLfloat, z GLfloat) { + syscall3(glScalef, 3, + uintptr(x), + uintptr(y), + uintptr(z)) +} + +func GlScissor(x GLint, y GLint, width GLsizei, height GLsizei) { + syscall6(glScissor, 4, + uintptr(x), + uintptr(y), + uintptr(width), + uintptr(height), + 0, + 0) +} + +func GlSelectBuffer(size GLsizei, buffer *GLuint) { + syscall3(glSelectBuffer, 2, + uintptr(size), + uintptr(unsafe.Pointer(buffer)), + 0) +} + +func GlShadeModel(mode GLenum) { + syscall3(glShadeModel, 1, + uintptr(mode), + 0, + 0) +} + +func GlStencilFunc(aFunc GLenum, ref GLint, mask GLuint) { + syscall3(glStencilFunc, 3, + uintptr(aFunc), + uintptr(ref), + uintptr(mask)) +} + +func GlStencilMask(mask GLuint) { + syscall3(glStencilMask, 1, + uintptr(mask), + 0, + 0) +} + +func GlStencilOp(fail GLenum, zfail GLenum, zpass GLenum) { + syscall3(glStencilOp, 3, + uintptr(fail), + uintptr(zfail), + uintptr(zpass)) +} + +func GlTexCoord1d(s GLdouble) { + syscall3(glTexCoord1d, 1, + uintptr(s), + 0, + 0) +} + +func GlTexCoord1dv(v /*const*/ *GLdouble) { + syscall3(glTexCoord1dv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord1f(s GLfloat) { + syscall3(glTexCoord1f, 1, + uintptr(s), + 0, + 0) +} + +func GlTexCoord1fv(v /*const*/ *GLfloat) { + syscall3(glTexCoord1fv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord1i(s GLint) { + syscall3(glTexCoord1i, 1, + uintptr(s), + 0, + 0) +} + +func GlTexCoord1iv(v /*const*/ *GLint) { + syscall3(glTexCoord1iv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord1s(s GLshort) { + syscall3(glTexCoord1s, 1, + uintptr(s), + 0, + 0) +} + +func GlTexCoord1sv(v /*const*/ *GLshort) { + syscall3(glTexCoord1sv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord2d(s GLdouble, t GLdouble) { + syscall3(glTexCoord2d, 2, + uintptr(s), + uintptr(t), + 0) +} + +func GlTexCoord2dv(v /*const*/ *GLdouble) { + syscall3(glTexCoord2dv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord2f(s GLfloat, t GLfloat) { + syscall3(glTexCoord2f, 2, + uintptr(s), + uintptr(t), + 0) +} + +func GlTexCoord2fv(v /*const*/ *GLfloat) { + syscall3(glTexCoord2fv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord2i(s GLint, t GLint) { + syscall3(glTexCoord2i, 2, + uintptr(s), + uintptr(t), + 0) +} + +func GlTexCoord2iv(v /*const*/ *GLint) { + syscall3(glTexCoord2iv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord2s(s GLshort, t GLshort) { + syscall3(glTexCoord2s, 2, + uintptr(s), + uintptr(t), + 0) +} + +func GlTexCoord2sv(v /*const*/ *GLshort) { + syscall3(glTexCoord2sv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord3d(s GLdouble, t GLdouble, r GLdouble) { + syscall3(glTexCoord3d, 3, + uintptr(s), + uintptr(t), + uintptr(r)) +} + +func GlTexCoord3dv(v /*const*/ *GLdouble) { + syscall3(glTexCoord3dv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord3f(s GLfloat, t GLfloat, r GLfloat) { + syscall3(glTexCoord3f, 3, + uintptr(s), + uintptr(t), + uintptr(r)) +} + +func GlTexCoord3fv(v /*const*/ *GLfloat) { + syscall3(glTexCoord3fv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord3i(s GLint, t GLint, r GLint) { + syscall3(glTexCoord3i, 3, + uintptr(s), + uintptr(t), + uintptr(r)) +} + +func GlTexCoord3iv(v /*const*/ *GLint) { + syscall3(glTexCoord3iv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord3s(s GLshort, t GLshort, r GLshort) { + syscall3(glTexCoord3s, 3, + uintptr(s), + uintptr(t), + uintptr(r)) +} + +func GlTexCoord3sv(v /*const*/ *GLshort) { + syscall3(glTexCoord3sv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord4d(s GLdouble, t GLdouble, r GLdouble, q GLdouble) { + syscall6(glTexCoord4d, 4, + uintptr(s), + uintptr(t), + uintptr(r), + uintptr(q), + 0, + 0) +} + +func GlTexCoord4dv(v /*const*/ *GLdouble) { + syscall3(glTexCoord4dv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord4f(s GLfloat, t GLfloat, r GLfloat, q GLfloat) { + syscall6(glTexCoord4f, 4, + uintptr(s), + uintptr(t), + uintptr(r), + uintptr(q), + 0, + 0) +} + +func GlTexCoord4fv(v /*const*/ *GLfloat) { + syscall3(glTexCoord4fv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord4i(s GLint, t GLint, r GLint, q GLint) { + syscall6(glTexCoord4i, 4, + uintptr(s), + uintptr(t), + uintptr(r), + uintptr(q), + 0, + 0) +} + +func GlTexCoord4iv(v /*const*/ *GLint) { + syscall3(glTexCoord4iv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoord4s(s GLshort, t GLshort, r GLshort, q GLshort) { + syscall6(glTexCoord4s, 4, + uintptr(s), + uintptr(t), + uintptr(r), + uintptr(q), + 0, + 0) +} + +func GlTexCoord4sv(v /*const*/ *GLshort) { + syscall3(glTexCoord4sv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlTexCoordPointer(size GLint, aType GLenum, stride GLsizei, pointer /*const*/ uintptr) { + syscall6(glTexCoordPointer, 4, + uintptr(size), + uintptr(aType), + uintptr(stride), + pointer, + 0, + 0) +} + +func GlTexEnvf(target GLenum, pname GLenum, param GLfloat) { + syscall3(glTexEnvf, 3, + uintptr(target), + uintptr(pname), + uintptr(param)) +} + +func GlTexEnvfv(target GLenum, pname GLenum, params /*const*/ *GLfloat) { + syscall3(glTexEnvfv, 3, + uintptr(target), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlTexEnvi(target GLenum, pname GLenum, param GLint) { + syscall3(glTexEnvi, 3, + uintptr(target), + uintptr(pname), + uintptr(param)) +} + +func GlTexEnviv(target GLenum, pname GLenum, params /*const*/ *GLint) { + syscall3(glTexEnviv, 3, + uintptr(target), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlTexGend(coord GLenum, pname GLenum, param GLdouble) { + syscall3(glTexGend, 3, + uintptr(coord), + uintptr(pname), + uintptr(param)) +} + +func GlTexGendv(coord GLenum, pname GLenum, params /*const*/ *GLdouble) { + syscall3(glTexGendv, 3, + uintptr(coord), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlTexGenf(coord GLenum, pname GLenum, param GLfloat) { + syscall3(glTexGenf, 3, + uintptr(coord), + uintptr(pname), + uintptr(param)) +} + +func GlTexGenfv(coord GLenum, pname GLenum, params /*const*/ *GLfloat) { + syscall3(glTexGenfv, 3, + uintptr(coord), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlTexGeni(coord GLenum, pname GLenum, param GLint) { + syscall3(glTexGeni, 3, + uintptr(coord), + uintptr(pname), + uintptr(param)) +} + +func GlTexGeniv(coord GLenum, pname GLenum, params /*const*/ *GLint) { + syscall3(glTexGeniv, 3, + uintptr(coord), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlTexImage1D(target GLenum, level GLint, internalformat GLint, width GLsizei, border GLint, format GLenum, aType GLenum, pixels /*const*/ uintptr) { + syscall9(glTexImage1D, 8, + uintptr(target), + uintptr(level), + uintptr(internalformat), + uintptr(width), + uintptr(border), + uintptr(format), + uintptr(aType), + pixels, + 0) +} + +func GlTexImage2D(target GLenum, level GLint, internalformat GLint, width GLsizei, height GLsizei, border GLint, format GLenum, aType GLenum, pixels /*const*/ uintptr) { + syscall9(glTexImage2D, 9, + uintptr(target), + uintptr(level), + uintptr(internalformat), + uintptr(width), + uintptr(height), + uintptr(border), + uintptr(format), + uintptr(aType), + pixels) +} + +func GlTexParameterf(target GLenum, pname GLenum, param GLfloat) { + syscall3(glTexParameterf, 3, + uintptr(target), + uintptr(pname), + uintptr(param)) +} + +func GlTexParameterfv(target GLenum, pname GLenum, params /*const*/ *GLfloat) { + syscall3(glTexParameterfv, 3, + uintptr(target), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlTexParameteri(target GLenum, pname GLenum, param GLint) { + syscall3(glTexParameteri, 3, + uintptr(target), + uintptr(pname), + uintptr(param)) +} + +func GlTexParameteriv(target GLenum, pname GLenum, params /*const*/ *GLint) { + syscall3(glTexParameteriv, 3, + uintptr(target), + uintptr(pname), + uintptr(unsafe.Pointer(params))) +} + +func GlTexSubImage1D(target GLenum, level GLint, xoffset GLint, width GLsizei, format GLenum, aType GLenum, pixels /*const*/ uintptr) { + syscall9(glTexSubImage1D, 7, + uintptr(target), + uintptr(level), + uintptr(xoffset), + uintptr(width), + uintptr(format), + uintptr(aType), + pixels, + 0, + 0) +} + +func GlTexSubImage2D(target GLenum, level GLint, xoffset GLint, yoffset GLint, width GLsizei, height GLsizei, format GLenum, aType GLenum, pixels /*const*/ uintptr) { + syscall9(glTexSubImage2D, 9, + uintptr(target), + uintptr(level), + uintptr(xoffset), + uintptr(yoffset), + uintptr(width), + uintptr(height), + uintptr(format), + uintptr(aType), + pixels) +} + +func GlTranslated(x GLdouble, y GLdouble, z GLdouble) { + syscall3(glTranslated, 3, + uintptr(x), + uintptr(y), + uintptr(z)) +} + +func GlTranslatef(x GLfloat, y GLfloat, z GLfloat) { + syscall3(glTranslatef, 3, + uintptr(x), + uintptr(y), + uintptr(z)) +} + +func GlVertex2d(x GLdouble, y GLdouble) { + syscall3(glVertex2d, 2, + uintptr(x), + uintptr(y), + 0) +} + +func GlVertex2dv(v /*const*/ *GLdouble) { + syscall3(glVertex2dv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlVertex2f(x GLfloat, y GLfloat) { + syscall3(glVertex2f, 2, + uintptr(x), + uintptr(y), + 0) +} + +func GlVertex2fv(v /*const*/ *GLfloat) { + syscall3(glVertex2fv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlVertex2i(x GLint, y GLint) { + syscall3(glVertex2i, 2, + uintptr(x), + uintptr(y), + 0) +} + +func GlVertex2iv(v /*const*/ *GLint) { + syscall3(glVertex2iv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlVertex2s(x GLshort, y GLshort) { + syscall3(glVertex2s, 2, + uintptr(x), + uintptr(y), + 0) +} + +func GlVertex2sv(v /*const*/ *GLshort) { + syscall3(glVertex2sv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlVertex3d(x GLdouble, y GLdouble, z GLdouble) { + syscall3(glVertex3d, 3, + uintptr(x), + uintptr(y), + uintptr(z)) +} + +func GlVertex3dv(v /*const*/ *GLdouble) { + syscall3(glVertex3dv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlVertex3f(x GLfloat, y GLfloat, z GLfloat) { + syscall3(glVertex3f, 3, + uintptr(x), + uintptr(y), + uintptr(z)) +} + +func GlVertex3fv(v /*const*/ *GLfloat) { + syscall3(glVertex3fv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlVertex3i(x GLint, y GLint, z GLint) { + syscall3(glVertex3i, 3, + uintptr(x), + uintptr(y), + uintptr(z)) +} + +func GlVertex3iv(v /*const*/ *GLint) { + syscall3(glVertex3iv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlVertex3s(x GLshort, y GLshort, z GLshort) { + syscall3(glVertex3s, 3, + uintptr(x), + uintptr(y), + uintptr(z)) +} + +func GlVertex3sv(v /*const*/ *GLshort) { + syscall3(glVertex3sv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlVertex4d(x GLdouble, y GLdouble, z GLdouble, w GLdouble) { + syscall6(glVertex4d, 4, + uintptr(x), + uintptr(y), + uintptr(z), + uintptr(w), + 0, + 0) +} + +func GlVertex4dv(v /*const*/ *GLdouble) { + syscall3(glVertex4dv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlVertex4f(x GLfloat, y GLfloat, z GLfloat, w GLfloat) { + syscall6(glVertex4f, 4, + uintptr(x), + uintptr(y), + uintptr(z), + uintptr(w), + 0, + 0) +} + +func GlVertex4fv(v /*const*/ *GLfloat) { + syscall3(glVertex4fv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlVertex4i(x GLint, y GLint, z GLint, w GLint) { + syscall6(glVertex4i, 4, + uintptr(x), + uintptr(y), + uintptr(z), + uintptr(w), + 0, + 0) +} + +func GlVertex4iv(v /*const*/ *GLint) { + syscall3(glVertex4iv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlVertex4s(x GLshort, y GLshort, z GLshort, w GLshort) { + syscall6(glVertex4s, 4, + uintptr(x), + uintptr(y), + uintptr(z), + uintptr(w), + 0, + 0) +} + +func GlVertex4sv(v /*const*/ *GLshort) { + syscall3(glVertex4sv, 1, + uintptr(unsafe.Pointer(v)), + 0, + 0) +} + +func GlVertexPointer(size GLint, aType GLenum, stride GLsizei, pointer /*const*/ uintptr) { + syscall6(glVertexPointer, 4, + uintptr(size), + uintptr(aType), + uintptr(stride), + pointer, + 0, + 0) +} + +func GlViewport(x GLint, y GLint, width GLsizei, height GLsizei) { + syscall6(glViewport, 4, + uintptr(x), + uintptr(y), + uintptr(width), + uintptr(height), + 0, + 0) +} + +func WglCopyContext(unnamed0 HGLRC, unnamed1 HGLRC, unnamed2 UINT) bool { + ret1 := syscall3(wglCopyContext, 3, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2)) + return ret1 != 0 +} + +func WglCreateContext(unnamed0 HDC) HGLRC { + ret1 := syscall3(wglCreateContext, 1, + uintptr(unnamed0), + 0, + 0) + return HGLRC(ret1) +} + +func WglCreateLayerContext(unnamed0 HDC, unnamed1 int32) HGLRC { + ret1 := syscall3(wglCreateLayerContext, 2, + uintptr(unnamed0), + uintptr(unnamed1), + 0) + return HGLRC(ret1) +} + +func WglDeleteContext(unnamed0 HGLRC) bool { + ret1 := syscall3(wglDeleteContext, 1, + uintptr(unnamed0), + 0, + 0) + return ret1 != 0 +} + +func WglDescribeLayerPlane(unnamed0 HDC, unnamed1 int32, unnamed2 int32, unnamed3 UINT, unnamed4 *LAYERPLANEDESCRIPTOR) bool { + ret1 := syscall6(wglDescribeLayerPlane, 5, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2), + uintptr(unnamed3), + uintptr(unsafe.Pointer(unnamed4)), + 0) + return ret1 != 0 +} + +func WglGetCurrentContext() HGLRC { + ret1 := syscall3(wglGetCurrentContext, 0, + 0, + 0, + 0) + return HGLRC(ret1) +} + +func WglGetCurrentDC() HDC { + ret1 := syscall3(wglGetCurrentDC, 0, + 0, + 0, + 0) + return HDC(ret1) +} + +func WglGetLayerPaletteEntries(unnamed0 HDC, unnamed1 int32, unnamed2 int32, unnamed3 int32, unnamed4 *COLORREF) int32 { + ret1 := syscall6(wglGetLayerPaletteEntries, 5, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2), + uintptr(unnamed3), + uintptr(unsafe.Pointer(unnamed4)), + 0) + return int32(ret1) +} + +func WglGetProcAddress(unnamed0 /*const*/ LPCSTR) PROC { + ret1 := syscall3(wglGetProcAddress, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return PROC(ret1) +} + +func WglMakeCurrent(unnamed0 HDC, unnamed1 HGLRC) bool { + ret1 := syscall3(wglMakeCurrent, 2, + uintptr(unnamed0), + uintptr(unnamed1), + 0) + return ret1 != 0 +} + +func WglRealizeLayerPalette(unnamed0 HDC, unnamed1 int32, unnamed2 bool) bool { + ret1 := syscall3(wglRealizeLayerPalette, 3, + uintptr(unnamed0), + uintptr(unnamed1), + getUintptrFromBool(unnamed2)) + return ret1 != 0 +} + +func WglSetLayerPaletteEntries(unnamed0 HDC, unnamed1 int32, unnamed2 int32, unnamed3 int32, unnamed4 /*const*/ *COLORREF) int32 { + ret1 := syscall6(wglSetLayerPaletteEntries, 5, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2), + uintptr(unnamed3), + uintptr(unsafe.Pointer(unnamed4)), + 0) + return int32(ret1) +} + +func WglShareLists(unnamed0 HGLRC, unnamed1 HGLRC) bool { + ret1 := syscall3(wglShareLists, 2, + uintptr(unnamed0), + uintptr(unnamed1), + 0) + return ret1 != 0 +} + +func WglSwapLayerBuffers(unnamed0 HDC, unnamed1 UINT) bool { + ret1 := syscall3(wglSwapLayerBuffers, 2, + uintptr(unnamed0), + uintptr(unnamed1), + 0) + return ret1 != 0 +} + +func WglSwapMultipleBuffers(unnamed0 UINT, unnamed1 /*const*/ *WGLSWAP) DWORD { + ret1 := syscall3(wglSwapMultipleBuffers, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + 0) + return DWORD(ret1) +} + +func WglUseFontBitmaps(unnamed0 HDC, unnamed1 DWORD, unnamed2 DWORD, unnamed3 DWORD) bool { + ret1 := syscall6(wglUseFontBitmaps, 4, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2), + uintptr(unnamed3), + 0, + 0) + return ret1 != 0 +} + +func WglUseFontOutlines(unnamed0 HDC, unnamed1 DWORD, unnamed2 DWORD, unnamed3 DWORD, unnamed4 FLOAT, unnamed5 FLOAT, unnamed6 int32, unnamed7 *GLYPHMETRICSFLOAT) bool { + ret1 := syscall9(wglUseFontOutlines, 8, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2), + uintptr(unnamed3), + uintptr(unnamed4), + uintptr(unnamed5), + uintptr(unnamed6), + uintptr(unsafe.Pointer(unnamed7)), + 0) + return ret1 != 0 +} + +func GlDebugEntry(unknown1 GLint, unknown2 GLint) GLint { + ret1 := syscall3(glDebugEntry, 2, + uintptr(unknown1), + uintptr(unknown2), + 0) + return GLint(ret1) +} + +func WglChoosePixelFormat(hdc HDC, ppfd /*const*/ *PIXELFORMATDESCRIPTOR) INT { + ret1 := syscall3(wglChoosePixelFormat, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(ppfd)), + 0) + return INT(ret1) +} + +func WglDescribePixelFormat(hdc HDC, format INT, size UINT, descr *PIXELFORMATDESCRIPTOR) INT { + ret1 := syscall6(wglDescribePixelFormat, 4, + uintptr(hdc), + uintptr(format), + uintptr(size), + uintptr(unsafe.Pointer(descr)), + 0, + 0) + return INT(ret1) +} + +func WglGetPixelFormat(hdc HDC) INT { + ret1 := syscall3(wglGetPixelFormat, 1, + uintptr(hdc), + 0, + 0) + return INT(ret1) +} + +func WglSetPixelFormat(hdc HDC, format INT, descr /*const*/ *PIXELFORMATDESCRIPTOR) bool { + ret1 := syscall3(wglSetPixelFormat, 3, + uintptr(hdc), + uintptr(format), + uintptr(unsafe.Pointer(descr))) + return ret1 != 0 +} diff --git a/grdp/win/pdh.go b/grdp/win/pdh.go new file mode 100644 index 0000000..a74bf5a --- /dev/null +++ b/grdp/win/pdh.go @@ -0,0 +1,328 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "unsafe" +) + +var ( + // Library + libpdh uintptr + + // Functions + pdhAddCounter uintptr + pdhAddEnglishCounter uintptr + pdhBindInputDataSource uintptr + pdhCalculateCounterFromRawValue uintptr + pdhCloseQuery uintptr + pdhCollectQueryData uintptr + pdhCollectQueryDataEx uintptr + pdhCollectQueryDataWithTime uintptr + pdhEnumObjectItems uintptr + pdhExpandCounterPath uintptr + pdhExpandWildCardPath uintptr + pdhGetCounterInfo uintptr + pdhGetCounterTimeBase uintptr + pdhGetDllVersion uintptr + pdhGetFormattedCounterValue uintptr + pdhGetLogFileType uintptr + pdhGetRawCounterValue uintptr + pdhLookupPerfIndexByName uintptr + pdhLookupPerfNameByIndex uintptr + pdhMakeCounterPath uintptr + pdhOpenQuery uintptr + pdhRemoveCounter uintptr + pdhSetCounterScaleFactor uintptr + pdhSetDefaultRealTimeDataSource uintptr + pdhValidatePathEx uintptr + pdhValidatePath uintptr +) + +func init() { + // Library + libpdh = doLoadLibrary("pdh.dll") + + // Functions + pdhAddCounter = doGetProcAddress(libpdh, "PdhAddCounterW") + pdhAddEnglishCounter = doGetProcAddress(libpdh, "PdhAddEnglishCounterW") + pdhBindInputDataSource = doGetProcAddress(libpdh, "PdhBindInputDataSourceW") + pdhCalculateCounterFromRawValue = doGetProcAddress(libpdh, "PdhCalculateCounterFromRawValue") + pdhCloseQuery = doGetProcAddress(libpdh, "PdhCloseQuery") + pdhCollectQueryData = doGetProcAddress(libpdh, "PdhCollectQueryData") + pdhCollectQueryDataEx = doGetProcAddress(libpdh, "PdhCollectQueryDataEx") + pdhCollectQueryDataWithTime = doGetProcAddress(libpdh, "PdhCollectQueryDataWithTime") + pdhEnumObjectItems = doGetProcAddress(libpdh, "PdhEnumObjectItemsW") + pdhExpandCounterPath = doGetProcAddress(libpdh, "PdhExpandCounterPathW") + pdhExpandWildCardPath = doGetProcAddress(libpdh, "PdhExpandWildCardPathW") + pdhGetCounterInfo = doGetProcAddress(libpdh, "PdhGetCounterInfoW") + pdhGetCounterTimeBase = doGetProcAddress(libpdh, "PdhGetCounterTimeBase") + pdhGetDllVersion = doGetProcAddress(libpdh, "PdhGetDllVersion") + pdhGetFormattedCounterValue = doGetProcAddress(libpdh, "PdhGetFormattedCounterValue") + pdhGetLogFileType = doGetProcAddress(libpdh, "PdhGetLogFileTypeW") + pdhGetRawCounterValue = doGetProcAddress(libpdh, "PdhGetRawCounterValue") + pdhLookupPerfIndexByName = doGetProcAddress(libpdh, "PdhLookupPerfIndexByNameW") + pdhLookupPerfNameByIndex = doGetProcAddress(libpdh, "PdhLookupPerfNameByIndexW") + pdhMakeCounterPath = doGetProcAddress(libpdh, "PdhMakeCounterPathW") + pdhOpenQuery = doGetProcAddress(libpdh, "PdhOpenQueryW") + pdhRemoveCounter = doGetProcAddress(libpdh, "PdhRemoveCounter") + pdhSetCounterScaleFactor = doGetProcAddress(libpdh, "PdhSetCounterScaleFactor") + pdhSetDefaultRealTimeDataSource = doGetProcAddress(libpdh, "PdhSetDefaultRealTimeDataSource") + pdhValidatePathEx = doGetProcAddress(libpdh, "PdhValidatePathExW") + pdhValidatePath = doGetProcAddress(libpdh, "PdhValidatePathW") +} + +func PdhAddCounter(hquery PDH_HQUERY, path string, userdata *uint32, hcounter *PDH_HCOUNTER) PDH_STATUS { + pathStr := unicode16FromString(path) + ret1 := syscall6(pdhAddCounter, 4, + uintptr(hquery), + uintptr(unsafe.Pointer(&pathStr[0])), + uintptr(unsafe.Pointer(userdata)), + uintptr(unsafe.Pointer(hcounter)), + 0, + 0) + return PDH_STATUS(ret1) +} + +func PdhAddEnglishCounter(query PDH_HQUERY, path string, userdata *uint32, counter *PDH_HCOUNTER) PDH_STATUS { + pathStr := unicode16FromString(path) + ret1 := syscall6(pdhAddEnglishCounter, 4, + uintptr(query), + uintptr(unsafe.Pointer(&pathStr[0])), + uintptr(unsafe.Pointer(userdata)), + uintptr(unsafe.Pointer(counter)), + 0, + 0) + return PDH_STATUS(ret1) +} + +func PdhBindInputDataSource(source *PDH_HLOG, filenamelist /*const*/ *WCHAR) PDH_STATUS { + ret1 := syscall3(pdhBindInputDataSource, 2, + uintptr(unsafe.Pointer(source)), + uintptr(unsafe.Pointer(filenamelist)), + 0) + return PDH_STATUS(ret1) +} + +func PdhCalculateCounterFromRawValue(handle PDH_HCOUNTER, format DWORD, raw1 *PDH_RAW_COUNTER, raw2 *PDH_RAW_COUNTER, value *PDH_FMT_COUNTERVALUE) PDH_STATUS { + ret1 := syscall6(pdhCalculateCounterFromRawValue, 5, + uintptr(handle), + uintptr(format), + uintptr(unsafe.Pointer(raw1)), + uintptr(unsafe.Pointer(raw2)), + uintptr(unsafe.Pointer(value)), + 0) + return PDH_STATUS(ret1) +} + +func PdhCloseQuery(handle PDH_HQUERY) PDH_STATUS { + ret1 := syscall3(pdhCloseQuery, 1, + uintptr(handle), + 0, + 0) + return PDH_STATUS(ret1) +} + +func PdhCollectQueryData(handle PDH_HQUERY) PDH_STATUS { + ret1 := syscall3(pdhCollectQueryData, 1, + uintptr(handle), + 0, + 0) + return PDH_STATUS(ret1) +} + +func PdhCollectQueryDataEx(handle PDH_HQUERY, interval DWORD, event HANDLE) PDH_STATUS { + ret1 := syscall3(pdhCollectQueryDataEx, 3, + uintptr(handle), + uintptr(interval), + uintptr(event)) + return PDH_STATUS(ret1) +} + +func PdhCollectQueryDataWithTime(handle PDH_HQUERY, timestamp *LONGLONG) PDH_STATUS { + ret1 := syscall3(pdhCollectQueryDataWithTime, 2, + uintptr(handle), + uintptr(unsafe.Pointer(timestamp)), + 0) + return PDH_STATUS(ret1) +} + +func PdhEnumObjectItems(szDataSource string, szMachineName string, szObjectName string, mszCounterList LPWSTR, pcchCounterListLength *uint32, mszInstanceList LPWSTR, pcchInstanceListLength *uint32, dwDetailLevel DWORD, dwFlags DWORD) PDH_STATUS { + szDataSourceStr := unicode16FromString(szDataSource) + szMachineNameStr := unicode16FromString(szMachineName) + szObjectNameStr := unicode16FromString(szObjectName) + ret1 := syscall9(pdhEnumObjectItems, 9, + uintptr(unsafe.Pointer(&szDataSourceStr[0])), + uintptr(unsafe.Pointer(&szMachineNameStr[0])), + uintptr(unsafe.Pointer(&szObjectNameStr[0])), + uintptr(unsafe.Pointer(mszCounterList)), + uintptr(unsafe.Pointer(pcchCounterListLength)), + uintptr(unsafe.Pointer(mszInstanceList)), + uintptr(unsafe.Pointer(pcchInstanceListLength)), + uintptr(dwDetailLevel), + uintptr(dwFlags)) + return PDH_STATUS(ret1) +} + +func PdhExpandCounterPath(szWildCardPath string, mszExpandedPathList LPWSTR, pcchPathListLength *uint32) PDH_STATUS { + szWildCardPathStr := unicode16FromString(szWildCardPath) + ret1 := syscall3(pdhExpandCounterPath, 3, + uintptr(unsafe.Pointer(&szWildCardPathStr[0])), + uintptr(unsafe.Pointer(mszExpandedPathList)), + uintptr(unsafe.Pointer(pcchPathListLength))) + return PDH_STATUS(ret1) +} + +func PdhExpandWildCardPath(szDataSource string, szWildCardPath string, mszExpandedPathList LPWSTR, pcchPathListLength *uint32, dwFlags DWORD) PDH_STATUS { + szDataSourceStr := unicode16FromString(szDataSource) + szWildCardPathStr := unicode16FromString(szWildCardPath) + ret1 := syscall6(pdhExpandWildCardPath, 5, + uintptr(unsafe.Pointer(&szDataSourceStr[0])), + uintptr(unsafe.Pointer(&szWildCardPathStr[0])), + uintptr(unsafe.Pointer(mszExpandedPathList)), + uintptr(unsafe.Pointer(pcchPathListLength)), + uintptr(dwFlags), + 0) + return PDH_STATUS(ret1) +} + +func PdhGetCounterInfo(handle PDH_HCOUNTER, text BOOLEAN, size *uint32, info *PDH_COUNTER_INFO) PDH_STATUS { + ret1 := syscall6(pdhGetCounterInfo, 4, + uintptr(handle), + uintptr(text), + uintptr(unsafe.Pointer(size)), + uintptr(unsafe.Pointer(info)), + 0, + 0) + return PDH_STATUS(ret1) +} + +func PdhGetCounterTimeBase(handle PDH_HCOUNTER, base *LONGLONG) PDH_STATUS { + ret1 := syscall3(pdhGetCounterTimeBase, 2, + uintptr(handle), + uintptr(unsafe.Pointer(base)), + 0) + return PDH_STATUS(ret1) +} + +func PdhGetDllVersion(version *uint32) PDH_STATUS { + ret1 := syscall3(pdhGetDllVersion, 1, + uintptr(unsafe.Pointer(version)), + 0, + 0) + return PDH_STATUS(ret1) +} + +func PdhGetFormattedCounterValue(handle PDH_HCOUNTER, format DWORD, aType *uint32, value *PDH_FMT_COUNTERVALUE) PDH_STATUS { + ret1 := syscall6(pdhGetFormattedCounterValue, 4, + uintptr(handle), + uintptr(format), + uintptr(unsafe.Pointer(aType)), + uintptr(unsafe.Pointer(value)), + 0, + 0) + return PDH_STATUS(ret1) +} + +func PdhGetLogFileType(log /*const*/ *WCHAR, aType *uint32) PDH_STATUS { + ret1 := syscall3(pdhGetLogFileType, 2, + uintptr(unsafe.Pointer(log)), + uintptr(unsafe.Pointer(aType)), + 0) + return PDH_STATUS(ret1) +} + +func PdhGetRawCounterValue(handle PDH_HCOUNTER, aType *uint32, value *PDH_RAW_COUNTER) PDH_STATUS { + ret1 := syscall3(pdhGetRawCounterValue, 3, + uintptr(handle), + uintptr(unsafe.Pointer(aType)), + uintptr(unsafe.Pointer(value))) + return PDH_STATUS(ret1) +} + +func PdhLookupPerfIndexByName(machine string, name string, index *uint32) PDH_STATUS { + machineStr := unicode16FromString(machine) + nameStr := unicode16FromString(name) + ret1 := syscall3(pdhLookupPerfIndexByName, 3, + uintptr(unsafe.Pointer(&machineStr[0])), + uintptr(unsafe.Pointer(&nameStr[0])), + uintptr(unsafe.Pointer(index))) + return PDH_STATUS(ret1) +} + +func PdhLookupPerfNameByIndex(machine string, index DWORD, buffer LPWSTR, size *uint32) PDH_STATUS { + machineStr := unicode16FromString(machine) + ret1 := syscall6(pdhLookupPerfNameByIndex, 4, + uintptr(unsafe.Pointer(&machineStr[0])), + uintptr(index), + uintptr(unsafe.Pointer(buffer)), + uintptr(unsafe.Pointer(size)), + 0, + 0) + return PDH_STATUS(ret1) +} + +func PdhMakeCounterPath(e *PDH_COUNTER_PATH_ELEMENTS, buffer LPWSTR, buflen *uint32, flags DWORD) PDH_STATUS { + ret1 := syscall6(pdhMakeCounterPath, 4, + uintptr(unsafe.Pointer(e)), + uintptr(unsafe.Pointer(buffer)), + uintptr(unsafe.Pointer(buflen)), + uintptr(flags), + 0, + 0) + return PDH_STATUS(ret1) +} + +func PdhOpenQuery(source LPCWSTR, userdata *uint32, handle *PDH_HQUERY) PDH_STATUS { + //sourceStr := unicode16FromString(source) + ret1 := syscall3(pdhOpenQuery, 3, + uintptr(unsafe.Pointer(source)), + uintptr(unsafe.Pointer(userdata)), + uintptr(unsafe.Pointer(handle))) + return PDH_STATUS(ret1) +} + +func PdhRemoveCounter(handle PDH_HCOUNTER) PDH_STATUS { + ret1 := syscall3(pdhRemoveCounter, 1, + uintptr(handle), + 0, + 0) + return PDH_STATUS(ret1) +} + +func PdhSetCounterScaleFactor(handle PDH_HCOUNTER, factor LONG) PDH_STATUS { + ret1 := syscall3(pdhSetCounterScaleFactor, 2, + uintptr(handle), + uintptr(factor), + 0) + return PDH_STATUS(ret1) +} + +func PdhSetDefaultRealTimeDataSource(source DWORD) PDH_STATUS { + ret1 := syscall3(pdhSetDefaultRealTimeDataSource, 1, + uintptr(source), + 0, + 0) + return PDH_STATUS(ret1) +} + +func PdhValidatePathEx(source PDH_HLOG, path string) PDH_STATUS { + pathStr := unicode16FromString(path) + ret1 := syscall3(pdhValidatePathEx, 2, + uintptr(source), + uintptr(unsafe.Pointer(&pathStr[0])), + 0) + return PDH_STATUS(ret1) +} + +func PdhValidatePath(path string) PDH_STATUS { + pathStr := unicode16FromString(path) + ret1 := syscall3(pdhValidatePath, 1, + uintptr(unsafe.Pointer(&pathStr[0])), + 0, + 0) + return PDH_STATUS(ret1) +} diff --git a/grdp/win/psapi.go b/grdp/win/psapi.go new file mode 100644 index 0000000..9ccc755 --- /dev/null +++ b/grdp/win/psapi.go @@ -0,0 +1,248 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "syscall" + "unsafe" +) + +var ( + // Library + libpsapi uintptr + + // Functions + emptyWorkingSet uintptr + enumDeviceDrivers uintptr + enumPageFiles uintptr + enumProcessModules uintptr + enumProcessModulesEx uintptr + enumProcesses uintptr + getDeviceDriverBaseName uintptr + getDeviceDriverFileName uintptr + getMappedFileName uintptr + getModuleBaseName uintptr + getModuleFileNameEx uintptr + getModuleInformation uintptr + getPerformanceInfo uintptr + getProcessImageFileName uintptr + getProcessMemoryInfo uintptr + getWsChanges uintptr + getWsChangesEx uintptr + initializeProcessForWsWatch uintptr + queryWorkingSet uintptr + queryWorkingSetEx uintptr +) + +func init() { + // Library + libpsapi = doLoadLibrary("psapi.dll") + + // Functions + emptyWorkingSet = doGetProcAddress(libpsapi, "EmptyWorkingSet") + enumDeviceDrivers = doGetProcAddress(libpsapi, "EnumDeviceDrivers") + enumPageFiles = doGetProcAddress(libpsapi, "EnumPageFilesW") + enumProcessModules = doGetProcAddress(libpsapi, "EnumProcessModules") + enumProcessModulesEx = doGetProcAddress(libpsapi, "EnumProcessModulesEx") + enumProcesses = doGetProcAddress(libpsapi, "EnumProcesses") + getDeviceDriverBaseName = doGetProcAddress(libpsapi, "GetDeviceDriverBaseNameW") + getDeviceDriverFileName = doGetProcAddress(libpsapi, "GetDeviceDriverFileNameW") + getMappedFileName = doGetProcAddress(libpsapi, "GetMappedFileNameW") + getModuleBaseName = doGetProcAddress(libpsapi, "GetModuleBaseNameW") + getModuleFileNameEx = doGetProcAddress(libpsapi, "GetModuleFileNameExW") + getModuleInformation = doGetProcAddress(libpsapi, "GetModuleInformation") + getPerformanceInfo = doGetProcAddress(libpsapi, "GetPerformanceInfo") + getProcessImageFileName = doGetProcAddress(libpsapi, "GetProcessImageFileNameW") + getProcessMemoryInfo = doGetProcAddress(libpsapi, "GetProcessMemoryInfo") + getWsChanges = doGetProcAddress(libpsapi, "GetWsChanges") + getWsChangesEx = doGetProcAddress(libpsapi, "GetWsChangesEx") + initializeProcessForWsWatch = doGetProcAddress(libpsapi, "InitializeProcessForWsWatch") + queryWorkingSet = doGetProcAddress(libpsapi, "QueryWorkingSet") + queryWorkingSetEx = doGetProcAddress(libpsapi, "QueryWorkingSetEx") +} + +func EmptyWorkingSet(hProcess HANDLE) bool { + ret1 := syscall3(emptyWorkingSet, 1, + uintptr(hProcess), + 0, + 0) + return ret1 != 0 +} + +func EnumDeviceDrivers(lpImageBase *LPVOID, cb DWORD, lpcbNeeded *uint32) bool { + ret1 := syscall3(enumDeviceDrivers, 3, + uintptr(unsafe.Pointer(lpImageBase)), + uintptr(cb), + uintptr(unsafe.Pointer(lpcbNeeded))) + return ret1 != 0 +} + +func EnumPageFiles(pCallBackRoutine PENUM_PAGE_FILE_CALLBACK, pContext LPVOID) bool { + pCallBackRoutineCallback := syscall.NewCallback(func(pContextRawArg LPVOID, pPageFileInfoRawArg PENUM_PAGE_FILE_INFORMATION, lpFilenameRawArg /*const*/ *uint16) uintptr { + lpFilename := stringFromUnicode16(lpFilenameRawArg) + ret := pCallBackRoutine(pContextRawArg, pPageFileInfoRawArg, lpFilename) + return uintptr(ret) + }) + ret1 := syscall3(enumPageFiles, 2, + pCallBackRoutineCallback, + uintptr(unsafe.Pointer(pContext)), + 0) + return ret1 != 0 +} + +func EnumProcessModules(hProcess HANDLE, lphModule *HMODULE, cb DWORD, lpcbNeeded *uint32) bool { + ret1 := syscall6(enumProcessModules, 4, + uintptr(hProcess), + uintptr(unsafe.Pointer(lphModule)), + uintptr(cb), + uintptr(unsafe.Pointer(lpcbNeeded)), + 0, + 0) + return ret1 != 0 +} + +func EnumProcessModulesEx(hProcess HANDLE, lphModule *HMODULE, cb DWORD, lpcbNeeded *uint32, dwFilterFlag DWORD) bool { + ret1 := syscall6(enumProcessModulesEx, 5, + uintptr(hProcess), + uintptr(unsafe.Pointer(lphModule)), + uintptr(cb), + uintptr(unsafe.Pointer(lpcbNeeded)), + uintptr(dwFilterFlag), + 0) + return ret1 != 0 +} + +func EnumProcesses(lpidProcess *uint32, cb DWORD, cbNeeded *uint32) bool { + ret1 := syscall3(enumProcesses, 3, + uintptr(unsafe.Pointer(lpidProcess)), + uintptr(cb), + uintptr(unsafe.Pointer(cbNeeded))) + return ret1 != 0 +} + +func GetDeviceDriverBaseName(imageBase LPVOID, lpBaseName LPWSTR, nSize DWORD) DWORD { + ret1 := syscall3(getDeviceDriverBaseName, 3, + uintptr(unsafe.Pointer(imageBase)), + uintptr(unsafe.Pointer(lpBaseName)), + uintptr(nSize)) + return DWORD(ret1) +} + +func GetDeviceDriverFileName(imageBase LPVOID, lpFilename LPWSTR, nSize DWORD) DWORD { + ret1 := syscall3(getDeviceDriverFileName, 3, + uintptr(unsafe.Pointer(imageBase)), + uintptr(unsafe.Pointer(lpFilename)), + uintptr(nSize)) + return DWORD(ret1) +} + +func GetMappedFileName(hProcess HANDLE, lpv LPVOID, lpFilename LPWSTR, nSize DWORD) DWORD { + ret1 := syscall6(getMappedFileName, 4, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpv)), + uintptr(unsafe.Pointer(lpFilename)), + uintptr(nSize), + 0, + 0) + return DWORD(ret1) +} + +func GetModuleBaseName(hProcess HANDLE, hModule HMODULE, lpBaseName LPWSTR, nSize DWORD) DWORD { + ret1 := syscall6(getModuleBaseName, 4, + uintptr(hProcess), + uintptr(hModule), + uintptr(unsafe.Pointer(lpBaseName)), + uintptr(nSize), + 0, + 0) + return DWORD(ret1) +} + +func GetModuleFileNameEx(hProcess HANDLE, hModule HMODULE, lpFilename LPWSTR, nSize DWORD) DWORD { + ret1 := syscall6(getModuleFileNameEx, 4, + uintptr(hProcess), + uintptr(hModule), + uintptr(unsafe.Pointer(lpFilename)), + uintptr(nSize), + 0, + 0) + return DWORD(ret1) +} + +func GetModuleInformation(hProcess HANDLE, hModule HMODULE, lpmodinfo *MODULEINFO, cb DWORD) bool { + ret1 := syscall6(getModuleInformation, 4, + uintptr(hProcess), + uintptr(hModule), + uintptr(unsafe.Pointer(lpmodinfo)), + uintptr(cb), + 0, + 0) + return ret1 != 0 +} + +func GetPerformanceInfo(pPerformanceInformation PPERFORMACE_INFORMATION, cb DWORD) bool { + ret1 := syscall3(getPerformanceInfo, 2, + uintptr(unsafe.Pointer(pPerformanceInformation)), + uintptr(cb), + 0) + return ret1 != 0 +} + +func GetProcessImageFileName(hProcess HANDLE, lpImageFileName LPWSTR, nSize DWORD) DWORD { + ret1 := syscall3(getProcessImageFileName, 3, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpImageFileName)), + uintptr(nSize)) + return DWORD(ret1) +} + +func GetProcessMemoryInfo(process HANDLE, ppsmemCounters PPROCESS_MEMORY_COUNTERS, cb DWORD) bool { + ret1 := syscall3(getProcessMemoryInfo, 3, + uintptr(process), + uintptr(unsafe.Pointer(ppsmemCounters)), + uintptr(cb)) + return ret1 != 0 +} + +func GetWsChanges(hProcess HANDLE, lpWatchInfo PPSAPI_WS_WATCH_INFORMATION, cb DWORD) bool { + ret1 := syscall3(getWsChanges, 3, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpWatchInfo)), + uintptr(cb)) + return ret1 != 0 +} + +func GetWsChangesEx(hProcess HANDLE, lpWatchInfoEx PPSAPI_WS_WATCH_INFORMATION_EX, cb DWORD) bool { + ret1 := syscall3(getWsChangesEx, 3, + uintptr(hProcess), + uintptr(unsafe.Pointer(lpWatchInfoEx)), + uintptr(cb)) + return ret1 != 0 +} + +func InitializeProcessForWsWatch(hProcess HANDLE) bool { + ret1 := syscall3(initializeProcessForWsWatch, 1, + uintptr(hProcess), + 0, + 0) + return ret1 != 0 +} + +func QueryWorkingSet(hProcess HANDLE, pv uintptr, cb DWORD) bool { + ret1 := syscall3(queryWorkingSet, 3, + uintptr(hProcess), + pv, + uintptr(cb)) + return ret1 != 0 +} + +func QueryWorkingSetEx(hProcess HANDLE, pv uintptr, cb DWORD) bool { + ret1 := syscall3(queryWorkingSetEx, 3, + uintptr(hProcess), + pv, + uintptr(cb)) + return ret1 != 0 +} diff --git a/grdp/win/rpcrt4.go b/grdp/win/rpcrt4.go new file mode 100644 index 0000000..db15a94 --- /dev/null +++ b/grdp/win/rpcrt4.go @@ -0,0 +1,1382 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "syscall" + "unsafe" +) + +var ( + // Library + librpcrt4 uintptr + + // Functions + cStdStubBuffer_AddRef uintptr + cStdStubBuffer_Connect uintptr + cStdStubBuffer_CountRefs uintptr + cStdStubBuffer_DebugServerQueryInterface uintptr + cStdStubBuffer_DebugServerRelease uintptr + cStdStubBuffer_Disconnect uintptr + cStdStubBuffer_QueryInterface uintptr + createStubFromTypeInfo uintptr + iUnknown_AddRef_Proxy uintptr + iUnknown_QueryInterface_Proxy uintptr + iUnknown_Release_Proxy uintptr + i_RpcBindingInqLocalClientPID uintptr + i_RpcExceptionFilter uintptr + i_RpcFree uintptr + i_RpcFreeBuffer uintptr + i_RpcGetBuffer uintptr + i_RpcGetCurrentCallHandle uintptr + i_RpcMapWin32Status uintptr + i_RpcNegotiateTransferSyntax uintptr + i_RpcReceive uintptr + i_RpcSend uintptr + i_RpcSendReceive uintptr + nDRSContextMarshall uintptr + nDRSContextMarshall2 uintptr + nDRSContextMarshallEx uintptr + nDRSContextUnmarshall uintptr + nDRSContextUnmarshall2 uintptr + nDRSContextUnmarshallEx uintptr + ndrByteCountPointerBufferSize uintptr + ndrByteCountPointerFree uintptr + ndrClearOutParameters uintptr + ndrComplexArrayBufferSize uintptr + ndrComplexArrayFree uintptr + ndrComplexArrayMemorySize uintptr + ndrComplexStructBufferSize uintptr + ndrComplexStructFree uintptr + ndrComplexStructMemorySize uintptr + ndrConformantArrayBufferSize uintptr + ndrConformantArrayFree uintptr + ndrConformantArrayMemorySize uintptr + ndrConformantStringBufferSize uintptr + ndrConformantStringMemorySize uintptr + ndrConformantStructBufferSize uintptr + ndrConformantStructFree uintptr + ndrConformantStructMemorySize uintptr + ndrConformantVaryingArrayBufferSize uintptr + ndrConformantVaryingArrayFree uintptr + ndrConformantVaryingArrayMemorySize uintptr + ndrConformantVaryingStructBufferSize uintptr + ndrConformantVaryingStructFree uintptr + ndrConformantVaryingStructMemorySize uintptr + ndrContextHandleInitialize uintptr + ndrContextHandleSize uintptr + ndrConvert uintptr + ndrConvert2 uintptr + ndrCorrelationFree uintptr + ndrCorrelationInitialize uintptr + ndrCorrelationPass uintptr + ndrEncapsulatedUnionBufferSize uintptr + ndrEncapsulatedUnionFree uintptr + ndrEncapsulatedUnionMemorySize uintptr + ndrFixedArrayBufferSize uintptr + ndrFixedArrayFree uintptr + ndrFixedArrayMemorySize uintptr + ndrFreeBuffer uintptr + ndrInterfacePointerBufferSize uintptr + ndrInterfacePointerFree uintptr + ndrInterfacePointerMemorySize uintptr + ndrNonConformantStringBufferSize uintptr + ndrNonConformantStringMemorySize uintptr + ndrNonEncapsulatedUnionBufferSize uintptr + ndrNonEncapsulatedUnionFree uintptr + ndrNonEncapsulatedUnionMemorySize uintptr + ndrOleFree uintptr + ndrPointerBufferSize uintptr + ndrPointerFree uintptr + ndrPointerMemorySize uintptr + ndrProxyErrorHandler uintptr + ndrProxyFreeBuffer uintptr + ndrProxyGetBuffer uintptr + ndrProxySendReceive uintptr + ndrRpcSmSetClientToOsf uintptr + ndrServerCall2 uintptr + ndrServerContextMarshall uintptr + ndrServerContextNewMarshall uintptr + ndrServerContextNewUnmarshall uintptr + ndrServerContextUnmarshall uintptr + ndrSimpleStructBufferSize uintptr + ndrSimpleStructFree uintptr + ndrSimpleStructMemorySize uintptr + ndrUserMarshalBufferSize uintptr + ndrUserMarshalFree uintptr + ndrUserMarshalMemorySize uintptr + ndrVaryingArrayBufferSize uintptr + ndrVaryingArrayFree uintptr + ndrVaryingArrayMemorySize uintptr + ndrXmitOrRepAsBufferSize uintptr + ndrXmitOrRepAsFree uintptr + ndrXmitOrRepAsMemorySize uintptr + rpcBindingFree uintptr + rpcBindingSetOption uintptr + rpcImpersonateClient uintptr + rpcMgmtEnableIdleCleanup uintptr + rpcMgmtIsServerListening uintptr + rpcMgmtSetComTimeout uintptr + rpcMgmtSetServerStackSize uintptr + rpcMgmtStopServerListening uintptr + rpcMgmtWaitServerListen uintptr + rpcRevertToSelf uintptr + rpcRevertToSelfEx uintptr + rpcServerListen uintptr + rpcSmDestroyClientContext uintptr + rpcSsDestroyClientContext uintptr + rpcSsDontSerializeContext uintptr +) + +func init() { + // Library + librpcrt4 = doLoadLibrary("rpcrt4.dll") + + // Functions + cStdStubBuffer_AddRef = doGetProcAddress(librpcrt4, "CStdStubBuffer_AddRef") + cStdStubBuffer_Connect = doGetProcAddress(librpcrt4, "CStdStubBuffer_Connect") + cStdStubBuffer_CountRefs = doGetProcAddress(librpcrt4, "CStdStubBuffer_CountRefs") + cStdStubBuffer_DebugServerQueryInterface = doGetProcAddress(librpcrt4, "CStdStubBuffer_DebugServerQueryInterface") + cStdStubBuffer_DebugServerRelease = doGetProcAddress(librpcrt4, "CStdStubBuffer_DebugServerRelease") + cStdStubBuffer_Disconnect = doGetProcAddress(librpcrt4, "CStdStubBuffer_Disconnect") + cStdStubBuffer_QueryInterface = doGetProcAddress(librpcrt4, "CStdStubBuffer_QueryInterface") + createStubFromTypeInfo = doGetProcAddress(librpcrt4, "CreateStubFromTypeInfo") + iUnknown_AddRef_Proxy = doGetProcAddress(librpcrt4, "IUnknown_AddRef_Proxy") + iUnknown_QueryInterface_Proxy = doGetProcAddress(librpcrt4, "IUnknown_QueryInterface_Proxy") + iUnknown_Release_Proxy = doGetProcAddress(librpcrt4, "IUnknown_Release_Proxy") + i_RpcBindingInqLocalClientPID = doGetProcAddress(librpcrt4, "I_RpcBindingInqLocalClientPID") + i_RpcExceptionFilter = doGetProcAddress(librpcrt4, "I_RpcExceptionFilter") + i_RpcFree = doGetProcAddress(librpcrt4, "I_RpcFree") + i_RpcFreeBuffer = doGetProcAddress(librpcrt4, "I_RpcFreeBuffer") + i_RpcGetBuffer = doGetProcAddress(librpcrt4, "I_RpcGetBuffer") + i_RpcGetCurrentCallHandle = doGetProcAddress(librpcrt4, "I_RpcGetCurrentCallHandle") + i_RpcMapWin32Status = doGetProcAddress(librpcrt4, "I_RpcMapWin32Status") + i_RpcNegotiateTransferSyntax = doGetProcAddress(librpcrt4, "I_RpcNegotiateTransferSyntax") + i_RpcReceive = doGetProcAddress(librpcrt4, "I_RpcReceive") + i_RpcSend = doGetProcAddress(librpcrt4, "I_RpcSend") + i_RpcSendReceive = doGetProcAddress(librpcrt4, "I_RpcSendReceive") + nDRSContextMarshall = doGetProcAddress(librpcrt4, "NDRSContextMarshall") + nDRSContextMarshall2 = doGetProcAddress(librpcrt4, "NDRSContextMarshall2") + nDRSContextMarshallEx = doGetProcAddress(librpcrt4, "NDRSContextMarshallEx") + nDRSContextUnmarshall = doGetProcAddress(librpcrt4, "NDRSContextUnmarshall") + nDRSContextUnmarshall2 = doGetProcAddress(librpcrt4, "NDRSContextUnmarshall2") + nDRSContextUnmarshallEx = doGetProcAddress(librpcrt4, "NDRSContextUnmarshallEx") + ndrByteCountPointerBufferSize = doGetProcAddress(librpcrt4, "NdrByteCountPointerBufferSize") + ndrByteCountPointerFree = doGetProcAddress(librpcrt4, "NdrByteCountPointerFree") + ndrClearOutParameters = doGetProcAddress(librpcrt4, "NdrClearOutParameters") + ndrComplexArrayBufferSize = doGetProcAddress(librpcrt4, "NdrComplexArrayBufferSize") + ndrComplexArrayFree = doGetProcAddress(librpcrt4, "NdrComplexArrayFree") + ndrComplexArrayMemorySize = doGetProcAddress(librpcrt4, "NdrComplexArrayMemorySize") + ndrComplexStructBufferSize = doGetProcAddress(librpcrt4, "NdrComplexStructBufferSize") + ndrComplexStructFree = doGetProcAddress(librpcrt4, "NdrComplexStructFree") + ndrComplexStructMemorySize = doGetProcAddress(librpcrt4, "NdrComplexStructMemorySize") + ndrConformantArrayBufferSize = doGetProcAddress(librpcrt4, "NdrConformantArrayBufferSize") + ndrConformantArrayFree = doGetProcAddress(librpcrt4, "NdrConformantArrayFree") + ndrConformantArrayMemorySize = doGetProcAddress(librpcrt4, "NdrConformantArrayMemorySize") + ndrConformantStringBufferSize = doGetProcAddress(librpcrt4, "NdrConformantStringBufferSize") + ndrConformantStringMemorySize = doGetProcAddress(librpcrt4, "NdrConformantStringMemorySize") + ndrConformantStructBufferSize = doGetProcAddress(librpcrt4, "NdrConformantStructBufferSize") + ndrConformantStructFree = doGetProcAddress(librpcrt4, "NdrConformantStructFree") + ndrConformantStructMemorySize = doGetProcAddress(librpcrt4, "NdrConformantStructMemorySize") + ndrConformantVaryingArrayBufferSize = doGetProcAddress(librpcrt4, "NdrConformantVaryingArrayBufferSize") + ndrConformantVaryingArrayFree = doGetProcAddress(librpcrt4, "NdrConformantVaryingArrayFree") + ndrConformantVaryingArrayMemorySize = doGetProcAddress(librpcrt4, "NdrConformantVaryingArrayMemorySize") + ndrConformantVaryingStructBufferSize = doGetProcAddress(librpcrt4, "NdrConformantVaryingStructBufferSize") + ndrConformantVaryingStructFree = doGetProcAddress(librpcrt4, "NdrConformantVaryingStructFree") + ndrConformantVaryingStructMemorySize = doGetProcAddress(librpcrt4, "NdrConformantVaryingStructMemorySize") + ndrContextHandleInitialize = doGetProcAddress(librpcrt4, "NdrContextHandleInitialize") + ndrContextHandleSize = doGetProcAddress(librpcrt4, "NdrContextHandleSize") + ndrConvert = doGetProcAddress(librpcrt4, "NdrConvert") + ndrConvert2 = doGetProcAddress(librpcrt4, "NdrConvert2") + ndrCorrelationFree = doGetProcAddress(librpcrt4, "NdrCorrelationFree") + ndrCorrelationInitialize = doGetProcAddress(librpcrt4, "NdrCorrelationInitialize") + ndrCorrelationPass = doGetProcAddress(librpcrt4, "NdrCorrelationPass") + ndrEncapsulatedUnionBufferSize = doGetProcAddress(librpcrt4, "NdrEncapsulatedUnionBufferSize") + ndrEncapsulatedUnionFree = doGetProcAddress(librpcrt4, "NdrEncapsulatedUnionFree") + ndrEncapsulatedUnionMemorySize = doGetProcAddress(librpcrt4, "NdrEncapsulatedUnionMemorySize") + ndrFixedArrayBufferSize = doGetProcAddress(librpcrt4, "NdrFixedArrayBufferSize") + ndrFixedArrayFree = doGetProcAddress(librpcrt4, "NdrFixedArrayFree") + ndrFixedArrayMemorySize = doGetProcAddress(librpcrt4, "NdrFixedArrayMemorySize") + ndrFreeBuffer = doGetProcAddress(librpcrt4, "NdrFreeBuffer") + ndrInterfacePointerBufferSize = doGetProcAddress(librpcrt4, "NdrInterfacePointerBufferSize") + ndrInterfacePointerFree = doGetProcAddress(librpcrt4, "NdrInterfacePointerFree") + ndrInterfacePointerMemorySize = doGetProcAddress(librpcrt4, "NdrInterfacePointerMemorySize") + ndrNonConformantStringBufferSize = doGetProcAddress(librpcrt4, "NdrNonConformantStringBufferSize") + ndrNonConformantStringMemorySize = doGetProcAddress(librpcrt4, "NdrNonConformantStringMemorySize") + ndrNonEncapsulatedUnionBufferSize = doGetProcAddress(librpcrt4, "NdrNonEncapsulatedUnionBufferSize") + ndrNonEncapsulatedUnionFree = doGetProcAddress(librpcrt4, "NdrNonEncapsulatedUnionFree") + ndrNonEncapsulatedUnionMemorySize = doGetProcAddress(librpcrt4, "NdrNonEncapsulatedUnionMemorySize") + ndrOleFree = doGetProcAddress(librpcrt4, "NdrOleFree") + ndrPointerBufferSize = doGetProcAddress(librpcrt4, "NdrPointerBufferSize") + ndrPointerFree = doGetProcAddress(librpcrt4, "NdrPointerFree") + ndrPointerMemorySize = doGetProcAddress(librpcrt4, "NdrPointerMemorySize") + ndrProxyErrorHandler = doGetProcAddress(librpcrt4, "NdrProxyErrorHandler") + ndrProxyFreeBuffer = doGetProcAddress(librpcrt4, "NdrProxyFreeBuffer") + ndrProxyGetBuffer = doGetProcAddress(librpcrt4, "NdrProxyGetBuffer") + ndrProxySendReceive = doGetProcAddress(librpcrt4, "NdrProxySendReceive") + ndrRpcSmSetClientToOsf = doGetProcAddress(librpcrt4, "NdrRpcSmSetClientToOsf") + ndrServerCall2 = doGetProcAddress(librpcrt4, "NdrServerCall2") + ndrServerContextMarshall = doGetProcAddress(librpcrt4, "NdrServerContextMarshall") + ndrServerContextNewMarshall = doGetProcAddress(librpcrt4, "NdrServerContextNewMarshall") + ndrServerContextNewUnmarshall = doGetProcAddress(librpcrt4, "NdrServerContextNewUnmarshall") + ndrServerContextUnmarshall = doGetProcAddress(librpcrt4, "NdrServerContextUnmarshall") + ndrSimpleStructBufferSize = doGetProcAddress(librpcrt4, "NdrSimpleStructBufferSize") + ndrSimpleStructFree = doGetProcAddress(librpcrt4, "NdrSimpleStructFree") + ndrSimpleStructMemorySize = doGetProcAddress(librpcrt4, "NdrSimpleStructMemorySize") + ndrUserMarshalBufferSize = doGetProcAddress(librpcrt4, "NdrUserMarshalBufferSize") + ndrUserMarshalFree = doGetProcAddress(librpcrt4, "NdrUserMarshalFree") + ndrUserMarshalMemorySize = doGetProcAddress(librpcrt4, "NdrUserMarshalMemorySize") + ndrVaryingArrayBufferSize = doGetProcAddress(librpcrt4, "NdrVaryingArrayBufferSize") + ndrVaryingArrayFree = doGetProcAddress(librpcrt4, "NdrVaryingArrayFree") + ndrVaryingArrayMemorySize = doGetProcAddress(librpcrt4, "NdrVaryingArrayMemorySize") + ndrXmitOrRepAsBufferSize = doGetProcAddress(librpcrt4, "NdrXmitOrRepAsBufferSize") + ndrXmitOrRepAsFree = doGetProcAddress(librpcrt4, "NdrXmitOrRepAsFree") + ndrXmitOrRepAsMemorySize = doGetProcAddress(librpcrt4, "NdrXmitOrRepAsMemorySize") + rpcBindingFree = doGetProcAddress(librpcrt4, "RpcBindingFree") + rpcBindingSetOption = doGetProcAddress(librpcrt4, "RpcBindingSetOption") + rpcImpersonateClient = doGetProcAddress(librpcrt4, "RpcImpersonateClient") + rpcMgmtEnableIdleCleanup = doGetProcAddress(librpcrt4, "RpcMgmtEnableIdleCleanup") + rpcMgmtIsServerListening = doGetProcAddress(librpcrt4, "RpcMgmtIsServerListening") + rpcMgmtSetComTimeout = doGetProcAddress(librpcrt4, "RpcMgmtSetComTimeout") + rpcMgmtSetServerStackSize = doGetProcAddress(librpcrt4, "RpcMgmtSetServerStackSize") + rpcMgmtStopServerListening = doGetProcAddress(librpcrt4, "RpcMgmtStopServerListening") + rpcMgmtWaitServerListen = doGetProcAddress(librpcrt4, "RpcMgmtWaitServerListen") + rpcRevertToSelf = doGetProcAddress(librpcrt4, "RpcRevertToSelf") + rpcRevertToSelfEx = doGetProcAddress(librpcrt4, "RpcRevertToSelfEx") + rpcServerListen = doGetProcAddress(librpcrt4, "RpcServerListen") + rpcSmDestroyClientContext = doGetProcAddress(librpcrt4, "RpcSmDestroyClientContext") + rpcSsDestroyClientContext = doGetProcAddress(librpcrt4, "RpcSsDestroyClientContext") + rpcSsDontSerializeContext = doGetProcAddress(librpcrt4, "RpcSsDontSerializeContext") +} + +func CStdStubBuffer_AddRef(this *IRpcStubBuffer) ULONG { + ret1 := syscall3(cStdStubBuffer_AddRef, 1, + uintptr(unsafe.Pointer(this)), + 0, + 0) + return ULONG(ret1) +} + +func CStdStubBuffer_Connect(this *IRpcStubBuffer, pUnkServer *IUnknown) HRESULT { + ret1 := syscall3(cStdStubBuffer_Connect, 2, + uintptr(unsafe.Pointer(this)), + uintptr(unsafe.Pointer(pUnkServer)), + 0) + return HRESULT(ret1) +} + +func CStdStubBuffer_CountRefs(this *IRpcStubBuffer) ULONG { + ret1 := syscall3(cStdStubBuffer_CountRefs, 1, + uintptr(unsafe.Pointer(this)), + 0, + 0) + return ULONG(ret1) +} + +func CStdStubBuffer_DebugServerQueryInterface(this *IRpcStubBuffer, ppv uintptr) HRESULT { + ret1 := syscall3(cStdStubBuffer_DebugServerQueryInterface, 2, + uintptr(unsafe.Pointer(this)), + ppv, + 0) + return HRESULT(ret1) +} + +func CStdStubBuffer_DebugServerRelease(this *IRpcStubBuffer, pv uintptr) { + syscall3(cStdStubBuffer_DebugServerRelease, 2, + uintptr(unsafe.Pointer(this)), + pv, + 0) +} + +func CStdStubBuffer_Disconnect(this *IRpcStubBuffer) { + syscall3(cStdStubBuffer_Disconnect, 1, + uintptr(unsafe.Pointer(this)), + 0, + 0) +} + +// TODO: Unknown type(s): RPCOLEMESSAGE * +// func CStdStubBuffer_Invoke(this *IRpcStubBuffer, pRpcMsg RPCOLEMESSAGE *, pRpcChannelBuffer *IRpcChannelBuffer) HRESULT + +func CStdStubBuffer_QueryInterface(this *IRpcStubBuffer, riid REFIID, ppvObject uintptr) HRESULT { + ret1 := syscall3(cStdStubBuffer_QueryInterface, 3, + uintptr(unsafe.Pointer(this)), + uintptr(unsafe.Pointer(riid)), + ppvObject) + return HRESULT(ret1) +} + +// TODO: Unknown type(s): IPSFactoryBuffer * +// func NdrCStdStubBuffer2_Release(this *IRpcStubBuffer, pPSF IPSFactoryBuffer *) ULONG + +// TODO: Unknown type(s): IPSFactoryBuffer * +// func NdrCStdStubBuffer_Release(this *IRpcStubBuffer, pPSF IPSFactoryBuffer *) ULONG + +// TODO: Unknown type(s): LPRPCSTUBBUFFER +// func CStdStubBuffer_IsIIDSupported(iface LPRPCSTUBBUFFER, riid REFIID) LPRPCSTUBBUFFER + +// TODO: Unknown type(s): LPRPCPROXYBUFFER *, LPTYPEINFO +// func CreateProxyFromTypeInfo(pTypeInfo LPTYPEINFO, pUnkOuter LPUNKNOWN, riid REFIID, ppProxy LPRPCPROXYBUFFER *, ppv *LPVOID) HRESULT + +func CreateStubFromTypeInfo(pTypeInfo *ITypeInfo, riid REFIID, pUnkServer *IUnknown, ppStub **IRpcStubBuffer) HRESULT { + ret1 := syscall6(createStubFromTypeInfo, 4, + uintptr(unsafe.Pointer(pTypeInfo)), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(pUnkServer)), + uintptr(unsafe.Pointer(ppStub)), + 0, + 0) + return HRESULT(ret1) +} + +func IUnknown_AddRef_Proxy(iface LPUNKNOWN) ULONG { + ret1 := syscall3(iUnknown_AddRef_Proxy, 1, + uintptr(unsafe.Pointer(iface)), + 0, + 0) + return ULONG(ret1) +} + +func IUnknown_QueryInterface_Proxy(iface LPUNKNOWN, riid REFIID, ppvObj *LPVOID) HRESULT { + ret1 := syscall3(iUnknown_QueryInterface_Proxy, 3, + uintptr(unsafe.Pointer(iface)), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(ppvObj))) + return HRESULT(ret1) +} + +func IUnknown_Release_Proxy(iface LPUNKNOWN) ULONG { + ret1 := syscall3(iUnknown_Release_Proxy, 1, + uintptr(unsafe.Pointer(iface)), + 0, + 0) + return ULONG(ret1) +} + +// TODO: Unknown type(s): PRPC_ASYNC_STATE +// func I_RpcAsyncAbortCall(pAsync PRPC_ASYNC_STATE, exceptionCode ULONG) RPC_STATUS + +// TODO: Unknown type(s): PRPC_ASYNC_STATE +// func I_RpcAsyncSetHandle(pMsg PRPC_MESSAGE, pAsync PRPC_ASYNC_STATE) RPC_STATUS + +func I_RpcBindingInqLocalClientPID(clientBinding RPC_BINDING_HANDLE, clientPID *ULONG) RPC_STATUS { + ret1 := syscall3(i_RpcBindingInqLocalClientPID, 2, + uintptr(clientBinding), + uintptr(unsafe.Pointer(clientPID)), + 0) + return RPC_STATUS(ret1) +} + +// TODO: Unknown type(s): unsigned int * +// func I_RpcBindingInqTransportType(binding RPC_BINDING_HANDLE, aType unsigned int *) RPC_STATUS + +func I_RpcExceptionFilter(exceptionCode ULONG) int32 { + ret1 := syscall3(i_RpcExceptionFilter, 1, + uintptr(exceptionCode), + 0, + 0) + return int32(ret1) +} + +func I_RpcFree(object uintptr) { + syscall3(i_RpcFree, 1, + object, + 0, + 0) +} + +func I_RpcFreeBuffer(pMsg PRPC_MESSAGE) RPC_STATUS { + ret1 := syscall3(i_RpcFreeBuffer, 1, + uintptr(unsafe.Pointer(pMsg)), + 0, + 0) + return RPC_STATUS(ret1) +} + +func I_RpcGetBuffer(pMsg PRPC_MESSAGE) RPC_STATUS { + ret1 := syscall3(i_RpcGetBuffer, 1, + uintptr(unsafe.Pointer(pMsg)), + 0, + 0) + return RPC_STATUS(ret1) +} + +func I_RpcGetCurrentCallHandle() RPC_BINDING_HANDLE { + ret1 := syscall3(i_RpcGetCurrentCallHandle, 0, + 0, + 0, + 0) + return RPC_BINDING_HANDLE(ret1) +} + +func I_RpcMapWin32Status(status RPC_STATUS) LONG { + ret1 := syscall3(i_RpcMapWin32Status, 1, + uintptr(status), + 0, + 0) + return LONG(ret1) +} + +func I_RpcNegotiateTransferSyntax(pMsg PRPC_MESSAGE) RPC_STATUS { + ret1 := syscall3(i_RpcNegotiateTransferSyntax, 1, + uintptr(unsafe.Pointer(pMsg)), + 0, + 0) + return RPC_STATUS(ret1) +} + +func I_RpcReceive(pMsg PRPC_MESSAGE) RPC_STATUS { + ret1 := syscall3(i_RpcReceive, 1, + uintptr(unsafe.Pointer(pMsg)), + 0, + 0) + return RPC_STATUS(ret1) +} + +func I_RpcSend(pMsg PRPC_MESSAGE) RPC_STATUS { + ret1 := syscall3(i_RpcSend, 1, + uintptr(unsafe.Pointer(pMsg)), + 0, + 0) + return RPC_STATUS(ret1) +} + +func I_RpcSendReceive(pMsg PRPC_MESSAGE) RPC_STATUS { + ret1 := syscall3(i_RpcSendReceive, 1, + uintptr(unsafe.Pointer(pMsg)), + 0, + 0) + return RPC_STATUS(ret1) +} + +// TODO: Unknown type(s): UUID * +// func I_UuidCreate(uuid UUID *) RPC_STATUS + +// TODO: Unknown type(s): MIDL_ES_CODE, char * *, handle_t +// func MesBufferHandleReset(handle handle_t, handleStyle ULONG, operation MIDL_ES_CODE, buffer char * *, bufferSize ULONG, encodedSize *ULONG) RPC_STATUS + +// TODO: Unknown type(s): MIDL_ES_READ, handle_t * +// func MesDecodeIncrementalHandleCreate(userState uintptr, readFn MIDL_ES_READ, pHandle handle_t *) RPC_STATUS + +// TODO: Unknown type(s): MIDL_ES_ALLOC, MIDL_ES_WRITE, handle_t * +// func MesEncodeIncrementalHandleCreate(userState uintptr, allocFn MIDL_ES_ALLOC, writeFn MIDL_ES_WRITE, pHandle handle_t *) RPC_STATUS + +// TODO: Unknown type(s): handle_t +// func MesHandleFree(handle handle_t) RPC_STATUS + +// TODO: Unknown type(s): MIDL_ES_ALLOC, MIDL_ES_CODE, MIDL_ES_READ, MIDL_ES_WRITE, handle_t +// func MesIncrementalHandleReset(handle handle_t, userState uintptr, allocFn MIDL_ES_ALLOC, writeFn MIDL_ES_WRITE, readFn MIDL_ES_READ, operation MIDL_ES_CODE) RPC_STATUS + +// TODO: Unknown type(s): NDR_CCONTEXT +// func NDRCContextBinding(cContext NDR_CCONTEXT) RPC_BINDING_HANDLE + +// TODO: Unknown type(s): NDR_CCONTEXT +// func NDRCContextMarshall(cContext NDR_CCONTEXT, pBuff uintptr) + +// TODO: Unknown type(s): NDR_CCONTEXT * +// func NDRCContextUnmarshall(cContext NDR_CCONTEXT *, hBinding RPC_BINDING_HANDLE, pBuff uintptr, dataRepresentation ULONG) + +func NDRSContextMarshall(sContext NDR_SCONTEXT, pBuff uintptr, userRunDownIn NDR_RUNDOWN) { + userRunDownInCallback := syscall.NewCallback(userRunDownIn) + syscall3(nDRSContextMarshall, 3, + uintptr(unsafe.Pointer(sContext)), + pBuff, + userRunDownInCallback) +} + +func NDRSContextMarshall2(hBinding RPC_BINDING_HANDLE, sContext NDR_SCONTEXT, pBuff uintptr, userRunDownIn NDR_RUNDOWN, ctxGuard uintptr, flags ULONG) { + userRunDownInCallback := syscall.NewCallback(userRunDownIn) + syscall6(nDRSContextMarshall2, 6, + uintptr(hBinding), + uintptr(unsafe.Pointer(sContext)), + pBuff, + userRunDownInCallback, + ctxGuard, + uintptr(flags)) +} + +func NDRSContextMarshallEx(hBinding RPC_BINDING_HANDLE, sContext NDR_SCONTEXT, pBuff uintptr, userRunDownIn NDR_RUNDOWN) { + userRunDownInCallback := syscall.NewCallback(userRunDownIn) + syscall6(nDRSContextMarshallEx, 4, + uintptr(hBinding), + uintptr(unsafe.Pointer(sContext)), + pBuff, + userRunDownInCallback, + 0, + 0) +} + +func NDRSContextUnmarshall(pBuff uintptr, dataRepresentation ULONG) NDR_SCONTEXT { + ret1 := syscall3(nDRSContextUnmarshall, 2, + pBuff, + uintptr(dataRepresentation), + 0) + return (NDR_SCONTEXT)(unsafe.Pointer(ret1)) +} + +func NDRSContextUnmarshall2(hBinding RPC_BINDING_HANDLE, pBuff uintptr, dataRepresentation ULONG, ctxGuard uintptr, flags ULONG) NDR_SCONTEXT { + ret1 := syscall6(nDRSContextUnmarshall2, 5, + uintptr(hBinding), + pBuff, + uintptr(dataRepresentation), + ctxGuard, + uintptr(flags), + 0) + return (NDR_SCONTEXT)(unsafe.Pointer(ret1)) +} + +func NDRSContextUnmarshallEx(hBinding RPC_BINDING_HANDLE, pBuff uintptr, dataRepresentation ULONG) NDR_SCONTEXT { + ret1 := syscall3(nDRSContextUnmarshallEx, 3, + uintptr(hBinding), + pBuff, + uintptr(dataRepresentation)) + return (NDR_SCONTEXT)(unsafe.Pointer(ret1)) +} + +func NdrByteCountPointerBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrByteCountPointerBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrByteCountPointerFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrByteCountPointerFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrClearOutParameters(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING, argAddr uintptr) { + syscall3(ndrClearOutParameters, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + argAddr) +} + +// TODO: Unknown type(s): NDR_CCONTEXT +// func NdrClientContextMarshall(pStubMsg PMIDL_STUB_MESSAGE, contextHandle NDR_CCONTEXT, fCheck int32) + +// TODO: Unknown type(s): NDR_CCONTEXT * +// func NdrClientContextUnmarshall(pStubMsg PMIDL_STUB_MESSAGE, pContextHandle NDR_CCONTEXT *, bindHandle RPC_BINDING_HANDLE) + +// TODO: Unknown type(s): PMIDL_STUB_DESC +// func NdrClientInitializeNew(pRpcMessage PRPC_MESSAGE, pStubMsg PMIDL_STUB_MESSAGE, pStubDesc PMIDL_STUB_DESC, procNum uint32) + +func NdrComplexArrayBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrComplexArrayBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrComplexArrayFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrComplexArrayFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrComplexArrayMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrComplexArrayMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrComplexStructBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrComplexStructBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrComplexStructFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrComplexStructFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrComplexStructMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrComplexStructMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrConformantArrayBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrConformantArrayBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrConformantArrayFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrConformantArrayFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrConformantArrayMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrConformantArrayMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrConformantStringBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrConformantStringBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrConformantStringMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrConformantStringMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrConformantStructBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrConformantStructBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrConformantStructFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrConformantStructFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrConformantStructMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrConformantStructMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrConformantVaryingArrayBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrConformantVaryingArrayBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrConformantVaryingArrayFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrConformantVaryingArrayFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrConformantVaryingArrayMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrConformantVaryingArrayMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrConformantVaryingStructBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrConformantVaryingStructBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrConformantVaryingStructFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrConformantVaryingStructFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrConformantVaryingStructMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrConformantVaryingStructMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrContextHandleInitialize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) NDR_SCONTEXT { + ret1 := syscall3(ndrContextHandleInitialize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return (NDR_SCONTEXT)(unsafe.Pointer(ret1)) +} + +func NdrContextHandleSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrContextHandleSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrConvert(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrConvert, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) +} + +func NdrConvert2(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING, numberParams LONG) { + syscall3(ndrConvert2, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + uintptr(numberParams)) +} + +func NdrCorrelationFree(pStubMsg PMIDL_STUB_MESSAGE) { + syscall3(ndrCorrelationFree, 1, + uintptr(unsafe.Pointer(pStubMsg)), + 0, + 0) +} + +func NdrCorrelationInitialize(pStubMsg PMIDL_STUB_MESSAGE, pMemory uintptr, cacheSize ULONG, flags ULONG) { + syscall6(ndrCorrelationInitialize, 4, + uintptr(unsafe.Pointer(pStubMsg)), + pMemory, + uintptr(cacheSize), + uintptr(flags), + 0, + 0) +} + +func NdrCorrelationPass(pStubMsg PMIDL_STUB_MESSAGE) { + syscall3(ndrCorrelationPass, 1, + uintptr(unsafe.Pointer(pStubMsg)), + 0, + 0) +} + +// TODO: Unknown type(s): CStdPSFactoryBuffer * +// func NdrDllCanUnloadNow(pPSFactoryBuffer CStdPSFactoryBuffer *) HRESULT + +// TODO: Unknown type(s): CStdPSFactoryBuffer *, const ProxyFileInfo * * +// func NdrDllGetClassObject(rclsid /*const*/ REFCLSID, iid REFIID, ppv *LPVOID, pProxyFileList /*const*/ const ProxyFileInfo * *, pclsid /*const*/ *CLSID, pPSFactoryBuffer CStdPSFactoryBuffer *) HRESULT + +// TODO: Unknown type(s): const ProxyFileInfo * * +// func NdrDllRegisterProxy(hDll HMODULE, pProxyFileList /*const*/ const ProxyFileInfo * *, pclsid /*const*/ *CLSID) HRESULT + +// TODO: Unknown type(s): const ProxyFileInfo * * +// func NdrDllUnregisterProxy(hDll HMODULE, pProxyFileList /*const*/ const ProxyFileInfo * *, pclsid /*const*/ *CLSID) HRESULT + +func NdrEncapsulatedUnionBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrEncapsulatedUnionBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrEncapsulatedUnionFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrEncapsulatedUnionFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrEncapsulatedUnionMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrEncapsulatedUnionMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrFixedArrayBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrFixedArrayBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrFixedArrayFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrFixedArrayFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrFixedArrayMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrFixedArrayMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrFreeBuffer(pStubMsg PMIDL_STUB_MESSAGE) { + syscall3(ndrFreeBuffer, 1, + uintptr(unsafe.Pointer(pStubMsg)), + 0, + 0) +} + +// TODO: Unknown type(s): PFULL_PTR_XLAT_TABLES +// func NdrFullPointerFree(pXlatTables PFULL_PTR_XLAT_TABLES, pointer uintptr) int32 + +// TODO: Unknown type(s): PFULL_PTR_XLAT_TABLES +// func NdrFullPointerInsertRefId(pXlatTables PFULL_PTR_XLAT_TABLES, refId ULONG, pPointer uintptr) + +// TODO: Unknown type(s): PFULL_PTR_XLAT_TABLES, unsigned char +// func NdrFullPointerQueryPointer(pXlatTables PFULL_PTR_XLAT_TABLES, pPointer uintptr, queryType unsigned char, pRefId *ULONG) int32 + +// TODO: Unknown type(s): PFULL_PTR_XLAT_TABLES, unsigned char +// func NdrFullPointerQueryRefId(pXlatTables PFULL_PTR_XLAT_TABLES, refId ULONG, queryType unsigned char, ppPointer uintptr) int32 + +// TODO: Unknown type(s): PFULL_PTR_XLAT_TABLES +// func NdrFullPointerXlatFree(pXlatTables PFULL_PTR_XLAT_TABLES) + +// TODO: Unknown type(s): PFULL_PTR_XLAT_TABLES +// func NdrFullPointerXlatInit(numberOfPointers ULONG, xlatSide XLAT_SIDE) PFULL_PTR_XLAT_TABLES + +func NdrInterfacePointerBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrInterfacePointerBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrInterfacePointerFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrInterfacePointerFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrInterfacePointerMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrInterfacePointerMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrNonConformantStringBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrNonConformantStringBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrNonConformantStringMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrNonConformantStringMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrNonEncapsulatedUnionBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrNonEncapsulatedUnionBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrNonEncapsulatedUnionFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrNonEncapsulatedUnionFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrNonEncapsulatedUnionMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrNonEncapsulatedUnionMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrOleFree(nodeToFree uintptr) { + syscall3(ndrOleFree, 1, + nodeToFree, + 0, + 0) +} + +func NdrPointerBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrPointerBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrPointerFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrPointerFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrPointerMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrPointerMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrProxyErrorHandler(dwExceptionCode DWORD) HRESULT { + ret1 := syscall3(ndrProxyErrorHandler, 1, + uintptr(dwExceptionCode), + 0, + 0) + return HRESULT(ret1) +} + +func NdrProxyFreeBuffer(this uintptr, pStubMsg PMIDL_STUB_MESSAGE) { + syscall3(ndrProxyFreeBuffer, 2, + this, + uintptr(unsafe.Pointer(pStubMsg)), + 0) +} + +func NdrProxyGetBuffer(this uintptr, pStubMsg PMIDL_STUB_MESSAGE) { + syscall3(ndrProxyGetBuffer, 2, + this, + uintptr(unsafe.Pointer(pStubMsg)), + 0) +} + +// TODO: Unknown type(s): PMIDL_STUB_DESC +// func NdrProxyInitialize(this uintptr, pRpcMsg PRPC_MESSAGE, pStubMsg PMIDL_STUB_MESSAGE, pStubDescriptor PMIDL_STUB_DESC, procNum uint32) + +func NdrProxySendReceive(this uintptr, pStubMsg PMIDL_STUB_MESSAGE) { + syscall3(ndrProxySendReceive, 2, + this, + uintptr(unsafe.Pointer(pStubMsg)), + 0) +} + +func NdrRpcSmSetClientToOsf(pMessage PMIDL_STUB_MESSAGE) { + syscall3(ndrRpcSmSetClientToOsf, 1, + uintptr(unsafe.Pointer(pMessage)), + 0, + 0) +} + +func NdrServerCall2(pRpcMsg PRPC_MESSAGE) { + syscall3(ndrServerCall2, 1, + uintptr(unsafe.Pointer(pRpcMsg)), + 0, + 0) +} + +func NdrServerContextMarshall(pStubMsg PMIDL_STUB_MESSAGE, contextHandle NDR_SCONTEXT, rundownRoutine NDR_RUNDOWN) { + rundownRoutineCallback := syscall.NewCallback(rundownRoutine) + syscall3(ndrServerContextMarshall, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(contextHandle)), + rundownRoutineCallback) +} + +func NdrServerContextNewMarshall(pStubMsg PMIDL_STUB_MESSAGE, contextHandle NDR_SCONTEXT, rundownRoutine NDR_RUNDOWN, pFormat /*const*/ PFORMAT_STRING) { + rundownRoutineCallback := syscall.NewCallback(rundownRoutine) + syscall6(ndrServerContextNewMarshall, 4, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(contextHandle)), + rundownRoutineCallback, + uintptr(unsafe.Pointer(pFormat)), + 0, + 0) +} + +func NdrServerContextNewUnmarshall(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) NDR_SCONTEXT { + ret1 := syscall3(ndrServerContextNewUnmarshall, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return (NDR_SCONTEXT)(unsafe.Pointer(ret1)) +} + +func NdrServerContextUnmarshall(pStubMsg PMIDL_STUB_MESSAGE) NDR_SCONTEXT { + ret1 := syscall3(ndrServerContextUnmarshall, 1, + uintptr(unsafe.Pointer(pStubMsg)), + 0, + 0) + return (NDR_SCONTEXT)(unsafe.Pointer(ret1)) +} + +func NdrSimpleStructBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrSimpleStructBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrSimpleStructFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrSimpleStructFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrSimpleStructMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrSimpleStructMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +// TODO: Unknown type(s): unsigned char +// func NdrSimpleTypeMarshall(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, formatChar unsigned char) + +// TODO: Unknown type(s): unsigned char +// func NdrSimpleTypeUnmarshall(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, formatChar unsigned char) + +// TODO: Unknown type(s): struct IRpcChannelBuffer *, struct IRpcStubBuffer * +// func NdrStubCall2(pThis struct IRpcStubBuffer *, pChannel struct IRpcChannelBuffer *, pRpcMsg PRPC_MESSAGE, pdwStubPhase *uint32) LONG + +// TODO: Unknown type(s): LPRPCCHANNELBUFFER, LPRPCSTUBBUFFER +// func NdrStubGetBuffer(iface LPRPCSTUBBUFFER, pRpcChannelBuffer LPRPCCHANNELBUFFER, pStubMsg PMIDL_STUB_MESSAGE) + +// TODO: Unknown type(s): LPRPCCHANNELBUFFER, PMIDL_STUB_DESC +// func NdrStubInitialize(pRpcMsg PRPC_MESSAGE, pStubMsg PMIDL_STUB_MESSAGE, pStubDescriptor PMIDL_STUB_DESC, pRpcChannelBuffer LPRPCCHANNELBUFFER) + +func NdrUserMarshalBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrUserMarshalBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrUserMarshalFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrUserMarshalFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrUserMarshalMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrUserMarshalMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrVaryingArrayBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrVaryingArrayBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrVaryingArrayFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrVaryingArrayFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrVaryingArrayMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrVaryingArrayMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +func NdrXmitOrRepAsBufferSize(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrXmitOrRepAsBufferSize, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrXmitOrRepAsFree(pStubMsg PMIDL_STUB_MESSAGE, pMemory *byte, pFormat /*const*/ PFORMAT_STRING) { + syscall3(ndrXmitOrRepAsFree, 3, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pMemory)), + uintptr(unsafe.Pointer(pFormat))) +} + +func NdrXmitOrRepAsMemorySize(pStubMsg PMIDL_STUB_MESSAGE, pFormat /*const*/ PFORMAT_STRING) ULONG { + ret1 := syscall3(ndrXmitOrRepAsMemorySize, 2, + uintptr(unsafe.Pointer(pStubMsg)), + uintptr(unsafe.Pointer(pFormat)), + 0) + return ULONG(ret1) +} + +// TODO: Unknown type(s): PRPC_ASYNC_STATE +// func RpcAsyncAbortCall(pAsync PRPC_ASYNC_STATE, exceptionCode ULONG) RPC_STATUS + +// TODO: Unknown type(s): PRPC_ASYNC_STATE +// func RpcAsyncCancelCall(pAsync PRPC_ASYNC_STATE, fAbortCall bool) RPC_STATUS + +// TODO: Unknown type(s): PRPC_ASYNC_STATE +// func RpcAsyncCompleteCall(pAsync PRPC_ASYNC_STATE, reply uintptr) RPC_STATUS + +// TODO: Unknown type(s): PRPC_ASYNC_STATE +// func RpcAsyncGetCallStatus(pAsync PRPC_ASYNC_STATE) RPC_STATUS + +// TODO: Unknown type(s): PRPC_ASYNC_STATE +// func RpcAsyncInitializeHandle(pAsync PRPC_ASYNC_STATE, size uint32) RPC_STATUS + +func RpcBindingFree(binding *RPC_BINDING_HANDLE) RPC_STATUS { + ret1 := syscall3(rpcBindingFree, 1, + uintptr(unsafe.Pointer(binding)), + 0, + 0) + return RPC_STATUS(ret1) +} + +// TODO: Unknown type(s): RPC_WSTR +// func RpcBindingFromStringBinding(stringBinding RPC_WSTR, binding *RPC_BINDING_HANDLE) RPC_STATUS + +// TODO: Unknown type(s): UUID * +// func RpcBindingInqObject(binding RPC_BINDING_HANDLE, objectUuid UUID *) RPC_STATUS + +// TODO: Unknown type(s): UUID * +// func RpcBindingSetObject(binding RPC_BINDING_HANDLE, objectUuid UUID *) RPC_STATUS + +func RpcBindingSetOption(bindingHandle RPC_BINDING_HANDLE, option ULONG, optionValue *uint32) RPC_STATUS { + ret1 := syscall3(rpcBindingSetOption, 3, + uintptr(bindingHandle), + uintptr(option), + uintptr(unsafe.Pointer(optionValue))) + return RPC_STATUS(ret1) +} + +// TODO: Unknown type(s): RPC_WSTR * +// func RpcBindingToStringBinding(binding RPC_BINDING_HANDLE, stringBinding RPC_WSTR *) RPC_STATUS + +// TODO: Unknown type(s): RPC_BINDING_VECTOR * * +// func RpcBindingVectorFree(bindingVector RPC_BINDING_VECTOR * *) RPC_STATUS + +// TODO: Unknown type(s): RPC_BINDING_VECTOR *, RPC_IF_HANDLE, RPC_WSTR, UUID_VECTOR * +// func RpcEpRegisterNoReplace(ifSpec RPC_IF_HANDLE, bindingVector RPC_BINDING_VECTOR *, uuidVector UUID_VECTOR *, annotation RPC_WSTR) RPC_STATUS + +// TODO: Unknown type(s): RPC_BINDING_VECTOR *, RPC_IF_HANDLE, RPC_WSTR, UUID_VECTOR * +// func RpcEpRegister(ifSpec RPC_IF_HANDLE, bindingVector RPC_BINDING_VECTOR *, uuidVector UUID_VECTOR *, annotation RPC_WSTR) RPC_STATUS + +// TODO: Unknown type(s): RPC_IF_HANDLE +// func RpcEpResolveBinding(binding RPC_BINDING_HANDLE, ifSpec RPC_IF_HANDLE) RPC_STATUS + +// TODO: Unknown type(s): RPC_BINDING_VECTOR *, RPC_IF_HANDLE, UUID_VECTOR * +// func RpcEpUnregister(ifSpec RPC_IF_HANDLE, bindingVector RPC_BINDING_VECTOR *, uuidVector UUID_VECTOR *) RPC_STATUS + +func RpcImpersonateClient(bindingHandle RPC_BINDING_HANDLE) RPC_STATUS { + ret1 := syscall3(rpcImpersonateClient, 1, + uintptr(bindingHandle), + 0, + 0) + return RPC_STATUS(ret1) +} + +func RpcMgmtEnableIdleCleanup() RPC_STATUS { + ret1 := syscall3(rpcMgmtEnableIdleCleanup, 0, + 0, + 0, + 0) + return RPC_STATUS(ret1) +} + +// TODO: Unknown type(s): RPC_EP_INQ_HANDLE *, RPC_IF_ID *, UUID * +// func RpcMgmtEpEltInqBegin(binding RPC_BINDING_HANDLE, inquiryType ULONG, ifId RPC_IF_ID *, versOption ULONG, objectUuid UUID *, inquiryContext RPC_EP_INQ_HANDLE *) RPC_STATUS + +// TODO: Unknown type(s): RPC_IF_ID_VECTOR * * +// func RpcMgmtInqIfIds(binding RPC_BINDING_HANDLE, ifIdVector RPC_IF_ID_VECTOR * *) RPC_STATUS + +// TODO: Unknown type(s): RPC_STATS_VECTOR * * +// func RpcMgmtInqStats(binding RPC_BINDING_HANDLE, statistics RPC_STATS_VECTOR * *) RPC_STATUS + +func RpcMgmtIsServerListening(binding RPC_BINDING_HANDLE) RPC_STATUS { + ret1 := syscall3(rpcMgmtIsServerListening, 1, + uintptr(binding), + 0, + 0) + return RPC_STATUS(ret1) +} + +// TODO: Unknown type(s): RPC_MGMT_AUTHORIZATION_FN +// func RpcMgmtSetAuthorizationFn(fn RPC_MGMT_AUTHORIZATION_FN) RPC_STATUS + +func RpcMgmtSetComTimeout(bindingHandle RPC_BINDING_HANDLE, timeout uint32) RPC_STATUS { + ret1 := syscall3(rpcMgmtSetComTimeout, 2, + uintptr(bindingHandle), + uintptr(timeout), + 0) + return RPC_STATUS(ret1) +} + +func RpcMgmtSetServerStackSize(threadStackSize ULONG) RPC_STATUS { + ret1 := syscall3(rpcMgmtSetServerStackSize, 1, + uintptr(threadStackSize), + 0, + 0) + return RPC_STATUS(ret1) +} + +// TODO: Unknown type(s): RPC_STATS_VECTOR * * +// func RpcMgmtStatsVectorFree(statsVector RPC_STATS_VECTOR * *) RPC_STATUS + +func RpcMgmtStopServerListening(binding RPC_BINDING_HANDLE) RPC_STATUS { + ret1 := syscall3(rpcMgmtStopServerListening, 1, + uintptr(binding), + 0, + 0) + return RPC_STATUS(ret1) +} + +func RpcMgmtWaitServerListen() RPC_STATUS { + ret1 := syscall3(rpcMgmtWaitServerListen, 0, + 0, + 0, + 0) + return RPC_STATUS(ret1) +} + +// TODO: Unknown type(s): RPC_PROTSEQ_VECTORW * * +// func RpcNetworkInqProtseqs(protseqs RPC_PROTSEQ_VECTORW * *) RPC_STATUS + +// TODO: Unknown type(s): RPC_WSTR +// func RpcNetworkIsProtseqValid(protseq RPC_WSTR) RPC_STATUS + +// TODO: Unknown type(s): UUID * +// func RpcObjectSetType(objUuid UUID *, typeUuid UUID *) RPC_STATUS + +// TODO: Unknown type(s): RPC_PROTSEQ_VECTORW * * +// func RpcProtseqVectorFree(protseqs RPC_PROTSEQ_VECTORW * *) RPC_STATUS + +// TODO: Unknown type(s): DECLSPEC_NORETURN +// func RpcRaiseException(exception RPC_STATUS) DECLSPEC_NORETURN + +func RpcRevertToSelf() RPC_STATUS { + ret1 := syscall3(rpcRevertToSelf, 0, + 0, + 0, + 0) + return RPC_STATUS(ret1) +} + +func RpcRevertToSelfEx(bindingHandle RPC_BINDING_HANDLE) RPC_STATUS { + ret1 := syscall3(rpcRevertToSelfEx, 1, + uintptr(bindingHandle), + 0, + 0) + return RPC_STATUS(ret1) +} + +// TODO: Unknown type(s): RPC_BINDING_VECTOR * * +// func RpcServerInqBindings(bindingVector RPC_BINDING_VECTOR * *) RPC_STATUS + +func RpcServerListen(minimumCallThreads UINT, maxCalls UINT, dontWait UINT) RPC_STATUS { + ret1 := syscall3(rpcServerListen, 3, + uintptr(minimumCallThreads), + uintptr(maxCalls), + uintptr(dontWait)) + return RPC_STATUS(ret1) +} + +// TODO: Unknown type(s): RPC_AUTH_KEY_RETRIEVAL_FN, RPC_WSTR +// func RpcServerRegisterAuthInfo(serverPrincName RPC_WSTR, authnSvc ULONG, getKeyFn RPC_AUTH_KEY_RETRIEVAL_FN, arg LPVOID) RPC_STATUS + +// TODO: Unknown type(s): RPC_IF_HANDLE, RPC_MGR_EPV *, UUID * +// func RpcServerRegisterIf(ifSpec RPC_IF_HANDLE, mgrTypeUuid UUID *, mgrEpv RPC_MGR_EPV *) RPC_STATUS + +// TODO: Unknown type(s): RPC_IF_CALLBACK_FN *, RPC_IF_HANDLE, RPC_MGR_EPV *, UUID * +// func RpcServerRegisterIf2(ifSpec RPC_IF_HANDLE, mgrTypeUuid UUID *, mgrEpv RPC_MGR_EPV *, flags UINT, maxCalls UINT, maxRpcSize UINT, ifCallbackFn RPC_IF_CALLBACK_FN *) RPC_STATUS + +// TODO: Unknown type(s): RPC_IF_CALLBACK_FN *, RPC_IF_HANDLE, RPC_MGR_EPV *, UUID * +// func RpcServerRegisterIfEx(ifSpec RPC_IF_HANDLE, mgrTypeUuid UUID *, mgrEpv RPC_MGR_EPV *, flags UINT, maxCalls UINT, ifCallbackFn RPC_IF_CALLBACK_FN *) RPC_STATUS + +// TODO: Unknown type(s): RPC_IF_HANDLE, UUID * +// func RpcServerUnregisterIf(ifSpec RPC_IF_HANDLE, mgrTypeUuid UUID *, waitForCallsToComplete UINT) RPC_STATUS + +// TODO: Unknown type(s): RPC_IF_HANDLE, UUID * +// func RpcServerUnregisterIfEx(ifSpec RPC_IF_HANDLE, mgrTypeUuid UUID *, rundownContextHandles int32) RPC_STATUS + +// TODO: Unknown type(s): PRPC_POLICY, RPC_WSTR +// func RpcServerUseProtseqEpEx(protseq RPC_WSTR, maxCalls UINT, endpoint RPC_WSTR, securityDescriptor LPVOID, lpPolicy PRPC_POLICY) RPC_STATUS + +// TODO: Unknown type(s): RPC_WSTR +// func RpcServerUseProtseqEp(protseq RPC_WSTR, maxCalls UINT, endpoint RPC_WSTR, securityDescriptor LPVOID) RPC_STATUS + +// TODO: Unknown type(s): RPC_WSTR +// func RpcServerUseProtseq(protseq RPC_WSTR, maxCalls uint32, securityDescriptor uintptr) RPC_STATUS + +func RpcSmDestroyClientContext(contextHandle uintptr) RPC_STATUS { + ret1 := syscall3(rpcSmDestroyClientContext, 1, + contextHandle, + 0, + 0) + return RPC_STATUS(ret1) +} + +func RpcSsDestroyClientContext(contextHandle uintptr) { + syscall3(rpcSsDestroyClientContext, 1, + contextHandle, + 0, + 0) +} + +func RpcSsDontSerializeContext() { + syscall3(rpcSsDontSerializeContext, 0, + 0, + 0, + 0) +} + +// TODO: Unknown type(s): RPC_WSTR, RPC_WSTR * +// func RpcStringBindingCompose(objUuid RPC_WSTR, protseq RPC_WSTR, networkAddr RPC_WSTR, endpoint RPC_WSTR, options RPC_WSTR, stringBinding RPC_WSTR *) RPC_STATUS + +// TODO: Unknown type(s): RPC_WSTR, RPC_WSTR * +// func RpcStringBindingParse(stringBinding RPC_WSTR, objUuid RPC_WSTR *, protseq RPC_WSTR *, networkAddr RPC_WSTR *, endpoint RPC_WSTR *, options RPC_WSTR *) RPC_STATUS + +// TODO: Unknown type(s): RPC_WSTR * +// func RpcStringFree(string RPC_WSTR *) RPC_STATUS + +// TODO: Unknown type(s): twr_t * * +// func TowerConstruct(object /*const*/ *RPC_SYNTAX_IDENTIFIER, syntax /*const*/ *RPC_SYNTAX_IDENTIFIER, protseq /*const*/ *CHAR, endpoint /*const*/ *CHAR, address /*const*/ *CHAR, tower twr_t * *) RPC_STATUS + +// TODO: Unknown type(s): char * *, const twr_t * +// func TowerExplode(tower /*const*/ const twr_t *, object PRPC_SYNTAX_IDENTIFIER, syntax PRPC_SYNTAX_IDENTIFIER, protseq char * *, endpoint char * *, address char * *) RPC_STATUS + +// TODO: Unknown type(s): UUID * +// func UuidCompare(uuid1 UUID *, uuid2 UUID *, status *RPC_STATUS) int32 + +// TODO: Unknown type(s): UUID * +// func UuidCreate(uuid UUID *) RPC_STATUS + +// TODO: Unknown type(s): UUID * +// func UuidCreateNil(uuid UUID *) RPC_STATUS + +// TODO: Unknown type(s): UUID * +// func UuidCreateSequential(uuid UUID *) RPC_STATUS + +// TODO: Unknown type(s): UUID * +// func UuidEqual(uuid1 UUID *, uuid2 UUID *, status *RPC_STATUS) int32 + +// TODO: Unknown type(s): RPC_WSTR, UUID * +// func UuidFromString(s RPC_WSTR, uuid UUID *) RPC_STATUS + +// TODO: Unknown type(s): UUID * +// func UuidHash(uuid UUID *, status *RPC_STATUS) int16 + +// TODO: Unknown type(s): UUID * +// func UuidIsNil(uuid UUID *, status *RPC_STATUS) int32 + +// TODO: Unknown type(s): RPC_WSTR *, UUID * +// func UuidToString(uuid UUID *, stringUuid RPC_WSTR *) RPC_STATUS diff --git a/grdp/win/shell32.go b/grdp/win/shell32.go new file mode 100644 index 0000000..208d7ba --- /dev/null +++ b/grdp/win/shell32.go @@ -0,0 +1,1908 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "syscall" + "unsafe" +) + +var ( + // Library + libshell32 uintptr + + // Functions + sHAddFromPropSheetExtArray uintptr + sHCreatePropSheetExtArray uintptr + sHDestroyPropSheetExtArray uintptr + sHReplaceFromPropSheetExtArray uintptr + cDefFolderMenu_Create2 uintptr + cIDLData_CreateFromIDArray uintptr + callCPLEntry16 uintptr + checkEscapes uintptr + control_FillCache_RunDLL uintptr + control_RunDLL uintptr + dAD_AutoScroll uintptr + dAD_DragEnterEx uintptr + dAD_DragLeave uintptr + dAD_DragMove uintptr + dAD_SetDragImage uintptr + dAD_ShowDragImage uintptr + doEnvironmentSubst uintptr + dragAcceptFiles uintptr + dragFinish uintptr + dragQueryFile uintptr + dragQueryPoint uintptr + driveType uintptr + duplicateIcon uintptr + extractAssociatedIconEx uintptr + extractAssociatedIcon uintptr + extractIconEx uintptr + extractIcon uintptr + extractVersionResource16W uintptr + findExecutable uintptr + freeIconList uintptr + getCurrentProcessExplicitAppUserModelID uintptr + iLAppendID uintptr + iLClone uintptr + iLCloneFirst uintptr + iLCombine uintptr + iLCreateFromPath uintptr + iLFindChild uintptr + iLFindLastID uintptr + iLFree uintptr + iLGetNext uintptr + iLGetSize uintptr + iLIsEqual uintptr + iLIsParent uintptr + iLLoadFromStream uintptr + iLRemoveLastID uintptr + iLSaveToStream uintptr + initNetworkAddressControl uintptr + isLFNDrive uintptr + isNetDrive uintptr + isUserAnAdmin uintptr + openAs_RunDLL uintptr + pathCleanupSpec uintptr + pathYetAnotherMakeUniqueName uintptr + pickIconDlg uintptr + readCabinetState uintptr + realDriveType uintptr + regenerateUserEnvironment uintptr + restartDialog uintptr + restartDialogEx uintptr + sHAddToRecentDocs uintptr + sHAlloc uintptr + sHAppBarMessage uintptr + sHAssocEnumHandlers uintptr + sHBindToParent uintptr + sHBrowseForFolder uintptr + sHChangeNotification_Lock uintptr + sHChangeNotification_Unlock uintptr + sHChangeNotify uintptr + sHChangeNotifyDeregister uintptr + sHChangeNotifyRegister uintptr + sHCloneSpecialIDList uintptr + sHCoCreateInstance uintptr + sHCreateDefaultContextMenu uintptr + sHCreateDirectory uintptr + sHCreateDirectoryEx uintptr + sHCreateFileExtractIconW uintptr + sHCreateItemFromIDList uintptr + sHCreateItemFromParsingName uintptr + sHCreateQueryCancelAutoPlayMoniker uintptr + sHCreateShellFolderView uintptr + sHCreateShellFolderViewEx uintptr + sHCreateShellItem uintptr + sHCreateShellItemArray uintptr + sHCreateShellItemArrayFromDataObject uintptr + sHCreateShellItemArrayFromIDLists uintptr + sHCreateShellItemArrayFromShellItem uintptr + sHCreateStdEnumFmtEtc uintptr + sHDefExtractIcon uintptr + sHDoDragDrop uintptr + sHEmptyRecycleBin uintptr + sHEnumerateUnreadMailAccountsW uintptr + sHFileOperation uintptr + sHFindFiles uintptr + sHFind_InitMenuPopup uintptr + sHFlushClipboard uintptr + sHFlushSFCache uintptr + sHFormatDrive uintptr + sHFree uintptr + sHFreeNameMappings uintptr + sHGetDataFromIDList uintptr + sHGetDesktopFolder uintptr + sHGetFileInfo uintptr + sHGetFolderLocation uintptr + sHGetFolderPathAndSubDir uintptr + sHGetFolderPathEx uintptr + sHGetFolderPath uintptr + sHGetIDListFromObject uintptr + sHGetIconOverlayIndex uintptr + sHGetImageList uintptr + sHGetInstanceExplorer uintptr + sHGetItemFromDataObject uintptr + sHGetItemFromObject uintptr + sHGetKnownFolderIDList uintptr + sHGetKnownFolderItem uintptr + sHGetKnownFolderPath uintptr + sHGetLocalizedName uintptr + sHGetMalloc uintptr + sHGetNameFromIDList uintptr + sHGetNewLinkInfo uintptr + sHGetPathFromIDList uintptr + sHGetPropertyStoreForWindow uintptr + sHGetPropertyStoreFromParsingName uintptr + sHGetRealIDL uintptr + sHGetSetSettings uintptr + sHGetSettings uintptr + sHGetSpecialFolderLocation uintptr + sHGetSpecialFolderPath uintptr + sHGetStockIconInfo uintptr + sHHandleUpdateImage uintptr + sHHelpShortcuts_RunDLL uintptr + sHIsFileAvailableOffline uintptr + sHLimitInputEdit uintptr + sHLoadInProc uintptr + sHLoadNonloadedIconOverlayIdentifiers uintptr + sHMapIDListToImageListIndexAsync uintptr + sHMapPIDLToSystemImageListIndex uintptr + sHObjectProperties uintptr + sHOpenFolderAndSelectItems uintptr + sHParseDisplayName uintptr + sHPathPrepareForWrite uintptr + sHPropStgCreate uintptr + sHPropStgReadMultiple uintptr + sHPropStgWriteMultiple uintptr + sHQueryRecycleBin uintptr + sHQueryUserNotificationState uintptr + sHRemoveLocalizedName uintptr + sHRestricted uintptr + sHRunControlPanel uintptr + sHSetInstanceExplorer uintptr + sHSetLocalizedName uintptr + sHSetUnreadMailCountW uintptr + sHShellFolderView_Message uintptr + sHUpdateImage uintptr + sHUpdateRecycleBinIcon uintptr + sHValidateUNC uintptr + setCurrentProcessExplicitAppUserModelID uintptr + sheChangeDir uintptr + sheGetDir uintptr + shellAbout uintptr + shellExecute uintptr + shell_GetImageLists uintptr + shell_MergeMenus uintptr + shell_NotifyIcon uintptr + signalFileOpen uintptr + wOWShellExecute uintptr + writeCabinetState uintptr +) + +func init() { + // Library + libshell32 = doLoadLibrary("shell32.dll") + + // Functions + sHAddFromPropSheetExtArray = doGetProcAddress(libshell32, "SHAddFromPropSheetExtArray") + sHCreatePropSheetExtArray = doGetProcAddress(libshell32, "SHCreatePropSheetExtArray") + sHDestroyPropSheetExtArray = doGetProcAddress(libshell32, "SHDestroyPropSheetExtArray") + sHReplaceFromPropSheetExtArray = doGetProcAddress(libshell32, "SHReplaceFromPropSheetExtArray") + cDefFolderMenu_Create2 = doGetProcAddress(libshell32, "CDefFolderMenu_Create2") + cIDLData_CreateFromIDArray = doGetProcAddress(libshell32, "CIDLData_CreateFromIDArray") + callCPLEntry16 = doGetProcAddress(libshell32, "CallCPLEntry16") + checkEscapes = doGetProcAddress(libshell32, "CheckEscapesW") + control_FillCache_RunDLL = doGetProcAddress(libshell32, "Control_FillCache_RunDLLW") + control_RunDLL = doGetProcAddress(libshell32, "Control_RunDLLW") + dAD_AutoScroll = doGetProcAddress(libshell32, "DAD_AutoScroll") + dAD_DragEnterEx = doGetProcAddress(libshell32, "DAD_DragEnterEx") + dAD_DragLeave = doGetProcAddress(libshell32, "DAD_DragLeave") + dAD_DragMove = doGetProcAddress(libshell32, "DAD_DragMove") + dAD_SetDragImage = doGetProcAddress(libshell32, "DAD_SetDragImage") + dAD_ShowDragImage = doGetProcAddress(libshell32, "DAD_ShowDragImage") + doEnvironmentSubst = doGetProcAddress(libshell32, "DoEnvironmentSubstW") + dragAcceptFiles = doGetProcAddress(libshell32, "DragAcceptFiles") + dragFinish = doGetProcAddress(libshell32, "DragFinish") + dragQueryFile = doGetProcAddress(libshell32, "DragQueryFileW") + dragQueryPoint = doGetProcAddress(libshell32, "DragQueryPoint") + driveType = doGetProcAddress(libshell32, "DriveType") + duplicateIcon = doGetProcAddress(libshell32, "DuplicateIcon") + extractAssociatedIconEx = doGetProcAddress(libshell32, "ExtractAssociatedIconExW") + extractAssociatedIcon = doGetProcAddress(libshell32, "ExtractAssociatedIconW") + extractIconEx = doGetProcAddress(libshell32, "ExtractIconExW") + extractIcon = doGetProcAddress(libshell32, "ExtractIconW") + extractVersionResource16W = doGetProcAddress(libshell32, "ExtractVersionResource16W") + findExecutable = doGetProcAddress(libshell32, "FindExecutableW") + freeIconList = doGetProcAddress(libshell32, "FreeIconList") + getCurrentProcessExplicitAppUserModelID = doGetProcAddress(libshell32, "GetCurrentProcessExplicitAppUserModelID") + iLAppendID = doGetProcAddress(libshell32, "ILAppendID") + iLClone = doGetProcAddress(libshell32, "ILClone") + iLCloneFirst = doGetProcAddress(libshell32, "ILCloneFirst") + iLCombine = doGetProcAddress(libshell32, "ILCombine") + iLCreateFromPath = doGetProcAddress(libshell32, "ILCreateFromPathW") + iLFindChild = doGetProcAddress(libshell32, "ILFindChild") + iLFindLastID = doGetProcAddress(libshell32, "ILFindLastID") + iLFree = doGetProcAddress(libshell32, "ILFree") + iLGetNext = doGetProcAddress(libshell32, "ILGetNext") + iLGetSize = doGetProcAddress(libshell32, "ILGetSize") + iLIsEqual = doGetProcAddress(libshell32, "ILIsEqual") + iLIsParent = doGetProcAddress(libshell32, "ILIsParent") + iLLoadFromStream = doGetProcAddress(libshell32, "ILLoadFromStream") + iLRemoveLastID = doGetProcAddress(libshell32, "ILRemoveLastID") + iLSaveToStream = doGetProcAddress(libshell32, "ILSaveToStream") + initNetworkAddressControl = doGetProcAddress(libshell32, "InitNetworkAddressControl") + isLFNDrive = doGetProcAddress(libshell32, "IsLFNDriveW") + isNetDrive = doGetProcAddress(libshell32, "IsNetDrive") + isUserAnAdmin = doGetProcAddress(libshell32, "IsUserAnAdmin") + openAs_RunDLL = doGetProcAddress(libshell32, "OpenAs_RunDLLW") + pathCleanupSpec = doGetProcAddress(libshell32, "PathCleanupSpec") + pathYetAnotherMakeUniqueName = doGetProcAddress(libshell32, "PathYetAnotherMakeUniqueName") + pickIconDlg = doGetProcAddress(libshell32, "PickIconDlg") + readCabinetState = doGetProcAddress(libshell32, "ReadCabinetState") + realDriveType = doGetProcAddress(libshell32, "RealDriveType") + regenerateUserEnvironment = doGetProcAddress(libshell32, "RegenerateUserEnvironment") + restartDialog = doGetProcAddress(libshell32, "RestartDialog") + restartDialogEx = doGetProcAddress(libshell32, "RestartDialogEx") + sHAddToRecentDocs = doGetProcAddress(libshell32, "SHAddToRecentDocs") + sHAlloc = doGetProcAddress(libshell32, "SHAlloc") + sHAppBarMessage = doGetProcAddress(libshell32, "SHAppBarMessage") + sHAssocEnumHandlers = doGetProcAddress(libshell32, "SHAssocEnumHandlers") + sHBindToParent = doGetProcAddress(libshell32, "SHBindToParent") + sHBrowseForFolder = doGetProcAddress(libshell32, "SHBrowseForFolderW") + sHChangeNotification_Lock = doGetProcAddress(libshell32, "SHChangeNotification_Lock") + sHChangeNotification_Unlock = doGetProcAddress(libshell32, "SHChangeNotification_Unlock") + sHChangeNotify = doGetProcAddress(libshell32, "SHChangeNotify") + sHChangeNotifyDeregister = doGetProcAddress(libshell32, "SHChangeNotifyDeregister") + sHChangeNotifyRegister = doGetProcAddress(libshell32, "SHChangeNotifyRegister") + sHCloneSpecialIDList = doGetProcAddress(libshell32, "SHCloneSpecialIDList") + sHCoCreateInstance = doGetProcAddress(libshell32, "SHCoCreateInstance") + sHCreateDefaultContextMenu = doGetProcAddress(libshell32, "SHCreateDefaultContextMenu") + sHCreateDirectory = doGetProcAddress(libshell32, "SHCreateDirectory") + sHCreateDirectoryEx = doGetProcAddress(libshell32, "SHCreateDirectoryExW") + sHCreateFileExtractIconW = doGetProcAddress(libshell32, "SHCreateFileExtractIconW") + sHCreateItemFromIDList = doGetProcAddress(libshell32, "SHCreateItemFromIDList") + sHCreateItemFromParsingName = doGetProcAddress(libshell32, "SHCreateItemFromParsingName") + sHCreateQueryCancelAutoPlayMoniker = doGetProcAddress(libshell32, "SHCreateQueryCancelAutoPlayMoniker") + sHCreateShellFolderView = doGetProcAddress(libshell32, "SHCreateShellFolderView") + sHCreateShellFolderViewEx = doGetProcAddress(libshell32, "SHCreateShellFolderViewEx") + sHCreateShellItem = doGetProcAddress(libshell32, "SHCreateShellItem") + sHCreateShellItemArray = doGetProcAddress(libshell32, "SHCreateShellItemArray") + sHCreateShellItemArrayFromDataObject = doGetProcAddress(libshell32, "SHCreateShellItemArrayFromDataObject") + sHCreateShellItemArrayFromIDLists = doGetProcAddress(libshell32, "SHCreateShellItemArrayFromIDLists") + sHCreateShellItemArrayFromShellItem = doGetProcAddress(libshell32, "SHCreateShellItemArrayFromShellItem") + sHCreateStdEnumFmtEtc = doGetProcAddress(libshell32, "SHCreateStdEnumFmtEtc") + sHDefExtractIcon = doGetProcAddress(libshell32, "SHDefExtractIconW") + sHDoDragDrop = doGetProcAddress(libshell32, "SHDoDragDrop") + sHEmptyRecycleBin = doGetProcAddress(libshell32, "SHEmptyRecycleBinW") + sHEnumerateUnreadMailAccountsW = doGetProcAddress(libshell32, "SHEnumerateUnreadMailAccountsW") + sHFileOperation = doGetProcAddress(libshell32, "SHFileOperationW") + sHFindFiles = doGetProcAddress(libshell32, "SHFindFiles") + sHFind_InitMenuPopup = doGetProcAddress(libshell32, "SHFind_InitMenuPopup") + sHFlushClipboard = doGetProcAddress(libshell32, "SHFlushClipboard") + sHFlushSFCache = doGetProcAddress(libshell32, "SHFlushSFCache") + sHFormatDrive = doGetProcAddress(libshell32, "SHFormatDrive") + sHFree = doGetProcAddress(libshell32, "SHFree") + sHFreeNameMappings = doGetProcAddress(libshell32, "SHFreeNameMappings") + sHGetDataFromIDList = doGetProcAddress(libshell32, "SHGetDataFromIDListW") + sHGetDesktopFolder = doGetProcAddress(libshell32, "SHGetDesktopFolder") + sHGetFileInfo = doGetProcAddress(libshell32, "SHGetFileInfoW") + sHGetFolderLocation = doGetProcAddress(libshell32, "SHGetFolderLocation") + sHGetFolderPathAndSubDir = doGetProcAddress(libshell32, "SHGetFolderPathAndSubDirW") + sHGetFolderPathEx = doGetProcAddress(libshell32, "SHGetFolderPathEx") + sHGetFolderPath = doGetProcAddress(libshell32, "SHGetFolderPathW") + sHGetIDListFromObject = doGetProcAddress(libshell32, "SHGetIDListFromObject") + sHGetIconOverlayIndex = doGetProcAddress(libshell32, "SHGetIconOverlayIndexW") + sHGetImageList = doGetProcAddress(libshell32, "SHGetImageList") + sHGetInstanceExplorer = doGetProcAddress(libshell32, "SHGetInstanceExplorer") + sHGetItemFromDataObject = doGetProcAddress(libshell32, "SHGetItemFromDataObject") + sHGetItemFromObject = doGetProcAddress(libshell32, "SHGetItemFromObject") + sHGetKnownFolderIDList = doGetProcAddress(libshell32, "SHGetKnownFolderIDList") + sHGetKnownFolderItem = doGetProcAddress(libshell32, "SHGetKnownFolderItem") + sHGetKnownFolderPath = doGetProcAddress(libshell32, "SHGetKnownFolderPath") + sHGetLocalizedName = doGetProcAddress(libshell32, "SHGetLocalizedName") + sHGetMalloc = doGetProcAddress(libshell32, "SHGetMalloc") + sHGetNameFromIDList = doGetProcAddress(libshell32, "SHGetNameFromIDList") + sHGetNewLinkInfo = doGetProcAddress(libshell32, "SHGetNewLinkInfoW") + sHGetPathFromIDList = doGetProcAddress(libshell32, "SHGetPathFromIDListW") + sHGetPropertyStoreForWindow = doGetProcAddress(libshell32, "SHGetPropertyStoreForWindow") + sHGetPropertyStoreFromParsingName = doGetProcAddress(libshell32, "SHGetPropertyStoreFromParsingName") + sHGetRealIDL = doGetProcAddress(libshell32, "SHGetRealIDL") + sHGetSetSettings = doGetProcAddress(libshell32, "SHGetSetSettings") + sHGetSettings = doGetProcAddress(libshell32, "SHGetSettings") + sHGetSpecialFolderLocation = doGetProcAddress(libshell32, "SHGetSpecialFolderLocation") + sHGetSpecialFolderPath = doGetProcAddress(libshell32, "SHGetSpecialFolderPathW") + sHGetStockIconInfo = doGetProcAddress(libshell32, "SHGetStockIconInfo") + sHHandleUpdateImage = doGetProcAddress(libshell32, "SHHandleUpdateImage") + sHHelpShortcuts_RunDLL = doGetProcAddress(libshell32, "SHHelpShortcuts_RunDLLW") + sHIsFileAvailableOffline = doGetProcAddress(libshell32, "SHIsFileAvailableOffline") + sHLimitInputEdit = doGetProcAddress(libshell32, "SHLimitInputEdit") + sHLoadInProc = doGetProcAddress(libshell32, "SHLoadInProc") + sHLoadNonloadedIconOverlayIdentifiers = doGetProcAddress(libshell32, "SHLoadNonloadedIconOverlayIdentifiers") + sHMapIDListToImageListIndexAsync = doGetProcAddress(libshell32, "SHMapIDListToImageListIndexAsync") + sHMapPIDLToSystemImageListIndex = doGetProcAddress(libshell32, "SHMapPIDLToSystemImageListIndex") + sHObjectProperties = doGetProcAddress(libshell32, "SHObjectProperties") + sHOpenFolderAndSelectItems = doGetProcAddress(libshell32, "SHOpenFolderAndSelectItems") + sHParseDisplayName = doGetProcAddress(libshell32, "SHParseDisplayName") + sHPathPrepareForWrite = doGetProcAddress(libshell32, "SHPathPrepareForWriteW") + sHPropStgCreate = doGetProcAddress(libshell32, "SHPropStgCreate") + sHPropStgReadMultiple = doGetProcAddress(libshell32, "SHPropStgReadMultiple") + sHPropStgWriteMultiple = doGetProcAddress(libshell32, "SHPropStgWriteMultiple") + sHQueryRecycleBin = doGetProcAddress(libshell32, "SHQueryRecycleBinW") + sHQueryUserNotificationState = doGetProcAddress(libshell32, "SHQueryUserNotificationState") + sHRemoveLocalizedName = doGetProcAddress(libshell32, "SHRemoveLocalizedName") + sHRestricted = doGetProcAddress(libshell32, "SHRestricted") + sHRunControlPanel = doGetProcAddress(libshell32, "SHRunControlPanel") + sHSetInstanceExplorer = doGetProcAddress(libshell32, "SHSetInstanceExplorer") + sHSetLocalizedName = doGetProcAddress(libshell32, "SHSetLocalizedName") + sHSetUnreadMailCountW = doGetProcAddress(libshell32, "SHSetUnreadMailCountW") + sHShellFolderView_Message = doGetProcAddress(libshell32, "SHShellFolderView_Message") + sHUpdateImage = doGetProcAddress(libshell32, "SHUpdateImageW") + sHUpdateRecycleBinIcon = doGetProcAddress(libshell32, "SHUpdateRecycleBinIcon") + sHValidateUNC = doGetProcAddress(libshell32, "SHValidateUNC") + setCurrentProcessExplicitAppUserModelID = doGetProcAddress(libshell32, "SetCurrentProcessExplicitAppUserModelID") + sheChangeDir = doGetProcAddress(libshell32, "SheChangeDirW") + sheGetDir = doGetProcAddress(libshell32, "SheGetDirW") + shellAbout = doGetProcAddress(libshell32, "ShellAboutW") + shellExecute = doGetProcAddress(libshell32, "ShellExecuteW") + shell_GetImageLists = doGetProcAddress(libshell32, "Shell_GetImageLists") + shell_MergeMenus = doGetProcAddress(libshell32, "Shell_MergeMenus") + shell_NotifyIcon = doGetProcAddress(libshell32, "Shell_NotifyIconW") + signalFileOpen = doGetProcAddress(libshell32, "SignalFileOpen") + wOWShellExecute = doGetProcAddress(libshell32, "WOWShellExecute") + writeCabinetState = doGetProcAddress(libshell32, "WriteCabinetState") +} + +func SHAddFromPropSheetExtArray(hpsxa HPSXA, lpfnAddPage LPFNADDPROPSHEETPAGE, lParam LPARAM) UINT { + lpfnAddPageCallback := syscall.NewCallback(func(unnamed0RawArg HPROPSHEETPAGE, unnamed1RawArg LPARAM) uintptr { + ret := lpfnAddPage(unnamed0RawArg, unnamed1RawArg) + return uintptr(ret) + }) + ret1 := syscall3(sHAddFromPropSheetExtArray, 3, + uintptr(hpsxa), + lpfnAddPageCallback, + uintptr(lParam)) + return UINT(ret1) +} + +func SHCreatePropSheetExtArray(hKey HKEY, pszSubKey string, max_iface UINT) HPSXA { + pszSubKeyStr := unicode16FromString(pszSubKey) + ret1 := syscall3(sHCreatePropSheetExtArray, 3, + uintptr(hKey), + uintptr(unsafe.Pointer(&pszSubKeyStr[0])), + uintptr(max_iface)) + return HPSXA(ret1) +} + +func SHDestroyPropSheetExtArray(hpsxa HPSXA) { + syscall3(sHDestroyPropSheetExtArray, 1, + uintptr(hpsxa), + 0, + 0) +} + +func SHReplaceFromPropSheetExtArray(hpsxa HPSXA, uPageID UINT, lpfnReplaceWith LPFNADDPROPSHEETPAGE, lParam LPARAM) UINT { + lpfnReplaceWithCallback := syscall.NewCallback(func(unnamed0RawArg HPROPSHEETPAGE, unnamed1RawArg LPARAM) uintptr { + ret := lpfnReplaceWith(unnamed0RawArg, unnamed1RawArg) + return uintptr(ret) + }) + ret1 := syscall6(sHReplaceFromPropSheetExtArray, 4, + uintptr(hpsxa), + uintptr(uPageID), + lpfnReplaceWithCallback, + uintptr(lParam), + 0, + 0) + return UINT(ret1) +} + +func CDefFolderMenu_Create2(pidlFolder /*const*/ LPCITEMIDLIST, hwnd HWND, cidl UINT, apidl *LPCITEMIDLIST, psf *IShellFolder, lpfn LPFNDFMCALLBACK, nKeys UINT, ahkeys /*const*/ *HKEY, ppcm **IContextMenu) HRESULT { + lpfnCallback := syscall.NewCallback(func(psfRawArg *IShellFolder, hwndRawArg HWND, pdtobjRawArg *IDataObject, uMsgRawArg UINT, wParamRawArg WPARAM, lParamRawArg LPARAM) uintptr { + ret := lpfn(psfRawArg, hwndRawArg, pdtobjRawArg, uMsgRawArg, wParamRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall9(cDefFolderMenu_Create2, 9, + uintptr(unsafe.Pointer(pidlFolder)), + uintptr(hwnd), + uintptr(cidl), + uintptr(unsafe.Pointer(apidl)), + uintptr(unsafe.Pointer(psf)), + lpfnCallback, + uintptr(nKeys), + uintptr(unsafe.Pointer(ahkeys)), + uintptr(unsafe.Pointer(ppcm))) + return HRESULT(ret1) +} + +func CIDLData_CreateFromIDArray(pidlFolder /*const*/ LPCITEMIDLIST, cpidlFiles DWORD, lppidlFiles *LPCITEMIDLIST, ppdataObject *LPDATAOBJECT) HRESULT { + ret1 := syscall6(cIDLData_CreateFromIDArray, 4, + uintptr(unsafe.Pointer(pidlFolder)), + uintptr(cpidlFiles), + uintptr(unsafe.Pointer(lppidlFiles)), + uintptr(unsafe.Pointer(ppdataObject)), + 0, + 0) + return HRESULT(ret1) +} + +func CallCPLEntry16(hMod HMODULE, pFunc FARPROC, dw3 DWORD, dw4 DWORD, dw5 DWORD, dw6 DWORD) DWORD { + pFuncCallback := syscall.NewCallback(func() uintptr { + ret := pFunc() + return uintptr(unsafe.Pointer(ret)) + }) + ret1 := syscall6(callCPLEntry16, 6, + uintptr(hMod), + pFuncCallback, + uintptr(dw3), + uintptr(dw4), + uintptr(dw5), + uintptr(dw6)) + return DWORD(ret1) +} + +func CheckEscapes(string LPWSTR, aLen DWORD) DWORD { + ret1 := syscall3(checkEscapes, 2, + uintptr(unsafe.Pointer(string)), + uintptr(aLen), + 0) + return DWORD(ret1) +} + +func Control_FillCache_RunDLL(hWnd HWND, hModule HANDLE, w DWORD, x DWORD) HRESULT { + ret1 := syscall6(control_FillCache_RunDLL, 4, + uintptr(hWnd), + uintptr(hModule), + uintptr(w), + uintptr(x), + 0, + 0) + return HRESULT(ret1) +} + +func Control_RunDLL(hWnd HWND, hInst HINSTANCE, cmd string, nCmdShow DWORD) { + cmdStr := unicode16FromString(cmd) + syscall6(control_RunDLL, 4, + uintptr(hWnd), + uintptr(hInst), + uintptr(unsafe.Pointer(&cmdStr[0])), + uintptr(nCmdShow), + 0, + 0) +} + +func DAD_AutoScroll(hwnd HWND, samples *AUTO_SCROLL_DATA, pt *POINT) bool { + ret1 := syscall3(dAD_AutoScroll, 3, + uintptr(hwnd), + uintptr(unsafe.Pointer(samples)), + uintptr(unsafe.Pointer(pt))) + return ret1 != 0 +} + +func DAD_DragEnterEx(hwnd HWND, p POINT) bool { + ret1 := syscall3(dAD_DragEnterEx, 3, + uintptr(hwnd), + uintptr(p.X), + uintptr(p.Y)) + return ret1 != 0 +} + +func DAD_DragLeave() bool { + ret1 := syscall3(dAD_DragLeave, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func DAD_DragMove(p POINT) bool { + ret1 := syscall3(dAD_DragMove, 2, + uintptr(p.X), + uintptr(p.Y), + 0) + return ret1 != 0 +} + +func DAD_SetDragImage(himlTrack HIMAGELIST, lppt *POINT) bool { + ret1 := syscall3(dAD_SetDragImage, 2, + uintptr(himlTrack), + uintptr(unsafe.Pointer(lppt)), + 0) + return ret1 != 0 +} + +func DAD_ShowDragImage(bShow bool) bool { + ret1 := syscall3(dAD_ShowDragImage, 1, + getUintptrFromBool(bShow), + 0, + 0) + return ret1 != 0 +} + +func DoEnvironmentSubst(pszString LPWSTR, cchString UINT) DWORD { + ret1 := syscall3(doEnvironmentSubst, 2, + uintptr(unsafe.Pointer(pszString)), + uintptr(cchString), + 0) + return DWORD(ret1) +} + +func DragAcceptFiles(hWnd HWND, b bool) { + syscall3(dragAcceptFiles, 2, + uintptr(hWnd), + getUintptrFromBool(b), + 0) +} + +func DragFinish(h HDROP) { + syscall3(dragFinish, 1, + uintptr(h), + 0, + 0) +} + +func DragQueryFile(hDrop HDROP, lFile UINT, lpszwFile LPWSTR, lLength UINT) UINT { + ret1 := syscall6(dragQueryFile, 4, + uintptr(hDrop), + uintptr(lFile), + uintptr(unsafe.Pointer(lpszwFile)), + uintptr(lLength), + 0, + 0) + return UINT(ret1) +} + +func DragQueryPoint(hDrop HDROP, p *POINT) bool { + ret1 := syscall3(dragQueryPoint, 2, + uintptr(hDrop), + uintptr(unsafe.Pointer(p)), + 0) + return ret1 != 0 +} + +func DriveType(u int32) int32 { + ret1 := syscall3(driveType, 1, + uintptr(u), + 0, + 0) + return int32(ret1) +} + +func DuplicateIcon(hInstance HINSTANCE, hIcon HICON) HICON { + ret1 := syscall3(duplicateIcon, 2, + uintptr(hInstance), + uintptr(hIcon), + 0) + return HICON(ret1) +} + +func ExtractAssociatedIconEx(hInst HINSTANCE, lpIconPath LPWSTR, lpiIconIdx *uint16, lpiIconId *uint16) HICON { + ret1 := syscall6(extractAssociatedIconEx, 4, + uintptr(hInst), + uintptr(unsafe.Pointer(lpIconPath)), + uintptr(unsafe.Pointer(lpiIconIdx)), + uintptr(unsafe.Pointer(lpiIconId)), + 0, + 0) + return HICON(ret1) +} + +func ExtractAssociatedIcon(hInst HINSTANCE, lpIconPath LPWSTR, lpiIcon *uint16) HICON { + ret1 := syscall3(extractAssociatedIcon, 3, + uintptr(hInst), + uintptr(unsafe.Pointer(lpIconPath)), + uintptr(unsafe.Pointer(lpiIcon))) + return HICON(ret1) +} + +func ExtractIconEx(lpszFile string, nIconIndex INT, phiconLarge *HICON, phiconSmall *HICON, nIcons UINT) UINT { + lpszFileStr := unicode16FromString(lpszFile) + ret1 := syscall6(extractIconEx, 5, + uintptr(unsafe.Pointer(&lpszFileStr[0])), + uintptr(nIconIndex), + uintptr(unsafe.Pointer(phiconLarge)), + uintptr(unsafe.Pointer(phiconSmall)), + uintptr(nIcons), + 0) + return UINT(ret1) +} + +func ExtractIcon(hInstance HINSTANCE, lpszFile string, nIconIndex UINT) HICON { + lpszFileStr := unicode16FromString(lpszFile) + ret1 := syscall3(extractIcon, 3, + uintptr(hInstance), + uintptr(unsafe.Pointer(&lpszFileStr[0])), + uintptr(nIconIndex)) + return HICON(ret1) +} + +func ExtractVersionResource16W(s LPWSTR, d DWORD) bool { + ret1 := syscall3(extractVersionResource16W, 2, + uintptr(unsafe.Pointer(s)), + uintptr(d), + 0) + return ret1 != 0 +} + +func FindExecutable(lpFile string, lpDirectory string, lpResult LPWSTR) HINSTANCE { + lpFileStr := unicode16FromString(lpFile) + lpDirectoryStr := unicode16FromString(lpDirectory) + ret1 := syscall3(findExecutable, 3, + uintptr(unsafe.Pointer(&lpFileStr[0])), + uintptr(unsafe.Pointer(&lpDirectoryStr[0])), + uintptr(unsafe.Pointer(lpResult))) + return HINSTANCE(ret1) +} + +func FreeIconList(dw DWORD) { + syscall3(freeIconList, 1, + uintptr(dw), + 0, + 0) +} + +func GetCurrentProcessExplicitAppUserModelID(appid *PWSTR) HRESULT { + ret1 := syscall3(getCurrentProcessExplicitAppUserModelID, 1, + uintptr(unsafe.Pointer(appid)), + 0, + 0) + return HRESULT(ret1) +} + +func ILAppendID(pidl LPITEMIDLIST, item /*const*/ *SHITEMID, bEnd bool) LPITEMIDLIST { + ret1 := syscall3(iLAppendID, 3, + uintptr(unsafe.Pointer(pidl)), + uintptr(unsafe.Pointer(item)), + getUintptrFromBool(bEnd)) + return (LPITEMIDLIST)(unsafe.Pointer(ret1)) +} + +func ILClone(pidl /*const*/ LPCITEMIDLIST) LPITEMIDLIST { + ret1 := syscall3(iLClone, 1, + uintptr(unsafe.Pointer(pidl)), + 0, + 0) + return (LPITEMIDLIST)(unsafe.Pointer(ret1)) +} + +func ILCloneFirst(pidl /*const*/ LPCITEMIDLIST) LPITEMIDLIST { + ret1 := syscall3(iLCloneFirst, 1, + uintptr(unsafe.Pointer(pidl)), + 0, + 0) + return (LPITEMIDLIST)(unsafe.Pointer(ret1)) +} + +func ILCombine(pidl1 /*const*/ LPCITEMIDLIST, pidl2 /*const*/ LPCITEMIDLIST) LPITEMIDLIST { + ret1 := syscall3(iLCombine, 2, + uintptr(unsafe.Pointer(pidl1)), + uintptr(unsafe.Pointer(pidl2)), + 0) + return (LPITEMIDLIST)(unsafe.Pointer(ret1)) +} + +func ILCreateFromPath(path string) LPITEMIDLIST { + pathStr := unicode16FromString(path) + ret1 := syscall3(iLCreateFromPath, 1, + uintptr(unsafe.Pointer(&pathStr[0])), + 0, + 0) + return (LPITEMIDLIST)(unsafe.Pointer(ret1)) +} + +func ILFindChild(pidl1 /*const*/ LPCITEMIDLIST, pidl2 /*const*/ LPCITEMIDLIST) LPITEMIDLIST { + ret1 := syscall3(iLFindChild, 2, + uintptr(unsafe.Pointer(pidl1)), + uintptr(unsafe.Pointer(pidl2)), + 0) + return (LPITEMIDLIST)(unsafe.Pointer(ret1)) +} + +func ILFindLastID(pidl /*const*/ LPCITEMIDLIST) LPITEMIDLIST { + ret1 := syscall3(iLFindLastID, 1, + uintptr(unsafe.Pointer(pidl)), + 0, + 0) + return (LPITEMIDLIST)(unsafe.Pointer(ret1)) +} + +func ILFree(pidl LPITEMIDLIST) { + syscall3(iLFree, 1, + uintptr(unsafe.Pointer(pidl)), + 0, + 0) +} + +func ILGetNext(pidl /*const*/ LPCITEMIDLIST) LPITEMIDLIST { + ret1 := syscall3(iLGetNext, 1, + uintptr(unsafe.Pointer(pidl)), + 0, + 0) + return (LPITEMIDLIST)(unsafe.Pointer(ret1)) +} + +func ILGetSize(pidl /*const*/ LPCITEMIDLIST) UINT { + ret1 := syscall3(iLGetSize, 1, + uintptr(unsafe.Pointer(pidl)), + 0, + 0) + return UINT(ret1) +} + +func ILIsEqual(pidl1 /*const*/ LPCITEMIDLIST, pidl2 /*const*/ LPCITEMIDLIST) bool { + ret1 := syscall3(iLIsEqual, 2, + uintptr(unsafe.Pointer(pidl1)), + uintptr(unsafe.Pointer(pidl2)), + 0) + return ret1 != 0 +} + +func ILIsParent(pidlParent /*const*/ LPCITEMIDLIST, pidlChild /*const*/ LPCITEMIDLIST, bImmediate bool) bool { + ret1 := syscall3(iLIsParent, 3, + uintptr(unsafe.Pointer(pidlParent)), + uintptr(unsafe.Pointer(pidlChild)), + getUintptrFromBool(bImmediate)) + return ret1 != 0 +} + +func ILLoadFromStream(pStream *IStream, ppPidl *LPITEMIDLIST) HRESULT { + ret1 := syscall3(iLLoadFromStream, 2, + uintptr(unsafe.Pointer(pStream)), + uintptr(unsafe.Pointer(ppPidl)), + 0) + return HRESULT(ret1) +} + +func ILRemoveLastID(pidl LPITEMIDLIST) bool { + ret1 := syscall3(iLRemoveLastID, 1, + uintptr(unsafe.Pointer(pidl)), + 0, + 0) + return ret1 != 0 +} + +func ILSaveToStream(pStream *IStream, pPidl /*const*/ LPCITEMIDLIST) HRESULT { + ret1 := syscall3(iLSaveToStream, 2, + uintptr(unsafe.Pointer(pStream)), + uintptr(unsafe.Pointer(pPidl)), + 0) + return HRESULT(ret1) +} + +func InitNetworkAddressControl() bool { + ret1 := syscall3(initNetworkAddressControl, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func IsLFNDrive(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(isLFNDrive, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func IsNetDrive(drive int32) int32 { + ret1 := syscall3(isNetDrive, 1, + uintptr(drive), + 0, + 0) + return int32(ret1) +} + +func IsUserAnAdmin() bool { + ret1 := syscall3(isUserAnAdmin, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func OpenAs_RunDLL(hwnd HWND, hinst HINSTANCE, cmdline string, cmdshow int32) { + cmdlineStr := unicode16FromString(cmdline) + syscall6(openAs_RunDLL, 4, + uintptr(hwnd), + uintptr(hinst), + uintptr(unsafe.Pointer(&cmdlineStr[0])), + uintptr(cmdshow), + 0, + 0) +} + +func PathCleanupSpec(lpszPathW string, lpszFileW LPWSTR) int32 { + lpszPathWStr := unicode16FromString(lpszPathW) + ret1 := syscall3(pathCleanupSpec, 2, + uintptr(unsafe.Pointer(&lpszPathWStr[0])), + uintptr(unsafe.Pointer(lpszFileW)), + 0) + return int32(ret1) +} + +func PathYetAnotherMakeUniqueName(buffer LPWSTR, path string, shortname string, longname string) bool { + pathStr := unicode16FromString(path) + shortnameStr := unicode16FromString(shortname) + longnameStr := unicode16FromString(longname) + ret1 := syscall6(pathYetAnotherMakeUniqueName, 4, + uintptr(unsafe.Pointer(buffer)), + uintptr(unsafe.Pointer(&pathStr[0])), + uintptr(unsafe.Pointer(&shortnameStr[0])), + uintptr(unsafe.Pointer(&longnameStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PickIconDlg(hwndOwner HWND, lpstrFile LPSTR, nMaxFile DWORD, lpdwIconIndex *uint32) INT { + ret1 := syscall6(pickIconDlg, 4, + uintptr(hwndOwner), + uintptr(unsafe.Pointer(lpstrFile)), + uintptr(nMaxFile), + uintptr(unsafe.Pointer(lpdwIconIndex)), + 0, + 0) + return INT(ret1) +} + +func ReadCabinetState(cs *CABINETSTATE, length int32) bool { + ret1 := syscall3(readCabinetState, 2, + uintptr(unsafe.Pointer(cs)), + uintptr(length), + 0) + return ret1 != 0 +} + +func RealDriveType(drive int32, bQueryNet bool) int32 { + ret1 := syscall3(realDriveType, 2, + uintptr(drive), + getUintptrFromBool(bQueryNet), + 0) + return int32(ret1) +} + +func RegenerateUserEnvironment(wunknown *WCHAR, bunknown bool) bool { + ret1 := syscall3(regenerateUserEnvironment, 2, + uintptr(unsafe.Pointer(wunknown)), + getUintptrFromBool(bunknown), + 0) + return ret1 != 0 +} + +func RestartDialog(hWndOwner HWND, lpstrReason string, uFlags DWORD) int32 { + lpstrReasonStr := unicode16FromString(lpstrReason) + ret1 := syscall3(restartDialog, 3, + uintptr(hWndOwner), + uintptr(unsafe.Pointer(&lpstrReasonStr[0])), + uintptr(uFlags)) + return int32(ret1) +} + +func RestartDialogEx(hWndOwner HWND, lpwstrReason string, uFlags DWORD, uReason DWORD) int32 { + lpwstrReasonStr := unicode16FromString(lpwstrReason) + ret1 := syscall6(restartDialogEx, 4, + uintptr(hWndOwner), + uintptr(unsafe.Pointer(&lpwstrReasonStr[0])), + uintptr(uFlags), + uintptr(uReason), + 0, + 0) + return int32(ret1) +} + +func SHAddToRecentDocs(uFlags UINT, pv /*const*/ uintptr) { + syscall3(sHAddToRecentDocs, 2, + uintptr(uFlags), + pv, + 0) +} + +func SHAlloc(aLen DWORD) LPVOID { + ret1 := syscall3(sHAlloc, 1, + uintptr(aLen), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func SHAppBarMessage(msg DWORD, data PAPPBARDATA) *uint32 { + ret1 := syscall3(sHAppBarMessage, 2, + uintptr(msg), + uintptr(unsafe.Pointer(data)), + 0) + return (*uint32)(unsafe.Pointer(ret1)) +} + +func SHAssocEnumHandlers(extra /*const*/ *WCHAR, filter ASSOC_FILTER, enumhandlers **IEnumAssocHandlers) HRESULT { + ret1 := syscall3(sHAssocEnumHandlers, 3, + uintptr(unsafe.Pointer(extra)), + uintptr(filter), + uintptr(unsafe.Pointer(enumhandlers))) + return HRESULT(ret1) +} + +func SHBindToParent(pidl /*const*/ LPCITEMIDLIST, riid REFIID, ppv *LPVOID, ppidlLast *LPCITEMIDLIST) HRESULT { + ret1 := syscall6(sHBindToParent, 4, + uintptr(unsafe.Pointer(pidl)), + uintptr(unsafe.Pointer(riid)), + uintptr(unsafe.Pointer(ppv)), + uintptr(unsafe.Pointer(ppidlLast)), + 0, + 0) + return HRESULT(ret1) +} + +func SHBrowseForFolder(lpbi LPBROWSEINFO) LPITEMIDLIST { + ret1 := syscall3(sHBrowseForFolder, 1, + uintptr(unsafe.Pointer(lpbi)), + 0, + 0) + return (LPITEMIDLIST)(unsafe.Pointer(ret1)) +} + +func SHChangeNotification_Lock(hChange HANDLE, dwProcessId DWORD, lppidls **LPITEMIDLIST, lpwEventId *LONG) HANDLE { + ret1 := syscall6(sHChangeNotification_Lock, 4, + uintptr(hChange), + uintptr(dwProcessId), + uintptr(unsafe.Pointer(lppidls)), + uintptr(unsafe.Pointer(lpwEventId)), + 0, + 0) + return HANDLE(ret1) +} + +func SHChangeNotification_Unlock(hLock HANDLE) bool { + ret1 := syscall3(sHChangeNotification_Unlock, 1, + uintptr(hLock), + 0, + 0) + return ret1 != 0 +} + +func SHChangeNotify(wEventId LONG, uFlags UINT, dwItem1 /*const*/ uintptr, dwItem2 /*const*/ uintptr) { + syscall6(sHChangeNotify, 4, + uintptr(wEventId), + uintptr(uFlags), + dwItem1, + dwItem2, + 0, + 0) +} + +func SHChangeNotifyDeregister(hNotify ULONG) bool { + ret1 := syscall3(sHChangeNotifyDeregister, 1, + uintptr(hNotify), + 0, + 0) + return ret1 != 0 +} + +func SHChangeNotifyRegister(hwnd HWND, fSources int32, wEventMask LONG, uMsg UINT, cItems int32, lpItems *SHChangeNotifyEntry) ULONG { + ret1 := syscall6(sHChangeNotifyRegister, 6, + uintptr(hwnd), + uintptr(fSources), + uintptr(wEventMask), + uintptr(uMsg), + uintptr(cItems), + uintptr(unsafe.Pointer(lpItems))) + return ULONG(ret1) +} + +func SHCloneSpecialIDList(hwndOwner HWND, nFolder DWORD, fCreate bool) LPITEMIDLIST { + ret1 := syscall3(sHCloneSpecialIDList, 3, + uintptr(hwndOwner), + uintptr(nFolder), + getUintptrFromBool(fCreate)) + return (LPITEMIDLIST)(unsafe.Pointer(ret1)) +} + +func SHCoCreateInstance(aclsid string, clsid /*const*/ *CLSID, pUnkOuter LPUNKNOWN, refiid REFIID, ppv *LPVOID) HRESULT { + aclsidStr := unicode16FromString(aclsid) + ret1 := syscall6(sHCoCreateInstance, 5, + uintptr(unsafe.Pointer(&aclsidStr[0])), + uintptr(unsafe.Pointer(clsid)), + uintptr(unsafe.Pointer(pUnkOuter)), + uintptr(unsafe.Pointer(refiid)), + uintptr(unsafe.Pointer(ppv)), + 0) + return HRESULT(ret1) +} + +func SHCreateDefaultContextMenu(pdcm /*const*/ *DEFCONTEXTMENU, riid REFIID, ppv uintptr) HRESULT { + ret1 := syscall3(sHCreateDefaultContextMenu, 3, + uintptr(unsafe.Pointer(pdcm)), + uintptr(unsafe.Pointer(riid)), + ppv) + return HRESULT(ret1) +} + +func SHCreateDirectory(hWnd HWND, path /*const*/ uintptr) DWORD { + ret1 := syscall3(sHCreateDirectory, 2, + uintptr(hWnd), + path, + 0) + return DWORD(ret1) +} + +func SHCreateDirectoryEx(hWnd HWND, path string, sec *SECURITY_ATTRIBUTES) int32 { + pathStr := unicode16FromString(path) + ret1 := syscall3(sHCreateDirectoryEx, 3, + uintptr(hWnd), + uintptr(unsafe.Pointer(&pathStr[0])), + uintptr(unsafe.Pointer(sec))) + return int32(ret1) +} + +func SHCreateFileExtractIconW(file string, attribs DWORD, riid REFIID, ppv uintptr) HRESULT { + fileStr := unicode16FromString(file) + ret1 := syscall6(sHCreateFileExtractIconW, 4, + uintptr(unsafe.Pointer(&fileStr[0])), + uintptr(attribs), + uintptr(unsafe.Pointer(riid)), + ppv, + 0, + 0) + return HRESULT(ret1) +} + +func SHCreateItemFromIDList(pidl /*const*/ PCIDLIST_ABSOLUTE, riid REFIID, ppv uintptr) HRESULT { + ret1 := syscall3(sHCreateItemFromIDList, 3, + uintptr(unsafe.Pointer(pidl)), + uintptr(unsafe.Pointer(riid)), + ppv) + return HRESULT(ret1) +} + +func SHCreateItemFromParsingName(pszPath string, pbc *IBindCtx, riid REFIID, ppv uintptr) HRESULT { + pszPathStr := unicode16FromString(pszPath) + ret1 := syscall6(sHCreateItemFromParsingName, 4, + uintptr(unsafe.Pointer(&pszPathStr[0])), + uintptr(unsafe.Pointer(pbc)), + uintptr(unsafe.Pointer(riid)), + ppv, + 0, + 0) + return HRESULT(ret1) +} + +func SHCreateQueryCancelAutoPlayMoniker(moniker **IMoniker) HRESULT { + ret1 := syscall3(sHCreateQueryCancelAutoPlayMoniker, 1, + uintptr(unsafe.Pointer(moniker)), + 0, + 0) + return HRESULT(ret1) +} + +func SHCreateShellFolderView(pcsfv /*const*/ *SFV_CREATE, ppsv **IShellView) HRESULT { + ret1 := syscall3(sHCreateShellFolderView, 2, + uintptr(unsafe.Pointer(pcsfv)), + uintptr(unsafe.Pointer(ppsv)), + 0) + return HRESULT(ret1) +} + +func SHCreateShellFolderViewEx(psvcbi LPCSFV, ppv **IShellView) HRESULT { + ret1 := syscall3(sHCreateShellFolderViewEx, 2, + uintptr(unsafe.Pointer(psvcbi)), + uintptr(unsafe.Pointer(ppv)), + 0) + return HRESULT(ret1) +} + +func SHCreateShellItem(pidlParent /*const*/ LPCITEMIDLIST, psfParent *IShellFolder, pidl /*const*/ LPCITEMIDLIST, ppsi **IShellItem) HRESULT { + ret1 := syscall6(sHCreateShellItem, 4, + uintptr(unsafe.Pointer(pidlParent)), + uintptr(unsafe.Pointer(psfParent)), + uintptr(unsafe.Pointer(pidl)), + uintptr(unsafe.Pointer(ppsi)), + 0, + 0) + return HRESULT(ret1) +} + +func SHCreateShellItemArray(pidlParent /*const*/ PCIDLIST_ABSOLUTE, psf *IShellFolder, cidl UINT, ppidl PCUITEMID_CHILD_ARRAY, ppsiItemArray **IShellItemArray) HRESULT { + ret1 := syscall6(sHCreateShellItemArray, 5, + uintptr(unsafe.Pointer(pidlParent)), + uintptr(unsafe.Pointer(psf)), + uintptr(cidl), + uintptr(unsafe.Pointer(ppidl)), + uintptr(unsafe.Pointer(ppsiItemArray)), + 0) + return HRESULT(ret1) +} + +func SHCreateShellItemArrayFromDataObject(pdo *IDataObject, riid REFIID, ppv uintptr) HRESULT { + ret1 := syscall3(sHCreateShellItemArrayFromDataObject, 3, + uintptr(unsafe.Pointer(pdo)), + uintptr(unsafe.Pointer(riid)), + ppv) + return HRESULT(ret1) +} + +func SHCreateShellItemArrayFromIDLists(cidl UINT, pidl_array PCIDLIST_ABSOLUTE_ARRAY, psia **IShellItemArray) HRESULT { + ret1 := syscall3(sHCreateShellItemArrayFromIDLists, 3, + uintptr(cidl), + uintptr(unsafe.Pointer(pidl_array)), + uintptr(unsafe.Pointer(psia))) + return HRESULT(ret1) +} + +func SHCreateShellItemArrayFromShellItem(item *IShellItem, riid REFIID, ppv uintptr) HRESULT { + ret1 := syscall3(sHCreateShellItemArrayFromShellItem, 3, + uintptr(unsafe.Pointer(item)), + uintptr(unsafe.Pointer(riid)), + ppv) + return HRESULT(ret1) +} + +func SHCreateStdEnumFmtEtc(cFormats DWORD, lpFormats /*const*/ *FORMATETC, ppenumFormatetc *LPENUMFORMATETC) HRESULT { + ret1 := syscall3(sHCreateStdEnumFmtEtc, 3, + uintptr(cFormats), + uintptr(unsafe.Pointer(lpFormats)), + uintptr(unsafe.Pointer(ppenumFormatetc))) + return HRESULT(ret1) +} + +func SHDefExtractIcon(pszIconFile string, iIndex int32, uFlags UINT, phiconLarge *HICON, phiconSmall *HICON, nIconSize UINT) HRESULT { + pszIconFileStr := unicode16FromString(pszIconFile) + ret1 := syscall6(sHDefExtractIcon, 6, + uintptr(unsafe.Pointer(&pszIconFileStr[0])), + uintptr(iIndex), + uintptr(uFlags), + uintptr(unsafe.Pointer(phiconLarge)), + uintptr(unsafe.Pointer(phiconSmall)), + uintptr(nIconSize)) + return HRESULT(ret1) +} + +func SHDoDragDrop(hWnd HWND, lpDataObject LPDATAOBJECT, lpDropSource LPDROPSOURCE, dwOKEffect DWORD, pdwEffect *uint32) HRESULT { + ret1 := syscall6(sHDoDragDrop, 5, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpDataObject)), + uintptr(unsafe.Pointer(lpDropSource)), + uintptr(dwOKEffect), + uintptr(unsafe.Pointer(pdwEffect)), + 0) + return HRESULT(ret1) +} + +func SHEmptyRecycleBin(hwnd HWND, pszRootPath string, dwFlags DWORD) HRESULT { + pszRootPathStr := unicode16FromString(pszRootPath) + ret1 := syscall3(sHEmptyRecycleBin, 3, + uintptr(hwnd), + uintptr(unsafe.Pointer(&pszRootPathStr[0])), + uintptr(dwFlags)) + return HRESULT(ret1) +} + +func SHEnumerateUnreadMailAccountsW(user HKEY, idx DWORD, mailaddress LPWSTR, mailaddresslen INT) HRESULT { + ret1 := syscall6(sHEnumerateUnreadMailAccountsW, 4, + uintptr(user), + uintptr(idx), + uintptr(unsafe.Pointer(mailaddress)), + uintptr(mailaddresslen), + 0, + 0) + return HRESULT(ret1) +} + +func SHFileOperation(lpFileOp LPSHFILEOPSTRUCT) int32 { + ret1 := syscall3(sHFileOperation, 1, + uintptr(unsafe.Pointer(lpFileOp)), + 0, + 0) + return int32(ret1) +} + +func SHFindFiles(pidlFolder /*const*/ LPCITEMIDLIST, pidlSaveFile /*const*/ LPCITEMIDLIST) bool { + ret1 := syscall3(sHFindFiles, 2, + uintptr(unsafe.Pointer(pidlFolder)), + uintptr(unsafe.Pointer(pidlSaveFile)), + 0) + return ret1 != 0 +} + +func SHFind_InitMenuPopup(hMenu HMENU, hWndParent HWND, w DWORD, x DWORD) LPVOID { + ret1 := syscall6(sHFind_InitMenuPopup, 4, + uintptr(hMenu), + uintptr(hWndParent), + uintptr(w), + uintptr(x), + 0, + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func SHFlushClipboard() HRESULT { + ret1 := syscall3(sHFlushClipboard, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func SHFlushSFCache() { + syscall3(sHFlushSFCache, 0, + 0, + 0, + 0) +} + +func SHFormatDrive(hwnd HWND, drive UINT, fmtID UINT, options UINT) DWORD { + ret1 := syscall6(sHFormatDrive, 4, + uintptr(hwnd), + uintptr(drive), + uintptr(fmtID), + uintptr(options), + 0, + 0) + return DWORD(ret1) +} + +func SHFree(pv LPVOID) { + syscall3(sHFree, 1, + uintptr(unsafe.Pointer(pv)), + 0, + 0) +} + +func SHFreeNameMappings(hNameMapping HANDLE) { + syscall3(sHFreeNameMappings, 1, + uintptr(hNameMapping), + 0, + 0) +} + +func SHGetDataFromIDList(psf LPSHELLFOLDER, pidl /*const*/ LPCITEMIDLIST, nFormat int32, dest LPVOID, aLen int32) HRESULT { + ret1 := syscall6(sHGetDataFromIDList, 5, + uintptr(unsafe.Pointer(psf)), + uintptr(unsafe.Pointer(pidl)), + uintptr(nFormat), + uintptr(unsafe.Pointer(dest)), + uintptr(aLen), + 0) + return HRESULT(ret1) +} + +func SHGetDesktopFolder(psf **IShellFolder) HRESULT { + ret1 := syscall3(sHGetDesktopFolder, 1, + uintptr(unsafe.Pointer(psf)), + 0, + 0) + return HRESULT(ret1) +} + +func SHGetFileInfo(path string, dwFileAttributes DWORD, psfi *SHFILEINFO, sizeofpsfi UINT, flags UINT) *uint32 { + pathStr := unicode16FromString(path) + ret1 := syscall6(sHGetFileInfo, 5, + uintptr(unsafe.Pointer(&pathStr[0])), + uintptr(dwFileAttributes), + uintptr(unsafe.Pointer(psfi)), + uintptr(sizeofpsfi), + uintptr(flags), + 0) + return (*uint32)(unsafe.Pointer(ret1)) +} + +func SHGetFolderLocation(hwndOwner HWND, nFolder int32, hToken HANDLE, dwReserved DWORD, ppidl *LPITEMIDLIST) HRESULT { + ret1 := syscall6(sHGetFolderLocation, 5, + uintptr(hwndOwner), + uintptr(nFolder), + uintptr(hToken), + uintptr(dwReserved), + uintptr(unsafe.Pointer(ppidl)), + 0) + return HRESULT(ret1) +} + +func SHGetFolderPathAndSubDir(hwndOwner HWND, nFolder int32, hToken HANDLE, dwFlags DWORD, pszSubPath string, pszPath LPWSTR) HRESULT { + pszSubPathStr := unicode16FromString(pszSubPath) + ret1 := syscall6(sHGetFolderPathAndSubDir, 6, + uintptr(hwndOwner), + uintptr(nFolder), + uintptr(hToken), + uintptr(dwFlags), + uintptr(unsafe.Pointer(&pszSubPathStr[0])), + uintptr(unsafe.Pointer(pszPath))) + return HRESULT(ret1) +} + +func SHGetFolderPathEx(rfid REFKNOWNFOLDERID, flags DWORD, token HANDLE, path LPWSTR, aLen DWORD) HRESULT { + ret1 := syscall6(sHGetFolderPathEx, 5, + uintptr(unsafe.Pointer(rfid)), + uintptr(flags), + uintptr(token), + uintptr(unsafe.Pointer(path)), + uintptr(aLen), + 0) + return HRESULT(ret1) +} + +func SHGetFolderPath(hwndOwner HWND, nFolder int32, hToken HANDLE, dwFlags DWORD, pszPath LPWSTR) HRESULT { + ret1 := syscall6(sHGetFolderPath, 5, + uintptr(hwndOwner), + uintptr(nFolder), + uintptr(hToken), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pszPath)), + 0) + return HRESULT(ret1) +} + +func SHGetIDListFromObject(punk *IUnknown, ppidl *PIDLIST_ABSOLUTE) HRESULT { + ret1 := syscall3(sHGetIDListFromObject, 2, + uintptr(unsafe.Pointer(punk)), + uintptr(unsafe.Pointer(ppidl)), + 0) + return HRESULT(ret1) +} + +func SHGetIconOverlayIndex(pszIconPath string, iIconIndex INT) INT { + pszIconPathStr := unicode16FromString(pszIconPath) + ret1 := syscall3(sHGetIconOverlayIndex, 2, + uintptr(unsafe.Pointer(&pszIconPathStr[0])), + uintptr(iIconIndex), + 0) + return INT(ret1) +} + +func SHGetImageList(iImageList int32, riid REFIID, ppv uintptr) HRESULT { + ret1 := syscall3(sHGetImageList, 3, + uintptr(iImageList), + uintptr(unsafe.Pointer(riid)), + ppv) + return HRESULT(ret1) +} + +func SHGetInstanceExplorer(lpUnknown **IUnknown) HRESULT { + ret1 := syscall3(sHGetInstanceExplorer, 1, + uintptr(unsafe.Pointer(lpUnknown)), + 0, + 0) + return HRESULT(ret1) +} + +func SHGetItemFromDataObject(pdtobj *IDataObject, dwFlags DATAOBJ_GET_ITEM_FLAGS, riid REFIID, ppv uintptr) HRESULT { + ret1 := syscall6(sHGetItemFromDataObject, 4, + uintptr(unsafe.Pointer(pdtobj)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(riid)), + ppv, + 0, + 0) + return HRESULT(ret1) +} + +func SHGetItemFromObject(punk *IUnknown, riid REFIID, ppv uintptr) HRESULT { + ret1 := syscall3(sHGetItemFromObject, 3, + uintptr(unsafe.Pointer(punk)), + uintptr(unsafe.Pointer(riid)), + ppv) + return HRESULT(ret1) +} + +func SHGetKnownFolderIDList(rfid REFKNOWNFOLDERID, flags DWORD, token HANDLE, pidl *PIDLIST_ABSOLUTE) HRESULT { + ret1 := syscall6(sHGetKnownFolderIDList, 4, + uintptr(unsafe.Pointer(rfid)), + uintptr(flags), + uintptr(token), + uintptr(unsafe.Pointer(pidl)), + 0, + 0) + return HRESULT(ret1) +} + +func SHGetKnownFolderItem(rfid REFKNOWNFOLDERID, flags KNOWN_FOLDER_FLAG, hToken HANDLE, riid REFIID, ppv uintptr) HRESULT { + ret1 := syscall6(sHGetKnownFolderItem, 5, + uintptr(unsafe.Pointer(rfid)), + uintptr(flags), + uintptr(hToken), + uintptr(unsafe.Pointer(riid)), + ppv, + 0) + return HRESULT(ret1) +} + +func SHGetKnownFolderPath(rfid REFKNOWNFOLDERID, flags DWORD, token HANDLE, path *PWSTR) HRESULT { + ret1 := syscall6(sHGetKnownFolderPath, 4, + uintptr(unsafe.Pointer(rfid)), + uintptr(flags), + uintptr(token), + uintptr(unsafe.Pointer(path)), + 0, + 0) + return HRESULT(ret1) +} + +func SHGetLocalizedName(path string, module LPWSTR, size UINT, res *int32) HRESULT { + pathStr := unicode16FromString(path) + ret1 := syscall6(sHGetLocalizedName, 4, + uintptr(unsafe.Pointer(&pathStr[0])), + uintptr(unsafe.Pointer(module)), + uintptr(size), + uintptr(unsafe.Pointer(res)), + 0, + 0) + return HRESULT(ret1) +} + +func SHGetMalloc(lpmal *LPMALLOC) HRESULT { + ret1 := syscall3(sHGetMalloc, 1, + uintptr(unsafe.Pointer(lpmal)), + 0, + 0) + return HRESULT(ret1) +} + +func SHGetNameFromIDList(pidl /*const*/ PCIDLIST_ABSOLUTE, sigdnName SIGDN, ppszName *PWSTR) HRESULT { + ret1 := syscall3(sHGetNameFromIDList, 3, + uintptr(unsafe.Pointer(pidl)), + uintptr(sigdnName), + uintptr(unsafe.Pointer(ppszName))) + return HRESULT(ret1) +} + +func SHGetNewLinkInfo(pszLinkTo string, pszDir string, pszName LPWSTR, pfMustCopy *BOOL, uFlags UINT) bool { + pszLinkToStr := unicode16FromString(pszLinkTo) + pszDirStr := unicode16FromString(pszDir) + ret1 := syscall6(sHGetNewLinkInfo, 5, + uintptr(unsafe.Pointer(&pszLinkToStr[0])), + uintptr(unsafe.Pointer(&pszDirStr[0])), + uintptr(unsafe.Pointer(pszName)), + uintptr(unsafe.Pointer(pfMustCopy)), + uintptr(uFlags), + 0) + return ret1 != 0 +} + +func SHGetPathFromIDList(pidl /*const*/ LPCITEMIDLIST, pszPath LPWSTR) bool { + ret1 := syscall3(sHGetPathFromIDList, 2, + uintptr(unsafe.Pointer(pidl)), + uintptr(unsafe.Pointer(pszPath)), + 0) + return ret1 != 0 +} + +func SHGetPropertyStoreForWindow(hwnd HWND, riid REFIID, ppv uintptr) HRESULT { + ret1 := syscall3(sHGetPropertyStoreForWindow, 3, + uintptr(hwnd), + uintptr(unsafe.Pointer(riid)), + ppv) + return HRESULT(ret1) +} + +func SHGetPropertyStoreFromParsingName(pszPath string, pbc *IBindCtx, flags GETPROPERTYSTOREFLAGS, riid REFIID, ppv uintptr) HRESULT { + pszPathStr := unicode16FromString(pszPath) + ret1 := syscall6(sHGetPropertyStoreFromParsingName, 5, + uintptr(unsafe.Pointer(&pszPathStr[0])), + uintptr(unsafe.Pointer(pbc)), + uintptr(flags), + uintptr(unsafe.Pointer(riid)), + ppv, + 0) + return HRESULT(ret1) +} + +func SHGetRealIDL(lpsf LPSHELLFOLDER, pidlSimple /*const*/ LPCITEMIDLIST, pidlReal *LPITEMIDLIST) HRESULT { + ret1 := syscall3(sHGetRealIDL, 3, + uintptr(unsafe.Pointer(lpsf)), + uintptr(unsafe.Pointer(pidlSimple)), + uintptr(unsafe.Pointer(pidlReal))) + return HRESULT(ret1) +} + +func SHGetSetSettings(lpss LPSHELLSTATE, dwMask DWORD, bSet bool) { + syscall3(sHGetSetSettings, 3, + uintptr(unsafe.Pointer(lpss)), + uintptr(dwMask), + getUintptrFromBool(bSet)) +} + +func SHGetSettings(lpsfs LPSHELLFLAGSTATE, dwMask DWORD) { + syscall3(sHGetSettings, 2, + uintptr(unsafe.Pointer(lpsfs)), + uintptr(dwMask), + 0) +} + +func SHGetSpecialFolderLocation(hwndOwner HWND, nFolder INT, ppidl *LPITEMIDLIST) HRESULT { + ret1 := syscall3(sHGetSpecialFolderLocation, 3, + uintptr(hwndOwner), + uintptr(nFolder), + uintptr(unsafe.Pointer(ppidl))) + return HRESULT(ret1) +} + +func SHGetSpecialFolderPath(hwndOwner HWND, szPath LPWSTR, nFolder int32, bCreate bool) bool { + ret1 := syscall6(sHGetSpecialFolderPath, 4, + uintptr(hwndOwner), + uintptr(unsafe.Pointer(szPath)), + uintptr(nFolder), + getUintptrFromBool(bCreate), + 0, + 0) + return ret1 != 0 +} + +func SHGetStockIconInfo(id SHSTOCKICONID, flags UINT, sii *SHSTOCKICONINFO) HRESULT { + ret1 := syscall3(sHGetStockIconInfo, 3, + uintptr(id), + uintptr(flags), + uintptr(unsafe.Pointer(sii))) + return HRESULT(ret1) +} + +func SHHandleUpdateImage(pidlExtra /*const*/ LPCITEMIDLIST) INT { + ret1 := syscall3(sHHandleUpdateImage, 1, + uintptr(unsafe.Pointer(pidlExtra)), + 0, + 0) + return INT(ret1) +} + +func SHHelpShortcuts_RunDLL(dwArg1 DWORD, dwArg2 DWORD, dwArg3 DWORD, dwArg4 DWORD) DWORD { + ret1 := syscall6(sHHelpShortcuts_RunDLL, 4, + uintptr(dwArg1), + uintptr(dwArg2), + uintptr(dwArg3), + uintptr(dwArg4), + 0, + 0) + return DWORD(ret1) +} + +func SHIsFileAvailableOffline(path string, status *uint32) HRESULT { + pathStr := unicode16FromString(path) + ret1 := syscall3(sHIsFileAvailableOffline, 2, + uintptr(unsafe.Pointer(&pathStr[0])), + uintptr(unsafe.Pointer(status)), + 0) + return HRESULT(ret1) +} + +func SHLimitInputEdit(textbox HWND, folder *IShellFolder) HRESULT { + ret1 := syscall3(sHLimitInputEdit, 2, + uintptr(textbox), + uintptr(unsafe.Pointer(folder)), + 0) + return HRESULT(ret1) +} + +func SHLoadInProc(rclsid /*const*/ REFCLSID) HRESULT { + ret1 := syscall3(sHLoadInProc, 1, + uintptr(unsafe.Pointer(rclsid)), + 0, + 0) + return HRESULT(ret1) +} + +func SHLoadNonloadedIconOverlayIdentifiers() HRESULT { + ret1 := syscall3(sHLoadNonloadedIconOverlayIdentifiers, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func SHMapIDListToImageListIndexAsync(pts *IUnknown, psf *IShellFolder, pidl /*const*/ LPCITEMIDLIST, flags UINT, pfn uintptr, pvData uintptr, pvHint uintptr, piIndex *int, piIndexSel *int) HRESULT { + ret1 := syscall9(sHMapIDListToImageListIndexAsync, 9, + uintptr(unsafe.Pointer(pts)), + uintptr(unsafe.Pointer(psf)), + uintptr(unsafe.Pointer(pidl)), + uintptr(flags), + pfn, + pvData, + pvHint, + uintptr(unsafe.Pointer(piIndex)), + uintptr(unsafe.Pointer(piIndexSel))) + return HRESULT(ret1) +} + +func SHMapPIDLToSystemImageListIndex(sh *IShellFolder, pidl /*const*/ LPCITEMIDLIST, pIndex *int) int32 { + ret1 := syscall3(sHMapPIDLToSystemImageListIndex, 3, + uintptr(unsafe.Pointer(sh)), + uintptr(unsafe.Pointer(pidl)), + uintptr(unsafe.Pointer(pIndex))) + return int32(ret1) +} + +func SHObjectProperties(hwnd HWND, dwType DWORD, szObject string, szPage string) bool { + szObjectStr := unicode16FromString(szObject) + szPageStr := unicode16FromString(szPage) + ret1 := syscall6(sHObjectProperties, 4, + uintptr(hwnd), + uintptr(dwType), + uintptr(unsafe.Pointer(&szObjectStr[0])), + uintptr(unsafe.Pointer(&szPageStr[0])), + 0, + 0) + return ret1 != 0 +} + +func SHOpenFolderAndSelectItems(pidlFolder /*const*/ PCIDLIST_ABSOLUTE, cidl UINT, apidl *PCUITEMID_CHILD_ARRAY, flags DWORD) HRESULT { + ret1 := syscall6(sHOpenFolderAndSelectItems, 4, + uintptr(unsafe.Pointer(pidlFolder)), + uintptr(cidl), + uintptr(unsafe.Pointer(apidl)), + uintptr(flags), + 0, + 0) + return HRESULT(ret1) +} + +func SHParseDisplayName(name string, bindctx *IBindCtx, pidlist *LPITEMIDLIST, attr_in SFGAOF, attr_out *SFGAOF) HRESULT { + nameStr := unicode16FromString(name) + ret1 := syscall6(sHParseDisplayName, 5, + uintptr(unsafe.Pointer(&nameStr[0])), + uintptr(unsafe.Pointer(bindctx)), + uintptr(unsafe.Pointer(pidlist)), + uintptr(attr_in), + uintptr(unsafe.Pointer(attr_out)), + 0) + return HRESULT(ret1) +} + +func SHPathPrepareForWrite(hwnd HWND, modless *IUnknown, path string, flags DWORD) HRESULT { + pathStr := unicode16FromString(path) + ret1 := syscall6(sHPathPrepareForWrite, 4, + uintptr(hwnd), + uintptr(unsafe.Pointer(modless)), + uintptr(unsafe.Pointer(&pathStr[0])), + uintptr(flags), + 0, + 0) + return HRESULT(ret1) +} + +func SHPropStgCreate(psstg *IPropertySetStorage, fmtid REFFMTID, pclsid /*const*/ *CLSID, grfFlags DWORD, grfMode DWORD, dwDisposition DWORD, ppstg **IPropertyStorage, puCodePage *UINT) HRESULT { + ret1 := syscall9(sHPropStgCreate, 8, + uintptr(unsafe.Pointer(psstg)), + uintptr(unsafe.Pointer(fmtid)), + uintptr(unsafe.Pointer(pclsid)), + uintptr(grfFlags), + uintptr(grfMode), + uintptr(dwDisposition), + uintptr(unsafe.Pointer(ppstg)), + uintptr(unsafe.Pointer(puCodePage)), + 0) + return HRESULT(ret1) +} + +func SHPropStgReadMultiple(pps *IPropertyStorage, uCodePage UINT, cpspec ULONG, rgpspec /*const*/ *PROPSPEC, rgvar *PROPVARIANT) HRESULT { + ret1 := syscall6(sHPropStgReadMultiple, 5, + uintptr(unsafe.Pointer(pps)), + uintptr(uCodePage), + uintptr(cpspec), + uintptr(unsafe.Pointer(rgpspec)), + uintptr(unsafe.Pointer(rgvar)), + 0) + return HRESULT(ret1) +} + +func SHPropStgWriteMultiple(pps *IPropertyStorage, uCodePage *UINT, cpspec ULONG, rgpspec /*const*/ *PROPSPEC, rgvar *PROPVARIANT, propidNameFirst PROPID) HRESULT { + ret1 := syscall6(sHPropStgWriteMultiple, 6, + uintptr(unsafe.Pointer(pps)), + uintptr(unsafe.Pointer(uCodePage)), + uintptr(cpspec), + uintptr(unsafe.Pointer(rgpspec)), + uintptr(unsafe.Pointer(rgvar)), + uintptr(propidNameFirst)) + return HRESULT(ret1) +} + +func SHQueryRecycleBin(pszRootPath string, pSHQueryRBInfo LPSHQUERYRBINFO) HRESULT { + pszRootPathStr := unicode16FromString(pszRootPath) + ret1 := syscall3(sHQueryRecycleBin, 2, + uintptr(unsafe.Pointer(&pszRootPathStr[0])), + uintptr(unsafe.Pointer(pSHQueryRBInfo)), + 0) + return HRESULT(ret1) +} + +func SHQueryUserNotificationState(state *QUERY_USER_NOTIFICATION_STATE) HRESULT { + ret1 := syscall3(sHQueryUserNotificationState, 1, + uintptr(unsafe.Pointer(state)), + 0, + 0) + return HRESULT(ret1) +} + +func SHRemoveLocalizedName(path /*const*/ *WCHAR) HRESULT { + ret1 := syscall3(sHRemoveLocalizedName, 1, + uintptr(unsafe.Pointer(path)), + 0, + 0) + return HRESULT(ret1) +} + +func SHRestricted(policy RESTRICTIONS) DWORD { + ret1 := syscall3(sHRestricted, 1, + uintptr(policy), + 0, + 0) + return DWORD(ret1) +} + +func SHRunControlPanel(commandLine string, parent HWND) bool { + commandLineStr := unicode16FromString(commandLine) + ret1 := syscall3(sHRunControlPanel, 2, + uintptr(unsafe.Pointer(&commandLineStr[0])), + uintptr(parent), + 0) + return ret1 != 0 +} + +func SHSetInstanceExplorer(lpUnknown LPUNKNOWN) { + syscall3(sHSetInstanceExplorer, 1, + uintptr(unsafe.Pointer(lpUnknown)), + 0, + 0) +} + +func SHSetLocalizedName(pszPath LPWSTR, pszResModule string, idsRes int32) HRESULT { + pszResModuleStr := unicode16FromString(pszResModule) + ret1 := syscall3(sHSetLocalizedName, 3, + uintptr(unsafe.Pointer(pszPath)), + uintptr(unsafe.Pointer(&pszResModuleStr[0])), + uintptr(idsRes)) + return HRESULT(ret1) +} + +func SHSetUnreadMailCountW(mailaddress string, count DWORD, executecommand string) HRESULT { + mailaddressStr := unicode16FromString(mailaddress) + executecommandStr := unicode16FromString(executecommand) + ret1 := syscall3(sHSetUnreadMailCountW, 3, + uintptr(unsafe.Pointer(&mailaddressStr[0])), + uintptr(count), + uintptr(unsafe.Pointer(&executecommandStr[0]))) + return HRESULT(ret1) +} + +func SHShellFolderView_Message(hwndCabinet HWND, uMessage UINT, lParam LPARAM) LRESULT { + ret1 := syscall3(sHShellFolderView_Message, 3, + uintptr(hwndCabinet), + uintptr(uMessage), + uintptr(lParam)) + return LRESULT(ret1) +} + +func SHUpdateImage(pszHashItem string, iIndex int32, uFlags UINT, iImageIndex int32) { + pszHashItemStr := unicode16FromString(pszHashItem) + syscall6(sHUpdateImage, 4, + uintptr(unsafe.Pointer(&pszHashItemStr[0])), + uintptr(iIndex), + uintptr(uFlags), + uintptr(iImageIndex), + 0, + 0) +} + +func SHUpdateRecycleBinIcon() HRESULT { + ret1 := syscall3(sHUpdateRecycleBinIcon, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func SHValidateUNC(hwndOwner HWND, pszFile PWSTR, fConnect UINT) bool { + ret1 := syscall3(sHValidateUNC, 3, + uintptr(hwndOwner), + uintptr(unsafe.Pointer(pszFile)), + uintptr(fConnect)) + return ret1 != 0 +} + +func SetCurrentProcessExplicitAppUserModelID(appid string) HRESULT { + appidStr := unicode16FromString(appid) + ret1 := syscall3(setCurrentProcessExplicitAppUserModelID, 1, + uintptr(unsafe.Pointer(&appidStr[0])), + 0, + 0) + return HRESULT(ret1) +} + +func SheChangeDir(path LPWSTR) DWORD { + ret1 := syscall3(sheChangeDir, 1, + uintptr(unsafe.Pointer(path)), + 0, + 0) + return DWORD(ret1) +} + +func SheGetDir(drive DWORD, buffer LPWSTR) DWORD { + ret1 := syscall3(sheGetDir, 2, + uintptr(drive), + uintptr(unsafe.Pointer(buffer)), + 0) + return DWORD(ret1) +} + +func ShellAbout(hWnd HWND, szApp string, szOtherStuff string, hIcon HICON) bool { + szAppStr := unicode16FromString(szApp) + szOtherStuffStr := unicode16FromString(szOtherStuff) + ret1 := syscall6(shellAbout, 4, + uintptr(hWnd), + uintptr(unsafe.Pointer(&szAppStr[0])), + uintptr(unsafe.Pointer(&szOtherStuffStr[0])), + uintptr(hIcon), + 0, + 0) + return ret1 != 0 +} + +func ShellExecute(hwnd HWND, lpVerb string, lpFile string, lpParameters string, lpDirectory string, nShowCmd INT) HINSTANCE { + lpVerbStr := unicode16FromString(lpVerb) + lpFileStr := unicode16FromString(lpFile) + lpParametersStr := unicode16FromString(lpParameters) + lpDirectoryStr := unicode16FromString(lpDirectory) + ret1 := syscall6(shellExecute, 6, + uintptr(hwnd), + uintptr(unsafe.Pointer(&lpVerbStr[0])), + uintptr(unsafe.Pointer(&lpFileStr[0])), + uintptr(unsafe.Pointer(&lpParametersStr[0])), + uintptr(unsafe.Pointer(&lpDirectoryStr[0])), + uintptr(nShowCmd)) + return HINSTANCE(ret1) +} + +func Shell_GetImageLists(lpBigList *HIMAGELIST, lpSmallList *HIMAGELIST) bool { + ret1 := syscall3(shell_GetImageLists, 2, + uintptr(unsafe.Pointer(lpBigList)), + uintptr(unsafe.Pointer(lpSmallList)), + 0) + return ret1 != 0 +} + +func Shell_MergeMenus(hmDst HMENU, hmSrc HMENU, uInsert UINT, uIDAdjust UINT, uIDAdjustMax UINT, uFlags ULONG) UINT { + ret1 := syscall6(shell_MergeMenus, 6, + uintptr(hmDst), + uintptr(hmSrc), + uintptr(uInsert), + uintptr(uIDAdjust), + uintptr(uIDAdjustMax), + uintptr(uFlags)) + return UINT(ret1) +} + +func Shell_NotifyIcon(dwMessage DWORD, nid PNOTIFYICONDATA) bool { + ret1 := syscall3(shell_NotifyIcon, 2, + uintptr(dwMessage), + uintptr(unsafe.Pointer(nid)), + 0) + return ret1 != 0 +} + +func SignalFileOpen(pidl /*const*/ PCIDLIST_ABSOLUTE) bool { + ret1 := syscall3(signalFileOpen, 1, + uintptr(unsafe.Pointer(pidl)), + 0, + 0) + return ret1 != 0 +} + +func WOWShellExecute(hWnd HWND, lpOperation /*const*/ LPCSTR, lpFile /*const*/ LPCSTR, lpParameters /*const*/ LPCSTR, lpDirectory /*const*/ LPCSTR, iShowCmd INT, callback uintptr) HINSTANCE { + ret1 := syscall9(wOWShellExecute, 7, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpOperation)), + uintptr(unsafe.Pointer(lpFile)), + uintptr(unsafe.Pointer(lpParameters)), + uintptr(unsafe.Pointer(lpDirectory)), + uintptr(iShowCmd), + callback, + 0, + 0) + return HINSTANCE(ret1) +} + +func WriteCabinetState(cs *CABINETSTATE) bool { + ret1 := syscall3(writeCabinetState, 1, + uintptr(unsafe.Pointer(cs)), + 0, + 0) + return ret1 != 0 +} diff --git a/grdp/win/shlwapi.go b/grdp/win/shlwapi.go new file mode 100644 index 0000000..8ca2ec4 --- /dev/null +++ b/grdp/win/shlwapi.go @@ -0,0 +1,2366 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "syscall" + "unsafe" +) + +var ( + // Library + libshlwapi uintptr + + // Functions + assocCreate uintptr + assocGetPerceivedType uintptr + assocIsDangerous uintptr + assocQueryKey uintptr + assocQueryStringByKey uintptr + assocQueryString uintptr + chrCmpI uintptr + colorAdjustLuma uintptr + colorHLSToRGB uintptr + colorRGBToHLS uintptr + connectToConnectionPoint uintptr + getAcceptLanguages uintptr + getMenuPosFromID uintptr + hashData uintptr + iStream_Reset uintptr + iStream_Size uintptr + iUnknown_AtomicRelease uintptr + iUnknown_GetSite uintptr + iUnknown_GetWindow uintptr + iUnknown_QueryService uintptr + iUnknown_Set uintptr + iUnknown_SetSite uintptr + intlStrEqWorker uintptr + isCharSpace uintptr + isInternetESCEnabled uintptr + isOS uintptr + mLFreeLibrary uintptr + mLLoadLibrary uintptr + parseURL uintptr + pathAddBackslash uintptr + pathAddExtension uintptr + pathAppend uintptr + pathBuildRoot uintptr + pathCanonicalize uintptr + pathCombine uintptr + pathCommonPrefix uintptr + pathCompactPathEx uintptr + pathCompactPath uintptr + pathCreateFromUrlAlloc uintptr + pathCreateFromUrl uintptr + pathFileExists uintptr + pathFindExtension uintptr + pathFindFileName uintptr + pathFindNextComponent uintptr + pathFindOnPath uintptr + pathFindSuffixArray uintptr + pathGetArgs uintptr + pathGetCharType uintptr + pathGetDriveNumber uintptr + pathIsContentType uintptr + pathIsDirectoryEmpty uintptr + pathIsDirectory uintptr + pathIsFileSpec uintptr + pathIsLFNFileSpec uintptr + pathIsNetworkPath uintptr + pathIsPrefix uintptr + pathIsRelative uintptr + pathIsRoot uintptr + pathIsSameRoot uintptr + pathIsSystemFolder uintptr + pathIsUNCServerShare uintptr + pathIsUNCServer uintptr + pathIsUNC uintptr + pathIsURL uintptr + pathMakePretty uintptr + pathMakeSystemFolder uintptr + pathMatchSpec uintptr + pathParseIconLocation uintptr + pathQuoteSpaces uintptr + pathRelativePathTo uintptr + pathRemoveArgs uintptr + pathRemoveBackslash uintptr + pathRemoveBlanks uintptr + pathRemoveExtension uintptr + pathRemoveFileSpec uintptr + pathRenameExtension uintptr + pathSearchAndQualify uintptr + pathSetDlgItemPath uintptr + pathSkipRoot uintptr + pathStripPath uintptr + pathStripToRoot uintptr + pathUnExpandEnvStrings uintptr + pathUndecorate uintptr + pathUnmakeSystemFolder uintptr + pathUnquoteSpaces uintptr + qISearch uintptr + sHAllocShared uintptr + sHAnsiToAnsi uintptr + sHAnsiToUnicode uintptr + sHAutoComplete uintptr + sHCopyKey uintptr + sHCreateShellPalette uintptr + sHCreateStreamOnFileEx uintptr + sHCreateStreamOnFile uintptr + sHCreateStreamWrapper uintptr + sHCreateThread uintptr + sHCreateThreadRef uintptr + sHDeleteEmptyKey uintptr + sHDeleteKey uintptr + sHDeleteOrphanKey uintptr + sHDeleteValue uintptr + sHEnumKeyEx uintptr + sHEnumValue uintptr + sHFormatDateTime uintptr + sHFreeShared uintptr + sHGetInverseCMAP uintptr + sHGetThreadRef uintptr + sHGetValue uintptr + sHGetViewStatePropertyBag uintptr + sHIsChildOrSelf uintptr + sHIsLowMemoryMachine uintptr + sHLoadIndirectString uintptr + sHLockShared uintptr + sHMessageBoxCheck uintptr + sHQueryInfoKey uintptr + sHQueryValueEx uintptr + sHRegCloseUSKey uintptr + sHRegCreateUSKey uintptr + sHRegDeleteEmptyUSKey uintptr + sHRegDeleteUSValue uintptr + sHRegDuplicateHKey uintptr + sHRegEnumUSKey uintptr + sHRegEnumUSValue uintptr + sHRegGetBoolUSValue uintptr + sHRegGetIntW uintptr + sHRegGetPath uintptr + sHRegGetUSValue uintptr + sHRegOpenUSKey uintptr + sHRegQueryInfoUSKey uintptr + sHRegQueryUSValue uintptr + sHRegSetPath uintptr + sHRegSetUSValue uintptr + sHRegWriteUSValue uintptr + sHRegisterValidateTemplate uintptr + sHReleaseThreadRef uintptr + sHSendMessageBroadcast uintptr + sHSetThreadRef uintptr + sHSetValue uintptr + sHSkipJunction uintptr + sHStrDup uintptr + sHStripMneumonic uintptr + sHUnicodeToAnsi uintptr + sHUnicodeToUnicode uintptr + sHUnlockShared uintptr + strCSpnI uintptr + strCSpn uintptr + strCatBuff uintptr + strCatChainW uintptr + strCatW uintptr + strChrI uintptr + strChrNW uintptr + strChr uintptr + strCmpC uintptr + strCmpIC uintptr + strCmpIW uintptr + strCmpLogicalW uintptr + strCmpNC uintptr + strCmpNIC uintptr + strCmpNI uintptr + strCmpN uintptr + strCmpW uintptr + strCpyNW uintptr + strCpyW uintptr + strDup uintptr + strFormatByteSize64A uintptr + strFormatByteSize uintptr + strFormatKBSize uintptr + strFromTimeInterval uintptr + strIsIntlEqual uintptr + strNCat uintptr + strPBrk uintptr + strRChrI uintptr + strRChr uintptr + strRStrI uintptr + strRetToBSTR uintptr + strRetToBuf uintptr + strRetToStr uintptr + strSpn uintptr + strStrI uintptr + strStrNIW uintptr + strStrNW uintptr + strStr uintptr + strToInt64Ex uintptr + strToIntEx uintptr + strToInt uintptr + strTrim uintptr + urlApplyScheme uintptr + urlCanonicalize uintptr + urlCombine uintptr + urlCompare uintptr + urlCreateFromPath uintptr + urlEscape uintptr + urlFixupW uintptr + urlGetLocation uintptr + urlGetPart uintptr + urlHash uintptr + urlIsNoHistory uintptr + urlIsOpaque uintptr + urlIs uintptr + urlUnescape uintptr + whichPlatform uintptr +) + +func init() { + // Library + libshlwapi = doLoadLibrary("shlwapi.dll") + + // Functions + assocCreate = doGetProcAddress(libshlwapi, "AssocCreate") + assocGetPerceivedType = doGetProcAddress(libshlwapi, "AssocGetPerceivedType") + assocIsDangerous = doGetProcAddress(libshlwapi, "AssocIsDangerous") + assocQueryKey = doGetProcAddress(libshlwapi, "AssocQueryKeyW") + assocQueryStringByKey = doGetProcAddress(libshlwapi, "AssocQueryStringByKeyW") + assocQueryString = doGetProcAddress(libshlwapi, "AssocQueryStringW") + chrCmpI = doGetProcAddress(libshlwapi, "ChrCmpIW") + colorAdjustLuma = doGetProcAddress(libshlwapi, "ColorAdjustLuma") + colorHLSToRGB = doGetProcAddress(libshlwapi, "ColorHLSToRGB") + colorRGBToHLS = doGetProcAddress(libshlwapi, "ColorRGBToHLS") + connectToConnectionPoint = doGetProcAddress(libshlwapi, "ConnectToConnectionPoint") + getAcceptLanguages = doGetProcAddress(libshlwapi, "GetAcceptLanguagesW") + getMenuPosFromID = doGetProcAddress(libshlwapi, "GetMenuPosFromID") + hashData = doGetProcAddress(libshlwapi, "HashData") + iStream_Reset = doGetProcAddress(libshlwapi, "IStream_Reset") + iStream_Size = doGetProcAddress(libshlwapi, "IStream_Size") + iUnknown_AtomicRelease = doGetProcAddress(libshlwapi, "IUnknown_AtomicRelease") + iUnknown_GetSite = doGetProcAddress(libshlwapi, "IUnknown_GetSite") + iUnknown_GetWindow = doGetProcAddress(libshlwapi, "IUnknown_GetWindow") + iUnknown_QueryService = doGetProcAddress(libshlwapi, "IUnknown_QueryService") + iUnknown_Set = doGetProcAddress(libshlwapi, "IUnknown_Set") + iUnknown_SetSite = doGetProcAddress(libshlwapi, "IUnknown_SetSite") + intlStrEqWorker = doGetProcAddress(libshlwapi, "IntlStrEqWorkerW") + isCharSpace = doGetProcAddress(libshlwapi, "IsCharSpaceW") + isInternetESCEnabled = doGetProcAddress(libshlwapi, "IsInternetESCEnabled") + isOS = doGetProcAddress(libshlwapi, "IsOS") + mLFreeLibrary = doGetProcAddress(libshlwapi, "MLFreeLibrary") + mLLoadLibrary = doGetProcAddress(libshlwapi, "MLLoadLibraryW") + parseURL = doGetProcAddress(libshlwapi, "ParseURLW") + pathAddBackslash = doGetProcAddress(libshlwapi, "PathAddBackslashW") + pathAddExtension = doGetProcAddress(libshlwapi, "PathAddExtensionW") + pathAppend = doGetProcAddress(libshlwapi, "PathAppendW") + pathBuildRoot = doGetProcAddress(libshlwapi, "PathBuildRootW") + pathCanonicalize = doGetProcAddress(libshlwapi, "PathCanonicalizeW") + pathCombine = doGetProcAddress(libshlwapi, "PathCombineW") + pathCommonPrefix = doGetProcAddress(libshlwapi, "PathCommonPrefixW") + pathCompactPathEx = doGetProcAddress(libshlwapi, "PathCompactPathExW") + pathCompactPath = doGetProcAddress(libshlwapi, "PathCompactPathW") + pathCreateFromUrlAlloc = doGetProcAddress(libshlwapi, "PathCreateFromUrlAlloc") + pathCreateFromUrl = doGetProcAddress(libshlwapi, "PathCreateFromUrlW") + pathFileExists = doGetProcAddress(libshlwapi, "PathFileExistsW") + pathFindExtension = doGetProcAddress(libshlwapi, "PathFindExtensionW") + pathFindFileName = doGetProcAddress(libshlwapi, "PathFindFileNameW") + pathFindNextComponent = doGetProcAddress(libshlwapi, "PathFindNextComponentW") + pathFindOnPath = doGetProcAddress(libshlwapi, "PathFindOnPathW") + pathFindSuffixArray = doGetProcAddress(libshlwapi, "PathFindSuffixArrayW") + pathGetArgs = doGetProcAddress(libshlwapi, "PathGetArgsW") + pathGetCharType = doGetProcAddress(libshlwapi, "PathGetCharTypeW") + pathGetDriveNumber = doGetProcAddress(libshlwapi, "PathGetDriveNumberW") + pathIsContentType = doGetProcAddress(libshlwapi, "PathIsContentTypeW") + pathIsDirectoryEmpty = doGetProcAddress(libshlwapi, "PathIsDirectoryEmptyW") + pathIsDirectory = doGetProcAddress(libshlwapi, "PathIsDirectoryW") + pathIsFileSpec = doGetProcAddress(libshlwapi, "PathIsFileSpecW") + pathIsLFNFileSpec = doGetProcAddress(libshlwapi, "PathIsLFNFileSpecW") + pathIsNetworkPath = doGetProcAddress(libshlwapi, "PathIsNetworkPathW") + pathIsPrefix = doGetProcAddress(libshlwapi, "PathIsPrefixW") + pathIsRelative = doGetProcAddress(libshlwapi, "PathIsRelativeW") + pathIsRoot = doGetProcAddress(libshlwapi, "PathIsRootW") + pathIsSameRoot = doGetProcAddress(libshlwapi, "PathIsSameRootW") + pathIsSystemFolder = doGetProcAddress(libshlwapi, "PathIsSystemFolderW") + pathIsUNCServerShare = doGetProcAddress(libshlwapi, "PathIsUNCServerShareW") + pathIsUNCServer = doGetProcAddress(libshlwapi, "PathIsUNCServerW") + pathIsUNC = doGetProcAddress(libshlwapi, "PathIsUNCW") + pathIsURL = doGetProcAddress(libshlwapi, "PathIsURLW") + pathMakePretty = doGetProcAddress(libshlwapi, "PathMakePrettyW") + pathMakeSystemFolder = doGetProcAddress(libshlwapi, "PathMakeSystemFolderW") + pathMatchSpec = doGetProcAddress(libshlwapi, "PathMatchSpecW") + pathParseIconLocation = doGetProcAddress(libshlwapi, "PathParseIconLocationW") + pathQuoteSpaces = doGetProcAddress(libshlwapi, "PathQuoteSpacesW") + pathRelativePathTo = doGetProcAddress(libshlwapi, "PathRelativePathToW") + pathRemoveArgs = doGetProcAddress(libshlwapi, "PathRemoveArgsW") + pathRemoveBackslash = doGetProcAddress(libshlwapi, "PathRemoveBackslashW") + pathRemoveBlanks = doGetProcAddress(libshlwapi, "PathRemoveBlanksW") + pathRemoveExtension = doGetProcAddress(libshlwapi, "PathRemoveExtensionW") + pathRemoveFileSpec = doGetProcAddress(libshlwapi, "PathRemoveFileSpecW") + pathRenameExtension = doGetProcAddress(libshlwapi, "PathRenameExtensionW") + pathSearchAndQualify = doGetProcAddress(libshlwapi, "PathSearchAndQualifyW") + pathSetDlgItemPath = doGetProcAddress(libshlwapi, "PathSetDlgItemPathW") + pathSkipRoot = doGetProcAddress(libshlwapi, "PathSkipRootW") + pathStripPath = doGetProcAddress(libshlwapi, "PathStripPathW") + pathStripToRoot = doGetProcAddress(libshlwapi, "PathStripToRootW") + pathUnExpandEnvStrings = doGetProcAddress(libshlwapi, "PathUnExpandEnvStringsW") + pathUndecorate = doGetProcAddress(libshlwapi, "PathUndecorateW") + pathUnmakeSystemFolder = doGetProcAddress(libshlwapi, "PathUnmakeSystemFolderW") + pathUnquoteSpaces = doGetProcAddress(libshlwapi, "PathUnquoteSpacesW") + qISearch = doGetProcAddress(libshlwapi, "QISearch") + sHAllocShared = doGetProcAddress(libshlwapi, "SHAllocShared") + sHAnsiToAnsi = doGetProcAddress(libshlwapi, "SHAnsiToAnsi") + sHAnsiToUnicode = doGetProcAddress(libshlwapi, "SHAnsiToUnicode") + sHAutoComplete = doGetProcAddress(libshlwapi, "SHAutoComplete") + sHCopyKey = doGetProcAddress(libshlwapi, "SHCopyKeyW") + sHCreateShellPalette = doGetProcAddress(libshlwapi, "SHCreateShellPalette") + sHCreateStreamOnFileEx = doGetProcAddress(libshlwapi, "SHCreateStreamOnFileEx") + sHCreateStreamOnFile = doGetProcAddress(libshlwapi, "SHCreateStreamOnFileW") + sHCreateStreamWrapper = doGetProcAddress(libshlwapi, "SHCreateStreamWrapper") + sHCreateThread = doGetProcAddress(libshlwapi, "SHCreateThread") + sHCreateThreadRef = doGetProcAddress(libshlwapi, "SHCreateThreadRef") + sHDeleteEmptyKey = doGetProcAddress(libshlwapi, "SHDeleteEmptyKeyW") + sHDeleteKey = doGetProcAddress(libshlwapi, "SHDeleteKeyW") + sHDeleteOrphanKey = doGetProcAddress(libshlwapi, "SHDeleteOrphanKeyW") + sHDeleteValue = doGetProcAddress(libshlwapi, "SHDeleteValueW") + sHEnumKeyEx = doGetProcAddress(libshlwapi, "SHEnumKeyExW") + sHEnumValue = doGetProcAddress(libshlwapi, "SHEnumValueW") + sHFormatDateTime = doGetProcAddress(libshlwapi, "SHFormatDateTimeW") + sHFreeShared = doGetProcAddress(libshlwapi, "SHFreeShared") + sHGetInverseCMAP = doGetProcAddress(libshlwapi, "SHGetInverseCMAP") + sHGetThreadRef = doGetProcAddress(libshlwapi, "SHGetThreadRef") + sHGetValue = doGetProcAddress(libshlwapi, "SHGetValueW") + sHGetViewStatePropertyBag = doGetProcAddress(libshlwapi, "SHGetViewStatePropertyBag") + sHIsChildOrSelf = doGetProcAddress(libshlwapi, "SHIsChildOrSelf") + sHIsLowMemoryMachine = doGetProcAddress(libshlwapi, "SHIsLowMemoryMachine") + sHLoadIndirectString = doGetProcAddress(libshlwapi, "SHLoadIndirectString") + sHLockShared = doGetProcAddress(libshlwapi, "SHLockShared") + sHMessageBoxCheck = doGetProcAddress(libshlwapi, "SHMessageBoxCheckW") + sHQueryInfoKey = doGetProcAddress(libshlwapi, "SHQueryInfoKeyW") + sHQueryValueEx = doGetProcAddress(libshlwapi, "SHQueryValueExW") + sHRegCloseUSKey = doGetProcAddress(libshlwapi, "SHRegCloseUSKey") + sHRegCreateUSKey = doGetProcAddress(libshlwapi, "SHRegCreateUSKeyW") + sHRegDeleteEmptyUSKey = doGetProcAddress(libshlwapi, "SHRegDeleteEmptyUSKeyW") + sHRegDeleteUSValue = doGetProcAddress(libshlwapi, "SHRegDeleteUSValueW") + sHRegDuplicateHKey = doGetProcAddress(libshlwapi, "SHRegDuplicateHKey") + sHRegEnumUSKey = doGetProcAddress(libshlwapi, "SHRegEnumUSKeyW") + sHRegEnumUSValue = doGetProcAddress(libshlwapi, "SHRegEnumUSValueW") + sHRegGetBoolUSValue = doGetProcAddress(libshlwapi, "SHRegGetBoolUSValueW") + sHRegGetIntW = doGetProcAddress(libshlwapi, "SHRegGetIntW") + sHRegGetPath = doGetProcAddress(libshlwapi, "SHRegGetPathW") + sHRegGetUSValue = doGetProcAddress(libshlwapi, "SHRegGetUSValueW") + sHRegOpenUSKey = doGetProcAddress(libshlwapi, "SHRegOpenUSKeyW") + sHRegQueryInfoUSKey = doGetProcAddress(libshlwapi, "SHRegQueryInfoUSKeyW") + sHRegQueryUSValue = doGetProcAddress(libshlwapi, "SHRegQueryUSValueW") + sHRegSetPath = doGetProcAddress(libshlwapi, "SHRegSetPathW") + sHRegSetUSValue = doGetProcAddress(libshlwapi, "SHRegSetUSValueW") + sHRegWriteUSValue = doGetProcAddress(libshlwapi, "SHRegWriteUSValueW") + sHRegisterValidateTemplate = doGetProcAddress(libshlwapi, "SHRegisterValidateTemplate") + sHReleaseThreadRef = doGetProcAddress(libshlwapi, "SHReleaseThreadRef") + sHSendMessageBroadcast = doGetProcAddress(libshlwapi, "SHSendMessageBroadcastW") + sHSetThreadRef = doGetProcAddress(libshlwapi, "SHSetThreadRef") + sHSetValue = doGetProcAddress(libshlwapi, "SHSetValueW") + sHSkipJunction = doGetProcAddress(libshlwapi, "SHSkipJunction") + sHStrDup = doGetProcAddress(libshlwapi, "SHStrDupW") + sHStripMneumonic = doGetProcAddress(libshlwapi, "SHStripMneumonicW") + sHUnicodeToAnsi = doGetProcAddress(libshlwapi, "SHUnicodeToAnsi") + sHUnicodeToUnicode = doGetProcAddress(libshlwapi, "SHUnicodeToUnicode") + sHUnlockShared = doGetProcAddress(libshlwapi, "SHUnlockShared") + strCSpnI = doGetProcAddress(libshlwapi, "StrCSpnIW") + strCSpn = doGetProcAddress(libshlwapi, "StrCSpnW") + strCatBuff = doGetProcAddress(libshlwapi, "StrCatBuffW") + strCatChainW = doGetProcAddress(libshlwapi, "StrCatChainW") + strCatW = doGetProcAddress(libshlwapi, "StrCatW") + strChrI = doGetProcAddress(libshlwapi, "StrChrIW") + strChrNW = doGetProcAddress(libshlwapi, "StrChrNW") + strChr = doGetProcAddress(libshlwapi, "StrChrW") + strCmpC = doGetProcAddress(libshlwapi, "StrCmpCW") + strCmpIC = doGetProcAddress(libshlwapi, "StrCmpICW") + strCmpIW = doGetProcAddress(libshlwapi, "StrCmpIW") + strCmpLogicalW = doGetProcAddress(libshlwapi, "StrCmpLogicalW") + strCmpNC = doGetProcAddress(libshlwapi, "StrCmpNCW") + strCmpNIC = doGetProcAddress(libshlwapi, "StrCmpNICW") + strCmpNI = doGetProcAddress(libshlwapi, "StrCmpNIW") + strCmpN = doGetProcAddress(libshlwapi, "StrCmpNW") + strCmpW = doGetProcAddress(libshlwapi, "StrCmpW") + strCpyNW = doGetProcAddress(libshlwapi, "StrCpyNW") + strCpyW = doGetProcAddress(libshlwapi, "StrCpyW") + strDup = doGetProcAddress(libshlwapi, "StrDupW") + strFormatByteSize64A = doGetProcAddress(libshlwapi, "StrFormatByteSize64A") + strFormatByteSize = doGetProcAddress(libshlwapi, "StrFormatByteSizeW") + strFormatKBSize = doGetProcAddress(libshlwapi, "StrFormatKBSizeW") + strFromTimeInterval = doGetProcAddress(libshlwapi, "StrFromTimeIntervalW") + strIsIntlEqual = doGetProcAddress(libshlwapi, "StrIsIntlEqualW") + strNCat = doGetProcAddress(libshlwapi, "StrNCatW") + strPBrk = doGetProcAddress(libshlwapi, "StrPBrkW") + strRChrI = doGetProcAddress(libshlwapi, "StrRChrIW") + strRChr = doGetProcAddress(libshlwapi, "StrRChrW") + strRStrI = doGetProcAddress(libshlwapi, "StrRStrIW") + strRetToBSTR = doGetProcAddress(libshlwapi, "StrRetToBSTR") + strRetToBuf = doGetProcAddress(libshlwapi, "StrRetToBufW") + strRetToStr = doGetProcAddress(libshlwapi, "StrRetToStrW") + strSpn = doGetProcAddress(libshlwapi, "StrSpnW") + strStrI = doGetProcAddress(libshlwapi, "StrStrIW") + strStrNIW = doGetProcAddress(libshlwapi, "StrStrNIW") + strStrNW = doGetProcAddress(libshlwapi, "StrStrNW") + strStr = doGetProcAddress(libshlwapi, "StrStrW") + strToInt64Ex = doGetProcAddress(libshlwapi, "StrToInt64ExW") + strToIntEx = doGetProcAddress(libshlwapi, "StrToIntExW") + strToInt = doGetProcAddress(libshlwapi, "StrToIntW") + strTrim = doGetProcAddress(libshlwapi, "StrTrimW") + urlApplyScheme = doGetProcAddress(libshlwapi, "UrlApplySchemeW") + urlCanonicalize = doGetProcAddress(libshlwapi, "UrlCanonicalizeW") + urlCombine = doGetProcAddress(libshlwapi, "UrlCombineW") + urlCompare = doGetProcAddress(libshlwapi, "UrlCompareW") + urlCreateFromPath = doGetProcAddress(libshlwapi, "UrlCreateFromPathW") + urlEscape = doGetProcAddress(libshlwapi, "UrlEscapeW") + urlFixupW = doGetProcAddress(libshlwapi, "UrlFixupW") + urlGetLocation = doGetProcAddress(libshlwapi, "UrlGetLocationW") + urlGetPart = doGetProcAddress(libshlwapi, "UrlGetPartW") + urlHash = doGetProcAddress(libshlwapi, "UrlHashW") + urlIsNoHistory = doGetProcAddress(libshlwapi, "UrlIsNoHistoryW") + urlIsOpaque = doGetProcAddress(libshlwapi, "UrlIsOpaqueW") + urlIs = doGetProcAddress(libshlwapi, "UrlIsW") + urlUnescape = doGetProcAddress(libshlwapi, "UrlUnescapeW") + whichPlatform = doGetProcAddress(libshlwapi, "WhichPlatform") +} + +func AssocCreate(clsid CLSID, refiid REFIID, lpInterface uintptr) HRESULT { + ret1 := syscall6(assocCreate, 6, + uintptr(clsid.Data1), + uintptr((uint32(clsid.Data2)<<16)|uint32(clsid.Data3)), + uintptr((uint32(clsid.Data4[0])<<24)|(uint32(clsid.Data4[1]<<16))|(uint32(clsid.Data4[2]<<8))|uint32(clsid.Data4[3])), + uintptr((uint32(clsid.Data4[4])<<24)|(uint32(clsid.Data4[5]<<16))|(uint32(clsid.Data4[6]<<8))|uint32(clsid.Data4[7])), + uintptr(unsafe.Pointer(refiid)), + lpInterface) + return HRESULT(ret1) +} + +func AssocGetPerceivedType(lpszExt string, lpType *PERCEIVED, lpFlag *int32, lppszType *LPWSTR) HRESULT { + lpszExtStr := unicode16FromString(lpszExt) + ret1 := syscall6(assocGetPerceivedType, 4, + uintptr(unsafe.Pointer(&lpszExtStr[0])), + uintptr(unsafe.Pointer(lpType)), + uintptr(unsafe.Pointer(lpFlag)), + uintptr(unsafe.Pointer(lppszType)), + 0, + 0) + return HRESULT(ret1) +} + +func AssocIsDangerous(lpszAssoc string) bool { + lpszAssocStr := unicode16FromString(lpszAssoc) + ret1 := syscall3(assocIsDangerous, 1, + uintptr(unsafe.Pointer(&lpszAssocStr[0])), + 0, + 0) + return ret1 != 0 +} + +func AssocQueryKey(cfFlags ASSOCF, assockey ASSOCKEY, pszAssoc string, pszExtra string, phkeyOut *HKEY) HRESULT { + pszAssocStr := unicode16FromString(pszAssoc) + pszExtraStr := unicode16FromString(pszExtra) + ret1 := syscall6(assocQueryKey, 5, + uintptr(cfFlags), + uintptr(assockey), + uintptr(unsafe.Pointer(&pszAssocStr[0])), + uintptr(unsafe.Pointer(&pszExtraStr[0])), + uintptr(unsafe.Pointer(phkeyOut)), + 0) + return HRESULT(ret1) +} + +func AssocQueryStringByKey(cfFlags ASSOCF, str ASSOCSTR, hkAssoc HKEY, pszExtra string, pszOut LPWSTR, pcchOut *uint32) HRESULT { + pszExtraStr := unicode16FromString(pszExtra) + ret1 := syscall6(assocQueryStringByKey, 6, + uintptr(cfFlags), + uintptr(str), + uintptr(hkAssoc), + uintptr(unsafe.Pointer(&pszExtraStr[0])), + uintptr(unsafe.Pointer(pszOut)), + uintptr(unsafe.Pointer(pcchOut))) + return HRESULT(ret1) +} + +func AssocQueryString(cfFlags ASSOCF, str ASSOCSTR, pszAssoc string, pszExtra string, pszOut LPWSTR, pcchOut *uint32) HRESULT { + pszAssocStr := unicode16FromString(pszAssoc) + pszExtraStr := unicode16FromString(pszExtra) + ret1 := syscall6(assocQueryString, 6, + uintptr(cfFlags), + uintptr(str), + uintptr(unsafe.Pointer(&pszAssocStr[0])), + uintptr(unsafe.Pointer(&pszExtraStr[0])), + uintptr(unsafe.Pointer(pszOut)), + uintptr(unsafe.Pointer(pcchOut))) + return HRESULT(ret1) +} + +func ChrCmpI(ch1 WCHAR, ch2 WCHAR) bool { + ret1 := syscall3(chrCmpI, 2, + uintptr(ch1), + uintptr(ch2), + 0) + return ret1 != 0 +} + +func ColorAdjustLuma(cRGB COLORREF, dwLuma int32, bUnknown bool) COLORREF { + ret1 := syscall3(colorAdjustLuma, 3, + uintptr(cRGB), + uintptr(dwLuma), + getUintptrFromBool(bUnknown)) + return COLORREF(ret1) +} + +func ColorHLSToRGB(wHue WORD, wLuminosity WORD, wSaturation WORD) COLORREF { + ret1 := syscall3(colorHLSToRGB, 3, + uintptr(wHue), + uintptr(wLuminosity), + uintptr(wSaturation)) + return COLORREF(ret1) +} + +func ColorRGBToHLS(cRGB COLORREF, pwHue *uint16, pwLuminance *uint16, pwSaturation *uint16) { + syscall6(colorRGBToHLS, 4, + uintptr(cRGB), + uintptr(unsafe.Pointer(pwHue)), + uintptr(unsafe.Pointer(pwLuminance)), + uintptr(unsafe.Pointer(pwSaturation)), + 0, + 0) +} + +func ConnectToConnectionPoint(lpUnkSink *IUnknown, riid REFIID, fConnect bool, lpUnknown *IUnknown, lpCookie *uint32, lppCP **IConnectionPoint) HRESULT { + ret1 := syscall6(connectToConnectionPoint, 6, + uintptr(unsafe.Pointer(lpUnkSink)), + uintptr(unsafe.Pointer(riid)), + getUintptrFromBool(fConnect), + uintptr(unsafe.Pointer(lpUnknown)), + uintptr(unsafe.Pointer(lpCookie)), + uintptr(unsafe.Pointer(lppCP))) + return HRESULT(ret1) +} + +func GetAcceptLanguages(langbuf LPWSTR, buflen *uint32) HRESULT { + ret1 := syscall3(getAcceptLanguages, 2, + uintptr(unsafe.Pointer(langbuf)), + uintptr(unsafe.Pointer(buflen)), + 0) + return HRESULT(ret1) +} + +func GetMenuPosFromID(hMenu HMENU, wID UINT) INT { + ret1 := syscall3(getMenuPosFromID, 2, + uintptr(hMenu), + uintptr(wID), + 0) + return INT(ret1) +} + +func HashData(lpSrc /*const*/ *byte, nSrcLen DWORD, lpDest *byte, nDestLen DWORD) HRESULT { + ret1 := syscall6(hashData, 4, + uintptr(unsafe.Pointer(lpSrc)), + uintptr(nSrcLen), + uintptr(unsafe.Pointer(lpDest)), + uintptr(nDestLen), + 0, + 0) + return HRESULT(ret1) +} + +func IStream_Reset(lpStream *IStream) HRESULT { + ret1 := syscall3(iStream_Reset, 1, + uintptr(unsafe.Pointer(lpStream)), + 0, + 0) + return HRESULT(ret1) +} + +func IStream_Size(lpStream *IStream, lpulSize *ULARGE_INTEGER) HRESULT { + ret1 := syscall3(iStream_Size, 2, + uintptr(unsafe.Pointer(lpStream)), + uintptr(unsafe.Pointer(lpulSize)), + 0) + return HRESULT(ret1) +} + +func IUnknown_AtomicRelease(lpUnknown **IUnknown) { + syscall3(iUnknown_AtomicRelease, 1, + uintptr(unsafe.Pointer(lpUnknown)), + 0, + 0) +} + +func IUnknown_GetSite(lpUnknown LPUNKNOWN, iid REFIID, lppSite *PVOID) HRESULT { + ret1 := syscall3(iUnknown_GetSite, 3, + uintptr(unsafe.Pointer(lpUnknown)), + uintptr(unsafe.Pointer(iid)), + uintptr(unsafe.Pointer(lppSite))) + return HRESULT(ret1) +} + +func IUnknown_GetWindow(lpUnknown *IUnknown, lphWnd *HWND) HRESULT { + ret1 := syscall3(iUnknown_GetWindow, 2, + uintptr(unsafe.Pointer(lpUnknown)), + uintptr(unsafe.Pointer(lphWnd)), + 0) + return HRESULT(ret1) +} + +func IUnknown_QueryService(unnamed0 *IUnknown, unnamed1 REFGUID, unnamed2 REFIID, unnamed3 *LPVOID) HRESULT { + ret1 := syscall6(iUnknown_QueryService, 4, + uintptr(unsafe.Pointer(unnamed0)), + uintptr(unsafe.Pointer(unnamed1)), + uintptr(unsafe.Pointer(unnamed2)), + uintptr(unsafe.Pointer(unnamed3)), + 0, + 0) + return HRESULT(ret1) +} + +func IUnknown_Set(lppDest **IUnknown, lpUnknown *IUnknown) { + syscall3(iUnknown_Set, 2, + uintptr(unsafe.Pointer(lppDest)), + uintptr(unsafe.Pointer(lpUnknown)), + 0) +} + +func IUnknown_SetSite(obj *IUnknown, site *IUnknown) HRESULT { + ret1 := syscall3(iUnknown_SetSite, 2, + uintptr(unsafe.Pointer(obj)), + uintptr(unsafe.Pointer(site)), + 0) + return HRESULT(ret1) +} + +func IntlStrEqWorker(bCase bool, lpszStr string, lpszComp string, iLen int32) bool { + lpszStrStr := unicode16FromString(lpszStr) + lpszCompStr := unicode16FromString(lpszComp) + ret1 := syscall6(intlStrEqWorker, 4, + getUintptrFromBool(bCase), + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszCompStr[0])), + uintptr(iLen), + 0, + 0) + return ret1 != 0 +} + +func IsCharSpace(wc WCHAR) bool { + ret1 := syscall3(isCharSpace, 1, + uintptr(wc), + 0, + 0) + return ret1 != 0 +} + +func IsInternetESCEnabled() bool { + ret1 := syscall3(isInternetESCEnabled, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func IsOS(feature DWORD) bool { + ret1 := syscall3(isOS, 1, + uintptr(feature), + 0, + 0) + return ret1 != 0 +} + +func MLFreeLibrary(hModule HMODULE) bool { + ret1 := syscall3(mLFreeLibrary, 1, + uintptr(hModule), + 0, + 0) + return ret1 != 0 +} + +func MLLoadLibrary(new_mod string, inst_hwnd HMODULE, dwCrossCodePage DWORD) HMODULE { + new_modStr := unicode16FromString(new_mod) + ret1 := syscall3(mLLoadLibrary, 3, + uintptr(unsafe.Pointer(&new_modStr[0])), + uintptr(inst_hwnd), + uintptr(dwCrossCodePage)) + return HMODULE(ret1) +} + +func ParseURL(x string, y *PARSEDURL) HRESULT { + xStr := unicode16FromString(x) + ret1 := syscall3(parseURL, 2, + uintptr(unsafe.Pointer(&xStr[0])), + uintptr(unsafe.Pointer(y)), + 0) + return HRESULT(ret1) +} + +func PathAddBackslash(lpszPath LPWSTR) LPWSTR { + ret1 := syscall3(pathAddBackslash, 1, + uintptr(unsafe.Pointer(lpszPath)), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func PathAddExtension(lpszPath LPWSTR, lpszExtension string) bool { + lpszExtensionStr := unicode16FromString(lpszExtension) + ret1 := syscall3(pathAddExtension, 2, + uintptr(unsafe.Pointer(lpszPath)), + uintptr(unsafe.Pointer(&lpszExtensionStr[0])), + 0) + return ret1 != 0 +} + +func PathAppend(lpszPath LPWSTR, lpszAppend string) bool { + lpszAppendStr := unicode16FromString(lpszAppend) + ret1 := syscall3(pathAppend, 2, + uintptr(unsafe.Pointer(lpszPath)), + uintptr(unsafe.Pointer(&lpszAppendStr[0])), + 0) + return ret1 != 0 +} + +func PathBuildRoot(lpszPath LPWSTR, drive int32) LPWSTR { + ret1 := syscall3(pathBuildRoot, 2, + uintptr(unsafe.Pointer(lpszPath)), + uintptr(drive), + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func PathCanonicalize(lpszBuf LPWSTR, lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathCanonicalize, 2, + uintptr(unsafe.Pointer(lpszBuf)), + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0) + return ret1 != 0 +} + +func PathCombine(lpszDest LPWSTR, lpszDir string, lpszFile string) LPWSTR { + lpszDirStr := unicode16FromString(lpszDir) + lpszFileStr := unicode16FromString(lpszFile) + ret1 := syscall3(pathCombine, 3, + uintptr(unsafe.Pointer(lpszDest)), + uintptr(unsafe.Pointer(&lpszDirStr[0])), + uintptr(unsafe.Pointer(&lpszFileStr[0]))) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func PathCommonPrefix(lpszFile1 string, lpszFile2 string, achPath LPWSTR) int32 { + lpszFile1Str := unicode16FromString(lpszFile1) + lpszFile2Str := unicode16FromString(lpszFile2) + ret1 := syscall3(pathCommonPrefix, 3, + uintptr(unsafe.Pointer(&lpszFile1Str[0])), + uintptr(unsafe.Pointer(&lpszFile2Str[0])), + uintptr(unsafe.Pointer(achPath))) + return int32(ret1) +} + +func PathCompactPathEx(lpszDest LPWSTR, lpszPath string, cchMax UINT, dwFlags DWORD) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall6(pathCompactPathEx, 4, + uintptr(unsafe.Pointer(lpszDest)), + uintptr(unsafe.Pointer(&lpszPathStr[0])), + uintptr(cchMax), + uintptr(dwFlags), + 0, + 0) + return ret1 != 0 +} + +func PathCompactPath(hDC HDC, lpszPath LPWSTR, dx UINT) bool { + ret1 := syscall3(pathCompactPath, 3, + uintptr(hDC), + uintptr(unsafe.Pointer(lpszPath)), + uintptr(dx)) + return ret1 != 0 +} + +func PathCreateFromUrlAlloc(pszUrl string, pszPath *LPWSTR, dwReserved DWORD) HRESULT { + pszUrlStr := unicode16FromString(pszUrl) + ret1 := syscall3(pathCreateFromUrlAlloc, 3, + uintptr(unsafe.Pointer(&pszUrlStr[0])), + uintptr(unsafe.Pointer(pszPath)), + uintptr(dwReserved)) + return HRESULT(ret1) +} + +func PathCreateFromUrl(pszUrl string, pszPath LPWSTR, pcchPath *uint32, dwReserved DWORD) HRESULT { + pszUrlStr := unicode16FromString(pszUrl) + ret1 := syscall6(pathCreateFromUrl, 4, + uintptr(unsafe.Pointer(&pszUrlStr[0])), + uintptr(unsafe.Pointer(pszPath)), + uintptr(unsafe.Pointer(pcchPath)), + uintptr(dwReserved), + 0, + 0) + return HRESULT(ret1) +} + +func PathFileExists(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathFileExists, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathFindExtension(lpszPath string) LPWSTR { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathFindExtension, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func PathFindFileName(lpszPath string) LPWSTR { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathFindFileName, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func PathFindNextComponent(lpszPath string) LPWSTR { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathFindNextComponent, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func PathFindOnPath(lpszFile LPWSTR, lppszOtherDirs *LPCWSTR) bool { + ret1 := syscall3(pathFindOnPath, 2, + uintptr(unsafe.Pointer(lpszFile)), + uintptr(unsafe.Pointer(lppszOtherDirs)), + 0) + return ret1 != 0 +} + +func PathFindSuffixArray(lpszSuffix string, lppszArray *LPCWSTR, dwCount int32) string { + lpszSuffixStr := unicode16FromString(lpszSuffix) + ret1 := syscall3(pathFindSuffixArray, 3, + uintptr(unsafe.Pointer(&lpszSuffixStr[0])), + uintptr(unsafe.Pointer(lppszArray)), + uintptr(dwCount)) + return stringFromUnicode16((*uint16)(unsafe.Pointer(ret1))) +} + +func PathGetArgs(lpszPath string) LPWSTR { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathGetArgs, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func PathGetCharType(ch WCHAR) UINT { + ret1 := syscall3(pathGetCharType, 1, + uintptr(ch), + 0, + 0) + return UINT(ret1) +} + +func PathGetDriveNumber(lpszPath string) int32 { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathGetDriveNumber, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return int32(ret1) +} + +func PathIsContentType(lpszPath string, lpszContentType string) bool { + lpszPathStr := unicode16FromString(lpszPath) + lpszContentTypeStr := unicode16FromString(lpszContentType) + ret1 := syscall3(pathIsContentType, 2, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + uintptr(unsafe.Pointer(&lpszContentTypeStr[0])), + 0) + return ret1 != 0 +} + +func PathIsDirectoryEmpty(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathIsDirectoryEmpty, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathIsDirectory(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathIsDirectory, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathIsFileSpec(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathIsFileSpec, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathIsLFNFileSpec(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathIsLFNFileSpec, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathIsNetworkPath(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathIsNetworkPath, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathIsPrefix(lpszPrefix string, lpszPath string) bool { + lpszPrefixStr := unicode16FromString(lpszPrefix) + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathIsPrefix, 2, + uintptr(unsafe.Pointer(&lpszPrefixStr[0])), + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0) + return ret1 != 0 +} + +func PathIsRelative(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathIsRelative, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathIsRoot(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathIsRoot, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathIsSameRoot(lpszPath1 string, lpszPath2 string) bool { + lpszPath1Str := unicode16FromString(lpszPath1) + lpszPath2Str := unicode16FromString(lpszPath2) + ret1 := syscall3(pathIsSameRoot, 2, + uintptr(unsafe.Pointer(&lpszPath1Str[0])), + uintptr(unsafe.Pointer(&lpszPath2Str[0])), + 0) + return ret1 != 0 +} + +func PathIsSystemFolder(lpszPath string, dwAttrib DWORD) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathIsSystemFolder, 2, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + uintptr(dwAttrib), + 0) + return ret1 != 0 +} + +func PathIsUNCServerShare(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathIsUNCServerShare, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathIsUNCServer(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathIsUNCServer, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathIsUNC(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathIsUNC, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathIsURL(lpstrPath string) bool { + lpstrPathStr := unicode16FromString(lpstrPath) + ret1 := syscall3(pathIsURL, 1, + uintptr(unsafe.Pointer(&lpstrPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathMakePretty(lpszPath LPWSTR) bool { + ret1 := syscall3(pathMakePretty, 1, + uintptr(unsafe.Pointer(lpszPath)), + 0, + 0) + return ret1 != 0 +} + +func PathMakeSystemFolder(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathMakeSystemFolder, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathMatchSpec(lpszPath string, lpszMask string) bool { + lpszPathStr := unicode16FromString(lpszPath) + lpszMaskStr := unicode16FromString(lpszMask) + ret1 := syscall3(pathMatchSpec, 2, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + uintptr(unsafe.Pointer(&lpszMaskStr[0])), + 0) + return ret1 != 0 +} + +func PathParseIconLocation(lpszPath LPWSTR) int32 { + ret1 := syscall3(pathParseIconLocation, 1, + uintptr(unsafe.Pointer(lpszPath)), + 0, + 0) + return int32(ret1) +} + +func PathQuoteSpaces(lpszPath LPWSTR) { + syscall3(pathQuoteSpaces, 1, + uintptr(unsafe.Pointer(lpszPath)), + 0, + 0) +} + +func PathRelativePathTo(lpszPath LPWSTR, lpszFrom string, dwAttrFrom DWORD, lpszTo string, dwAttrTo DWORD) bool { + lpszFromStr := unicode16FromString(lpszFrom) + lpszToStr := unicode16FromString(lpszTo) + ret1 := syscall6(pathRelativePathTo, 5, + uintptr(unsafe.Pointer(lpszPath)), + uintptr(unsafe.Pointer(&lpszFromStr[0])), + uintptr(dwAttrFrom), + uintptr(unsafe.Pointer(&lpszToStr[0])), + uintptr(dwAttrTo), + 0) + return ret1 != 0 +} + +func PathRemoveArgs(lpszPath LPWSTR) { + syscall3(pathRemoveArgs, 1, + uintptr(unsafe.Pointer(lpszPath)), + 0, + 0) +} + +func PathRemoveBackslash(lpszPath LPWSTR) LPWSTR { + ret1 := syscall3(pathRemoveBackslash, 1, + uintptr(unsafe.Pointer(lpszPath)), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func PathRemoveBlanks(lpszPath LPWSTR) { + syscall3(pathRemoveBlanks, 1, + uintptr(unsafe.Pointer(lpszPath)), + 0, + 0) +} + +func PathRemoveExtension(lpszPath LPWSTR) { + syscall3(pathRemoveExtension, 1, + uintptr(unsafe.Pointer(lpszPath)), + 0, + 0) +} + +func PathRemoveFileSpec(lpszPath LPWSTR) bool { + ret1 := syscall3(pathRemoveFileSpec, 1, + uintptr(unsafe.Pointer(lpszPath)), + 0, + 0) + return ret1 != 0 +} + +func PathRenameExtension(lpszPath LPWSTR, lpszExt string) bool { + lpszExtStr := unicode16FromString(lpszExt) + ret1 := syscall3(pathRenameExtension, 2, + uintptr(unsafe.Pointer(lpszPath)), + uintptr(unsafe.Pointer(&lpszExtStr[0])), + 0) + return ret1 != 0 +} + +func PathSearchAndQualify(lpszPath string, lpszBuf LPWSTR, cchBuf UINT) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathSearchAndQualify, 3, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + uintptr(unsafe.Pointer(lpszBuf)), + uintptr(cchBuf)) + return ret1 != 0 +} + +func PathSetDlgItemPath(hDlg HWND, id int32, lpszPath string) { + lpszPathStr := unicode16FromString(lpszPath) + syscall3(pathSetDlgItemPath, 3, + uintptr(hDlg), + uintptr(id), + uintptr(unsafe.Pointer(&lpszPathStr[0]))) +} + +func PathSkipRoot(lpszPath string) LPWSTR { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathSkipRoot, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func PathStripPath(lpszPath LPWSTR) { + syscall3(pathStripPath, 1, + uintptr(unsafe.Pointer(lpszPath)), + 0, + 0) +} + +func PathStripToRoot(lpszPath LPWSTR) bool { + ret1 := syscall3(pathStripToRoot, 1, + uintptr(unsafe.Pointer(lpszPath)), + 0, + 0) + return ret1 != 0 +} + +func PathUnExpandEnvStrings(path string, buffer LPWSTR, buf_len UINT) bool { + pathStr := unicode16FromString(path) + ret1 := syscall3(pathUnExpandEnvStrings, 3, + uintptr(unsafe.Pointer(&pathStr[0])), + uintptr(unsafe.Pointer(buffer)), + uintptr(buf_len)) + return ret1 != 0 +} + +func PathUndecorate(lpszPath LPWSTR) { + syscall3(pathUndecorate, 1, + uintptr(unsafe.Pointer(lpszPath)), + 0, + 0) +} + +func PathUnmakeSystemFolder(lpszPath string) bool { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(pathUnmakeSystemFolder, 1, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + 0, + 0) + return ret1 != 0 +} + +func PathUnquoteSpaces(lpszPath LPWSTR) { + syscall3(pathUnquoteSpaces, 1, + uintptr(unsafe.Pointer(lpszPath)), + 0, + 0) +} + +func QISearch(base uintptr, table /*const*/ *QITAB, riid REFIID, ppv uintptr) HRESULT { + ret1 := syscall6(qISearch, 4, + base, + uintptr(unsafe.Pointer(table)), + uintptr(unsafe.Pointer(riid)), + ppv, + 0, + 0) + return HRESULT(ret1) +} + +func SHAllocShared(lpvData LPVOID, dwSize DWORD, dwProcId DWORD) HANDLE { + ret1 := syscall3(sHAllocShared, 3, + uintptr(unsafe.Pointer(lpvData)), + uintptr(dwSize), + uintptr(dwProcId)) + return HANDLE(ret1) +} + +func SHAnsiToAnsi(lpszSrc /*const*/ LPCSTR, lpszDst LPSTR, iLen int32) DWORD { + ret1 := syscall3(sHAnsiToAnsi, 3, + uintptr(unsafe.Pointer(lpszSrc)), + uintptr(unsafe.Pointer(lpszDst)), + uintptr(iLen)) + return DWORD(ret1) +} + +func SHAnsiToUnicode(lpSrcStr /*const*/ LPCSTR, lpDstStr LPWSTR, iLen int32) DWORD { + ret1 := syscall3(sHAnsiToUnicode, 3, + uintptr(unsafe.Pointer(lpSrcStr)), + uintptr(unsafe.Pointer(lpDstStr)), + uintptr(iLen)) + return DWORD(ret1) +} + +func SHAutoComplete(hwndEdit HWND, dwFlags DWORD) HRESULT { + ret1 := syscall3(sHAutoComplete, 2, + uintptr(hwndEdit), + uintptr(dwFlags), + 0) + return HRESULT(ret1) +} + +func SHCopyKey(hKeySrc HKEY, lpszSrcSubKey string, hKeyDst HKEY, dwReserved DWORD) DWORD { + lpszSrcSubKeyStr := unicode16FromString(lpszSrcSubKey) + ret1 := syscall6(sHCopyKey, 4, + uintptr(hKeySrc), + uintptr(unsafe.Pointer(&lpszSrcSubKeyStr[0])), + uintptr(hKeyDst), + uintptr(dwReserved), + 0, + 0) + return DWORD(ret1) +} + +func SHCreateShellPalette(hdc HDC) HPALETTE { + ret1 := syscall3(sHCreateShellPalette, 1, + uintptr(hdc), + 0, + 0) + return HPALETTE(ret1) +} + +func SHCreateStreamOnFileEx(lpszPath string, dwMode DWORD, dwAttributes DWORD, bCreate bool, lpTemplate *IStream, lppStream **IStream) HRESULT { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall6(sHCreateStreamOnFileEx, 6, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + uintptr(dwMode), + uintptr(dwAttributes), + getUintptrFromBool(bCreate), + uintptr(unsafe.Pointer(lpTemplate)), + uintptr(unsafe.Pointer(lppStream))) + return HRESULT(ret1) +} + +func SHCreateStreamOnFile(lpszPath string, dwMode DWORD, lppStream **IStream) HRESULT { + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall3(sHCreateStreamOnFile, 3, + uintptr(unsafe.Pointer(&lpszPathStr[0])), + uintptr(dwMode), + uintptr(unsafe.Pointer(lppStream))) + return HRESULT(ret1) +} + +func SHCreateStreamWrapper(lpbData *byte, dwDataLen DWORD, dwReserved DWORD, lppStream **IStream) HRESULT { + ret1 := syscall6(sHCreateStreamWrapper, 4, + uintptr(unsafe.Pointer(lpbData)), + uintptr(dwDataLen), + uintptr(dwReserved), + uintptr(unsafe.Pointer(lppStream)), + 0, + 0) + return HRESULT(ret1) +} + +func SHCreateThread(pfnThreadProc THREAD_START_ROUTINE, pData uintptr, dwFlags DWORD, pfnCallback THREAD_START_ROUTINE) bool { + pfnThreadProcCallback := syscall.NewCallback(func(lpThreadParameterRawArg LPVOID) uintptr { + ret := pfnThreadProc(lpThreadParameterRawArg) + return uintptr(ret) + }) + pfnCallbackCallback := syscall.NewCallback(func(lpThreadParameterRawArg LPVOID) uintptr { + ret := pfnCallback(lpThreadParameterRawArg) + return uintptr(ret) + }) + ret1 := syscall6(sHCreateThread, 4, + pfnThreadProcCallback, + pData, + uintptr(dwFlags), + pfnCallbackCallback, + 0, + 0) + return ret1 != 0 +} + +func SHCreateThreadRef(lprefcount *LONG, lppUnknown **IUnknown) HRESULT { + ret1 := syscall3(sHCreateThreadRef, 2, + uintptr(unsafe.Pointer(lprefcount)), + uintptr(unsafe.Pointer(lppUnknown)), + 0) + return HRESULT(ret1) +} + +func SHDeleteEmptyKey(hKey HKEY, lpszSubKey string) DWORD { + lpszSubKeyStr := unicode16FromString(lpszSubKey) + ret1 := syscall3(sHDeleteEmptyKey, 2, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpszSubKeyStr[0])), + 0) + return DWORD(ret1) +} + +func SHDeleteKey(hKey HKEY, lpszSubKey string) DWORD { + lpszSubKeyStr := unicode16FromString(lpszSubKey) + ret1 := syscall3(sHDeleteKey, 2, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpszSubKeyStr[0])), + 0) + return DWORD(ret1) +} + +func SHDeleteOrphanKey(hKey HKEY, lpszSubKey string) DWORD { + lpszSubKeyStr := unicode16FromString(lpszSubKey) + ret1 := syscall3(sHDeleteOrphanKey, 2, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpszSubKeyStr[0])), + 0) + return DWORD(ret1) +} + +func SHDeleteValue(hKey HKEY, lpszSubKey string, lpszValue string) DWORD { + lpszSubKeyStr := unicode16FromString(lpszSubKey) + lpszValueStr := unicode16FromString(lpszValue) + ret1 := syscall3(sHDeleteValue, 3, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpszSubKeyStr[0])), + uintptr(unsafe.Pointer(&lpszValueStr[0]))) + return DWORD(ret1) +} + +func SHEnumKeyEx(hKey HKEY, dwIndex DWORD, lpszSubKey LPWSTR, pwLen *uint32) LONG { + ret1 := syscall6(sHEnumKeyEx, 4, + uintptr(hKey), + uintptr(dwIndex), + uintptr(unsafe.Pointer(lpszSubKey)), + uintptr(unsafe.Pointer(pwLen)), + 0, + 0) + return LONG(ret1) +} + +func SHEnumValue(hKey HKEY, dwIndex DWORD, lpszValue LPWSTR, pwLen *uint32, pwType *uint32, pvData LPVOID, pcbData *uint32) LONG { + ret1 := syscall9(sHEnumValue, 7, + uintptr(hKey), + uintptr(dwIndex), + uintptr(unsafe.Pointer(lpszValue)), + uintptr(unsafe.Pointer(pwLen)), + uintptr(unsafe.Pointer(pwType)), + uintptr(unsafe.Pointer(pvData)), + uintptr(unsafe.Pointer(pcbData)), + 0, + 0) + return LONG(ret1) +} + +func SHFormatDateTime(fileTime /*const*/ *FILETIME, flags *uint32, buf LPWSTR, size UINT) INT { + ret1 := syscall6(sHFormatDateTime, 4, + uintptr(unsafe.Pointer(fileTime)), + uintptr(unsafe.Pointer(flags)), + uintptr(unsafe.Pointer(buf)), + uintptr(size), + 0, + 0) + return INT(ret1) +} + +func SHFreeShared(hShared HANDLE, dwProcId DWORD) bool { + ret1 := syscall3(sHFreeShared, 2, + uintptr(hShared), + uintptr(dwProcId), + 0) + return ret1 != 0 +} + +func SHGetInverseCMAP(dest *uint32, dwSize DWORD) HRESULT { + ret1 := syscall3(sHGetInverseCMAP, 2, + uintptr(unsafe.Pointer(dest)), + uintptr(dwSize), + 0) + return HRESULT(ret1) +} + +func SHGetThreadRef(lppUnknown **IUnknown) HRESULT { + ret1 := syscall3(sHGetThreadRef, 1, + uintptr(unsafe.Pointer(lppUnknown)), + 0, + 0) + return HRESULT(ret1) +} + +func SHGetValue(hKey HKEY, lpszSubKey string, lpszValue string, pwType *uint32, pvData LPVOID, pcbData *uint32) DWORD { + lpszSubKeyStr := unicode16FromString(lpszSubKey) + lpszValueStr := unicode16FromString(lpszValue) + ret1 := syscall6(sHGetValue, 6, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpszSubKeyStr[0])), + uintptr(unsafe.Pointer(&lpszValueStr[0])), + uintptr(unsafe.Pointer(pwType)), + uintptr(unsafe.Pointer(pvData)), + uintptr(unsafe.Pointer(pcbData))) + return DWORD(ret1) +} + +func SHGetViewStatePropertyBag(pidl /*const*/ LPCITEMIDLIST, bag_name LPWSTR, flags DWORD, riid REFIID, ppv uintptr) HRESULT { + ret1 := syscall6(sHGetViewStatePropertyBag, 5, + uintptr(unsafe.Pointer(pidl)), + uintptr(unsafe.Pointer(bag_name)), + uintptr(flags), + uintptr(unsafe.Pointer(riid)), + ppv, + 0) + return HRESULT(ret1) +} + +func SHIsChildOrSelf(hParent HWND, hChild HWND) bool { + ret1 := syscall3(sHIsChildOrSelf, 2, + uintptr(hParent), + uintptr(hChild), + 0) + return ret1 != 0 +} + +func SHIsLowMemoryMachine(x DWORD) bool { + ret1 := syscall3(sHIsLowMemoryMachine, 1, + uintptr(x), + 0, + 0) + return ret1 != 0 +} + +func SHLoadIndirectString(src string, dst LPWSTR, dst_len UINT, reserved uintptr) HRESULT { + srcStr := unicode16FromString(src) + ret1 := syscall6(sHLoadIndirectString, 4, + uintptr(unsafe.Pointer(&srcStr[0])), + uintptr(unsafe.Pointer(dst)), + uintptr(dst_len), + reserved, + 0, + 0) + return HRESULT(ret1) +} + +func SHLockShared(hShared HANDLE, dwProcId DWORD) LPVOID { + ret1 := syscall3(sHLockShared, 2, + uintptr(hShared), + uintptr(dwProcId), + 0) + return (LPVOID)(unsafe.Pointer(ret1)) +} + +func SHMessageBoxCheck(unnamed0 HWND, unnamed1 string, unnamed2 string, unnamed3 DWORD, unnamed4 INT_PTR, unnamed5 string) INT_PTR { + unnamed1Str := unicode16FromString(unnamed1) + unnamed2Str := unicode16FromString(unnamed2) + unnamed5Str := unicode16FromString(unnamed5) + ret1 := syscall6(sHMessageBoxCheck, 6, + uintptr(unnamed0), + uintptr(unsafe.Pointer(&unnamed1Str[0])), + uintptr(unsafe.Pointer(&unnamed2Str[0])), + uintptr(unnamed3), + uintptr(unsafe.Pointer(unnamed4)), + uintptr(unsafe.Pointer(&unnamed5Str[0]))) + return (INT_PTR)(unsafe.Pointer(ret1)) +} + +func SHQueryInfoKey(hKey HKEY, pwSubKeys *uint32, pwSubKeyMax *uint32, pwValues *uint32, pwValueMax *uint32) LONG { + ret1 := syscall6(sHQueryInfoKey, 5, + uintptr(hKey), + uintptr(unsafe.Pointer(pwSubKeys)), + uintptr(unsafe.Pointer(pwSubKeyMax)), + uintptr(unsafe.Pointer(pwValues)), + uintptr(unsafe.Pointer(pwValueMax)), + 0) + return LONG(ret1) +} + +func SHQueryValueEx(hKey HKEY, lpszValue string, lpReserved *uint32, pwType *uint32, pvData LPVOID, pcbData *uint32) DWORD { + lpszValueStr := unicode16FromString(lpszValue) + ret1 := syscall6(sHQueryValueEx, 6, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpszValueStr[0])), + uintptr(unsafe.Pointer(lpReserved)), + uintptr(unsafe.Pointer(pwType)), + uintptr(unsafe.Pointer(pvData)), + uintptr(unsafe.Pointer(pcbData))) + return DWORD(ret1) +} + +func SHRegCloseUSKey(hUSKey HUSKEY) LONG { + ret1 := syscall3(sHRegCloseUSKey, 1, + uintptr(hUSKey), + 0, + 0) + return LONG(ret1) +} + +func SHRegCreateUSKey(path string, samDesired REGSAM, relative_key HUSKEY, new_uskey PHUSKEY, flags DWORD) LONG { + pathStr := unicode16FromString(path) + ret1 := syscall6(sHRegCreateUSKey, 5, + uintptr(unsafe.Pointer(&pathStr[0])), + uintptr(samDesired), + uintptr(relative_key), + uintptr(unsafe.Pointer(new_uskey)), + uintptr(flags), + 0) + return LONG(ret1) +} + +func SHRegDeleteEmptyUSKey(hUSKey HUSKEY, pszValue string, delRegFlags SHREGDEL_FLAGS) LONG { + pszValueStr := unicode16FromString(pszValue) + ret1 := syscall3(sHRegDeleteEmptyUSKey, 3, + uintptr(hUSKey), + uintptr(unsafe.Pointer(&pszValueStr[0])), + uintptr(delRegFlags)) + return LONG(ret1) +} + +func SHRegDeleteUSValue(hUSKey HUSKEY, pszValue string, delRegFlags SHREGDEL_FLAGS) LONG { + pszValueStr := unicode16FromString(pszValue) + ret1 := syscall3(sHRegDeleteUSValue, 3, + uintptr(hUSKey), + uintptr(unsafe.Pointer(&pszValueStr[0])), + uintptr(delRegFlags)) + return LONG(ret1) +} + +func SHRegDuplicateHKey(hKey HKEY) HKEY { + ret1 := syscall3(sHRegDuplicateHKey, 1, + uintptr(hKey), + 0, + 0) + return HKEY(ret1) +} + +func SHRegEnumUSKey(hUSKey HUSKEY, dwIndex DWORD, pszName LPWSTR, pcchValueNameLen *uint32, enumRegFlags SHREGENUM_FLAGS) LONG { + ret1 := syscall6(sHRegEnumUSKey, 5, + uintptr(hUSKey), + uintptr(dwIndex), + uintptr(unsafe.Pointer(pszName)), + uintptr(unsafe.Pointer(pcchValueNameLen)), + uintptr(enumRegFlags), + 0) + return LONG(ret1) +} + +func SHRegEnumUSValue(hUSKey HUSKEY, dwIndex DWORD, pszValueName LPWSTR, pcchValueNameLen *uint32, pdwType *uint32, pvData LPVOID, pcbData *uint32, enumRegFlags SHREGENUM_FLAGS) LONG { + ret1 := syscall9(sHRegEnumUSValue, 8, + uintptr(hUSKey), + uintptr(dwIndex), + uintptr(unsafe.Pointer(pszValueName)), + uintptr(unsafe.Pointer(pcchValueNameLen)), + uintptr(unsafe.Pointer(pdwType)), + uintptr(unsafe.Pointer(pvData)), + uintptr(unsafe.Pointer(pcbData)), + uintptr(enumRegFlags), + 0) + return LONG(ret1) +} + +func SHRegGetBoolUSValue(pszSubKey string, pszValue string, fIgnoreHKCU bool, fDefault bool) bool { + pszSubKeyStr := unicode16FromString(pszSubKey) + pszValueStr := unicode16FromString(pszValue) + ret1 := syscall6(sHRegGetBoolUSValue, 4, + uintptr(unsafe.Pointer(&pszSubKeyStr[0])), + uintptr(unsafe.Pointer(&pszValueStr[0])), + getUintptrFromBool(fIgnoreHKCU), + getUintptrFromBool(fDefault), + 0, + 0) + return ret1 != 0 +} + +func SHRegGetIntW(hKey HKEY, lpszValue string, iDefault int32) int32 { + lpszValueStr := unicode16FromString(lpszValue) + ret1 := syscall3(sHRegGetIntW, 3, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpszValueStr[0])), + uintptr(iDefault)) + return int32(ret1) +} + +func SHRegGetPath(hKey HKEY, lpszSubKey string, lpszValue string, lpszPath LPWSTR, dwFlags DWORD) DWORD { + lpszSubKeyStr := unicode16FromString(lpszSubKey) + lpszValueStr := unicode16FromString(lpszValue) + ret1 := syscall6(sHRegGetPath, 5, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpszSubKeyStr[0])), + uintptr(unsafe.Pointer(&lpszValueStr[0])), + uintptr(unsafe.Pointer(lpszPath)), + uintptr(dwFlags), + 0) + return DWORD(ret1) +} + +func SHRegGetUSValue(pSubKey string, pValue string, pwType *uint32, pvData LPVOID, pcbData *uint32, flagIgnoreHKCU bool, pDefaultData LPVOID, wDefaultDataSize DWORD) LONG { + pSubKeyStr := unicode16FromString(pSubKey) + pValueStr := unicode16FromString(pValue) + ret1 := syscall9(sHRegGetUSValue, 8, + uintptr(unsafe.Pointer(&pSubKeyStr[0])), + uintptr(unsafe.Pointer(&pValueStr[0])), + uintptr(unsafe.Pointer(pwType)), + uintptr(unsafe.Pointer(pvData)), + uintptr(unsafe.Pointer(pcbData)), + getUintptrFromBool(flagIgnoreHKCU), + uintptr(unsafe.Pointer(pDefaultData)), + uintptr(wDefaultDataSize), + 0) + return LONG(ret1) +} + +func SHRegOpenUSKey(path string, accessType REGSAM, hRelativeUSKey HUSKEY, phNewUSKey PHUSKEY, fIgnoreHKCU bool) LONG { + pathStr := unicode16FromString(path) + ret1 := syscall6(sHRegOpenUSKey, 5, + uintptr(unsafe.Pointer(&pathStr[0])), + uintptr(accessType), + uintptr(hRelativeUSKey), + uintptr(unsafe.Pointer(phNewUSKey)), + getUintptrFromBool(fIgnoreHKCU), + 0) + return LONG(ret1) +} + +func SHRegQueryInfoUSKey(hUSKey HUSKEY, pcSubKeys *uint32, pcchMaxSubKeyLen *uint32, pcValues *uint32, pcchMaxValueNameLen *uint32, enumRegFlags SHREGENUM_FLAGS) LONG { + ret1 := syscall6(sHRegQueryInfoUSKey, 6, + uintptr(hUSKey), + uintptr(unsafe.Pointer(pcSubKeys)), + uintptr(unsafe.Pointer(pcchMaxSubKeyLen)), + uintptr(unsafe.Pointer(pcValues)), + uintptr(unsafe.Pointer(pcchMaxValueNameLen)), + uintptr(enumRegFlags)) + return LONG(ret1) +} + +func SHRegQueryUSValue(hUSKey HUSKEY, pszValue string, pdwType *uint32, pvData LPVOID, pcbData *uint32, fIgnoreHKCU bool, pvDefaultData LPVOID, dwDefaultDataSize DWORD) LONG { + pszValueStr := unicode16FromString(pszValue) + ret1 := syscall9(sHRegQueryUSValue, 8, + uintptr(hUSKey), + uintptr(unsafe.Pointer(&pszValueStr[0])), + uintptr(unsafe.Pointer(pdwType)), + uintptr(unsafe.Pointer(pvData)), + uintptr(unsafe.Pointer(pcbData)), + getUintptrFromBool(fIgnoreHKCU), + uintptr(unsafe.Pointer(pvDefaultData)), + uintptr(dwDefaultDataSize), + 0) + return LONG(ret1) +} + +func SHRegSetPath(hKey HKEY, lpszSubKey string, lpszValue string, lpszPath string, dwFlags DWORD) DWORD { + lpszSubKeyStr := unicode16FromString(lpszSubKey) + lpszValueStr := unicode16FromString(lpszValue) + lpszPathStr := unicode16FromString(lpszPath) + ret1 := syscall6(sHRegSetPath, 5, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpszSubKeyStr[0])), + uintptr(unsafe.Pointer(&lpszValueStr[0])), + uintptr(unsafe.Pointer(&lpszPathStr[0])), + uintptr(dwFlags), + 0) + return DWORD(ret1) +} + +func SHRegSetUSValue(pszSubKey string, pszValue string, dwType DWORD, pvData LPVOID, cbData DWORD, dwFlags DWORD) LONG { + pszSubKeyStr := unicode16FromString(pszSubKey) + pszValueStr := unicode16FromString(pszValue) + ret1 := syscall6(sHRegSetUSValue, 6, + uintptr(unsafe.Pointer(&pszSubKeyStr[0])), + uintptr(unsafe.Pointer(&pszValueStr[0])), + uintptr(dwType), + uintptr(unsafe.Pointer(pvData)), + uintptr(cbData), + uintptr(dwFlags)) + return LONG(ret1) +} + +func SHRegWriteUSValue(hUSKey HUSKEY, pszValue string, dwType DWORD, pvData LPVOID, cbData DWORD, dwFlags DWORD) LONG { + pszValueStr := unicode16FromString(pszValue) + ret1 := syscall6(sHRegWriteUSValue, 6, + uintptr(hUSKey), + uintptr(unsafe.Pointer(&pszValueStr[0])), + uintptr(dwType), + uintptr(unsafe.Pointer(pvData)), + uintptr(cbData), + uintptr(dwFlags)) + return LONG(ret1) +} + +func SHRegisterValidateTemplate(filename string, unknown bool) HRESULT { + filenameStr := unicode16FromString(filename) + ret1 := syscall3(sHRegisterValidateTemplate, 2, + uintptr(unsafe.Pointer(&filenameStr[0])), + getUintptrFromBool(unknown), + 0) + return HRESULT(ret1) +} + +func SHReleaseThreadRef() HRESULT { + ret1 := syscall3(sHReleaseThreadRef, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func SHSendMessageBroadcast(uMsg UINT, wParam WPARAM, lParam LPARAM) DWORD { + ret1 := syscall3(sHSendMessageBroadcast, 3, + uintptr(uMsg), + uintptr(wParam), + uintptr(lParam)) + return DWORD(ret1) +} + +func SHSetThreadRef(lpUnknown *IUnknown) HRESULT { + ret1 := syscall3(sHSetThreadRef, 1, + uintptr(unsafe.Pointer(lpUnknown)), + 0, + 0) + return HRESULT(ret1) +} + +func SHSetValue(hKey HKEY, lpszSubKey string, lpszValue string, dwType DWORD, pvData /*const*/ uintptr, cbData DWORD) DWORD { + lpszSubKeyStr := unicode16FromString(lpszSubKey) + lpszValueStr := unicode16FromString(lpszValue) + ret1 := syscall6(sHSetValue, 6, + uintptr(hKey), + uintptr(unsafe.Pointer(&lpszSubKeyStr[0])), + uintptr(unsafe.Pointer(&lpszValueStr[0])), + uintptr(dwType), + pvData, + uintptr(cbData)) + return DWORD(ret1) +} + +func SHSkipJunction(pbc *IBindCtx, pclsid /*const*/ *CLSID) bool { + ret1 := syscall3(sHSkipJunction, 2, + uintptr(unsafe.Pointer(pbc)), + uintptr(unsafe.Pointer(pclsid)), + 0) + return ret1 != 0 +} + +func SHStrDup(src string, dest *LPWSTR) HRESULT { + srcStr := unicode16FromString(src) + ret1 := syscall3(sHStrDup, 2, + uintptr(unsafe.Pointer(&srcStr[0])), + uintptr(unsafe.Pointer(dest)), + 0) + return HRESULT(ret1) +} + +func SHStripMneumonic(lpszStr string) WCHAR { + lpszStrStr := unicode16FromString(lpszStr) + ret1 := syscall3(sHStripMneumonic, 1, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + 0, + 0) + return WCHAR(ret1) +} + +func SHUnicodeToAnsi(lpSrcStr string, lpDstStr LPSTR, iLen INT) INT { + lpSrcStrStr := unicode16FromString(lpSrcStr) + ret1 := syscall3(sHUnicodeToAnsi, 3, + uintptr(unsafe.Pointer(&lpSrcStrStr[0])), + uintptr(unsafe.Pointer(lpDstStr)), + uintptr(iLen)) + return INT(ret1) +} + +func SHUnicodeToUnicode(lpszSrc string, lpszDst LPWSTR, iLen int32) DWORD { + lpszSrcStr := unicode16FromString(lpszSrc) + ret1 := syscall3(sHUnicodeToUnicode, 3, + uintptr(unsafe.Pointer(&lpszSrcStr[0])), + uintptr(unsafe.Pointer(lpszDst)), + uintptr(iLen)) + return DWORD(ret1) +} + +func SHUnlockShared(lpView LPVOID) bool { + ret1 := syscall3(sHUnlockShared, 1, + uintptr(unsafe.Pointer(lpView)), + 0, + 0) + return ret1 != 0 +} + +func StrCSpnI(lpszStr string, lpszMatch string) int32 { + lpszStrStr := unicode16FromString(lpszStr) + lpszMatchStr := unicode16FromString(lpszMatch) + ret1 := syscall3(strCSpnI, 2, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszMatchStr[0])), + 0) + return int32(ret1) +} + +func StrCSpn(lpszStr string, lpszMatch string) int32 { + lpszStrStr := unicode16FromString(lpszStr) + lpszMatchStr := unicode16FromString(lpszMatch) + ret1 := syscall3(strCSpn, 2, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszMatchStr[0])), + 0) + return int32(ret1) +} + +func StrCatBuff(lpszStr LPWSTR, lpszCat string, cchMax INT) LPWSTR { + lpszCatStr := unicode16FromString(lpszCat) + ret1 := syscall3(strCatBuff, 3, + uintptr(unsafe.Pointer(lpszStr)), + uintptr(unsafe.Pointer(&lpszCatStr[0])), + uintptr(cchMax)) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrCatChainW(lpszStr LPWSTR, cchMax DWORD, ichAt DWORD, lpszCat string) DWORD { + lpszCatStr := unicode16FromString(lpszCat) + ret1 := syscall6(strCatChainW, 4, + uintptr(unsafe.Pointer(lpszStr)), + uintptr(cchMax), + uintptr(ichAt), + uintptr(unsafe.Pointer(&lpszCatStr[0])), + 0, + 0) + return DWORD(ret1) +} + +func StrCatW(lpszStr LPWSTR, lpszSrc string) LPWSTR { + lpszSrcStr := unicode16FromString(lpszSrc) + ret1 := syscall3(strCatW, 2, + uintptr(unsafe.Pointer(lpszStr)), + uintptr(unsafe.Pointer(&lpszSrcStr[0])), + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrChrI(lpszStr string, ch WCHAR) LPWSTR { + lpszStrStr := unicode16FromString(lpszStr) + ret1 := syscall3(strChrI, 2, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(ch), + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrChrNW(lpszStr string, ch WCHAR, cchMax UINT) LPWSTR { + lpszStrStr := unicode16FromString(lpszStr) + ret1 := syscall3(strChrNW, 3, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(ch), + uintptr(cchMax)) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrChr(lpszStr string, ch WCHAR) LPWSTR { + lpszStrStr := unicode16FromString(lpszStr) + ret1 := syscall3(strChr, 2, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(ch), + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrCmpC(lpszSrc string, lpszCmp string) DWORD { + lpszSrcStr := unicode16FromString(lpszSrc) + lpszCmpStr := unicode16FromString(lpszCmp) + ret1 := syscall3(strCmpC, 2, + uintptr(unsafe.Pointer(&lpszSrcStr[0])), + uintptr(unsafe.Pointer(&lpszCmpStr[0])), + 0) + return DWORD(ret1) +} + +func StrCmpIC(lpszSrc string, lpszCmp string) DWORD { + lpszSrcStr := unicode16FromString(lpszSrc) + lpszCmpStr := unicode16FromString(lpszCmp) + ret1 := syscall3(strCmpIC, 2, + uintptr(unsafe.Pointer(&lpszSrcStr[0])), + uintptr(unsafe.Pointer(&lpszCmpStr[0])), + 0) + return DWORD(ret1) +} + +func StrCmpIW(lpszStr string, lpszComp string) int32 { + lpszStrStr := unicode16FromString(lpszStr) + lpszCompStr := unicode16FromString(lpszComp) + ret1 := syscall3(strCmpIW, 2, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszCompStr[0])), + 0) + return int32(ret1) +} + +func StrCmpLogicalW(lpszStr string, lpszComp string) INT { + lpszStrStr := unicode16FromString(lpszStr) + lpszCompStr := unicode16FromString(lpszComp) + ret1 := syscall3(strCmpLogicalW, 2, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszCompStr[0])), + 0) + return INT(ret1) +} + +func StrCmpNC(lpszSrc string, lpszCmp string, aLen INT) DWORD { + lpszSrcStr := unicode16FromString(lpszSrc) + lpszCmpStr := unicode16FromString(lpszCmp) + ret1 := syscall3(strCmpNC, 3, + uintptr(unsafe.Pointer(&lpszSrcStr[0])), + uintptr(unsafe.Pointer(&lpszCmpStr[0])), + uintptr(aLen)) + return DWORD(ret1) +} + +func StrCmpNIC(lpszSrc string, lpszCmp string, aLen DWORD) DWORD { + lpszSrcStr := unicode16FromString(lpszSrc) + lpszCmpStr := unicode16FromString(lpszCmp) + ret1 := syscall3(strCmpNIC, 3, + uintptr(unsafe.Pointer(&lpszSrcStr[0])), + uintptr(unsafe.Pointer(&lpszCmpStr[0])), + uintptr(aLen)) + return DWORD(ret1) +} + +func StrCmpNI(lpszStr string, lpszComp string, iLen INT) INT { + lpszStrStr := unicode16FromString(lpszStr) + lpszCompStr := unicode16FromString(lpszComp) + ret1 := syscall3(strCmpNI, 3, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszCompStr[0])), + uintptr(iLen)) + return INT(ret1) +} + +func StrCmpN(lpszStr string, lpszComp string, iLen INT) INT { + lpszStrStr := unicode16FromString(lpszStr) + lpszCompStr := unicode16FromString(lpszComp) + ret1 := syscall3(strCmpN, 3, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszCompStr[0])), + uintptr(iLen)) + return INT(ret1) +} + +func StrCmpW(lpszStr string, lpszComp string) int32 { + lpszStrStr := unicode16FromString(lpszStr) + lpszCompStr := unicode16FromString(lpszComp) + ret1 := syscall3(strCmpW, 2, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszCompStr[0])), + 0) + return int32(ret1) +} + +func StrCpyNW(dst LPWSTR, src string, count int32) LPWSTR { + srcStr := unicode16FromString(src) + ret1 := syscall3(strCpyNW, 3, + uintptr(unsafe.Pointer(dst)), + uintptr(unsafe.Pointer(&srcStr[0])), + uintptr(count)) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrCpyW(lpszStr LPWSTR, lpszSrc string) LPWSTR { + lpszSrcStr := unicode16FromString(lpszSrc) + ret1 := syscall3(strCpyW, 2, + uintptr(unsafe.Pointer(lpszStr)), + uintptr(unsafe.Pointer(&lpszSrcStr[0])), + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrDup(lpszStr string) LPWSTR { + lpszStrStr := unicode16FromString(lpszStr) + ret1 := syscall3(strDup, 1, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrFormatByteSize64A(llBytes LONGLONG, lpszDest LPSTR, cchMax UINT) LPSTR { + ret1 := syscall3(strFormatByteSize64A, 3, + uintptr(llBytes), + uintptr(unsafe.Pointer(lpszDest)), + uintptr(cchMax)) + return (LPSTR)(unsafe.Pointer(ret1)) +} + +func StrFormatByteSize(llBytes LONGLONG, lpszDest LPWSTR, cchMax UINT) LPWSTR { + ret1 := syscall3(strFormatByteSize, 3, + uintptr(llBytes), + uintptr(unsafe.Pointer(lpszDest)), + uintptr(cchMax)) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrFormatKBSize(llBytes LONGLONG, lpszDest LPWSTR, cchMax UINT) LPWSTR { + ret1 := syscall3(strFormatKBSize, 3, + uintptr(llBytes), + uintptr(unsafe.Pointer(lpszDest)), + uintptr(cchMax)) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrFromTimeInterval(lpszStr LPWSTR, cchMax UINT, dwMS DWORD, iDigits int32) INT { + ret1 := syscall6(strFromTimeInterval, 4, + uintptr(unsafe.Pointer(lpszStr)), + uintptr(cchMax), + uintptr(dwMS), + uintptr(iDigits), + 0, + 0) + return INT(ret1) +} + +func StrIsIntlEqual(bCase bool, lpszStr string, lpszComp string, iLen int32) bool { + lpszStrStr := unicode16FromString(lpszStr) + lpszCompStr := unicode16FromString(lpszComp) + ret1 := syscall6(strIsIntlEqual, 4, + getUintptrFromBool(bCase), + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszCompStr[0])), + uintptr(iLen), + 0, + 0) + return ret1 != 0 +} + +func StrNCat(lpszStr LPWSTR, lpszCat string, cchMax INT) LPWSTR { + lpszCatStr := unicode16FromString(lpszCat) + ret1 := syscall3(strNCat, 3, + uintptr(unsafe.Pointer(lpszStr)), + uintptr(unsafe.Pointer(&lpszCatStr[0])), + uintptr(cchMax)) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrPBrk(lpszStr string, lpszMatch string) LPWSTR { + lpszStrStr := unicode16FromString(lpszStr) + lpszMatchStr := unicode16FromString(lpszMatch) + ret1 := syscall3(strPBrk, 2, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszMatchStr[0])), + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrRChrI(str string, end string, ch WORD) LPWSTR { + strStr := unicode16FromString(str) + endStr := unicode16FromString(end) + ret1 := syscall3(strRChrI, 3, + uintptr(unsafe.Pointer(&strStr[0])), + uintptr(unsafe.Pointer(&endStr[0])), + uintptr(ch)) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrRChr(str string, end string, ch WORD) LPWSTR { + strStr := unicode16FromString(str) + endStr := unicode16FromString(end) + ret1 := syscall3(strRChr, 3, + uintptr(unsafe.Pointer(&strStr[0])), + uintptr(unsafe.Pointer(&endStr[0])), + uintptr(ch)) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrRStrI(lpszStr string, lpszEnd string, lpszSearch string) LPWSTR { + lpszStrStr := unicode16FromString(lpszStr) + lpszEndStr := unicode16FromString(lpszEnd) + lpszSearchStr := unicode16FromString(lpszSearch) + ret1 := syscall3(strRStrI, 3, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszEndStr[0])), + uintptr(unsafe.Pointer(&lpszSearchStr[0]))) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrRetToBSTR(lpStrRet *STRRET, pidl /*const*/ LPCITEMIDLIST, pBstrOut *BSTR) HRESULT { + ret1 := syscall3(strRetToBSTR, 3, + uintptr(unsafe.Pointer(lpStrRet)), + uintptr(unsafe.Pointer(pidl)), + uintptr(unsafe.Pointer(pBstrOut))) + return HRESULT(ret1) +} + +func StrRetToBuf(src *STRRET, pidl /*const*/ *ITEMIDLIST, dest LPWSTR, aLen UINT) HRESULT { + ret1 := syscall6(strRetToBuf, 4, + uintptr(unsafe.Pointer(src)), + uintptr(unsafe.Pointer(pidl)), + uintptr(unsafe.Pointer(dest)), + uintptr(aLen), + 0, + 0) + return HRESULT(ret1) +} + +func StrRetToStr(lpStrRet *STRRET, pidl /*const*/ *ITEMIDLIST, ppszName *LPWSTR) HRESULT { + ret1 := syscall3(strRetToStr, 3, + uintptr(unsafe.Pointer(lpStrRet)), + uintptr(unsafe.Pointer(pidl)), + uintptr(unsafe.Pointer(ppszName))) + return HRESULT(ret1) +} + +func StrSpn(lpszStr string, lpszMatch string) int32 { + lpszStrStr := unicode16FromString(lpszStr) + lpszMatchStr := unicode16FromString(lpszMatch) + ret1 := syscall3(strSpn, 2, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszMatchStr[0])), + 0) + return int32(ret1) +} + +func StrStrI(lpszStr string, lpszSearch string) LPWSTR { + lpszStrStr := unicode16FromString(lpszStr) + lpszSearchStr := unicode16FromString(lpszSearch) + ret1 := syscall3(strStrI, 2, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszSearchStr[0])), + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrStrNIW(lpFirst string, lpSrch string, cchMax UINT) LPWSTR { + lpFirstStr := unicode16FromString(lpFirst) + lpSrchStr := unicode16FromString(lpSrch) + ret1 := syscall3(strStrNIW, 3, + uintptr(unsafe.Pointer(&lpFirstStr[0])), + uintptr(unsafe.Pointer(&lpSrchStr[0])), + uintptr(cchMax)) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrStrNW(lpFirst string, lpSrch string, cchMax UINT) LPWSTR { + lpFirstStr := unicode16FromString(lpFirst) + lpSrchStr := unicode16FromString(lpSrch) + ret1 := syscall3(strStrNW, 3, + uintptr(unsafe.Pointer(&lpFirstStr[0])), + uintptr(unsafe.Pointer(&lpSrchStr[0])), + uintptr(cchMax)) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrStr(lpszStr string, lpszSearch string) LPWSTR { + lpszStrStr := unicode16FromString(lpszStr) + lpszSearchStr := unicode16FromString(lpszSearch) + ret1 := syscall3(strStr, 2, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(unsafe.Pointer(&lpszSearchStr[0])), + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func StrToInt64Ex(lpszStr string, dwFlags DWORD, lpiRet *LONGLONG) bool { + lpszStrStr := unicode16FromString(lpszStr) + ret1 := syscall3(strToInt64Ex, 3, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpiRet))) + return ret1 != 0 +} + +func StrToIntEx(lpszStr string, dwFlags DWORD, lpiRet *int32) bool { + lpszStrStr := unicode16FromString(lpszStr) + ret1 := syscall3(strToIntEx, 3, + uintptr(unsafe.Pointer(&lpszStrStr[0])), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpiRet))) + return ret1 != 0 +} + +func StrToInt(lpString string) INT { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(strToInt, 1, + uintptr(unsafe.Pointer(&lpStringStr[0])), + 0, + 0) + return INT(ret1) +} + +func StrTrim(lpszStr LPWSTR, lpszTrim string) bool { + lpszTrimStr := unicode16FromString(lpszTrim) + ret1 := syscall3(strTrim, 2, + uintptr(unsafe.Pointer(lpszStr)), + uintptr(unsafe.Pointer(&lpszTrimStr[0])), + 0) + return ret1 != 0 +} + +func UrlApplyScheme(pszIn string, pszOut LPWSTR, pcchOut *uint32, dwFlags DWORD) HRESULT { + pszInStr := unicode16FromString(pszIn) + ret1 := syscall6(urlApplyScheme, 4, + uintptr(unsafe.Pointer(&pszInStr[0])), + uintptr(unsafe.Pointer(pszOut)), + uintptr(unsafe.Pointer(pcchOut)), + uintptr(dwFlags), + 0, + 0) + return HRESULT(ret1) +} + +func UrlCanonicalize(pszUrl string, pszCanonicalized LPWSTR, pcchCanonicalized *uint32, dwFlags DWORD) HRESULT { + pszUrlStr := unicode16FromString(pszUrl) + ret1 := syscall6(urlCanonicalize, 4, + uintptr(unsafe.Pointer(&pszUrlStr[0])), + uintptr(unsafe.Pointer(pszCanonicalized)), + uintptr(unsafe.Pointer(pcchCanonicalized)), + uintptr(dwFlags), + 0, + 0) + return HRESULT(ret1) +} + +func UrlCombine(pszBase string, pszRelative string, pszCombined LPWSTR, pcchCombined *uint32, dwFlags DWORD) HRESULT { + pszBaseStr := unicode16FromString(pszBase) + pszRelativeStr := unicode16FromString(pszRelative) + ret1 := syscall6(urlCombine, 5, + uintptr(unsafe.Pointer(&pszBaseStr[0])), + uintptr(unsafe.Pointer(&pszRelativeStr[0])), + uintptr(unsafe.Pointer(pszCombined)), + uintptr(unsafe.Pointer(pcchCombined)), + uintptr(dwFlags), + 0) + return HRESULT(ret1) +} + +func UrlCompare(pszUrl1 string, pszUrl2 string, fIgnoreSlash bool) INT { + pszUrl1Str := unicode16FromString(pszUrl1) + pszUrl2Str := unicode16FromString(pszUrl2) + ret1 := syscall3(urlCompare, 3, + uintptr(unsafe.Pointer(&pszUrl1Str[0])), + uintptr(unsafe.Pointer(&pszUrl2Str[0])), + getUintptrFromBool(fIgnoreSlash)) + return INT(ret1) +} + +func UrlCreateFromPath(pszPath string, pszUrl LPWSTR, pcchUrl *uint32, dwReserved DWORD) HRESULT { + pszPathStr := unicode16FromString(pszPath) + ret1 := syscall6(urlCreateFromPath, 4, + uintptr(unsafe.Pointer(&pszPathStr[0])), + uintptr(unsafe.Pointer(pszUrl)), + uintptr(unsafe.Pointer(pcchUrl)), + uintptr(dwReserved), + 0, + 0) + return HRESULT(ret1) +} + +func UrlEscape(pszUrl string, pszEscaped LPWSTR, pcchEscaped *uint32, dwFlags DWORD) HRESULT { + pszUrlStr := unicode16FromString(pszUrl) + ret1 := syscall6(urlEscape, 4, + uintptr(unsafe.Pointer(&pszUrlStr[0])), + uintptr(unsafe.Pointer(pszEscaped)), + uintptr(unsafe.Pointer(pcchEscaped)), + uintptr(dwFlags), + 0, + 0) + return HRESULT(ret1) +} + +func UrlFixupW(url string, translatedUrl LPWSTR, maxChars DWORD) HRESULT { + urlStr := unicode16FromString(url) + ret1 := syscall3(urlFixupW, 3, + uintptr(unsafe.Pointer(&urlStr[0])), + uintptr(unsafe.Pointer(translatedUrl)), + uintptr(maxChars)) + return HRESULT(ret1) +} + +func UrlGetLocation(pszUrl string) string { + pszUrlStr := unicode16FromString(pszUrl) + ret1 := syscall3(urlGetLocation, 1, + uintptr(unsafe.Pointer(&pszUrlStr[0])), + 0, + 0) + return stringFromUnicode16((*uint16)(unsafe.Pointer(ret1))) +} + +func UrlGetPart(pszIn string, pszOut LPWSTR, pcchOut *uint32, dwPart DWORD, dwFlags DWORD) HRESULT { + pszInStr := unicode16FromString(pszIn) + ret1 := syscall6(urlGetPart, 5, + uintptr(unsafe.Pointer(&pszInStr[0])), + uintptr(unsafe.Pointer(pszOut)), + uintptr(unsafe.Pointer(pcchOut)), + uintptr(dwPart), + uintptr(dwFlags), + 0) + return HRESULT(ret1) +} + +func UrlHash(pszUrl string, lpDest *byte, nDestLen DWORD) HRESULT { + pszUrlStr := unicode16FromString(pszUrl) + ret1 := syscall3(urlHash, 3, + uintptr(unsafe.Pointer(&pszUrlStr[0])), + uintptr(unsafe.Pointer(lpDest)), + uintptr(nDestLen)) + return HRESULT(ret1) +} + +func UrlIsNoHistory(pszUrl string) bool { + pszUrlStr := unicode16FromString(pszUrl) + ret1 := syscall3(urlIsNoHistory, 1, + uintptr(unsafe.Pointer(&pszUrlStr[0])), + 0, + 0) + return ret1 != 0 +} + +func UrlIsOpaque(pszUrl string) bool { + pszUrlStr := unicode16FromString(pszUrl) + ret1 := syscall3(urlIsOpaque, 1, + uintptr(unsafe.Pointer(&pszUrlStr[0])), + 0, + 0) + return ret1 != 0 +} + +func UrlIs(pszUrl string, urlis URLIS) bool { + pszUrlStr := unicode16FromString(pszUrl) + ret1 := syscall3(urlIs, 2, + uintptr(unsafe.Pointer(&pszUrlStr[0])), + uintptr(urlis), + 0) + return ret1 != 0 +} + +func UrlUnescape(pszUrl LPWSTR, pszUnescaped LPWSTR, pcchUnescaped *uint32, dwFlags DWORD) HRESULT { + ret1 := syscall6(urlUnescape, 4, + uintptr(unsafe.Pointer(pszUrl)), + uintptr(unsafe.Pointer(pszUnescaped)), + uintptr(unsafe.Pointer(pcchUnescaped)), + uintptr(dwFlags), + 0, + 0) + return HRESULT(ret1) +} + +func WhichPlatform() DWORD { + ret1 := syscall3(whichPlatform, 0, + 0, + 0, + 0) + return DWORD(ret1) +} diff --git a/grdp/win/types.go b/grdp/win/types.go new file mode 100644 index 0000000..58f53ad --- /dev/null +++ b/grdp/win/types.go @@ -0,0 +1,6225 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go + +package win + +import ( + "reflect" + "unsafe" +) + +var ( + types map[string]reflect.Type +) + +func init() { + types = make(map[string]reflect.Type) + types["ABC"] = reflect.TypeOf((*ABC)(nil)).Elem() + types["ABCFLOAT"] = reflect.TypeOf((*ABCFLOAT)(nil)).Elem() + types["ABORTPROC"] = reflect.TypeOf((*ABORTPROC)(nil)).Elem() + types["ACCEL"] = reflect.TypeOf((*ACCEL)(nil)).Elem() + types["ACCESS_MASK"] = reflect.TypeOf((*ACCESS_MASK)(nil)).Elem() + types["ACCESS_MODE"] = reflect.TypeOf((*ACCESS_MODE)(nil)).Elem() + types["ACL"] = reflect.TypeOf((*ACL)(nil)).Elem() + types["ADDRESS_FAMILY"] = reflect.TypeOf((*ADDRESS_FAMILY)(nil)).Elem() + types["ADDRINFO"] = reflect.TypeOf((*ADDRINFO)(nil)).Elem() + types["ADDRINFOEX"] = reflect.TypeOf((*ADDRINFOEX)(nil)).Elem() + types["AFPROTOCOLS"] = reflect.TypeOf((*AFPROTOCOLS)(nil)).Elem() + types["ALG_ID"] = reflect.TypeOf((*ALG_ID)(nil)).Elem() + types["ALTTABINFO"] = reflect.TypeOf((*ALTTABINFO)(nil)).Elem() + types["APPBARDATA"] = reflect.TypeOf((*APPBARDATA)(nil)).Elem() + types["APTTYPE"] = reflect.TypeOf((*APTTYPE)(nil)).Elem() + types["APTTYPEQUALIFIER"] = reflect.TypeOf((*APTTYPEQUALIFIER)(nil)).Elem() + types["ARRAY_INFO"] = reflect.TypeOf((*ARRAY_INFO)(nil)).Elem() + types["ASSOCF"] = reflect.TypeOf((*ASSOCF)(nil)).Elem() + types["ASSOCKEY"] = reflect.TypeOf((*ASSOCKEY)(nil)).Elem() + types["ASSOCSTR"] = reflect.TypeOf((*ASSOCSTR)(nil)).Elem() + types["ASSOC_FILTER"] = reflect.TypeOf((*ASSOC_FILTER)(nil)).Elem() + types["ATOM"] = reflect.TypeOf((*ATOM)(nil)).Elem() + types["AUDIT_POLICY_INFORMATION"] = reflect.TypeOf((*AUDIT_POLICY_INFORMATION)(nil)).Elem() + types["AUTO_SCROLL_DATA"] = reflect.TypeOf((*AUTO_SCROLL_DATA)(nil)).Elem() + types["AUXCAPS"] = reflect.TypeOf((*AUXCAPS)(nil)).Elem() + types["BFFCALLBACK"] = reflect.TypeOf((*BFFCALLBACK)(nil)).Elem() + types["BIND_OPTS"] = reflect.TypeOf((*BIND_OPTS)(nil)).Elem() + types["BITMAP"] = reflect.TypeOf((*BITMAP)(nil)).Elem() + types["BITMAPINFO"] = reflect.TypeOf((*BITMAPINFO)(nil)).Elem() + types["BITMAPINFOHEADER"] = reflect.TypeOf((*BITMAPINFOHEADER)(nil)).Elem() + types["BLENDFUNCTION"] = reflect.TypeOf((*BLENDFUNCTION)(nil)).Elem() + types["BLENDOBJ"] = reflect.TypeOf((*BLENDOBJ)(nil)).Elem() + types["BLOB"] = reflect.TypeOf((*BLOB)(nil)).Elem() + types["BOOL"] = reflect.TypeOf((*BOOL)(nil)).Elem() + types["BOOLEAN"] = reflect.TypeOf((*BOOLEAN)(nil)).Elem() + types["BP_ANIMATIONPARAMS"] = reflect.TypeOf((*BP_ANIMATIONPARAMS)(nil)).Elem() + types["BP_BUFFERFORMAT"] = reflect.TypeOf((*BP_BUFFERFORMAT)(nil)).Elem() + types["BP_PAINTPARAMS"] = reflect.TypeOf((*BP_PAINTPARAMS)(nil)).Elem() + types["BROWSEINFO"] = reflect.TypeOf((*BROWSEINFO)(nil)).Elem() + types["BRUSHOBJ"] = reflect.TypeOf((*BRUSHOBJ)(nil)).Elem() + types["BSMINFO"] = reflect.TypeOf((*BSMINFO)(nil)).Elem() + types["BSTR"] = reflect.TypeOf((*BSTR)(nil)).Elem() + types["BSTRBLOB"] = reflect.TypeOf((*BSTRBLOB)(nil)).Elem() + types["BYTE"] = reflect.TypeOf((*BYTE)(nil)).Elem() + types["CABINETSTATE"] = reflect.TypeOf((*CABINETSTATE)(nil)).Elem() + types["CABOOL"] = reflect.TypeOf((*CABOOL)(nil)).Elem() + types["CABSTR"] = reflect.TypeOf((*CABSTR)(nil)).Elem() + types["CABSTRBLOB"] = reflect.TypeOf((*CABSTRBLOB)(nil)).Elem() + types["CAC"] = reflect.TypeOf((*CAC)(nil)).Elem() + types["CACLIPDATA"] = reflect.TypeOf((*CACLIPDATA)(nil)).Elem() + types["CACLSID"] = reflect.TypeOf((*CACLSID)(nil)).Elem() + types["CACY"] = reflect.TypeOf((*CACY)(nil)).Elem() + types["CADATE"] = reflect.TypeOf((*CADATE)(nil)).Elem() + types["CADBL"] = reflect.TypeOf((*CADBL)(nil)).Elem() + types["CAFILETIME"] = reflect.TypeOf((*CAFILETIME)(nil)).Elem() + types["CAFLT"] = reflect.TypeOf((*CAFLT)(nil)).Elem() + types["CAH"] = reflect.TypeOf((*CAH)(nil)).Elem() + types["CAI"] = reflect.TypeOf((*CAI)(nil)).Elem() + types["CAL"] = reflect.TypeOf((*CAL)(nil)).Elem() + types["CALID"] = reflect.TypeOf((*CALID)(nil)).Elem() + types["CALLCONV"] = reflect.TypeOf((*CALLCONV)(nil)).Elem() + types["CALPSTR"] = reflect.TypeOf((*CALPSTR)(nil)).Elem() + types["CALPWSTR"] = reflect.TypeOf((*CALPWSTR)(nil)).Elem() + types["CALTYPE"] = reflect.TypeOf((*CALTYPE)(nil)).Elem() + types["CANDIDATEFORM"] = reflect.TypeOf((*CANDIDATEFORM)(nil)).Elem() + types["CANDIDATELIST"] = reflect.TypeOf((*CANDIDATELIST)(nil)).Elem() + types["CAPROPVARIANT"] = reflect.TypeOf((*CAPROPVARIANT)(nil)).Elem() + types["CASCODE"] = reflect.TypeOf((*CASCODE)(nil)).Elem() + types["CAUB"] = reflect.TypeOf((*CAUB)(nil)).Elem() + types["CAUH"] = reflect.TypeOf((*CAUH)(nil)).Elem() + types["CAUI"] = reflect.TypeOf((*CAUI)(nil)).Elem() + types["CAUL"] = reflect.TypeOf((*CAUL)(nil)).Elem() + types["CCHOOKPROC"] = reflect.TypeOf((*CCHOOKPROC)(nil)).Elem() + types["CERT_CONTEXT"] = reflect.TypeOf((*CERT_CONTEXT)(nil)).Elem() + types["CERT_EXTENSION"] = reflect.TypeOf((*CERT_EXTENSION)(nil)).Elem() + types["CERT_INFO"] = reflect.TypeOf((*CERT_INFO)(nil)).Elem() + types["CERT_NAME_BLOB"] = reflect.TypeOf((*CERT_NAME_BLOB)(nil)).Elem() + types["CERT_PUBLIC_KEY_INFO"] = reflect.TypeOf((*CERT_PUBLIC_KEY_INFO)(nil)).Elem() + types["CERT_RDN_VALUE_BLOB"] = reflect.TypeOf((*CERT_RDN_VALUE_BLOB)(nil)).Elem() + types["CHAR"] = reflect.TypeOf((*CHAR)(nil)).Elem() + types["CHARSETINFO"] = reflect.TypeOf((*CHARSETINFO)(nil)).Elem() + types["CHOOSECOLOR"] = reflect.TypeOf((*CHOOSECOLOR)(nil)).Elem() + types["CHOOSEFONT"] = reflect.TypeOf((*CHOOSEFONT)(nil)).Elem() + types["CIEXYZ"] = reflect.TypeOf((*CIEXYZ)(nil)).Elem() + types["CIEXYZTRIPLE"] = reflect.TypeOf((*CIEXYZTRIPLE)(nil)).Elem() + types["CLIPDATA"] = reflect.TypeOf((*CLIPDATA)(nil)).Elem() + types["CLIPFORMAT"] = reflect.TypeOf((*CLIPFORMAT)(nil)).Elem() + types["CLIPLINE"] = reflect.TypeOf((*CLIPLINE)(nil)).Elem() + types["CLIPOBJ"] = reflect.TypeOf((*CLIPOBJ)(nil)).Elem() + types["CLSID"] = reflect.TypeOf((*CLSID)(nil)).Elem() + types["COAUTHIDENTITY"] = reflect.TypeOf((*COAUTHIDENTITY)(nil)).Elem() + types["COAUTHINFO"] = reflect.TypeOf((*COAUTHINFO)(nil)).Elem() + types["COLOR16"] = reflect.TypeOf((*COLOR16)(nil)).Elem() + types["COLORADJUSTMENT"] = reflect.TypeOf((*COLORADJUSTMENT)(nil)).Elem() + types["COLORMAP"] = reflect.TypeOf((*COLORMAP)(nil)).Elem() + types["COLORREF"] = reflect.TypeOf((*COLORREF)(nil)).Elem() + types["COMBOBOXINFO"] = reflect.TypeOf((*COMBOBOXINFO)(nil)).Elem() + types["COMM_FAULT_OFFSETS"] = reflect.TypeOf((*COMM_FAULT_OFFSETS)(nil)).Elem() + types["COMPOSITIONFORM"] = reflect.TypeOf((*COMPOSITIONFORM)(nil)).Elem() + types["CONSOLE_SCREEN_BUFFER_INFO"] = reflect.TypeOf((*CONSOLE_SCREEN_BUFFER_INFO)(nil)).Elem() + types["CONSOLE_SCREEN_BUFFER_INFOEX"] = reflect.TypeOf((*CONSOLE_SCREEN_BUFFER_INFOEX)(nil)).Elem() + types["CONVCONTEXT"] = reflect.TypeOf((*CONVCONTEXT)(nil)).Elem() + types["CONVINFO"] = reflect.TypeOf((*CONVINFO)(nil)).Elem() + types["COORD"] = reflect.TypeOf((*COORD)(nil)).Elem() + types["COSERVERINFO"] = reflect.TypeOf((*COSERVERINFO)(nil)).Elem() + types["CPINFO"] = reflect.TypeOf((*CPINFO)(nil)).Elem() + types["CPINFOEX"] = reflect.TypeOf((*CPINFOEX)(nil)).Elem() + types["CREDENTIAL"] = reflect.TypeOf((*CREDENTIAL)(nil)).Elem() + types["CREDENTIAL_ATTRIBUTE"] = reflect.TypeOf((*CREDENTIAL_ATTRIBUTE)(nil)).Elem() + types["CRL_CONTEXT"] = reflect.TypeOf((*CRL_CONTEXT)(nil)).Elem() + types["CRL_ENTRY"] = reflect.TypeOf((*CRL_ENTRY)(nil)).Elem() + types["CRL_INFO"] = reflect.TypeOf((*CRL_INFO)(nil)).Elem() + types["CRYPTOAPI_BLOB_"] = reflect.TypeOf((*CRYPTOAPI_BLOB_)(nil)).Elem() + types["CRYPT_ALGORITHM_IDENTIFIER"] = reflect.TypeOf((*CRYPT_ALGORITHM_IDENTIFIER)(nil)).Elem() + types["CRYPT_ATTRIBUTE"] = reflect.TypeOf((*CRYPT_ATTRIBUTE)(nil)).Elem() + types["CRYPT_ATTR_BLOB"] = reflect.TypeOf((*CRYPT_ATTR_BLOB)(nil)).Elem() + types["CRYPT_BIT_BLOB"] = reflect.TypeOf((*CRYPT_BIT_BLOB)(nil)).Elem() + types["CRYPT_DATA_BLOB"] = reflect.TypeOf((*CRYPT_DATA_BLOB)(nil)).Elem() + types["CRYPT_DER_BLOB"] = reflect.TypeOf((*CRYPT_DER_BLOB)(nil)).Elem() + types["CRYPT_HASH_BLOB"] = reflect.TypeOf((*CRYPT_HASH_BLOB)(nil)).Elem() + types["CRYPT_INTEGER_BLOB"] = reflect.TypeOf((*CRYPT_INTEGER_BLOB)(nil)).Elem() + types["CRYPT_OBJID_BLOB"] = reflect.TypeOf((*CRYPT_OBJID_BLOB)(nil)).Elem() + types["CSADDR_INFO"] = reflect.TypeOf((*CSADDR_INFO)(nil)).Elem() + types["CSFV"] = reflect.TypeOf((*CSFV)(nil)).Elem() + types["CS_TAG_GETTING_ROUTINE"] = reflect.TypeOf((*CS_TAG_GETTING_ROUTINE)(nil)).Elem() + types["CS_TYPE_FROM_NETCS_ROUTINE"] = reflect.TypeOf((*CS_TYPE_FROM_NETCS_ROUTINE)(nil)).Elem() + types["CS_TYPE_LOCAL_SIZE_ROUTINE"] = reflect.TypeOf((*CS_TYPE_LOCAL_SIZE_ROUTINE)(nil)).Elem() + types["CS_TYPE_NET_SIZE_ROUTINE"] = reflect.TypeOf((*CS_TYPE_NET_SIZE_ROUTINE)(nil)).Elem() + types["CS_TYPE_TO_NETCS_ROUTINE"] = reflect.TypeOf((*CS_TYPE_TO_NETCS_ROUTINE)(nil)).Elem() + types["CTL_CONTEXT"] = reflect.TypeOf((*CTL_CONTEXT)(nil)).Elem() + types["CTL_ENTRY"] = reflect.TypeOf((*CTL_ENTRY)(nil)).Elem() + types["CTL_INFO"] = reflect.TypeOf((*CTL_INFO)(nil)).Elem() + types["CTL_USAGE"] = reflect.TypeOf((*CTL_USAGE)(nil)).Elem() + types["CURSORINFO"] = reflect.TypeOf((*CURSORINFO)(nil)).Elem() + types["CUSTDATA"] = reflect.TypeOf((*CUSTDATA)(nil)).Elem() + types["CUSTDATAITEM"] = reflect.TypeOf((*CUSTDATAITEM)(nil)).Elem() + types["CY"] = reflect.TypeOf((*CY)(nil)).Elem() + types["DACOMPARE"] = reflect.TypeOf((*DACOMPARE)(nil)).Elem() + types["DAENUMCALLBACK"] = reflect.TypeOf((*DAENUMCALLBACK)(nil)).Elem() + types["DATAOBJ_GET_ITEM_FLAGS"] = reflect.TypeOf((*DATAOBJ_GET_ITEM_FLAGS)(nil)).Elem() + types["DATE"] = reflect.TypeOf((*DATE)(nil)).Elem() + types["DATETIME"] = reflect.TypeOf((*DATETIME)(nil)).Elem() + types["DECIMAL"] = reflect.TypeOf((*DECIMAL)(nil)).Elem() + types["DEFCONTEXTMENU"] = reflect.TypeOf((*DEFCONTEXTMENU)(nil)).Elem() + types["DESIGNVECTOR"] = reflect.TypeOf((*DESIGNVECTOR)(nil)).Elem() + types["DESKTOPENUMPROC"] = reflect.TypeOf((*DESKTOPENUMPROC)(nil)).Elem() + types["DEVMODE"] = reflect.TypeOf((*DEVMODE)(nil)).Elem() + types["DHPDEV"] = reflect.TypeOf((*DHPDEV)(nil)).Elem() + types["DHSURF"] = reflect.TypeOf((*DHSURF)(nil)).Elem() + types["DISPID"] = reflect.TypeOf((*DISPID)(nil)).Elem() + types["DISPLAY_DEVICE"] = reflect.TypeOf((*DISPLAY_DEVICE)(nil)).Elem() + types["DISPPARAMS"] = reflect.TypeOf((*DISPPARAMS)(nil)).Elem() + types["DLGPROC"] = reflect.TypeOf((*DLGPROC)(nil)).Elem() + types["DLGTEMPLATE"] = reflect.TypeOf((*DLGTEMPLATE)(nil)).Elem() + types["DOCINFO"] = reflect.TypeOf((*DOCINFO)(nil)).Elem() + types["DOUBLE"] = reflect.TypeOf((*DOUBLE)(nil)).Elem() + types["DRAWSTATEPROC"] = reflect.TypeOf((*DRAWSTATEPROC)(nil)).Elem() + types["DRAWTEXTPARAMS"] = reflect.TypeOf((*DRAWTEXTPARAMS)(nil)).Elem() + types["DTBGOPTS"] = reflect.TypeOf((*DTBGOPTS)(nil)).Elem() + types["DTTOPTS"] = reflect.TypeOf((*DTTOPTS)(nil)).Elem() + types["DTT_CALLBACK_PROC"] = reflect.TypeOf((*DTT_CALLBACK_PROC)(nil)).Elem() + types["DVTARGETDEVICE"] = reflect.TypeOf((*DVTARGETDEVICE)(nil)).Elem() + types["DWORD"] = reflect.TypeOf((*DWORD)(nil)).Elem() + types["DWORD_PTR"] = reflect.TypeOf((*DWORD_PTR)(nil)).Elem() + types["EFS_CERTIFICATE_BLOB"] = reflect.TypeOf((*EFS_CERTIFICATE_BLOB)(nil)).Elem() + types["ENCRYPTION_CERTIFICATE"] = reflect.TypeOf((*ENCRYPTION_CERTIFICATE)(nil)).Elem() + types["ENCRYPTION_CERTIFICATE_LIST"] = reflect.TypeOf((*ENCRYPTION_CERTIFICATE_LIST)(nil)).Elem() + types["ENG_TIME_FIELDS"] = reflect.TypeOf((*ENG_TIME_FIELDS)(nil)).Elem() + types["ENHMETAHEADER"] = reflect.TypeOf((*ENHMETAHEADER)(nil)).Elem() + types["ENHMETARECORD"] = reflect.TypeOf((*ENHMETARECORD)(nil)).Elem() + types["ENHMFENUMPROC"] = reflect.TypeOf((*ENHMFENUMPROC)(nil)).Elem() + types["ENUMLOGFONTEX"] = reflect.TypeOf((*ENUMLOGFONTEX)(nil)).Elem() + types["ENUMLOGFONTEXDV"] = reflect.TypeOf((*ENUMLOGFONTEXDV)(nil)).Elem() + types["ENUMRESLANGPROC"] = reflect.TypeOf((*ENUMRESLANGPROC)(nil)).Elem() + types["ENUM_PAGE_FILE_INFORMATION"] = reflect.TypeOf((*ENUM_PAGE_FILE_INFORMATION)(nil)).Elem() + types["EXCEPINFO"] = reflect.TypeOf((*EXCEPINFO)(nil)).Elem() + types["EXPLICIT_ACCESS"] = reflect.TypeOf((*EXPLICIT_ACCESS)(nil)).Elem() + types["EXPR_EVAL"] = reflect.TypeOf((*EXPR_EVAL)(nil)).Elem() + types["Error_status_t"] = reflect.TypeOf((*Error_status_t)(nil)).Elem() + types["FARPROC"] = reflect.TypeOf((*FARPROC)(nil)).Elem() + types["FD_GLYPHATTR"] = reflect.TypeOf((*FD_GLYPHATTR)(nil)).Elem() + types["FILEOP_FLAGS"] = reflect.TypeOf((*FILEOP_FLAGS)(nil)).Elem() + types["FILETIME"] = reflect.TypeOf((*FILETIME)(nil)).Elem() + types["FINDREPLACE"] = reflect.TypeOf((*FINDREPLACE)(nil)).Elem() + types["FIX"] = reflect.TypeOf((*FIX)(nil)).Elem() + types["FIXED"] = reflect.TypeOf((*FIXED)(nil)).Elem() + types["FIXED_INFO_W2KSP1"] = reflect.TypeOf((*FIXED_INFO_W2KSP1)(nil)).Elem() + types["FLASHWINFO"] = reflect.TypeOf((*FLASHWINFO)(nil)).Elem() + types["FLOAT"] = reflect.TypeOf((*FLOAT)(nil)).Elem() + types["FLOATL"] = reflect.TypeOf((*FLOATL)(nil)).Elem() + types["FLOAT_LONG"] = reflect.TypeOf((*FLOAT_LONG)(nil)).Elem() + types["FLONG"] = reflect.TypeOf((*FLONG)(nil)).Elem() + types["FLOWSPEC"] = reflect.TypeOf((*FLOWSPEC)(nil)).Elem() + types["FMTID"] = reflect.TypeOf((*FMTID)(nil)).Elem() + types["FOLDERVIEWMODE"] = reflect.TypeOf((*FOLDERVIEWMODE)(nil)).Elem() + types["FONTDESC"] = reflect.TypeOf((*FONTDESC)(nil)).Elem() + types["FONTENUMPROC"] = reflect.TypeOf((*FONTENUMPROC)(nil)).Elem() + types["FONTINFO"] = reflect.TypeOf((*FONTINFO)(nil)).Elem() + types["FONTOBJ"] = reflect.TypeOf((*FONTOBJ)(nil)).Elem() + types["FONTSIGNATURE"] = reflect.TypeOf((*FONTSIGNATURE)(nil)).Elem() + types["FORMATETC"] = reflect.TypeOf((*FORMATETC)(nil)).Elem() + types["FOURCC"] = reflect.TypeOf((*FOURCC)(nil)).Elem() + types["FULL_PTR_XLAT_TABLES"] = reflect.TypeOf((*FULL_PTR_XLAT_TABLES)(nil)).Elem() + types["FXPT2DOT30"] = reflect.TypeOf((*FXPT2DOT30)(nil)).Elem() + types["GCP_RESULTS"] = reflect.TypeOf((*GCP_RESULTS)(nil)).Elem() + types["GENERIC_BINDING_INFO"] = reflect.TypeOf((*GENERIC_BINDING_INFO)(nil)).Elem() + types["GENERIC_BINDING_ROUTINE"] = reflect.TypeOf((*GENERIC_BINDING_ROUTINE)(nil)).Elem() + types["GENERIC_BINDING_ROUTINE_PAIR"] = reflect.TypeOf((*GENERIC_BINDING_ROUTINE_PAIR)(nil)).Elem() + types["GENERIC_MAPPING"] = reflect.TypeOf((*GENERIC_MAPPING)(nil)).Elem() + types["GENERIC_UNBIND_ROUTINE"] = reflect.TypeOf((*GENERIC_UNBIND_ROUTINE)(nil)).Elem() + types["GEOID"] = reflect.TypeOf((*GEOID)(nil)).Elem() + types["GESTURECONFIG"] = reflect.TypeOf((*GESTURECONFIG)(nil)).Elem() + types["GESTUREINFO"] = reflect.TypeOf((*GESTUREINFO)(nil)).Elem() + types["GETPROPERTYSTOREFLAGS"] = reflect.TypeOf((*GETPROPERTYSTOREFLAGS)(nil)).Elem() + types["GLYPHBITS"] = reflect.TypeOf((*GLYPHBITS)(nil)).Elem() + types["GLYPHDEF"] = reflect.TypeOf((*GLYPHDEF)(nil)).Elem() + types["GLYPHMETRICS"] = reflect.TypeOf((*GLYPHMETRICS)(nil)).Elem() + types["GLYPHMETRICSFLOAT"] = reflect.TypeOf((*GLYPHMETRICSFLOAT)(nil)).Elem() + types["GLYPHPOS"] = reflect.TypeOf((*GLYPHPOS)(nil)).Elem() + types["GLYPHSET"] = reflect.TypeOf((*GLYPHSET)(nil)).Elem() + types["GLbitfield"] = reflect.TypeOf((*GLbitfield)(nil)).Elem() + types["GLboolean"] = reflect.TypeOf((*GLboolean)(nil)).Elem() + types["GLbyte"] = reflect.TypeOf((*GLbyte)(nil)).Elem() + types["GLclampd"] = reflect.TypeOf((*GLclampd)(nil)).Elem() + types["GLclampf"] = reflect.TypeOf((*GLclampf)(nil)).Elem() + types["GLdouble"] = reflect.TypeOf((*GLdouble)(nil)).Elem() + types["GLenum"] = reflect.TypeOf((*GLenum)(nil)).Elem() + types["GLfloat"] = reflect.TypeOf((*GLfloat)(nil)).Elem() + types["GLint"] = reflect.TypeOf((*GLint)(nil)).Elem() + types["GLshort"] = reflect.TypeOf((*GLshort)(nil)).Elem() + types["GLsizei"] = reflect.TypeOf((*GLsizei)(nil)).Elem() + types["GLubyte"] = reflect.TypeOf((*GLubyte)(nil)).Elem() + types["GLuint"] = reflect.TypeOf((*GLuint)(nil)).Elem() + types["GLushort"] = reflect.TypeOf((*GLushort)(nil)).Elem() + types["GOBJENUMPROC"] = reflect.TypeOf((*GOBJENUMPROC)(nil)).Elem() + types["GRAYSTRINGPROC"] = reflect.TypeOf((*GRAYSTRINGPROC)(nil)).Elem() + types["GROUP"] = reflect.TypeOf((*GROUP)(nil)).Elem() + types["GUID"] = reflect.TypeOf((*GUID)(nil)).Elem() + types["GUITHREADINFO"] = reflect.TypeOf((*GUITHREADINFO)(nil)).Elem() + types["GdiplusStartupInput"] = reflect.TypeOf((*GdiplusStartupInput)(nil)).Elem() + types["GdiplusStartupOutput"] = reflect.TypeOf((*GdiplusStartupOutput)(nil)).Elem() + types["GpStatus"] = reflect.TypeOf((*GpStatus)(nil)).Elem() + types["HACCEL"] = reflect.TypeOf((*HACCEL)(nil)).Elem() + types["HANDLE"] = reflect.TypeOf((*HANDLE)(nil)).Elem() + types["HANDLER_FUNCTION_EX"] = reflect.TypeOf((*HANDLER_FUNCTION_EX)(nil)).Elem() + types["HANDLETABLE"] = reflect.TypeOf((*HANDLETABLE)(nil)).Elem() + types["HANIMATIONBUFFER"] = reflect.TypeOf((*HANIMATIONBUFFER)(nil)).Elem() + types["HARDWAREINPUT"] = reflect.TypeOf((*HARDWAREINPUT)(nil)).Elem() + types["HBITMAP"] = reflect.TypeOf((*HBITMAP)(nil)).Elem() + types["HBRUSH"] = reflect.TypeOf((*HBRUSH)(nil)).Elem() + types["HCERTSTORE"] = reflect.TypeOf((*HCERTSTORE)(nil)).Elem() + types["HCOLORSPACE"] = reflect.TypeOf((*HCOLORSPACE)(nil)).Elem() + types["HCONV"] = reflect.TypeOf((*HCONV)(nil)).Elem() + types["HCONVLIST"] = reflect.TypeOf((*HCONVLIST)(nil)).Elem() + types["HCRYPTHASH"] = reflect.TypeOf((*HCRYPTHASH)(nil)).Elem() + types["HCRYPTKEY"] = reflect.TypeOf((*HCRYPTKEY)(nil)).Elem() + types["HCRYPTMSG"] = reflect.TypeOf((*HCRYPTMSG)(nil)).Elem() + types["HCRYPTPROV"] = reflect.TypeOf((*HCRYPTPROV)(nil)).Elem() + types["HCURSOR"] = reflect.TypeOf((*HCURSOR)(nil)).Elem() + types["HDC"] = reflect.TypeOf((*HDC)(nil)).Elem() + types["HDDEDATA"] = reflect.TypeOf((*HDDEDATA)(nil)).Elem() + types["HDESK"] = reflect.TypeOf((*HDESK)(nil)).Elem() + types["HDEV"] = reflect.TypeOf((*HDEV)(nil)).Elem() + types["HDEVNOTIFY"] = reflect.TypeOf((*HDEVNOTIFY)(nil)).Elem() + types["HDPA"] = reflect.TypeOf((*HDPA)(nil)).Elem() + types["HDROP"] = reflect.TypeOf((*HDROP)(nil)).Elem() + types["HDRVR"] = reflect.TypeOf((*HDRVR)(nil)).Elem() + types["HDSA"] = reflect.TypeOf((*HDSA)(nil)).Elem() + types["HDWP"] = reflect.TypeOf((*HDWP)(nil)).Elem() + types["HELPINFO"] = reflect.TypeOf((*HELPINFO)(nil)).Elem() + types["HENHMETAFILE"] = reflect.TypeOf((*HENHMETAFILE)(nil)).Elem() + types["HFONT"] = reflect.TypeOf((*HFONT)(nil)).Elem() + types["HGDIOBJ"] = reflect.TypeOf((*HGDIOBJ)(nil)).Elem() + types["HGESTUREINFO"] = reflect.TypeOf((*HGESTUREINFO)(nil)).Elem() + types["HGLOBAL"] = reflect.TypeOf((*HGLOBAL)(nil)).Elem() + types["HGLRC"] = reflect.TypeOf((*HGLRC)(nil)).Elem() + types["HGLYPH"] = reflect.TypeOf((*HGLYPH)(nil)).Elem() + types["HHOOK"] = reflect.TypeOf((*HHOOK)(nil)).Elem() + types["HICON"] = reflect.TypeOf((*HICON)(nil)).Elem() + types["HIMAGELIST"] = reflect.TypeOf((*HIMAGELIST)(nil)).Elem() + types["HIMC"] = reflect.TypeOf((*HIMC)(nil)).Elem() + types["HIMCC"] = reflect.TypeOf((*HIMCC)(nil)).Elem() + types["HINSTANCE"] = reflect.TypeOf((*HINSTANCE)(nil)).Elem() + types["HKEY"] = reflect.TypeOf((*HKEY)(nil)).Elem() + types["HKL"] = reflect.TypeOf((*HKL)(nil)).Elem() + types["HLOCAL"] = reflect.TypeOf((*HLOCAL)(nil)).Elem() + types["HMENU"] = reflect.TypeOf((*HMENU)(nil)).Elem() + types["HMETAFILE"] = reflect.TypeOf((*HMETAFILE)(nil)).Elem() + types["HMETAFILEPICT"] = reflect.TypeOf((*HMETAFILEPICT)(nil)).Elem() + types["HMIDI"] = reflect.TypeOf((*HMIDI)(nil)).Elem() + types["HMIDIIN"] = reflect.TypeOf((*HMIDIIN)(nil)).Elem() + types["HMIDIOUT"] = reflect.TypeOf((*HMIDIOUT)(nil)).Elem() + types["HMIDISTRM"] = reflect.TypeOf((*HMIDISTRM)(nil)).Elem() + types["HMIXER"] = reflect.TypeOf((*HMIXER)(nil)).Elem() + types["HMIXEROBJ"] = reflect.TypeOf((*HMIXEROBJ)(nil)).Elem() + types["HMMIO"] = reflect.TypeOf((*HMMIO)(nil)).Elem() + types["HMODULE"] = reflect.TypeOf((*HMODULE)(nil)).Elem() + types["HMONITOR"] = reflect.TypeOf((*HMONITOR)(nil)).Elem() + types["HOLEMENU"] = reflect.TypeOf((*HOLEMENU)(nil)).Elem() + types["HOOKPROC"] = reflect.TypeOf((*HOOKPROC)(nil)).Elem() + types["HPAINTBUFFER"] = reflect.TypeOf((*HPAINTBUFFER)(nil)).Elem() + types["HPALETTE"] = reflect.TypeOf((*HPALETTE)(nil)).Elem() + types["HPEN"] = reflect.TypeOf((*HPEN)(nil)).Elem() + types["HPOWERNOTIFY"] = reflect.TypeOf((*HPOWERNOTIFY)(nil)).Elem() + types["HPROPSHEETPAGE"] = reflect.TypeOf((*HPROPSHEETPAGE)(nil)).Elem() + types["HPSTR"] = reflect.TypeOf((*HPSTR)(nil)).Elem() + types["HPSXA"] = reflect.TypeOf((*HPSXA)(nil)).Elem() + types["HRAWINPUT"] = reflect.TypeOf((*HRAWINPUT)(nil)).Elem() + types["HRESULT"] = reflect.TypeOf((*HRESULT)(nil)).Elem() + types["HRGN"] = reflect.TypeOf((*HRGN)(nil)).Elem() + types["HRSRC"] = reflect.TypeOf((*HRSRC)(nil)).Elem() + types["HSEMAPHORE"] = reflect.TypeOf((*HSEMAPHORE)(nil)).Elem() + types["HSURF"] = reflect.TypeOf((*HSURF)(nil)).Elem() + types["HSZ"] = reflect.TypeOf((*HSZ)(nil)).Elem() + types["HTASK"] = reflect.TypeOf((*HTASK)(nil)).Elem() + types["HTHEME"] = reflect.TypeOf((*HTHEME)(nil)).Elem() + types["HTOUCHINPUT"] = reflect.TypeOf((*HTOUCHINPUT)(nil)).Elem() + types["HUSKEY"] = reflect.TypeOf((*HUSKEY)(nil)).Elem() + types["HWAVEIN"] = reflect.TypeOf((*HWAVEIN)(nil)).Elem() + types["HWAVEOUT"] = reflect.TypeOf((*HWAVEOUT)(nil)).Elem() + types["HWCT"] = reflect.TypeOf((*HWCT)(nil)).Elem() + types["HWINEVENTHOOK"] = reflect.TypeOf((*HWINEVENTHOOK)(nil)).Elem() + types["HWINSTA"] = reflect.TypeOf((*HWINSTA)(nil)).Elem() + types["HWND"] = reflect.TypeOf((*HWND)(nil)).Elem() + types["Handle_t"] = reflect.TypeOf((*Handle_t)(nil)).Elem() + types["IAdviseSink"] = reflect.TypeOf((*IAdviseSink)(nil)).Elem() + types["IBindCtx"] = reflect.TypeOf((*IBindCtx)(nil)).Elem() + types["ICMENUMPROC"] = reflect.TypeOf((*ICMENUMPROC)(nil)).Elem() + types["ICONINFO"] = reflect.TypeOf((*ICONINFO)(nil)).Elem() + types["IChannelHook"] = reflect.TypeOf((*IChannelHook)(nil)).Elem() + types["IClassFactory"] = reflect.TypeOf((*IClassFactory)(nil)).Elem() + types["IConnectionPoint"] = reflect.TypeOf((*IConnectionPoint)(nil)).Elem() + types["IContextMenu"] = reflect.TypeOf((*IContextMenu)(nil)).Elem() + types["IContextMenuCB"] = reflect.TypeOf((*IContextMenuCB)(nil)).Elem() + types["ICreateErrorInfo"] = reflect.TypeOf((*ICreateErrorInfo)(nil)).Elem() + types["ICreateTypeLib"] = reflect.TypeOf((*ICreateTypeLib)(nil)).Elem() + types["ICreateTypeLib2"] = reflect.TypeOf((*ICreateTypeLib2)(nil)).Elem() + types["IDL_CS_CONVERT"] = reflect.TypeOf((*IDL_CS_CONVERT)(nil)).Elem() + types["IDataAdviseHolder"] = reflect.TypeOf((*IDataAdviseHolder)(nil)).Elem() + types["IDataObject"] = reflect.TypeOf((*IDataObject)(nil)).Elem() + types["IDispatch"] = reflect.TypeOf((*IDispatch)(nil)).Elem() + types["IDropSource"] = reflect.TypeOf((*IDropSource)(nil)).Elem() + types["IDropTarget"] = reflect.TypeOf((*IDropTarget)(nil)).Elem() + types["IEnumAssocHandlers"] = reflect.TypeOf((*IEnumAssocHandlers)(nil)).Elem() + types["IEnumFORMATETC"] = reflect.TypeOf((*IEnumFORMATETC)(nil)).Elem() + types["IEnumOLEVERB"] = reflect.TypeOf((*IEnumOLEVERB)(nil)).Elem() + types["IErrorInfo"] = reflect.TypeOf((*IErrorInfo)(nil)).Elem() + types["IFTYPE"] = reflect.TypeOf((*IFTYPE)(nil)).Elem() + types["IF_INDEX"] = reflect.TypeOf((*IF_INDEX)(nil)).Elem() + types["IF_LUID"] = reflect.TypeOf((*IF_LUID)(nil)).Elem() + types["IF_OPER_STATUS"] = reflect.TypeOf((*IF_OPER_STATUS)(nil)).Elem() + types["IID"] = reflect.TypeOf((*IID)(nil)).Elem() + types["IInitializeSpy"] = reflect.TypeOf((*IInitializeSpy)(nil)).Elem() + types["ILockBytes"] = reflect.TypeOf((*ILockBytes)(nil)).Elem() + types["IMAGEINFO"] = reflect.TypeOf((*IMAGEINFO)(nil)).Elem() + types["IMAGELISTDRAWPARAMS"] = reflect.TypeOf((*IMAGELISTDRAWPARAMS)(nil)).Elem() + types["IMCENUMPROC"] = reflect.TypeOf((*IMCENUMPROC)(nil)).Elem() + types["IMEMENUITEMINFO"] = reflect.TypeOf((*IMEMENUITEMINFO)(nil)).Elem() + types["IMEPRO"] = reflect.TypeOf((*IMEPRO)(nil)).Elem() + types["IMalloc"] = reflect.TypeOf((*IMalloc)(nil)).Elem() + types["IMallocSpy"] = reflect.TypeOf((*IMallocSpy)(nil)).Elem() + types["IMarshal"] = reflect.TypeOf((*IMarshal)(nil)).Elem() + types["IMessageFilter"] = reflect.TypeOf((*IMessageFilter)(nil)).Elem() + types["IMoniker"] = reflect.TypeOf((*IMoniker)(nil)).Elem() + types["IN6_ADDR"] = reflect.TypeOf((*IN6_ADDR)(nil)).Elem() + types["INITCOMMONCONTROLSEX"] = reflect.TypeOf((*INITCOMMONCONTROLSEX)(nil)).Elem() + types["INPUT"] = reflect.TypeOf((*INPUT)(nil)).Elem() + types["INPUTCONTEXT"] = reflect.TypeOf((*INPUTCONTEXT)(nil)).Elem() + types["INT"] = reflect.TypeOf((*INT)(nil)).Elem() + types["INTERFACEDATA"] = reflect.TypeOf((*INTERFACEDATA)(nil)).Elem() + types["INTERFACE_HANDLE"] = reflect.TypeOf((*INTERFACE_HANDLE)(nil)).Elem() + types["INTERNAL_IF_OPER_STATUS"] = reflect.TypeOf((*INTERNAL_IF_OPER_STATUS)(nil)).Elem() + types["INTLIST"] = reflect.TypeOf((*INTLIST)(nil)).Elem() + types["INT_PTR"] = reflect.TypeOf((*INT_PTR)(nil)).Elem() + types["IN_ADDR"] = reflect.TypeOf((*IN_ADDR)(nil)).Elem() + types["IO_STATUS_BLOCK"] = reflect.TypeOf((*IO_STATUS_BLOCK)(nil)).Elem() + types["IOleAdviseHolder"] = reflect.TypeOf((*IOleAdviseHolder)(nil)).Elem() + types["IOleClientSite"] = reflect.TypeOf((*IOleClientSite)(nil)).Elem() + types["IOleInPlaceActiveObject"] = reflect.TypeOf((*IOleInPlaceActiveObject)(nil)).Elem() + types["IOleInPlaceFrame"] = reflect.TypeOf((*IOleInPlaceFrame)(nil)).Elem() + types["IOleObject"] = reflect.TypeOf((*IOleObject)(nil)).Elem() + types["IPAddr"] = reflect.TypeOf((*IPAddr)(nil)).Elem() + types["IPMask"] = reflect.TypeOf((*IPMask)(nil)).Elem() + types["IP_ADAPTER_ADDRESSES_LH"] = reflect.TypeOf((*IP_ADAPTER_ADDRESSES_LH)(nil)).Elem() + types["IP_ADAPTER_ANYCAST_ADDRESS_XP"] = reflect.TypeOf((*IP_ADAPTER_ANYCAST_ADDRESS_XP)(nil)).Elem() + types["IP_ADAPTER_DNS_SERVER_ADDRESS_XP"] = reflect.TypeOf((*IP_ADAPTER_DNS_SERVER_ADDRESS_XP)(nil)).Elem() + types["IP_ADAPTER_DNS_SUFFIX"] = reflect.TypeOf((*IP_ADAPTER_DNS_SUFFIX)(nil)).Elem() + types["IP_ADAPTER_GATEWAY_ADDRESS_LH"] = reflect.TypeOf((*IP_ADAPTER_GATEWAY_ADDRESS_LH)(nil)).Elem() + types["IP_ADAPTER_INDEX_MAP"] = reflect.TypeOf((*IP_ADAPTER_INDEX_MAP)(nil)).Elem() + types["IP_ADAPTER_INFO"] = reflect.TypeOf((*IP_ADAPTER_INFO)(nil)).Elem() + types["IP_ADAPTER_MULTICAST_ADDRESS_XP"] = reflect.TypeOf((*IP_ADAPTER_MULTICAST_ADDRESS_XP)(nil)).Elem() + types["IP_ADAPTER_ORDER_MAP"] = reflect.TypeOf((*IP_ADAPTER_ORDER_MAP)(nil)).Elem() + types["IP_ADAPTER_PREFIX_XP"] = reflect.TypeOf((*IP_ADAPTER_PREFIX_XP)(nil)).Elem() + types["IP_ADAPTER_UNICAST_ADDRESS_LH"] = reflect.TypeOf((*IP_ADAPTER_UNICAST_ADDRESS_LH)(nil)).Elem() + types["IP_ADAPTER_WINS_SERVER_ADDRESS_LH"] = reflect.TypeOf((*IP_ADAPTER_WINS_SERVER_ADDRESS_LH)(nil)).Elem() + types["IP_ADDRESS_STRING"] = reflect.TypeOf((*IP_ADDRESS_STRING)(nil)).Elem() + types["IP_ADDR_STRING"] = reflect.TypeOf((*IP_ADDR_STRING)(nil)).Elem() + types["IP_DAD_STATE"] = reflect.TypeOf((*IP_DAD_STATE)(nil)).Elem() + types["IP_INTERFACE_INFO"] = reflect.TypeOf((*IP_INTERFACE_INFO)(nil)).Elem() + types["IP_INTERFACE_NAME_INFO"] = reflect.TypeOf((*IP_INTERFACE_NAME_INFO)(nil)).Elem() + types["IP_INTERFACE_NAME_INFO_W2KSP1"] = reflect.TypeOf((*IP_INTERFACE_NAME_INFO_W2KSP1)(nil)).Elem() + types["IP_MASK_STRING"] = reflect.TypeOf((*IP_MASK_STRING)(nil)).Elem() + types["IP_OPTION_INFORMATION"] = reflect.TypeOf((*IP_OPTION_INFORMATION)(nil)).Elem() + types["IP_PER_ADAPTER_INFO_W2KSP1"] = reflect.TypeOf((*IP_PER_ADAPTER_INFO_W2KSP1)(nil)).Elem() + types["IP_PREFIX_ORIGIN"] = reflect.TypeOf((*IP_PREFIX_ORIGIN)(nil)).Elem() + types["IP_STATUS"] = reflect.TypeOf((*IP_STATUS)(nil)).Elem() + types["IP_SUFFIX_ORIGIN"] = reflect.TypeOf((*IP_SUFFIX_ORIGIN)(nil)).Elem() + types["IP_UNIDIRECTIONAL_ADAPTER_ADDRESS"] = reflect.TypeOf((*IP_UNIDIRECTIONAL_ADAPTER_ADDRESS)(nil)).Elem() + types["IPersistStorage"] = reflect.TypeOf((*IPersistStorage)(nil)).Elem() + types["IPersistStream"] = reflect.TypeOf((*IPersistStream)(nil)).Elem() + types["IPropertySetStorage"] = reflect.TypeOf((*IPropertySetStorage)(nil)).Elem() + types["IPropertyStorage"] = reflect.TypeOf((*IPropertyStorage)(nil)).Elem() + types["IRecordInfo"] = reflect.TypeOf((*IRecordInfo)(nil)).Elem() + types["IRpcChannelBuffer"] = reflect.TypeOf((*IRpcChannelBuffer)(nil)).Elem() + types["IRpcStubBuffer"] = reflect.TypeOf((*IRpcStubBuffer)(nil)).Elem() + types["IRunningObjectTable"] = reflect.TypeOf((*IRunningObjectTable)(nil)).Elem() + types["IShellFolder"] = reflect.TypeOf((*IShellFolder)(nil)).Elem() + types["IShellFolderViewCB"] = reflect.TypeOf((*IShellFolderViewCB)(nil)).Elem() + types["IShellItem"] = reflect.TypeOf((*IShellItem)(nil)).Elem() + types["IShellItemArray"] = reflect.TypeOf((*IShellItemArray)(nil)).Elem() + types["IShellView"] = reflect.TypeOf((*IShellView)(nil)).Elem() + types["IStorage"] = reflect.TypeOf((*IStorage)(nil)).Elem() + types["IStream"] = reflect.TypeOf((*IStream)(nil)).Elem() + types["ITEMIDLIST"] = reflect.TypeOf((*ITEMIDLIST)(nil)).Elem() + types["ITypeInfo"] = reflect.TypeOf((*ITypeInfo)(nil)).Elem() + types["ITypeLib"] = reflect.TypeOf((*ITypeLib)(nil)).Elem() + types["IUnknown"] = reflect.TypeOf((*IUnknown)(nil)).Elem() + types["I_RPC_HANDLE"] = reflect.TypeOf((*I_RPC_HANDLE)(nil)).Elem() + types["JOYCAPS"] = reflect.TypeOf((*JOYCAPS)(nil)).Elem() + types["JOYINFO"] = reflect.TypeOf((*JOYINFO)(nil)).Elem() + types["JOYINFOEX"] = reflect.TypeOf((*JOYINFOEX)(nil)).Elem() + types["KERNINGPAIR"] = reflect.TypeOf((*KERNINGPAIR)(nil)).Elem() + types["KEYBDINPUT"] = reflect.TypeOf((*KEYBDINPUT)(nil)).Elem() + types["KNOWNFOLDERID"] = reflect.TypeOf((*KNOWNFOLDERID)(nil)).Elem() + types["KNOWN_FOLDER_FLAG"] = reflect.TypeOf((*KNOWN_FOLDER_FLAG)(nil)).Elem() + types["LANGID"] = reflect.TypeOf((*LANGID)(nil)).Elem() + types["LARGE_INTEGER"] = reflect.TypeOf((*LARGE_INTEGER)(nil)).Elem() + types["LASTINPUTINFO"] = reflect.TypeOf((*LASTINPUTINFO)(nil)).Elem() + types["LAYERPLANEDESCRIPTOR"] = reflect.TypeOf((*LAYERPLANEDESCRIPTOR)(nil)).Elem() + types["LCID"] = reflect.TypeOf((*LCID)(nil)).Elem() + types["LCSCSTYPE"] = reflect.TypeOf((*LCSCSTYPE)(nil)).Elem() + types["LCSGAMUTMATCH"] = reflect.TypeOf((*LCSGAMUTMATCH)(nil)).Elem() + types["LCTYPE"] = reflect.TypeOf((*LCTYPE)(nil)).Elem() + types["LINEATTRS"] = reflect.TypeOf((*LINEATTRS)(nil)).Elem() + types["LINEDDAPROC"] = reflect.TypeOf((*LINEDDAPROC)(nil)).Elem() + types["LOGBRUSH"] = reflect.TypeOf((*LOGBRUSH)(nil)).Elem() + types["LOGCOLORSPACE"] = reflect.TypeOf((*LOGCOLORSPACE)(nil)).Elem() + types["LOGFONT"] = reflect.TypeOf((*LOGFONT)(nil)).Elem() + types["LOGPALETTE"] = reflect.TypeOf((*LOGPALETTE)(nil)).Elem() + types["LOGPEN"] = reflect.TypeOf((*LOGPEN)(nil)).Elem() + types["LONG"] = reflect.TypeOf((*LONG)(nil)).Elem() + types["LONG64"] = reflect.TypeOf((*LONG64)(nil)).Elem() + types["LONGLONG"] = reflect.TypeOf((*LONGLONG)(nil)).Elem() + types["LONG_PTR"] = reflect.TypeOf((*LONG_PTR)(nil)).Elem() + types["LPAFPROTOCOLS"] = reflect.TypeOf((*LPAFPROTOCOLS)(nil)).Elem() + types["LPARAM"] = reflect.TypeOf((*LPARAM)(nil)).Elem() + types["LPBC"] = reflect.TypeOf((*LPBC)(nil)).Elem() + types["LPBLOB"] = reflect.TypeOf((*LPBLOB)(nil)).Elem() + types["LPBROWSEINFO"] = reflect.TypeOf((*LPBROWSEINFO)(nil)).Elem() + types["LPBYTE"] = reflect.TypeOf((*LPBYTE)(nil)).Elem() + types["LPCFHOOKPROC"] = reflect.TypeOf((*LPCFHOOKPROC)(nil)).Elem() + types["LPCHOOSEFONT"] = reflect.TypeOf((*LPCHOOSEFONT)(nil)).Elem() + types["LPCITEMIDLIST"] = reflect.TypeOf((*LPCITEMIDLIST)(nil)).Elem() + types["LPCOLESTR"] = reflect.TypeOf((*LPCOLESTR)(nil)).Elem() + types["LPCONDITIONPROC"] = reflect.TypeOf((*LPCONDITIONPROC)(nil)).Elem() + types["LPCPINFO"] = reflect.TypeOf((*LPCPINFO)(nil)).Elem() + types["LPCPINFOEX"] = reflect.TypeOf((*LPCPINFOEX)(nil)).Elem() + types["LPCSADDR_INFO"] = reflect.TypeOf((*LPCSADDR_INFO)(nil)).Elem() + types["LPCSFV"] = reflect.TypeOf((*LPCSFV)(nil)).Elem() + types["LPCSTR"] = reflect.TypeOf((*LPCSTR)(nil)).Elem() + types["LPCWSTR"] = reflect.TypeOf((*LPCWSTR)(nil)).Elem() + types["LPDATAOBJECT"] = reflect.TypeOf((*LPDATAOBJECT)(nil)).Elem() + types["LPDEVMODE"] = reflect.TypeOf((*LPDEVMODE)(nil)).Elem() + types["LPDISPATCH"] = reflect.TypeOf((*LPDISPATCH)(nil)).Elem() + types["LPDROPSOURCE"] = reflect.TypeOf((*LPDROPSOURCE)(nil)).Elem() + types["LPDROPTARGET"] = reflect.TypeOf((*LPDROPTARGET)(nil)).Elem() + types["LPENUMFORMATETC"] = reflect.TypeOf((*LPENUMFORMATETC)(nil)).Elem() + types["LPENUMOLEVERB"] = reflect.TypeOf((*LPENUMOLEVERB)(nil)).Elem() + types["LPFINDREPLACE"] = reflect.TypeOf((*LPFINDREPLACE)(nil)).Elem() + types["LPFNADDPROPSHEETPAGE"] = reflect.TypeOf((*LPFNADDPROPSHEETPAGE)(nil)).Elem() + types["LPFNDFMCALLBACK"] = reflect.TypeOf((*LPFNDFMCALLBACK)(nil)).Elem() + types["LPFNVIEWCALLBACK"] = reflect.TypeOf((*LPFNVIEWCALLBACK)(nil)).Elem() + types["LPFRHOOKPROC"] = reflect.TypeOf((*LPFRHOOKPROC)(nil)).Elem() + types["LPGCP_RESULTS"] = reflect.TypeOf((*LPGCP_RESULTS)(nil)).Elem() + types["LPGUID"] = reflect.TypeOf((*LPGUID)(nil)).Elem() + types["LPHELPINFO"] = reflect.TypeOf((*LPHELPINFO)(nil)).Elem() + types["LPIMEMENUITEMINFO"] = reflect.TypeOf((*LPIMEMENUITEMINFO)(nil)).Elem() + types["LPITEMIDLIST"] = reflect.TypeOf((*LPITEMIDLIST)(nil)).Elem() + types["LPJOYCAPS"] = reflect.TypeOf((*LPJOYCAPS)(nil)).Elem() + types["LPJOYINFO"] = reflect.TypeOf((*LPJOYINFO)(nil)).Elem() + types["LPLOGCOLORSPACE"] = reflect.TypeOf((*LPLOGCOLORSPACE)(nil)).Elem() + types["LPLOGFONT"] = reflect.TypeOf((*LPLOGFONT)(nil)).Elem() + types["LPLOOKUPSERVICE_COMPLETION_ROUTINE"] = reflect.TypeOf((*LPLOOKUPSERVICE_COMPLETION_ROUTINE)(nil)).Elem() + types["LPMALLOC"] = reflect.TypeOf((*LPMALLOC)(nil)).Elem() + types["LPMALLOCSPY"] = reflect.TypeOf((*LPMALLOCSPY)(nil)).Elem() + types["LPMARSHAL"] = reflect.TypeOf((*LPMARSHAL)(nil)).Elem() + types["LPMESSAGEFILTER"] = reflect.TypeOf((*LPMESSAGEFILTER)(nil)).Elem() + types["LPMIDIOUTCAPS"] = reflect.TypeOf((*LPMIDIOUTCAPS)(nil)).Elem() + types["LPMIXERCAPS"] = reflect.TypeOf((*LPMIXERCAPS)(nil)).Elem() + types["LPMIXERCONTROL"] = reflect.TypeOf((*LPMIXERCONTROL)(nil)).Elem() + types["LPMIXERLINE"] = reflect.TypeOf((*LPMIXERLINE)(nil)).Elem() + types["LPMIXERLINECONTROLS"] = reflect.TypeOf((*LPMIXERLINECONTROLS)(nil)).Elem() + types["LPMMCKINFO"] = reflect.TypeOf((*LPMMCKINFO)(nil)).Elem() + types["LPMMIOINFO"] = reflect.TypeOf((*LPMMIOINFO)(nil)).Elem() + types["LPMONIKER"] = reflect.TypeOf((*LPMONIKER)(nil)).Elem() + types["LPOFNHOOKPROC"] = reflect.TypeOf((*LPOFNHOOKPROC)(nil)).Elem() + types["LPOLECLIENTSITE"] = reflect.TypeOf((*LPOLECLIENTSITE)(nil)).Elem() + types["LPOLEINPLACEACTIVEOBJECT"] = reflect.TypeOf((*LPOLEINPLACEACTIVEOBJECT)(nil)).Elem() + types["LPOLEINPLACEFRAME"] = reflect.TypeOf((*LPOLEINPLACEFRAME)(nil)).Elem() + types["LPOLEINPLACEFRAMEINFO"] = reflect.TypeOf((*LPOLEINPLACEFRAMEINFO)(nil)).Elem() + types["LPOLEMENUGROUPWIDTHS"] = reflect.TypeOf((*LPOLEMENUGROUPWIDTHS)(nil)).Elem() + types["LPOLEOBJECT"] = reflect.TypeOf((*LPOLEOBJECT)(nil)).Elem() + types["LPOLESTR"] = reflect.TypeOf((*LPOLESTR)(nil)).Elem() + types["LPOLESTREAM"] = reflect.TypeOf((*LPOLESTREAM)(nil)).Elem() + types["LPOPENFILENAME"] = reflect.TypeOf((*LPOPENFILENAME)(nil)).Elem() + types["LPOUTLINETEXTMETRIC"] = reflect.TypeOf((*LPOUTLINETEXTMETRIC)(nil)).Elem() + types["LPPAGEPAINTHOOK"] = reflect.TypeOf((*LPPAGEPAINTHOOK)(nil)).Elem() + types["LPPAGESETUPDLG"] = reflect.TypeOf((*LPPAGESETUPDLG)(nil)).Elem() + types["LPPAGESETUPHOOK"] = reflect.TypeOf((*LPPAGESETUPHOOK)(nil)).Elem() + types["LPPERSISTSTORAGE"] = reflect.TypeOf((*LPPERSISTSTORAGE)(nil)).Elem() + types["LPPRINTDLG"] = reflect.TypeOf((*LPPRINTDLG)(nil)).Elem() + types["LPPRINTDLGEX"] = reflect.TypeOf((*LPPRINTDLGEX)(nil)).Elem() + types["LPPRINTHOOKPROC"] = reflect.TypeOf((*LPPRINTHOOKPROC)(nil)).Elem() + types["LPPRINTPAGERANGE"] = reflect.TypeOf((*LPPRINTPAGERANGE)(nil)).Elem() + types["LPQOS"] = reflect.TypeOf((*LPQOS)(nil)).Elem() + types["LPRASTERIZER_STATUS"] = reflect.TypeOf((*LPRASTERIZER_STATUS)(nil)).Elem() + types["LPRECT"] = reflect.TypeOf((*LPRECT)(nil)).Elem() + types["LPRUNNINGOBJECTTABLE"] = reflect.TypeOf((*LPRUNNINGOBJECTTABLE)(nil)).Elem() + types["LPSAFEARRAY"] = reflect.TypeOf((*LPSAFEARRAY)(nil)).Elem() + types["LPSETUPHOOKPROC"] = reflect.TypeOf((*LPSETUPHOOKPROC)(nil)).Elem() + types["LPSHELLFLAGSTATE"] = reflect.TypeOf((*LPSHELLFLAGSTATE)(nil)).Elem() + types["LPSHELLFOLDER"] = reflect.TypeOf((*LPSHELLFOLDER)(nil)).Elem() + types["LPSHELLSTATE"] = reflect.TypeOf((*LPSHELLSTATE)(nil)).Elem() + types["LPSHFILEOPSTRUCT"] = reflect.TypeOf((*LPSHFILEOPSTRUCT)(nil)).Elem() + types["LPSHQUERYRBINFO"] = reflect.TypeOf((*LPSHQUERYRBINFO)(nil)).Elem() + types["LPSOCKADDR"] = reflect.TypeOf((*LPSOCKADDR)(nil)).Elem() + types["LPSTORAGE"] = reflect.TypeOf((*LPSTORAGE)(nil)).Elem() + types["LPSTR"] = reflect.TypeOf((*LPSTR)(nil)).Elem() + types["LPSTREAM"] = reflect.TypeOf((*LPSTREAM)(nil)).Elem() + types["LPSTYLEBUF"] = reflect.TypeOf((*LPSTYLEBUF)(nil)).Elem() + types["LPTEXTMETRIC"] = reflect.TypeOf((*LPTEXTMETRIC)(nil)).Elem() + types["LPTIMECAPS"] = reflect.TypeOf((*LPTIMECAPS)(nil)).Elem() + types["LPUNKNOWN"] = reflect.TypeOf((*LPUNKNOWN)(nil)).Elem() + types["LPVERSIONEDSTREAM"] = reflect.TypeOf((*LPVERSIONEDSTREAM)(nil)).Elem() + types["LPVOID"] = reflect.TypeOf((*LPVOID)(nil)).Elem() + types["LPWAVEHDR"] = reflect.TypeOf((*LPWAVEHDR)(nil)).Elem() + types["LPWAVEINCAPS"] = reflect.TypeOf((*LPWAVEINCAPS)(nil)).Elem() + types["LPWAVEOUTCAPS"] = reflect.TypeOf((*LPWAVEOUTCAPS)(nil)).Elem() + types["LPWPUPOSTMESSAGE"] = reflect.TypeOf((*LPWPUPOSTMESSAGE)(nil)).Elem() + types["LPWSABUF"] = reflect.TypeOf((*LPWSABUF)(nil)).Elem() + types["LPWSANAMESPACE_INFO"] = reflect.TypeOf((*LPWSANAMESPACE_INFO)(nil)).Elem() + types["LPWSANSCLASSINFO"] = reflect.TypeOf((*LPWSANSCLASSINFO)(nil)).Elem() + types["LPWSAOVERLAPPED"] = reflect.TypeOf((*LPWSAOVERLAPPED)(nil)).Elem() + types["LPWSAOVERLAPPED_COMPLETION_ROUTINE"] = reflect.TypeOf((*LPWSAOVERLAPPED_COMPLETION_ROUTINE)(nil)).Elem() + types["LPWSAPROTOCOL_INFO"] = reflect.TypeOf((*LPWSAPROTOCOL_INFO)(nil)).Elem() + types["LPWSAQUERYSET"] = reflect.TypeOf((*LPWSAQUERYSET)(nil)).Elem() + types["LPWSASERVICECLASSINFO"] = reflect.TypeOf((*LPWSASERVICECLASSINFO)(nil)).Elem() + types["LPWSAVERSION"] = reflect.TypeOf((*LPWSAVERSION)(nil)).Elem() + types["LPWSTR"] = reflect.TypeOf((*LPWSTR)(nil)).Elem() + types["LRESULT"] = reflect.TypeOf((*LRESULT)(nil)).Elem() + types["LUID"] = reflect.TypeOf((*LUID)(nil)).Elem() + types["LUID_AND_ATTRIBUTES"] = reflect.TypeOf((*LUID_AND_ATTRIBUTES)(nil)).Elem() + types["MALLOC_FREE_STRUCT"] = reflect.TypeOf((*MALLOC_FREE_STRUCT)(nil)).Elem() + types["MARGINS"] = reflect.TypeOf((*MARGINS)(nil)).Elem() + types["MAT2"] = reflect.TypeOf((*MAT2)(nil)).Elem() + types["MCIDEVICEID"] = reflect.TypeOf((*MCIDEVICEID)(nil)).Elem() + types["MCIERROR"] = reflect.TypeOf((*MCIERROR)(nil)).Elem() + types["MENUBARINFO"] = reflect.TypeOf((*MENUBARINFO)(nil)).Elem() + types["MENUINFO"] = reflect.TypeOf((*MENUINFO)(nil)).Elem() + types["MENUITEMINFO"] = reflect.TypeOf((*MENUITEMINFO)(nil)).Elem() + types["METAFILEPICT"] = reflect.TypeOf((*METAFILEPICT)(nil)).Elem() + types["METARECORD"] = reflect.TypeOf((*METARECORD)(nil)).Elem() + types["METHODDATA"] = reflect.TypeOf((*METHODDATA)(nil)).Elem() + types["MFENUMPROC"] = reflect.TypeOf((*MFENUMPROC)(nil)).Elem() + types["MIBICMPINFO"] = reflect.TypeOf((*MIBICMPINFO)(nil)).Elem() + types["MIBICMPSTATS"] = reflect.TypeOf((*MIBICMPSTATS)(nil)).Elem() + types["MIBICMPSTATS_EX"] = reflect.TypeOf((*MIBICMPSTATS_EX)(nil)).Elem() + types["MIBICMPSTATS_EX_XPSP1"] = reflect.TypeOf((*MIBICMPSTATS_EX_XPSP1)(nil)).Elem() + types["MIB_ICMP"] = reflect.TypeOf((*MIB_ICMP)(nil)).Elem() + types["MIB_ICMP_EX_XPSP1"] = reflect.TypeOf((*MIB_ICMP_EX_XPSP1)(nil)).Elem() + types["MIB_IFROW"] = reflect.TypeOf((*MIB_IFROW)(nil)).Elem() + types["MIB_IFTABLE"] = reflect.TypeOf((*MIB_IFTABLE)(nil)).Elem() + types["MIB_IF_ROW2"] = reflect.TypeOf((*MIB_IF_ROW2)(nil)).Elem() + types["MIB_IF_TABLE2"] = reflect.TypeOf((*MIB_IF_TABLE2)(nil)).Elem() + types["MIB_IPADDRROW"] = reflect.TypeOf((*MIB_IPADDRROW)(nil)).Elem() + types["MIB_IPADDRROW_XP"] = reflect.TypeOf((*MIB_IPADDRROW_XP)(nil)).Elem() + types["MIB_IPADDRTABLE"] = reflect.TypeOf((*MIB_IPADDRTABLE)(nil)).Elem() + types["MIB_IPFORWARDROW"] = reflect.TypeOf((*MIB_IPFORWARDROW)(nil)).Elem() + types["MIB_IPFORWARDTABLE"] = reflect.TypeOf((*MIB_IPFORWARDTABLE)(nil)).Elem() + types["MIB_IPFORWARD_PROTO"] = reflect.TypeOf((*MIB_IPFORWARD_PROTO)(nil)).Elem() + types["MIB_IPFORWARD_TYPE"] = reflect.TypeOf((*MIB_IPFORWARD_TYPE)(nil)).Elem() + types["MIB_IPNETROW"] = reflect.TypeOf((*MIB_IPNETROW)(nil)).Elem() + types["MIB_IPNETROW_LH"] = reflect.TypeOf((*MIB_IPNETROW_LH)(nil)).Elem() + types["MIB_IPNETTABLE"] = reflect.TypeOf((*MIB_IPNETTABLE)(nil)).Elem() + types["MIB_IPNET_TYPE"] = reflect.TypeOf((*MIB_IPNET_TYPE)(nil)).Elem() + types["MIB_IPSTATS_FORWARDING"] = reflect.TypeOf((*MIB_IPSTATS_FORWARDING)(nil)).Elem() + types["MIB_IPSTATS_LH"] = reflect.TypeOf((*MIB_IPSTATS_LH)(nil)).Elem() + types["MIB_TCP6ROW"] = reflect.TypeOf((*MIB_TCP6ROW)(nil)).Elem() + types["MIB_TCP6ROW2"] = reflect.TypeOf((*MIB_TCP6ROW2)(nil)).Elem() + types["MIB_TCP6ROW_OWNER_MODULE"] = reflect.TypeOf((*MIB_TCP6ROW_OWNER_MODULE)(nil)).Elem() + types["MIB_TCP6TABLE"] = reflect.TypeOf((*MIB_TCP6TABLE)(nil)).Elem() + types["MIB_TCP6TABLE2"] = reflect.TypeOf((*MIB_TCP6TABLE2)(nil)).Elem() + types["MIB_TCPROW"] = reflect.TypeOf((*MIB_TCPROW)(nil)).Elem() + types["MIB_TCPROW2"] = reflect.TypeOf((*MIB_TCPROW2)(nil)).Elem() + types["MIB_TCPROW_LH"] = reflect.TypeOf((*MIB_TCPROW_LH)(nil)).Elem() + types["MIB_TCPROW_OWNER_MODULE"] = reflect.TypeOf((*MIB_TCPROW_OWNER_MODULE)(nil)).Elem() + types["MIB_TCPSTATS_LH"] = reflect.TypeOf((*MIB_TCPSTATS_LH)(nil)).Elem() + types["MIB_TCPTABLE"] = reflect.TypeOf((*MIB_TCPTABLE)(nil)).Elem() + types["MIB_TCPTABLE2"] = reflect.TypeOf((*MIB_TCPTABLE2)(nil)).Elem() + types["MIB_TCP_STATE"] = reflect.TypeOf((*MIB_TCP_STATE)(nil)).Elem() + types["MIB_UDP6ROW"] = reflect.TypeOf((*MIB_UDP6ROW)(nil)).Elem() + types["MIB_UDP6ROW_OWNER_MODULE"] = reflect.TypeOf((*MIB_UDP6ROW_OWNER_MODULE)(nil)).Elem() + types["MIB_UDP6TABLE"] = reflect.TypeOf((*MIB_UDP6TABLE)(nil)).Elem() + types["MIB_UDPROW"] = reflect.TypeOf((*MIB_UDPROW)(nil)).Elem() + types["MIB_UDPROW_OWNER_MODULE"] = reflect.TypeOf((*MIB_UDPROW_OWNER_MODULE)(nil)).Elem() + types["MIB_UDPSTATS"] = reflect.TypeOf((*MIB_UDPSTATS)(nil)).Elem() + types["MIB_UDPTABLE"] = reflect.TypeOf((*MIB_UDPTABLE)(nil)).Elem() + types["MIDIHDR"] = reflect.TypeOf((*MIDIHDR)(nil)).Elem() + types["MIDIINCAPS"] = reflect.TypeOf((*MIDIINCAPS)(nil)).Elem() + types["MIDIOUTCAPS"] = reflect.TypeOf((*MIDIOUTCAPS)(nil)).Elem() + types["MIDL_STUB_DESC"] = reflect.TypeOf((*MIDL_STUB_DESC)(nil)).Elem() + types["MIDL_STUB_MESSAGE"] = reflect.TypeOf((*MIDL_STUB_MESSAGE)(nil)).Elem() + types["MIX"] = reflect.TypeOf((*MIX)(nil)).Elem() + types["MIXERCAPS"] = reflect.TypeOf((*MIXERCAPS)(nil)).Elem() + types["MIXERCONTROL"] = reflect.TypeOf((*MIXERCONTROL)(nil)).Elem() + types["MIXERCONTROLDETAILS"] = reflect.TypeOf((*MIXERCONTROLDETAILS)(nil)).Elem() + types["MIXERLINE"] = reflect.TypeOf((*MIXERLINE)(nil)).Elem() + types["MIXERLINECONTROLS"] = reflect.TypeOf((*MIXERLINECONTROLS)(nil)).Elem() + types["MMCKINFO"] = reflect.TypeOf((*MMCKINFO)(nil)).Elem() + types["MMIOINFO"] = reflect.TypeOf((*MMIOINFO)(nil)).Elem() + types["MMIOPROC"] = reflect.TypeOf((*MMIOPROC)(nil)).Elem() + types["MMRESULT"] = reflect.TypeOf((*MMRESULT)(nil)).Elem() + types["MMTIME"] = reflect.TypeOf((*MMTIME)(nil)).Elem() + types["MMVERSION"] = reflect.TypeOf((*MMVERSION)(nil)).Elem() + types["MODULEINFO"] = reflect.TypeOf((*MODULEINFO)(nil)).Elem() + types["MONITORENUMPROC"] = reflect.TypeOf((*MONITORENUMPROC)(nil)).Elem() + types["MONITORINFO"] = reflect.TypeOf((*MONITORINFO)(nil)).Elem() + types["MOUSEINPUT"] = reflect.TypeOf((*MOUSEINPUT)(nil)).Elem() + types["MOUSEMOVEPOINT"] = reflect.TypeOf((*MOUSEMOVEPOINT)(nil)).Elem() + types["MRUCMPPROC"] = reflect.TypeOf((*MRUCMPPROC)(nil)).Elem() + types["MRUINFO"] = reflect.TypeOf((*MRUINFO)(nil)).Elem() + types["MSG"] = reflect.TypeOf((*MSG)(nil)).Elem() + types["MSGBOXCALLBACK"] = reflect.TypeOf((*MSGBOXCALLBACK)(nil)).Elem() + types["MSGBOXPARAMS"] = reflect.TypeOf((*MSGBOXPARAMS)(nil)).Elem() + types["MULTIPLE_TRUSTEE_OPERATION"] = reflect.TypeOf((*MULTIPLE_TRUSTEE_OPERATION)(nil)).Elem() + types["MULTI_QI"] = reflect.TypeOf((*MULTI_QI)(nil)).Elem() + types["NDIS_MEDIUM"] = reflect.TypeOf((*NDIS_MEDIUM)(nil)).Elem() + types["NDIS_PHYSICAL_MEDIUM"] = reflect.TypeOf((*NDIS_PHYSICAL_MEDIUM)(nil)).Elem() + types["NDR_CS_ROUTINES"] = reflect.TypeOf((*NDR_CS_ROUTINES)(nil)).Elem() + types["NDR_CS_SIZE_CONVERT_ROUTINES"] = reflect.TypeOf((*NDR_CS_SIZE_CONVERT_ROUTINES)(nil)).Elem() + types["NDR_EXPR_DESC"] = reflect.TypeOf((*NDR_EXPR_DESC)(nil)).Elem() + types["NDR_RUNDOWN"] = reflect.TypeOf((*NDR_RUNDOWN)(nil)).Elem() + types["NDR_SCONTEXT"] = reflect.TypeOf((*NDR_SCONTEXT)(nil)).Elem() + types["NDR_SCONTEXT_"] = reflect.TypeOf((*NDR_SCONTEXT_)(nil)).Elem() + types["NET_ADDRESS_FORMAT"] = reflect.TypeOf((*NET_ADDRESS_FORMAT)(nil)).Elem() + types["NET_ADDRESS_INFO"] = reflect.TypeOf((*NET_ADDRESS_INFO)(nil)).Elem() + types["NET_IFINDEX"] = reflect.TypeOf((*NET_IFINDEX)(nil)).Elem() + types["NET_IF_ACCESS_TYPE"] = reflect.TypeOf((*NET_IF_ACCESS_TYPE)(nil)).Elem() + types["NET_IF_ADMIN_STATUS"] = reflect.TypeOf((*NET_IF_ADMIN_STATUS)(nil)).Elem() + types["NET_IF_COMPARTMENT_ID"] = reflect.TypeOf((*NET_IF_COMPARTMENT_ID)(nil)).Elem() + types["NET_IF_CONNECTION_TYPE"] = reflect.TypeOf((*NET_IF_CONNECTION_TYPE)(nil)).Elem() + types["NET_IF_DIRECTION_TYPE"] = reflect.TypeOf((*NET_IF_DIRECTION_TYPE)(nil)).Elem() + types["NET_IF_MEDIA_CONNECT_STATE"] = reflect.TypeOf((*NET_IF_MEDIA_CONNECT_STATE)(nil)).Elem() + types["NET_IF_NETWORK_GUID"] = reflect.TypeOf((*NET_IF_NETWORK_GUID)(nil)).Elem() + types["NET_LUID"] = reflect.TypeOf((*NET_LUID)(nil)).Elem() + types["NET_LUID_LH"] = reflect.TypeOf((*NET_LUID_LH)(nil)).Elem() + types["NL_DAD_STATE"] = reflect.TypeOf((*NL_DAD_STATE)(nil)).Elem() + types["NL_PREFIX_ORIGIN"] = reflect.TypeOf((*NL_PREFIX_ORIGIN)(nil)).Elem() + types["NL_ROUTE_PROTOCOL"] = reflect.TypeOf((*NL_ROUTE_PROTOCOL)(nil)).Elem() + types["NL_SUFFIX_ORIGIN"] = reflect.TypeOf((*NL_SUFFIX_ORIGIN)(nil)).Elem() + types["NOTIFYICONDATA"] = reflect.TypeOf((*NOTIFYICONDATA)(nil)).Elem() + types["NTSTATUS"] = reflect.TypeOf((*NTSTATUS)(nil)).Elem() + types["NUMPARSE"] = reflect.TypeOf((*NUMPARSE)(nil)).Elem() + types["OBJECTS_AND_NAME"] = reflect.TypeOf((*OBJECTS_AND_NAME)(nil)).Elem() + types["OBJECTS_AND_SID"] = reflect.TypeOf((*OBJECTS_AND_SID)(nil)).Elem() + types["OBJECT_TYPE_LIST"] = reflect.TypeOf((*OBJECT_TYPE_LIST)(nil)).Elem() + types["OCPFIPARAMS"] = reflect.TypeOf((*OCPFIPARAMS)(nil)).Elem() + types["OLECHAR"] = reflect.TypeOf((*OLECHAR)(nil)).Elem() + types["OLEINPLACEFRAMEINFO"] = reflect.TypeOf((*OLEINPLACEFRAMEINFO)(nil)).Elem() + types["OLEMENUGROUPWIDTHS"] = reflect.TypeOf((*OLEMENUGROUPWIDTHS)(nil)).Elem() + types["OLE_COLOR"] = reflect.TypeOf((*OLE_COLOR)(nil)).Elem() + types["OPENFILENAME"] = reflect.TypeOf((*OPENFILENAME)(nil)).Elem() + types["OUTLINETEXTMETRIC"] = reflect.TypeOf((*OUTLINETEXTMETRIC)(nil)).Elem() + types["OVERLAPPED"] = reflect.TypeOf((*OVERLAPPED)(nil)).Elem() + types["PADDRINFO"] = reflect.TypeOf((*PADDRINFO)(nil)).Elem() + types["PAGESETUPDLG"] = reflect.TypeOf((*PAGESETUPDLG)(nil)).Elem() + types["PAINTSTRUCT"] = reflect.TypeOf((*PAINTSTRUCT)(nil)).Elem() + types["PALETTEENTRY"] = reflect.TypeOf((*PALETTEENTRY)(nil)).Elem() + types["PANOSE"] = reflect.TypeOf((*PANOSE)(nil)).Elem() + types["PAPPBARDATA"] = reflect.TypeOf((*PAPPBARDATA)(nil)).Elem() + types["PARAMDATA"] = reflect.TypeOf((*PARAMDATA)(nil)).Elem() + types["PARRAY_INFO"] = reflect.TypeOf((*PARRAY_INFO)(nil)).Elem() + types["PARSEDURL"] = reflect.TypeOf((*PARSEDURL)(nil)).Elem() + types["PATHDATA"] = reflect.TypeOf((*PATHDATA)(nil)).Elem() + types["PATHOBJ"] = reflect.TypeOf((*PATHOBJ)(nil)).Elem() + types["PAUDIT_POLICY_INFORMATION"] = reflect.TypeOf((*PAUDIT_POLICY_INFORMATION)(nil)).Elem() + types["PBYTE"] = reflect.TypeOf((*PBYTE)(nil)).Elem() + types["PCCERT_CONTEXT"] = reflect.TypeOf((*PCCERT_CONTEXT)(nil)).Elem() + types["PCCRL_CONTEXT"] = reflect.TypeOf((*PCCRL_CONTEXT)(nil)).Elem() + types["PCCTL_CONTEXT"] = reflect.TypeOf((*PCCTL_CONTEXT)(nil)).Elem() + types["PCERT_EXTENSION"] = reflect.TypeOf((*PCERT_EXTENSION)(nil)).Elem() + types["PCERT_INFO"] = reflect.TypeOf((*PCERT_INFO)(nil)).Elem() + types["PCERT_NAME_BLOB"] = reflect.TypeOf((*PCERT_NAME_BLOB)(nil)).Elem() + types["PCERT_RDN_VALUE_BLOB"] = reflect.TypeOf((*PCERT_RDN_VALUE_BLOB)(nil)).Elem() + types["PCHAR"] = reflect.TypeOf((*PCHAR)(nil)).Elem() + types["PCIDLIST_ABSOLUTE"] = reflect.TypeOf((*PCIDLIST_ABSOLUTE)(nil)).Elem() + types["PCIDLIST_ABSOLUTE_ARRAY"] = reflect.TypeOf((*PCIDLIST_ABSOLUTE_ARRAY)(nil)).Elem() + types["PCONSOLE_SCREEN_BUFFER_INFO"] = reflect.TypeOf((*PCONSOLE_SCREEN_BUFFER_INFO)(nil)).Elem() + types["PCONSOLE_SCREEN_BUFFER_INFOEX"] = reflect.TypeOf((*PCONSOLE_SCREEN_BUFFER_INFOEX)(nil)).Elem() + types["PCRL_ENTRY"] = reflect.TypeOf((*PCRL_ENTRY)(nil)).Elem() + types["PCRL_INFO"] = reflect.TypeOf((*PCRL_INFO)(nil)).Elem() + types["PCRYPT_ATTRIBUTE"] = reflect.TypeOf((*PCRYPT_ATTRIBUTE)(nil)).Elem() + types["PCRYPT_ATTR_BLOB"] = reflect.TypeOf((*PCRYPT_ATTR_BLOB)(nil)).Elem() + types["PCRYPT_DATA_BLOB"] = reflect.TypeOf((*PCRYPT_DATA_BLOB)(nil)).Elem() + types["PCRYPT_DER_BLOB"] = reflect.TypeOf((*PCRYPT_DER_BLOB)(nil)).Elem() + types["PCRYPT_INTEGER_BLOB"] = reflect.TypeOf((*PCRYPT_INTEGER_BLOB)(nil)).Elem() + types["PCTL_ENTRY"] = reflect.TypeOf((*PCTL_ENTRY)(nil)).Elem() + types["PCTL_INFO"] = reflect.TypeOf((*PCTL_INFO)(nil)).Elem() + types["PCUITEMID_CHILD_ARRAY"] = reflect.TypeOf((*PCUITEMID_CHILD_ARRAY)(nil)).Elem() + types["PCWSTR"] = reflect.TypeOf((*PCWSTR)(nil)).Elem() + types["PCZZWSTR"] = reflect.TypeOf((*PCZZWSTR)(nil)).Elem() + types["PDH_COUNTER_INFO"] = reflect.TypeOf((*PDH_COUNTER_INFO)(nil)).Elem() + types["PDH_COUNTER_PATH_ELEMENTS"] = reflect.TypeOf((*PDH_COUNTER_PATH_ELEMENTS)(nil)).Elem() + types["PDH_DATA_ITEM_PATH_ELEMENTS"] = reflect.TypeOf((*PDH_DATA_ITEM_PATH_ELEMENTS)(nil)).Elem() + types["PDH_FMT_COUNTERVALUE"] = reflect.TypeOf((*PDH_FMT_COUNTERVALUE)(nil)).Elem() + types["PDH_HCOUNTER"] = reflect.TypeOf((*PDH_HCOUNTER)(nil)).Elem() + types["PDH_HLOG"] = reflect.TypeOf((*PDH_HLOG)(nil)).Elem() + types["PDH_HQUERY"] = reflect.TypeOf((*PDH_HQUERY)(nil)).Elem() + types["PDH_RAW_COUNTER"] = reflect.TypeOf((*PDH_RAW_COUNTER)(nil)).Elem() + types["PDH_STATUS"] = reflect.TypeOf((*PDH_STATUS)(nil)).Elem() + types["PENCRYPTION_CERTIFICATE"] = reflect.TypeOf((*PENCRYPTION_CERTIFICATE)(nil)).Elem() + types["PENG_TIME_FIELDS"] = reflect.TypeOf((*PENG_TIME_FIELDS)(nil)).Elem() + types["PENUM_PAGE_FILE_CALLBACK"] = reflect.TypeOf((*PENUM_PAGE_FILE_CALLBACK)(nil)).Elem() + types["PENUM_PAGE_FILE_INFORMATION"] = reflect.TypeOf((*PENUM_PAGE_FILE_INFORMATION)(nil)).Elem() + types["PERCEIVED"] = reflect.TypeOf((*PERCEIVED)(nil)).Elem() + types["PERFORMANCE_INFORMATION"] = reflect.TypeOf((*PERFORMANCE_INFORMATION)(nil)).Elem() + types["PERF_COUNTERSET_INSTANCE"] = reflect.TypeOf((*PERF_COUNTERSET_INSTANCE)(nil)).Elem() + types["PFADDRESSTYPE"] = reflect.TypeOf((*PFADDRESSTYPE)(nil)).Elem() + types["PFD_GLYPHATTR"] = reflect.TypeOf((*PFD_GLYPHATTR)(nil)).Elem() + types["PFFORWARD_ACTION"] = reflect.TypeOf((*PFFORWARD_ACTION)(nil)).Elem() + types["PFIXED_INFO"] = reflect.TypeOf((*PFIXED_INFO)(nil)).Elem() + types["PFLOAT_LONG"] = reflect.TypeOf((*PFLOAT_LONG)(nil)).Elem() + types["PFNCALLBACK"] = reflect.TypeOf((*PFNCALLBACK)(nil)).Elem() + types["PFORMAT_STRING"] = reflect.TypeOf((*PFORMAT_STRING)(nil)).Elem() + types["PGENERIC_BINDING_INFO"] = reflect.TypeOf((*PGENERIC_BINDING_INFO)(nil)).Elem() + types["PGLYPHPOS"] = reflect.TypeOf((*PGLYPHPOS)(nil)).Elem() + types["PHUSKEY"] = reflect.TypeOf((*PHUSKEY)(nil)).Elem() + types["PICTDESC"] = reflect.TypeOf((*PICTDESC)(nil)).Elem() + types["PIDLIST_ABSOLUTE"] = reflect.TypeOf((*PIDLIST_ABSOLUTE)(nil)).Elem() + types["PINT_PTR"] = reflect.TypeOf((*PINT_PTR)(nil)).Elem() + types["PIO_APC_ROUTINE"] = reflect.TypeOf((*PIO_APC_ROUTINE)(nil)).Elem() + types["PIO_STATUS_BLOCK"] = reflect.TypeOf((*PIO_STATUS_BLOCK)(nil)).Elem() + types["PIP_ADAPTER_ADDRESSES"] = reflect.TypeOf((*PIP_ADAPTER_ADDRESSES)(nil)).Elem() + types["PIP_ADAPTER_ANYCAST_ADDRESS_XP"] = reflect.TypeOf((*PIP_ADAPTER_ANYCAST_ADDRESS_XP)(nil)).Elem() + types["PIP_ADAPTER_DNS_SERVER_ADDRESS_XP"] = reflect.TypeOf((*PIP_ADAPTER_DNS_SERVER_ADDRESS_XP)(nil)).Elem() + types["PIP_ADAPTER_DNS_SUFFIX"] = reflect.TypeOf((*PIP_ADAPTER_DNS_SUFFIX)(nil)).Elem() + types["PIP_ADAPTER_GATEWAY_ADDRESS_LH"] = reflect.TypeOf((*PIP_ADAPTER_GATEWAY_ADDRESS_LH)(nil)).Elem() + types["PIP_ADAPTER_INDEX_MAP"] = reflect.TypeOf((*PIP_ADAPTER_INDEX_MAP)(nil)).Elem() + types["PIP_ADAPTER_INFO"] = reflect.TypeOf((*PIP_ADAPTER_INFO)(nil)).Elem() + types["PIP_ADAPTER_MULTICAST_ADDRESS_XP"] = reflect.TypeOf((*PIP_ADAPTER_MULTICAST_ADDRESS_XP)(nil)).Elem() + types["PIP_ADAPTER_ORDER_MAP"] = reflect.TypeOf((*PIP_ADAPTER_ORDER_MAP)(nil)).Elem() + types["PIP_ADAPTER_PREFIX_XP"] = reflect.TypeOf((*PIP_ADAPTER_PREFIX_XP)(nil)).Elem() + types["PIP_ADAPTER_UNICAST_ADDRESS_LH"] = reflect.TypeOf((*PIP_ADAPTER_UNICAST_ADDRESS_LH)(nil)).Elem() + types["PIP_ADAPTER_WINS_SERVER_ADDRESS_LH"] = reflect.TypeOf((*PIP_ADAPTER_WINS_SERVER_ADDRESS_LH)(nil)).Elem() + types["PIP_ADDR_STRING"] = reflect.TypeOf((*PIP_ADDR_STRING)(nil)).Elem() + types["PIP_INTERFACE_INFO"] = reflect.TypeOf((*PIP_INTERFACE_INFO)(nil)).Elem() + types["PIP_OPTION_INFORMATION"] = reflect.TypeOf((*PIP_OPTION_INFORMATION)(nil)).Elem() + types["PIP_PER_ADAPTER_INFO"] = reflect.TypeOf((*PIP_PER_ADAPTER_INFO)(nil)).Elem() + types["PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS"] = reflect.TypeOf((*PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS)(nil)).Elem() + types["PIXELFORMATDESCRIPTOR"] = reflect.TypeOf((*PIXELFORMATDESCRIPTOR)(nil)).Elem() + types["PMIB_ICMP"] = reflect.TypeOf((*PMIB_ICMP)(nil)).Elem() + types["PMIB_ICMP_EX"] = reflect.TypeOf((*PMIB_ICMP_EX)(nil)).Elem() + types["PMIB_IFROW"] = reflect.TypeOf((*PMIB_IFROW)(nil)).Elem() + types["PMIB_IFTABLE"] = reflect.TypeOf((*PMIB_IFTABLE)(nil)).Elem() + types["PMIB_IPADDRTABLE"] = reflect.TypeOf((*PMIB_IPADDRTABLE)(nil)).Elem() + types["PMIB_IPFORWARDROW"] = reflect.TypeOf((*PMIB_IPFORWARDROW)(nil)).Elem() + types["PMIB_IPFORWARDTABLE"] = reflect.TypeOf((*PMIB_IPFORWARDTABLE)(nil)).Elem() + types["PMIB_IPNETROW"] = reflect.TypeOf((*PMIB_IPNETROW)(nil)).Elem() + types["PMIB_IPNETTABLE"] = reflect.TypeOf((*PMIB_IPNETTABLE)(nil)).Elem() + types["PMIB_IPSTATS"] = reflect.TypeOf((*PMIB_IPSTATS)(nil)).Elem() + types["PMIB_TCP6ROW"] = reflect.TypeOf((*PMIB_TCP6ROW)(nil)).Elem() + types["PMIB_TCP6ROW_OWNER_MODULE"] = reflect.TypeOf((*PMIB_TCP6ROW_OWNER_MODULE)(nil)).Elem() + types["PMIB_TCP6TABLE"] = reflect.TypeOf((*PMIB_TCP6TABLE)(nil)).Elem() + types["PMIB_TCP6TABLE2"] = reflect.TypeOf((*PMIB_TCP6TABLE2)(nil)).Elem() + types["PMIB_TCPROW"] = reflect.TypeOf((*PMIB_TCPROW)(nil)).Elem() + types["PMIB_TCPROW_OWNER_MODULE"] = reflect.TypeOf((*PMIB_TCPROW_OWNER_MODULE)(nil)).Elem() + types["PMIB_TCPSTATS"] = reflect.TypeOf((*PMIB_TCPSTATS)(nil)).Elem() + types["PMIB_TCPTABLE"] = reflect.TypeOf((*PMIB_TCPTABLE)(nil)).Elem() + types["PMIB_TCPTABLE2"] = reflect.TypeOf((*PMIB_TCPTABLE2)(nil)).Elem() + types["PMIB_UDP6ROW_OWNER_MODULE"] = reflect.TypeOf((*PMIB_UDP6ROW_OWNER_MODULE)(nil)).Elem() + types["PMIB_UDP6TABLE"] = reflect.TypeOf((*PMIB_UDP6TABLE)(nil)).Elem() + types["PMIB_UDPROW_OWNER_MODULE"] = reflect.TypeOf((*PMIB_UDPROW_OWNER_MODULE)(nil)).Elem() + types["PMIB_UDPSTATS"] = reflect.TypeOf((*PMIB_UDPSTATS)(nil)).Elem() + types["PMIB_UDPTABLE"] = reflect.TypeOf((*PMIB_UDPTABLE)(nil)).Elem() + types["PMIDL_STUB_MESSAGE"] = reflect.TypeOf((*PMIDL_STUB_MESSAGE)(nil)).Elem() + types["PNET_ADDRESS_INFO"] = reflect.TypeOf((*PNET_ADDRESS_INFO)(nil)).Elem() + types["PNOTIFYICONDATA"] = reflect.TypeOf((*PNOTIFYICONDATA)(nil)).Elem() + types["POINT"] = reflect.TypeOf((*POINT)(nil)).Elem() + types["POINTFIX"] = reflect.TypeOf((*POINTFIX)(nil)).Elem() + types["POINTFLOAT"] = reflect.TypeOf((*POINTFLOAT)(nil)).Elem() + types["POINTL"] = reflect.TypeOf((*POINTL)(nil)).Elem() + types["POINTQF"] = reflect.TypeOf((*POINTQF)(nil)).Elem() + types["POINTS"] = reflect.TypeOf((*POINTS)(nil)).Elem() + types["POLICY_AUDIT_EVENT_TYPE"] = reflect.TypeOf((*POLICY_AUDIT_EVENT_TYPE)(nil)).Elem() + types["POLICY_AUDIT_SID_ARRAY"] = reflect.TypeOf((*POLICY_AUDIT_SID_ARRAY)(nil)).Elem() + types["POLYTEXT"] = reflect.TypeOf((*POLYTEXT)(nil)).Elem() + types["PPERFORMACE_INFORMATION"] = reflect.TypeOf((*PPERFORMACE_INFORMATION)(nil)).Elem() + types["PPOLICY_AUDIT_EVENT_TYPE"] = reflect.TypeOf((*PPOLICY_AUDIT_EVENT_TYPE)(nil)).Elem() + types["PPOLICY_AUDIT_SID_ARRAY"] = reflect.TypeOf((*PPOLICY_AUDIT_SID_ARRAY)(nil)).Elem() + types["PPROCESS_MEMORY_COUNTERS"] = reflect.TypeOf((*PPROCESS_MEMORY_COUNTERS)(nil)).Elem() + types["PPSAPI_WS_WATCH_INFORMATION"] = reflect.TypeOf((*PPSAPI_WS_WATCH_INFORMATION)(nil)).Elem() + types["PPSAPI_WS_WATCH_INFORMATION_EX"] = reflect.TypeOf((*PPSAPI_WS_WATCH_INFORMATION_EX)(nil)).Elem() + types["PRECTFX"] = reflect.TypeOf((*PRECTFX)(nil)).Elem() + types["PRINTDLG"] = reflect.TypeOf((*PRINTDLG)(nil)).Elem() + types["PRINTDLGEX"] = reflect.TypeOf((*PRINTDLGEX)(nil)).Elem() + types["PRINTPAGERANGE"] = reflect.TypeOf((*PRINTPAGERANGE)(nil)).Elem() + types["PRIVILEGE_SET"] = reflect.TypeOf((*PRIVILEGE_SET)(nil)).Elem() + types["PROC"] = reflect.TypeOf((*PROC)(nil)).Elem() + types["PROCESS_INFORMATION"] = reflect.TypeOf((*PROCESS_INFORMATION)(nil)).Elem() + types["PROCESS_MEMORY_COUNTERS"] = reflect.TypeOf((*PROCESS_MEMORY_COUNTERS)(nil)).Elem() + types["PROPENUMPROC"] = reflect.TypeOf((*PROPENUMPROC)(nil)).Elem() + types["PROPENUMPROCEX"] = reflect.TypeOf((*PROPENUMPROCEX)(nil)).Elem() + types["PROPERTYORIGIN"] = reflect.TypeOf((*PROPERTYORIGIN)(nil)).Elem() + types["PROPID"] = reflect.TypeOf((*PROPID)(nil)).Elem() + types["PROPSHEETCALLBACK"] = reflect.TypeOf((*PROPSHEETCALLBACK)(nil)).Elem() + types["PROPSHEETHEADER"] = reflect.TypeOf((*PROPSHEETHEADER)(nil)).Elem() + types["PROPSHEETHEADER_V2"] = reflect.TypeOf((*PROPSHEETHEADER_V2)(nil)).Elem() + types["PROPSHEETPAGE"] = reflect.TypeOf((*PROPSHEETPAGE)(nil)).Elem() + types["PROPSHEETPAGE_RESOURCE"] = reflect.TypeOf((*PROPSHEETPAGE_RESOURCE)(nil)).Elem() + types["PROPSHEETPAGE_V4"] = reflect.TypeOf((*PROPSHEETPAGE_V4)(nil)).Elem() + types["PROPSPEC"] = reflect.TypeOf((*PROPSPEC)(nil)).Elem() + types["PROPVARIANT"] = reflect.TypeOf((*PROPVARIANT)(nil)).Elem() + types["PROPVAR_CHANGE_FLAGS"] = reflect.TypeOf((*PROPVAR_CHANGE_FLAGS)(nil)).Elem() + types["PRPC_MESSAGE"] = reflect.TypeOf((*PRPC_MESSAGE)(nil)).Elem() + types["PRPC_SYNTAX_IDENTIFIER"] = reflect.TypeOf((*PRPC_SYNTAX_IDENTIFIER)(nil)).Elem() + types["PSAPI_WS_WATCH_INFORMATION"] = reflect.TypeOf((*PSAPI_WS_WATCH_INFORMATION)(nil)).Elem() + types["PSAPI_WS_WATCH_INFORMATION_EX"] = reflect.TypeOf((*PSAPI_WS_WATCH_INFORMATION_EX)(nil)).Elem() + types["PSECURE_MEMORY_CACHE_CALLBACK"] = reflect.TypeOf((*PSECURE_MEMORY_CACHE_CALLBACK)(nil)).Elem() + types["PSECURITY_DESCRIPTOR"] = reflect.TypeOf((*PSECURITY_DESCRIPTOR)(nil)).Elem() + types["PSID"] = reflect.TypeOf((*PSID)(nil)).Elem() + types["PSOCKADDR_IN6"] = reflect.TypeOf((*PSOCKADDR_IN6)(nil)).Elem() + types["PSOCKADDR_IN6_PAIR"] = reflect.TypeOf((*PSOCKADDR_IN6_PAIR)(nil)).Elem() + types["PSPCALLBACK"] = reflect.TypeOf((*PSPCALLBACK)(nil)).Elem() + types["PSRWLOCK"] = reflect.TypeOf((*PSRWLOCK)(nil)).Elem() + types["PSTR"] = reflect.TypeOf((*PSTR)(nil)).Elem() + types["PTRIVERTEX"] = reflect.TypeOf((*PTRIVERTEX)(nil)).Elem() + types["PUCHAR"] = reflect.TypeOf((*PUCHAR)(nil)).Elem() + types["PULONG64"] = reflect.TypeOf((*PULONG64)(nil)).Elem() + types["PUSHORT"] = reflect.TypeOf((*PUSHORT)(nil)).Elem() + types["PVOID"] = reflect.TypeOf((*PVOID)(nil)).Elem() + types["PWCHAR"] = reflect.TypeOf((*PWCHAR)(nil)).Elem() + types["PWSTR"] = reflect.TypeOf((*PWSTR)(nil)).Elem() + types["QITAB"] = reflect.TypeOf((*QITAB)(nil)).Elem() + types["QOS"] = reflect.TypeOf((*QOS)(nil)).Elem() + types["QUERY_USER_NOTIFICATION_STATE"] = reflect.TypeOf((*QUERY_USER_NOTIFICATION_STATE)(nil)).Elem() + types["RASTERIZER_STATUS"] = reflect.TypeOf((*RASTERIZER_STATUS)(nil)).Elem() + types["RAWHID"] = reflect.TypeOf((*RAWHID)(nil)).Elem() + types["RAWINPUT"] = reflect.TypeOf((*RAWINPUT)(nil)).Elem() + types["RAWINPUTDEVICE"] = reflect.TypeOf((*RAWINPUTDEVICE)(nil)).Elem() + types["RAWINPUTDEVICELIST"] = reflect.TypeOf((*RAWINPUTDEVICELIST)(nil)).Elem() + types["RAWINPUTHEADER"] = reflect.TypeOf((*RAWINPUTHEADER)(nil)).Elem() + types["RAWKEYBOARD"] = reflect.TypeOf((*RAWKEYBOARD)(nil)).Elem() + types["RAWMOUSE"] = reflect.TypeOf((*RAWMOUSE)(nil)).Elem() + types["RECT"] = reflect.TypeOf((*RECT)(nil)).Elem() + types["RECTFX"] = reflect.TypeOf((*RECTFX)(nil)).Elem() + types["RECTL"] = reflect.TypeOf((*RECTL)(nil)).Elem() + types["REFCLSID"] = reflect.TypeOf((*REFCLSID)(nil)).Elem() + types["REFFMTID"] = reflect.TypeOf((*REFFMTID)(nil)).Elem() + types["REFGUID"] = reflect.TypeOf((*REFGUID)(nil)).Elem() + types["REFIID"] = reflect.TypeOf((*REFIID)(nil)).Elem() + types["REFKNOWNFOLDERID"] = reflect.TypeOf((*REFKNOWNFOLDERID)(nil)).Elem() + types["REFPROPVARIANT"] = reflect.TypeOf((*REFPROPVARIANT)(nil)).Elem() + types["REGISTERWORDENUMPROC"] = reflect.TypeOf((*REGISTERWORDENUMPROC)(nil)).Elem() + types["REGKIND"] = reflect.TypeOf((*REGKIND)(nil)).Elem() + types["REGSAM"] = reflect.TypeOf((*REGSAM)(nil)).Elem() + types["RESTRICTIONS"] = reflect.TypeOf((*RESTRICTIONS)(nil)).Elem() + types["RGBQUAD"] = reflect.TypeOf((*RGBQUAD)(nil)).Elem() + types["RGNDATA"] = reflect.TypeOf((*RGNDATA)(nil)).Elem() + types["RGNDATAHEADER"] = reflect.TypeOf((*RGNDATAHEADER)(nil)).Elem() + types["ROP4"] = reflect.TypeOf((*ROP4)(nil)).Elem() + types["RPC_AUTHZ_HANDLE"] = reflect.TypeOf((*RPC_AUTHZ_HANDLE)(nil)).Elem() + types["RPC_BINDING_HANDLE"] = reflect.TypeOf((*RPC_BINDING_HANDLE)(nil)).Elem() + types["RPC_MESSAGE"] = reflect.TypeOf((*RPC_MESSAGE)(nil)).Elem() + types["RPC_STATUS"] = reflect.TypeOf((*RPC_STATUS)(nil)).Elem() + types["RPC_SYNTAX_IDENTIFIER"] = reflect.TypeOf((*RPC_SYNTAX_IDENTIFIER)(nil)).Elem() + types["RPC_VERSION"] = reflect.TypeOf((*RPC_VERSION)(nil)).Elem() + types["RTL_SRWLOCK"] = reflect.TypeOf((*RTL_SRWLOCK)(nil)).Elem() + types["RUN"] = reflect.TypeOf((*RUN)(nil)).Elem() + types["SAFEARRAY"] = reflect.TypeOf((*SAFEARRAY)(nil)).Elem() + types["SAFEARRAYBOUND"] = reflect.TypeOf((*SAFEARRAYBOUND)(nil)).Elem() + types["SAFER_LEVEL_HANDLE"] = reflect.TypeOf((*SAFER_LEVEL_HANDLE)(nil)).Elem() + types["SCODE"] = reflect.TypeOf((*SCODE)(nil)).Elem() + types["SCOPE_ID"] = reflect.TypeOf((*SCOPE_ID)(nil)).Elem() + types["SCROLLBARINFO"] = reflect.TypeOf((*SCROLLBARINFO)(nil)).Elem() + types["SCROLLINFO"] = reflect.TypeOf((*SCROLLINFO)(nil)).Elem() + types["SC_HANDLE"] = reflect.TypeOf((*SC_HANDLE)(nil)).Elem() + types["SC_LOCK"] = reflect.TypeOf((*SC_LOCK)(nil)).Elem() + types["SECURITY_ATTRIBUTES"] = reflect.TypeOf((*SECURITY_ATTRIBUTES)(nil)).Elem() + types["SECURITY_CONTEXT_TRACKING_MODE"] = reflect.TypeOf((*SECURITY_CONTEXT_TRACKING_MODE)(nil)).Elem() + types["SECURITY_DESCRIPTOR"] = reflect.TypeOf((*SECURITY_DESCRIPTOR)(nil)).Elem() + types["SECURITY_DESCRIPTOR_CONTROL"] = reflect.TypeOf((*SECURITY_DESCRIPTOR_CONTROL)(nil)).Elem() + types["SECURITY_IMPERSONATION_LEVEL"] = reflect.TypeOf((*SECURITY_IMPERSONATION_LEVEL)(nil)).Elem() + types["SECURITY_INFORMATION"] = reflect.TypeOf((*SECURITY_INFORMATION)(nil)).Elem() + types["SECURITY_QUALITY_OF_SERVICE"] = reflect.TypeOf((*SECURITY_QUALITY_OF_SERVICE)(nil)).Elem() + types["SENDASYNCPROC"] = reflect.TypeOf((*SENDASYNCPROC)(nil)).Elem() + types["SERVICETYPE"] = reflect.TypeOf((*SERVICETYPE)(nil)).Elem() + types["SERVICE_STATUS"] = reflect.TypeOf((*SERVICE_STATUS)(nil)).Elem() + types["SERVICE_STATUS_HANDLE"] = reflect.TypeOf((*SERVICE_STATUS_HANDLE)(nil)).Elem() + types["SE_OBJECT_TYPE"] = reflect.TypeOf((*SE_OBJECT_TYPE)(nil)).Elem() + types["SFGAOF"] = reflect.TypeOf((*SFGAOF)(nil)).Elem() + types["SFV_CREATE"] = reflect.TypeOf((*SFV_CREATE)(nil)).Elem() + types["SHChangeNotifyEntry"] = reflect.TypeOf((*SHChangeNotifyEntry)(nil)).Elem() + types["SHELLFLAGSTATE"] = reflect.TypeOf((*SHELLFLAGSTATE)(nil)).Elem() + types["SHELLSTATE"] = reflect.TypeOf((*SHELLSTATE)(nil)).Elem() + types["SHFILEINFO"] = reflect.TypeOf((*SHFILEINFO)(nil)).Elem() + types["SHFILEOPSTRUCT"] = reflect.TypeOf((*SHFILEOPSTRUCT)(nil)).Elem() + types["SHITEMID"] = reflect.TypeOf((*SHITEMID)(nil)).Elem() + types["SHORT"] = reflect.TypeOf((*SHORT)(nil)).Elem() + types["SHQUERYRBINFO"] = reflect.TypeOf((*SHQUERYRBINFO)(nil)).Elem() + types["SHREGDEL_FLAGS"] = reflect.TypeOf((*SHREGDEL_FLAGS)(nil)).Elem() + types["SHREGENUM_FLAGS"] = reflect.TypeOf((*SHREGENUM_FLAGS)(nil)).Elem() + types["SHSTOCKICONID"] = reflect.TypeOf((*SHSTOCKICONID)(nil)).Elem() + types["SHSTOCKICONINFO"] = reflect.TypeOf((*SHSTOCKICONINFO)(nil)).Elem() + types["SID"] = reflect.TypeOf((*SID)(nil)).Elem() + types["SID_AND_ATTRIBUTES"] = reflect.TypeOf((*SID_AND_ATTRIBUTES)(nil)).Elem() + types["SID_IDENTIFIER_AUTHORITY"] = reflect.TypeOf((*SID_IDENTIFIER_AUTHORITY)(nil)).Elem() + types["SIGDN"] = reflect.TypeOf((*SIGDN)(nil)).Elem() + types["SIZE"] = reflect.TypeOf((*SIZE)(nil)).Elem() + types["SIZEL"] = reflect.TypeOf((*SIZEL)(nil)).Elem() + types["SIZE_T"] = reflect.TypeOf((*SIZE_T)(nil)).Elem() + types["SMALL_RECT"] = reflect.TypeOf((*SMALL_RECT)(nil)).Elem() + types["SOCKADDR"] = reflect.TypeOf((*SOCKADDR)(nil)).Elem() + types["SOCKADDR_IN"] = reflect.TypeOf((*SOCKADDR_IN)(nil)).Elem() + types["SOCKADDR_IN6"] = reflect.TypeOf((*SOCKADDR_IN6)(nil)).Elem() + types["SOCKADDR_IN6_LH"] = reflect.TypeOf((*SOCKADDR_IN6_LH)(nil)).Elem() + types["SOCKADDR_IN6_PAIR"] = reflect.TypeOf((*SOCKADDR_IN6_PAIR)(nil)).Elem() + types["SOCKET"] = reflect.TypeOf((*SOCKET)(nil)).Elem() + types["SOCKET_ADDRESS"] = reflect.TypeOf((*SOCKET_ADDRESS)(nil)).Elem() + types["SOLE_AUTHENTICATION_SERVICE"] = reflect.TypeOf((*SOLE_AUTHENTICATION_SERVICE)(nil)).Elem() + types["STARTUPINFO"] = reflect.TypeOf((*STARTUPINFO)(nil)).Elem() + types["STGMEDIUM"] = reflect.TypeOf((*STGMEDIUM)(nil)).Elem() + types["STROBJ"] = reflect.TypeOf((*STROBJ)(nil)).Elem() + types["STRRET"] = reflect.TypeOf((*STRRET)(nil)).Elem() + types["STYLEBUF"] = reflect.TypeOf((*STYLEBUF)(nil)).Elem() + types["SUBCLASSPROC"] = reflect.TypeOf((*SUBCLASSPROC)(nil)).Elem() + types["SURFOBJ"] = reflect.TypeOf((*SURFOBJ)(nil)).Elem() + types["SYSKIND"] = reflect.TypeOf((*SYSKIND)(nil)).Elem() + types["SYSTEMTIME"] = reflect.TypeOf((*SYSTEMTIME)(nil)).Elem() + types["SYSTEM_INFO"] = reflect.TypeOf((*SYSTEM_INFO)(nil)).Elem() + types["Sockaddr"] = reflect.TypeOf((*Sockaddr)(nil)).Elem() + types["Socklen_t"] = reflect.TypeOf((*Socklen_t)(nil)).Elem() + types["Status"] = reflect.TypeOf((*Status)(nil)).Elem() + types["TASKCALLBACK"] = reflect.TypeOf((*TASKCALLBACK)(nil)).Elem() + types["TASKDIALOGCALLBACK"] = reflect.TypeOf((*TASKDIALOGCALLBACK)(nil)).Elem() + types["TASKDIALOGCONFIG"] = reflect.TypeOf((*TASKDIALOGCONFIG)(nil)).Elem() + types["TASKDIALOG_BUTTON"] = reflect.TypeOf((*TASKDIALOG_BUTTON)(nil)).Elem() + types["TASKDIALOG_COMMON_BUTTON_FLAGS"] = reflect.TypeOf((*TASKDIALOG_COMMON_BUTTON_FLAGS)(nil)).Elem() + types["TASKDIALOG_FLAGS"] = reflect.TypeOf((*TASKDIALOG_FLAGS)(nil)).Elem() + types["TBBUTTON"] = reflect.TypeOf((*TBBUTTON)(nil)).Elem() + types["TCPIP_OWNER_MODULE_INFO_CLASS"] = reflect.TypeOf((*TCPIP_OWNER_MODULE_INFO_CLASS)(nil)).Elem() + types["TCP_CONNECTION_OFFLOAD_STATE"] = reflect.TypeOf((*TCP_CONNECTION_OFFLOAD_STATE)(nil)).Elem() + types["TCP_ESTATS_TYPE"] = reflect.TypeOf((*TCP_ESTATS_TYPE)(nil)).Elem() + types["TCP_RTO_ALGORITHM"] = reflect.TypeOf((*TCP_RTO_ALGORITHM)(nil)).Elem() + types["TCP_TABLE_CLASS"] = reflect.TypeOf((*TCP_TABLE_CLASS)(nil)).Elem() + types["TEXTMETRIC"] = reflect.TypeOf((*TEXTMETRIC)(nil)).Elem() + types["THEMESIZE"] = reflect.TypeOf((*THEMESIZE)(nil)).Elem() + types["THREAD_START_ROUTINE"] = reflect.TypeOf((*THREAD_START_ROUTINE)(nil)).Elem() + types["TIMECALLBACK"] = reflect.TypeOf((*TIMECALLBACK)(nil)).Elem() + types["TIMECAPS"] = reflect.TypeOf((*TIMECAPS)(nil)).Elem() + types["TIMERPROC"] = reflect.TypeOf((*TIMERPROC)(nil)).Elem() + types["TITLEBARINFO"] = reflect.TypeOf((*TITLEBARINFO)(nil)).Elem() + types["TOKEN_GROUPS"] = reflect.TypeOf((*TOKEN_GROUPS)(nil)).Elem() + types["TOKEN_PRIVILEGES"] = reflect.TypeOf((*TOKEN_PRIVILEGES)(nil)).Elem() + types["TOUCHINPUT"] = reflect.TypeOf((*TOUCHINPUT)(nil)).Elem() + types["TPMPARAMS"] = reflect.TypeOf((*TPMPARAMS)(nil)).Elem() + types["TRACKMOUSEEVENT"] = reflect.TypeOf((*TRACKMOUSEEVENT)(nil)).Elem() + types["TRIVERTEX"] = reflect.TypeOf((*TRIVERTEX)(nil)).Elem() + types["TRUSTEE"] = reflect.TypeOf((*TRUSTEE)(nil)).Elem() + types["TRUSTEE_FORM"] = reflect.TypeOf((*TRUSTEE_FORM)(nil)).Elem() + types["TRUSTEE_TYPE"] = reflect.TypeOf((*TRUSTEE_TYPE)(nil)).Elem() + types["TUNNEL_TYPE"] = reflect.TypeOf((*TUNNEL_TYPE)(nil)).Elem() + types["Time_t"] = reflect.TypeOf((*Time_t)(nil)).Elem() + types["Timeval"] = reflect.TypeOf((*Timeval)(nil)).Elem() + types["UCHAR"] = reflect.TypeOf((*UCHAR)(nil)).Elem() + types["UDATE"] = reflect.TypeOf((*UDATE)(nil)).Elem() + types["UDP_TABLE_CLASS"] = reflect.TypeOf((*UDP_TABLE_CLASS)(nil)).Elem() + types["UINT"] = reflect.TypeOf((*UINT)(nil)).Elem() + types["UINT8"] = reflect.TypeOf((*UINT8)(nil)).Elem() + types["UINT_PTR"] = reflect.TypeOf((*UINT_PTR)(nil)).Elem() + types["ULARGE_INTEGER"] = reflect.TypeOf((*ULARGE_INTEGER)(nil)).Elem() + types["ULONG"] = reflect.TypeOf((*ULONG)(nil)).Elem() + types["ULONG64"] = reflect.TypeOf((*ULONG64)(nil)).Elem() + types["ULONGLONG"] = reflect.TypeOf((*ULONGLONG)(nil)).Elem() + types["ULONG_PTR"] = reflect.TypeOf((*ULONG_PTR)(nil)).Elem() + types["UPDATELAYEREDWINDOWINFO"] = reflect.TypeOf((*UPDATELAYEREDWINDOWINFO)(nil)).Elem() + types["URLIS"] = reflect.TypeOf((*URLIS)(nil)).Elem() + types["USER_MARSHAL_FREEING_ROUTINE"] = reflect.TypeOf((*USER_MARSHAL_FREEING_ROUTINE)(nil)).Elem() + types["USER_MARSHAL_MARSHALLING_ROUTINE"] = reflect.TypeOf((*USER_MARSHAL_MARSHALLING_ROUTINE)(nil)).Elem() + types["USER_MARSHAL_ROUTINE_QUADRUPLE"] = reflect.TypeOf((*USER_MARSHAL_ROUTINE_QUADRUPLE)(nil)).Elem() + types["USER_MARSHAL_SIZING_ROUTINE"] = reflect.TypeOf((*USER_MARSHAL_SIZING_ROUTINE)(nil)).Elem() + types["USER_MARSHAL_UNMARSHALLING_ROUTINE"] = reflect.TypeOf((*USER_MARSHAL_UNMARSHALLING_ROUTINE)(nil)).Elem() + types["USHORT"] = reflect.TypeOf((*USHORT)(nil)).Elem() + types["VARIANT"] = reflect.TypeOf((*VARIANT)(nil)).Elem() + types["VARIANTARG"] = reflect.TypeOf((*VARIANTARG)(nil)).Elem() + types["VARIANT_BOOL"] = reflect.TypeOf((*VARIANT_BOOL)(nil)).Elem() + types["VARTYPE"] = reflect.TypeOf((*VARTYPE)(nil)).Elem() + types["VERSIONEDSTREAM"] = reflect.TypeOf((*VERSIONEDSTREAM)(nil)).Elem() + types["WAVEFORMATEX"] = reflect.TypeOf((*WAVEFORMATEX)(nil)).Elem() + types["WAVEHDR"] = reflect.TypeOf((*WAVEHDR)(nil)).Elem() + types["WAVEINCAPS"] = reflect.TypeOf((*WAVEINCAPS)(nil)).Elem() + types["WAVEOUTCAPS"] = reflect.TypeOf((*WAVEOUTCAPS)(nil)).Elem() + types["WCHAR"] = reflect.TypeOf((*WCHAR)(nil)).Elem() + types["WCRANGE"] = reflect.TypeOf((*WCRANGE)(nil)).Elem() + types["WGLSWAP"] = reflect.TypeOf((*WGLSWAP)(nil)).Elem() + types["WINDOWINFO"] = reflect.TypeOf((*WINDOWINFO)(nil)).Elem() + types["WINDOWPLACEMENT"] = reflect.TypeOf((*WINDOWPLACEMENT)(nil)).Elem() + types["WINEVENTPROC"] = reflect.TypeOf((*WINEVENTPROC)(nil)).Elem() + types["WINSTAENUMPROC"] = reflect.TypeOf((*WINSTAENUMPROC)(nil)).Elem() + types["WNDCLASS"] = reflect.TypeOf((*WNDCLASS)(nil)).Elem() + types["WNDCLASSEX"] = reflect.TypeOf((*WNDCLASSEX)(nil)).Elem() + types["WNDENUMPROC"] = reflect.TypeOf((*WNDENUMPROC)(nil)).Elem() + types["WNDPROC"] = reflect.TypeOf((*WNDPROC)(nil)).Elem() + types["WORD"] = reflect.TypeOf((*WORD)(nil)).Elem() + types["WPARAM"] = reflect.TypeOf((*WPARAM)(nil)).Elem() + types["WSABUF"] = reflect.TypeOf((*WSABUF)(nil)).Elem() + types["WSACOMPLETION"] = reflect.TypeOf((*WSACOMPLETION)(nil)).Elem() + types["WSACOMPLETIONTYPE"] = reflect.TypeOf((*WSACOMPLETIONTYPE)(nil)).Elem() + types["WSADATA"] = reflect.TypeOf((*WSADATA)(nil)).Elem() + types["WSAECOMPARATOR"] = reflect.TypeOf((*WSAECOMPARATOR)(nil)).Elem() + types["WSAESETSERVICEOP"] = reflect.TypeOf((*WSAESETSERVICEOP)(nil)).Elem() + types["WSAEVENT"] = reflect.TypeOf((*WSAEVENT)(nil)).Elem() + types["WSAMSG"] = reflect.TypeOf((*WSAMSG)(nil)).Elem() + types["WSANAMESPACE_INFO"] = reflect.TypeOf((*WSANAMESPACE_INFO)(nil)).Elem() + types["WSANETWORKEVENTS"] = reflect.TypeOf((*WSANETWORKEVENTS)(nil)).Elem() + types["WSANSCLASSINFO"] = reflect.TypeOf((*WSANSCLASSINFO)(nil)).Elem() + types["WSAPOLLFD"] = reflect.TypeOf((*WSAPOLLFD)(nil)).Elem() + types["WSAPROTOCOLCHAIN"] = reflect.TypeOf((*WSAPROTOCOLCHAIN)(nil)).Elem() + types["WSAPROTOCOL_INFO"] = reflect.TypeOf((*WSAPROTOCOL_INFO)(nil)).Elem() + types["WSAQUERYSET"] = reflect.TypeOf((*WSAQUERYSET)(nil)).Elem() + types["WSASERVICECLASSINFO"] = reflect.TypeOf((*WSASERVICECLASSINFO)(nil)).Elem() + types["WSAVERSION"] = reflect.TypeOf((*WSAVERSION)(nil)).Elem() + types["XFORM"] = reflect.TypeOf((*XFORM)(nil)).Elem() + types["XFORML"] = reflect.TypeOf((*XFORML)(nil)).Elem() + types["XFORMOBJ"] = reflect.TypeOf((*XFORMOBJ)(nil)).Elem() + types["XLATEOBJ"] = reflect.TypeOf((*XLATEOBJ)(nil)).Elem() + types["XLAT_SIDE"] = reflect.TypeOf((*XLAT_SIDE)(nil)).Elem() + types["XMIT_HELPER_ROUTINE"] = reflect.TypeOf((*XMIT_HELPER_ROUTINE)(nil)).Elem() + types["XMIT_ROUTINE_QUINTUPLE"] = reflect.TypeOf((*XMIT_ROUTINE_QUINTUPLE)(nil)).Elem() + types["YIELDPROC"] = reflect.TypeOf((*YIELDPROC)(nil)).Elem() + types["bool"] = reflect.TypeOf((*bool)(nil)).Elem() + types["byte"] = reflect.TypeOf((*byte)(nil)).Elem() + types["float32"] = reflect.TypeOf((*float32)(nil)).Elem() + types["float64"] = reflect.TypeOf((*float64)(nil)).Elem() + types["int"] = reflect.TypeOf((*int)(nil)).Elem() + types["int16"] = reflect.TypeOf((*int16)(nil)).Elem() + types["int32"] = reflect.TypeOf((*int32)(nil)).Elem() + types["int8"] = reflect.TypeOf((*int8)(nil)).Elem() + types["string"] = reflect.TypeOf((*string)(nil)).Elem() + types["uint16"] = reflect.TypeOf((*uint16)(nil)).Elem() + types["uint32"] = reflect.TypeOf((*uint32)(nil)).Elem() + types["uintptr"] = reflect.TypeOf((*uintptr)(nil)).Elem() +} + +type ABC struct { + AbcA int32 + AbcB UINT + AbcC int32 +} +type ABCFLOAT struct { + AbcfA FLOAT + AbcfB FLOAT + AbcfC FLOAT +} +type ABORTPROC func(unnamed0 HDC, unnamed1 int32) BOOL +type ACCEL struct { + FVirt BYTE + Key WORD + Cmd WORD +} +type ACCESS_MASK uint32 +type ACL struct { + AclRevision byte + Sbz1 byte + AclSize uint16 + AceCount uint16 + Sbz2 uint16 +} +type ADDRINFO struct { + Ai_flags int32 + Ai_family int32 + Ai_socktype int32 + Ai_protocol int32 + Ai_addrlen SIZE_T + Ai_canonname PWSTR + Ai_addr uintptr // struct sockaddr * + Ai_next *ADDRINFO +} +type ADDRINFOEX struct { + Ai_flags int32 + Ai_family int32 + Ai_socktype int32 + Ai_protocol int32 + Ai_addrlen SIZE_T + Ai_canonname PWSTR + Ai_addr uintptr // struct sockaddr* + Ai_blob LPVOID + Ai_bloblen SIZE_T + Ai_provider LPGUID + Ai_next *ADDRINFOEX +} +type AFPROTOCOLS struct { + IAddressFamily INT + IProtocol INT +} +type ALG_ID uint32 +type ALTTABINFO struct { + CbSize uint32 + CItems int32 + CColumns int32 + CRows int32 + IColFocus int32 + IRowFocus int32 + CxItem int32 + CyItem int32 + PtStart POINT +} +type APPBARDATA struct { + CbSize DWORD + HWnd HWND + UCallbackMessage UINT + UEdge UINT + Rc RECT + LParam LPARAM +} +type ARRAY_INFO struct { + Dimension int32 + BufferConformanceMark *uint32 + BufferVarianceMark *uint32 + MaxCountArray *uint32 + OffsetArray *uint32 + ActualCountArray *uint32 +} +type ATOM uint16 +type AUDIT_POLICY_INFORMATION struct { + AuditSubCategoryGuid GUID + AuditingInformation ULONG + AuditCategoryGuid GUID +} +type AUTO_SCROLL_DATA struct { + INextSample int32 + DwLastScroll DWORD + BFull BOOL + Pts [NUM_POINTS]POINT + DwTimes [NUM_POINTS]DWORD +} +type AUXCAPS struct { + WMid WORD + WPid WORD + VDriverVersion MMVERSION + SzPname [MAXPNAMELEN]WCHAR + WTechnology WORD + WReserved1 WORD + DwSupport DWORD +} +type BFFCALLBACK func(hwnd HWND, uMsg UINT, lParam LPARAM, lpData LPARAM) int32 +type BIND_OPTS struct { + CbStruct DWORD + GrfFlags DWORD + GrfMode DWORD + DwTickCountDeadline DWORD +} +type BITMAP struct { + BmType LONG + BmWidth LONG + BmHeight LONG + BmWidthBytes LONG + BmPlanes WORD + BmBitsPixel WORD + BmBits LPVOID +} +type BITMAPINFO struct { + BmiHeader BITMAPINFOHEADER + BmiColors [1]RGBQUAD +} +type BITMAPINFOHEADER struct { + BiSize DWORD + BiWidth LONG + BiHeight LONG + BiPlanes WORD + BiBitCount WORD + BiCompression DWORD + BiSizeImage DWORD + BiXPelsPerMeter LONG + BiYPelsPerMeter LONG + BiClrUsed DWORD + BiClrImportant DWORD +} +type BLENDFUNCTION struct { + BlendOp byte + BlendFlags byte + SourceConstantAlpha byte + AlphaFormat byte +} + +func getUintptrFromBLENDFUNCTION(v BLENDFUNCTION) uintptr { + ret := (uint32(v.BlendOp) << 12) | (uint32(v.BlendFlags) << 8) | (uint32(v.SourceConstantAlpha) << 4) | uint32(v.AlphaFormat) + return uintptr(ret) +} + +type BLENDOBJ struct { + BlendFunction BLENDFUNCTION +} +type BLOB struct { + CbSize ULONG + PBlobData *BYTE +} +type BOOLEAN byte +type BP_ANIMATIONPARAMS struct { + CbSize DWORD + DwFlags DWORD + Style BP_ANIMATIONSTYLE + DwDuration DWORD +} +type BP_PAINTPARAMS struct { + CbSize DWORD + DwFlags DWORD + PrcExclude/*const*/ *RECT + PBlendFunction/*const*/ *BLENDFUNCTION +} +type BROWSEINFO struct { + HwndOwner HWND + PidlRoot PCIDLIST_ABSOLUTE + PszDisplayName LPWSTR + LpszTitle LPCWSTR + UlFlags UINT + Lpfn uintptr // BFFCALLBACK + LParam LPARAM + IImage int32 +} +type BRUSHOBJ struct { + ISolidColor ULONG + PvRbrush PVOID + FlColorType FLONG +} +type BSMINFO struct { + CbSize uint32 + Hdesk HDESK + Hwnd HWND + Luid LUID +} +type BSTR *OLECHAR +type BSTRBLOB struct { + CbSize ULONG + PData *BYTE +} +type BYTE byte +type CABINETSTATE struct { + CLength WORD + NVersion WORD + flags1 uint16 + FMenuEnumFilter UINT +} + +func (this *CABINETSTATE) FFullPathTitle() BOOL { + return (BOOL)(0x1 & (this.flags1 >> 15)) +} +func (this *CABINETSTATE) FSaveLocalView() BOOL { + return (BOOL)(0x1 & (this.flags1 >> 14)) +} +func (this *CABINETSTATE) FNotShell() BOOL { + return (BOOL)(0x1 & (this.flags1 >> 13)) +} +func (this *CABINETSTATE) FSimpleDefault() BOOL { + return (BOOL)(0x1 & (this.flags1 >> 12)) +} +func (this *CABINETSTATE) FDontShowDescBar() BOOL { + return (BOOL)(0x1 & (this.flags1 >> 11)) +} +func (this *CABINETSTATE) FNewWindowMode() BOOL { + return (BOOL)(0x1 & (this.flags1 >> 10)) +} +func (this *CABINETSTATE) FShowCompColor() BOOL { + return (BOOL)(0x1 & (this.flags1 >> 9)) +} +func (this *CABINETSTATE) FDontPrettyNames() BOOL { + return (BOOL)(0x1 & (this.flags1 >> 8)) +} +func (this *CABINETSTATE) FAdminsCreateCommonGroups() BOOL { + return (BOOL)(0x1 & (this.flags1 >> 7)) +} + +type CABOOL struct { + CElems ULONG + PElems *VARIANT_BOOL +} +type CABSTR struct { + CElems ULONG + PElems *BSTR +} +type CABSTRBLOB struct { + CElems ULONG + PElems *BSTRBLOB +} +type CAC struct { + CElems ULONG + PElems *CHAR +} +type CACLIPDATA struct { + CElems ULONG + PElems *CLIPDATA +} +type CACLSID struct { + CElems ULONG + PElems *CLSID +} +type CACY struct { + CElems ULONG + PElems *CY +} +type CADATE struct { + CElems ULONG + PElems *DATE +} +type CADBL struct { + CElems ULONG + PElems *DOUBLE +} +type CAFILETIME struct { + CElems ULONG + PElems *FILETIME +} +type CAFLT struct { + CElems ULONG + PElems *FLOAT +} +type CAH struct { + CElems ULONG + PElems *LARGE_INTEGER +} +type CAI struct { + CElems ULONG + PElems *SHORT +} +type CAL struct { + CElems ULONG + PElems *LONG +} +type CALID uint32 +type CALPSTR struct { + CElems ULONG + PElems *LPSTR +} +type CALPWSTR struct { + CElems ULONG + PElems *LPWSTR +} +type CALTYPE DWORD +type CANDIDATEFORM struct { + DwIndex DWORD + DwStyle DWORD + PtCurrentPos POINT + RcArea RECT +} +type CANDIDATELIST struct { + DwSize DWORD + DwStyle DWORD + DwCount DWORD + DwSelection DWORD + DwPageStart DWORD + DwPageSize DWORD + DwOffset [1]DWORD +} +type CAPROPVARIANT struct { + CElems ULONG + PElems *PROPVARIANT +} +type CASCODE struct { + CElems ULONG + PElems *SCODE +} +type CAUB struct { + CElems ULONG + PElems *UCHAR +} +type CAUH struct { + CElems ULONG + PElems *ULARGE_INTEGER +} +type CAUI struct { + CElems ULONG + PElems *USHORT +} +type CAUL struct { + CElems ULONG + PElems *ULONG +} +type CCHOOKPROC func(unnamed0 HWND, unnamed1 UINT, unnamed2 WPARAM, unnamed3 LPARAM) UINT_PTR +type CERT_CONTEXT struct { + DwCertEncodingType DWORD + PbCertEncoded *BYTE + CbCertEncoded DWORD + PCertInfo PCERT_INFO + HCertStore HCERTSTORE +} +type CERT_EXTENSION struct { + PszObjId LPSTR + FCritical BOOL + Value CRYPT_OBJID_BLOB +} +type CERT_INFO struct { + DwVersion DWORD + SerialNumber CRYPT_INTEGER_BLOB + SignatureAlgorithm CRYPT_ALGORITHM_IDENTIFIER + Issuer CERT_NAME_BLOB + NotBefore FILETIME + NotAfter FILETIME + Subject CERT_NAME_BLOB + SubjectPublicKeyInfo CERT_PUBLIC_KEY_INFO + IssuerUniqueId CRYPT_BIT_BLOB + SubjectUniqueId CRYPT_BIT_BLOB + CExtension DWORD + RgExtension PCERT_EXTENSION +} +type CERT_NAME_BLOB CRYPTOAPI_BLOB_ +type CERT_PUBLIC_KEY_INFO struct { + Algorithm CRYPT_ALGORITHM_IDENTIFIER + PublicKey CRYPT_BIT_BLOB +} +type CERT_RDN_VALUE_BLOB CRYPTOAPI_BLOB_ +type CHAR byte +type CHARSETINFO struct { + CiCharset UINT + CiACP UINT + Fs FONTSIGNATURE +} +type CHOOSECOLOR struct { + LStructSize DWORD + HwndOwner HWND + HInstance HWND + RgbResult COLORREF + LpCustColors *COLORREF + Flags DWORD + LCustData LPARAM + LpfnHook uintptr // LPCCHOOKPROC + LpTemplateName LPCWSTR +} +type CHOOSEFONT struct { + LStructSize DWORD + HwndOwner HWND + HDC HDC + LpLogFont LPLOGFONT + IPointSize INT + Flags DWORD + RgbColors COLORREF + LCustData LPARAM + LpfnHook uintptr // LPCFHOOKPROC + LpTemplateName LPCWSTR + HInstance HINSTANCE + LpszStyle LPWSTR + NFontType WORD + ___MISSING_ALIGNMENT__ WORD + NSizeMin INT + NSizeMax INT +} +type CIEXYZ struct { + CiexyzX FXPT2DOT30 + CiexyzY FXPT2DOT30 + CiexyzZ FXPT2DOT30 +} +type CIEXYZTRIPLE struct { + CiexyzRed CIEXYZ + CiexyzGreen CIEXYZ + CiexyzBlue CIEXYZ +} +type CLIPDATA struct { + CbSize ULONG + UlClipFmt LONG + PClipData *BYTE +} +type CLIPFORMAT WORD +type CLIPLINE struct { + PtfxA POINTFIX + PtfxB POINTFIX + LStyleState LONG + C ULONG + Arun [1]RUN +} +type CLIPOBJ struct { + IUniq ULONG + RclBounds RECTL + IDComplexity BYTE + IFComplexity BYTE + IMode BYTE + FjOptions BYTE +} +type CLSID GUID +type COAUTHIDENTITY struct { + User *USHORT + UserLength ULONG + Domain *USHORT + DomainLength ULONG + Password *USHORT + PasswordLength ULONG + Flags ULONG +} +type COAUTHINFO struct { + DwAuthnSvc DWORD + DwAuthzSvc DWORD + PwszServerPrincName LPWSTR + DwAuthnLevel DWORD + DwImpersonationLevel DWORD + PAuthIdentityData *COAUTHIDENTITY + DwCapabilities DWORD +} +type COLOR16 USHORT +type COLORADJUSTMENT struct { + CaSize WORD + CaFlags WORD + CaIlluminantIndex WORD + CaRedGamma WORD + CaGreenGamma WORD + CaBlueGamma WORD + CaReferenceBlack WORD + CaReferenceWhite WORD + CaContrast SHORT + CaBrightness SHORT + CaColorfulness SHORT + CaRedGreenTint SHORT +} +type COLORMAP struct { + From COLORREF + To COLORREF +} +type COLORREF uint32 +type COMBOBOXINFO struct { + CbSize uint32 + RcItem RECT + RcButton RECT + StateButton uint32 + HwndCombo HWND + HwndItem HWND + HwndList HWND +} +type COMM_FAULT_OFFSETS struct { + CommOffset int16 + FaultOffset int16 +} +type COMPOSITIONFORM struct { + DwStyle DWORD + PtCurrentPos POINT + RcArea RECT +} +type CONSOLE_SCREEN_BUFFER_INFO struct { + DwSize COORD + DwCursorPosition COORD + WAttributes WORD + SrWindow SMALL_RECT + DwMaximumWindowSize COORD +} +type CONSOLE_SCREEN_BUFFER_INFOEX struct { + CbSize ULONG + DwSize COORD + DwCursorPosition COORD + WAttributes WORD + SrWindow SMALL_RECT + DwMaximumWindowSize COORD + WPopupAttributes WORD + BFullscreenSupported BOOL + ColorTable [16]COLORREF +} +type CONVCONTEXT struct { + Cb uint32 + WFlags uint32 + WCountryID uint32 + ICodePage int32 + DwLangID uint32 + DwSecurity uint32 + Qos SECURITY_QUALITY_OF_SERVICE +} +type CONVINFO struct { + Cb uint32 + HUser *uint32 // DWORD_PTR + HConvPartner HCONV + HszSvcPartner HSZ + HszServiceReq HSZ + HszTopic HSZ + HszItem HSZ + WFmt uint32 // UINT + WType uint32 // UINT + WStatus uint32 // UINT + WConvst uint32 // UINT + WLastError uint32 // UINT + HConvList HCONVLIST + ConvCtxt CONVCONTEXT + Hwnd HWND + HwndPartner HWND +} +type COORD struct { + X int16 + Y int16 +} + +func getCOORDFromUintptr(v uintptr) COORD { + var ret COORD + u32 := uint32(v) + ret.X = *(*int16)(unsafe.Pointer(&u32)) + ret.Y = *(*int16)(unsafe.Pointer(uintptr(unsafe.Pointer(&u32)) + uintptr(2))) + return ret +} +func getUintptrFromCOORD(c COORD) uintptr { + var ret uintptr + xPtr := (*int16)(unsafe.Pointer(&ret)) + *xPtr = c.X + yPtr := (*int16)(unsafe.Pointer(uintptr(unsafe.Pointer(&ret)) + uintptr(2))) + *yPtr = c.Y + return ret +} + +type COSERVERINFO struct { + DwReserved1 DWORD + PwszName LPWSTR + PAuthInfo *COAUTHINFO + DwReserved2 DWORD +} +type CPINFO struct { + MaxCharSize UINT + DefaultChar [MAX_DEFAULTCHAR]BYTE + LeadByte [MAX_LEADBYTES]BYTE +} +type CPINFOEX struct { + MaxCharSize UINT + DefaultChar [MAX_DEFAULTCHAR]BYTE + LeadByte [MAX_LEADBYTES]BYTE + UnicodeDefaultChar WCHAR + CodePage UINT + CodePageName [MAX_PATH]WCHAR +} +type CREDENTIAL struct { + Flags uint32 + Type uint32 + TargetName LPWSTR + Comment LPWSTR + LastWritten FILETIME + CredentialBlobSize uint32 + CredentialBlob *byte + Persist uint32 + AttributeCount uint32 + Attributes *CREDENTIAL_ATTRIBUTE + TargetAlias LPWSTR + UserName LPWSTR +} +type CREDENTIAL_ATTRIBUTE struct { + Keyword LPWSTR + Flags uint32 + ValueSize uint32 + Value *byte +} +type CRL_CONTEXT struct { + DwCertEncodingType DWORD + PbCrlEncoded *BYTE + CbCrlEncoded DWORD + PCrlInfo PCRL_INFO + HCertStore HCERTSTORE +} +type CRL_ENTRY struct { + SerialNumber CRYPT_INTEGER_BLOB + RevocationDate FILETIME + CExtension DWORD + RgExtension PCERT_EXTENSION +} +type CRL_INFO struct { + DwVersion DWORD + SignatureAlgorithm CRYPT_ALGORITHM_IDENTIFIER + Issuer CERT_NAME_BLOB + ThisUpdate FILETIME + NextUpdate FILETIME + CCRLEntry DWORD + RgCRLEntry PCRL_ENTRY + CExtension DWORD + RgExtension PCERT_EXTENSION +} +type CRYPTOAPI_BLOB_ struct { + CbData DWORD + PbData *BYTE +} +type CRYPT_ALGORITHM_IDENTIFIER struct { + PszObjId LPSTR + Parameters CRYPT_OBJID_BLOB +} +type CRYPT_ATTRIBUTE struct { + PszObjId LPSTR + CValue DWORD + RgValue PCRYPT_ATTR_BLOB +} +type CRYPT_ATTR_BLOB CRYPTOAPI_BLOB_ +type CRYPT_BIT_BLOB struct { + CbData DWORD + PbData *BYTE + CUnusedBits DWORD +} +type CRYPT_DATA_BLOB CRYPTOAPI_BLOB_ +type CRYPT_DER_BLOB CRYPTOAPI_BLOB_ +type CRYPT_HASH_BLOB CRYPTOAPI_BLOB_ +type CRYPT_INTEGER_BLOB CRYPTOAPI_BLOB_ +type CRYPT_OBJID_BLOB CRYPTOAPI_BLOB_ +type CSADDR_INFO struct { + LocalAddr SOCKET_ADDRESS + RemoteAddr SOCKET_ADDRESS + ISocketType INT + IProtocol INT +} +type CSFV struct { + CbSize UINT + Pshf *IShellFolder + PsvOuter *IShellView + Pidl PCIDLIST_ABSOLUTE + LEvents LONG + PfnCallback LPFNVIEWCALLBACK + Fvm FOLDERVIEWMODE +} +type CS_TAG_GETTING_ROUTINE func(hBinding RPC_BINDING_HANDLE, fServerSide int32, pulSendingTag *uint32, pulDesiredReceivingTag *uint32, pulReceivingTag *uint32, pStatus *Error_status_t) +type CS_TYPE_FROM_NETCS_ROUTINE func(hBinding RPC_BINDING_HANDLE, ulNetworkCodeSet uint32, pNetworkData *byte, ulNetworkDataLength uint32, ulLocalBufferSize uint32, pLocalData uintptr, pulLocalDataLength *uint32, pStatus *Error_status_t) +type CS_TYPE_LOCAL_SIZE_ROUTINE func(hBinding RPC_BINDING_HANDLE, ulNetworkCodeSet uint32, ulNetworkBufferSize uint32, conversionType *IDL_CS_CONVERT, pulLocalBufferSize *uint32, pStatus *Error_status_t) +type CS_TYPE_NET_SIZE_ROUTINE func(hBinding RPC_BINDING_HANDLE, ulNetworkCodeSet uint32, ulLocalBufferSize uint32, conversionType *IDL_CS_CONVERT, pulNetworkBufferSize *uint32, pStatus *Error_status_t) +type CS_TYPE_TO_NETCS_ROUTINE func(hBinding RPC_BINDING_HANDLE, ulNetworkCodeSet uint32, pLocalData uintptr, ulLocalDataLength uint32, pNetworkData *byte, pulNetworkDataLength *uint32, pStatus *Error_status_t) +type CTL_CONTEXT struct { + DwMsgAndCertEncodingType DWORD + PbCtlEncoded *BYTE + CbCtlEncoded DWORD + PCtlInfo PCTL_INFO + HCertStore HCERTSTORE + HCryptMsg HCRYPTMSG + PbCtlContent *BYTE + CbCtlContent DWORD +} +type CTL_ENTRY struct { + SubjectIdentifier CRYPT_DATA_BLOB + CAttribute DWORD + RgAttribute PCRYPT_ATTRIBUTE +} +type CTL_INFO struct { + DwVersion DWORD + SubjectUsage CTL_USAGE + ListIdentifier CRYPT_DATA_BLOB + SequenceNumber CRYPT_INTEGER_BLOB + ThisUpdate FILETIME + NextUpdate FILETIME + SubjectAlgorithm CRYPT_ALGORITHM_IDENTIFIER + CCTLEntry DWORD + RgCTLEntry PCTL_ENTRY + CExtension DWORD + RgExtension PCERT_EXTENSION +} +type CTL_USAGE struct { + CUsageIdentifier DWORD + RgpszUsageIdentifier *LPSTR +} +type CURSORINFO struct { + CbSize uint32 + Flags uint32 + HCursor HCURSOR + PtScreenPos POINT +} +type CUSTDATA struct { + CCustData DWORD + PrgCustData *CUSTDATAITEM +} +type CUSTDATAITEM struct { + Guid GUID + VarValue VARIANTARG +} +type CY struct { + union1 [8]byte +} + +func (this *CY) GetLo() uint32 { + return *(*uint32)(unsafe.Pointer(&this.union1[0])) +} +func (this *CY) SetLo(v uint32) { + *(*uint32)(unsafe.Pointer(&this.union1[0])) = v +} +func (this *CY) GetHi() int32 { + return *(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1[0])) + uintptr(4))) +} +func (this *CY) SetHi(v int32) { + *(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1[0])) + uintptr(4))) = v +} +func (this *CY) GetInt64() int64 { + return *(*int64)(unsafe.Pointer(&this.union1[0])) +} +func (this *CY) SetInt64(v int64) { + *(*int64)(unsafe.Pointer(&this.union1[0])) = v +} + +type DACOMPARE func(p1 uintptr, p2 uintptr, lParam LPARAM) int32 +type DAENUMCALLBACK func(p uintptr, pData uintptr) int32 +type DATE float64 +type DATETIME struct { + Year uint16 // WORD + Month uint16 // WORD + Day uint16 // WORD + Hour uint16 // WORD + Min uint16 // WORD + Sec uint16 // WORD +} +type DECIMAL struct { + WReserved USHORT + union1 [2]byte + Hi32 ULONG + union2 [8]byte +} + +func (this *DECIMAL) Scale() *BYTE { + return (*BYTE)(unsafe.Pointer(&this.union1[0])) +} +func (this *DECIMAL) Sign() *BYTE { + return (*BYTE)(unsafe.Pointer(&this.union1[1])) +} +func (this *DECIMAL) Signscale() *USHORT { + return (*USHORT)(unsafe.Pointer(&this.union1[0])) +} +func (this *DECIMAL) Lo32() *ULONG { + return (*ULONG)(unsafe.Pointer(&this.union2[0])) +} +func (this *DECIMAL) Mid32() *ULONG { + return (*ULONG)(unsafe.Pointer(&this.union2[4])) +} +func (this *DECIMAL) Lo64() *ULONGLONG { + return (*ULONGLONG)(unsafe.Pointer(&this.union2[0])) +} + +type DEFCONTEXTMENU struct { + Hwnd HWND + Pcmcb *IContextMenuCB + PidlFolder PCIDLIST_ABSOLUTE + Psf *IShellFolder + Cidl UINT + Apidl PCUITEMID_CHILD_ARRAY + PunkAssociationInfo *IUnknown + CKeys UINT + AKeys/*const*/ *HKEY +} +type DESIGNVECTOR struct { + DvReserved DWORD + DvNumAxes DWORD + DvValues [MM_MAX_NUMAXES]LONG +} +type DESKTOPENUMPROC func(lpszDesktop LPWSTR, lParam LPARAM) BOOL +type DEVMODE struct { + DmDeviceName [CCHDEVICENAME]uint16 + DmSpecVersion uint16 + DmDriverVersion uint16 + DmSize uint16 + DmDriverExtra uint16 + DmFields uint32 + DmOrientation int16 + DmPaperSize int16 + DmPaperLength int16 + DmPaperWidth int16 + DmScale int16 + DmCopies int16 + DmDefaultSource int16 + DmPrintQuality int16 + DmColor int16 + DmDuplex int16 + DmYResolution int16 + DmTTOption int16 + DmCollate int16 + DmFormName [CCHFORMNAME]uint16 + DmLogPixels uint16 + DmBitsPerPel uint32 + DmPelsWidth uint32 + DmPelsHeight uint32 + DmDisplayFlags uint32 + DmDisplayFrequency uint32 + DmICMMethod uint32 + DmICMIntent uint32 + DmMediaType uint32 + DmDitherType uint32 + DmReserved1 uint32 + DmReserved2 uint32 + DmPanningWidth uint32 + DmPanningHeight uint32 +} +type DHPDEV HANDLE +type DHSURF HANDLE +type DISPID LONG +type DISPLAY_DEVICE struct { + Cb uint32 + DeviceName [32]uint16 + DeviceString [128]uint16 + StateFlags uint32 + DeviceID [128]uint16 + DeviceKey [128]uint16 +} +type DISPPARAMS struct { + Rgvarg *VARIANTARG + RgdispidNamedArgs *DISPID + CArgs UINT + CNamedArgs UINT +} +type DLGPROC func(hwndDlg HWND, uMsg uint32, wParam WPARAM, lParam LPARAM) int32 +type DLGTEMPLATE struct { + storage [18]byte +} + +func (this *DLGTEMPLATE) Style() *uint32 { + return (*uint32)(unsafe.Pointer(&this.storage[0])) +} +func (this *DLGTEMPLATE) DwExtendedStyle() *uint32 { + return (*uint32)(unsafe.Pointer(&this.storage[4])) +} +func (this *DLGTEMPLATE) Cdit() *uint16 { + return (*uint16)(unsafe.Pointer(&this.storage[8])) +} +func (this *DLGTEMPLATE) X() *int16 { + return (*int16)(unsafe.Pointer(&this.storage[10])) +} +func (this *DLGTEMPLATE) Y() *int16 { + return (*int16)(unsafe.Pointer(&this.storage[12])) +} +func (this *DLGTEMPLATE) Cx() *int16 { + return (*int16)(unsafe.Pointer(&this.storage[14])) +} +func (this *DLGTEMPLATE) Cy() *int16 { + return (*int16)(unsafe.Pointer(&this.storage[16])) +} + +type DOCINFO struct { + CbSize int32 + LpszDocName LPCWSTR + LpszOutput LPCWSTR + LpszDatatype LPCWSTR + FwType DWORD +} +type DOUBLE float64 +type DRAWSTATEPROC func(hdc HDC, lData uintptr, wData uintptr, cx int32, cy int32) BOOL +type DRAWTEXTPARAMS struct { + CbSize uint32 + ITabLength int32 + ILeftMargin int32 + IRightMargin int32 + UiLengthDrawn uint32 +} +type DTBGOPTS struct { + DwSize DWORD + DwFlags DWORD + RcClip RECT +} +type DTTOPTS struct { + DwSize DWORD + DwFlags DWORD + CrText COLORREF + CrBorder COLORREF + CrShadow COLORREF + ITextShadowType int32 + PtShadowOffset POINT + IBorderSize int32 + IFontPropId int32 + IColorPropId int32 + IStateId int32 + FApplyOverlay BOOL + IGlowSize int32 + PfnDrawTextCallback uintptr // DTT_CALLBACK_PROC + LParam LPARAM +} +type DTT_CALLBACK_PROC func(hdc HDC, pszText LPWSTR, cchText int32, prc LPRECT, dwFlags UINT, lParam LPARAM) int32 +type DVTARGETDEVICE struct { + TdSize DWORD + TdDriverNameOffset WORD + TdDeviceNameOffset WORD + TdPortNameOffset WORD + TdExtDevmodeOffset WORD + TdData [1]BYTE +} +type DWORD_PTR *DWORD +type EFS_CERTIFICATE_BLOB struct { + DwCertEncodingType DWORD + CbData DWORD + PbData PBYTE +} +type ENCRYPTION_CERTIFICATE struct { + CbTotalLength DWORD + PUserSid *SID + PCertBlob *EFS_CERTIFICATE_BLOB +} +type ENCRYPTION_CERTIFICATE_LIST struct { + NUsers DWORD + PUsers *PENCRYPTION_CERTIFICATE +} +type ENG_TIME_FIELDS struct { + UsYear USHORT + UsMonth USHORT + UsDay USHORT + UsHour USHORT + UsMinute USHORT + UsSecond USHORT + UsMilliseconds USHORT + UsWeekday USHORT +} +type ENHMETAHEADER struct { + IType DWORD + NSize DWORD + RclBounds RECTL + RclFrame RECTL + DSignature DWORD + NVersion DWORD + NBytes DWORD + NRecords DWORD + NHandles WORD + SReserved WORD + NDescription DWORD + OffDescription DWORD + NPalEntries DWORD + SzlDevice SIZEL + SzlMillimeters SIZEL + CbPixelFormat DWORD + OffPixelFormat DWORD + BOpenGL DWORD + SzlMicrometers SIZEL +} +type ENHMETARECORD struct { + IType DWORD + NSize DWORD + DParm [1]DWORD +} +type ENHMFENUMPROC func(hdc HDC, lpht *HANDLETABLE, lpmr /*const*/ *ENHMETARECORD, nHandles int32, data LPARAM) int32 +type ENUMLOGFONTEX struct { + ElfLogFont LOGFONT + ElfFullName [LF_FULLFACESIZE]WCHAR + ElfStyle [LF_FACESIZE]WCHAR + ElfScript [LF_FACESIZE]WCHAR +} +type ENUMLOGFONTEXDV struct { + ElfEnumLogfontEx ENUMLOGFONTEX + ElfDesignVector DESIGNVECTOR +} +type ENUMRESLANGPROC func(hModule HMODULE, lpType string, lpName string, wLanguage WORD, lParam LONG_PTR) BOOL +type ENUM_PAGE_FILE_INFORMATION struct { + Cb DWORD + Reserved DWORD + TotalSize SIZE_T + TotalInUse SIZE_T + PeakUsage SIZE_T +} +type EXCEPINFO struct { + WCode WORD + WReserved WORD + BstrSource BSTR + BstrDescription BSTR + BstrHelpFile BSTR + DwHelpContext DWORD + PvReserved PVOID + PfnDeferredFillIn uintptr + Scode SCODE +} + +func (this *EXCEPINFO) DeferredFillIn() func(unnamed0 *EXCEPINFO) HRESULT { + return func(unnamed0 *EXCEPINFO) HRESULT { + ret := syscall3(this.PfnDeferredFillIn, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return HRESULT(ret) + } +} + +type EXPLICIT_ACCESS struct { + GrfAccessPermissions DWORD + GrfAccessMode ACCESS_MODE + GrfInheritance DWORD + Trustee TRUSTEE +} +type EXPR_EVAL func(unnamed0 *MIDL_STUB_MESSAGE) +type Error_status_t uint32 +type FARPROC func() INT_PTR +type FD_GLYPHATTR struct { + CjThis ULONG + CGlyphs ULONG + IMode ULONG + AGlyphAttr [1]BYTE +} +type FILETIME struct { + DwLowDateTime uint32 + DwHighDateTime uint32 +} +type FINDREPLACE struct { + LStructSize DWORD + HwndOwner HWND + HInstance HINSTANCE + Flags DWORD + LpstrFindWhat LPWSTR + LpstrReplaceWith LPWSTR + WFindWhatLen WORD + WReplaceWithLen WORD + LCustData LPARAM + LpfnHook uintptr // LPFRHOOKPROC + LpTemplateName LPCWSTR +} +type FIX LONG +type FIXED struct { + Fract WORD + Value int16 +} +type FIXED_INFO_W2KSP1 struct { + HostName [MAX_HOSTNAME_LEN + 4]CHAR + DomainName [MAX_DOMAIN_NAME_LEN + 4]CHAR + CurrentDnsServer PIP_ADDR_STRING + DnsServerList IP_ADDR_STRING + NodeType UINT + ScopeId [MAX_SCOPE_ID_LEN + 4]CHAR + EnableRouting UINT + EnableProxy UINT + EnableDns UINT +} +type FLASHWINFO struct { + CbSize uint32 // UINT + Hwnd HWND + DwFlags uint32 + UCount uint32 // UINT + DwTimeout uint32 +} +type FLOAT float32 +type FLOATL FLOAT +type FLOAT_LONG struct { + storage [4]byte +} + +func (this *FLOAT_LONG) E() *FLOATL { + return (*FLOATL)(unsafe.Pointer(&this.storage[0])) +} +func (this *FLOAT_LONG) L() *LONG { + return (*LONG)(unsafe.Pointer(&this.storage[0])) +} + +type FLONG uint32 +type FLOWSPEC struct { + TokenRate ULONG + TokenBucketSize ULONG + PeakBandwidth ULONG + Latency ULONG + DelayVariation ULONG + ServiceType SERVICETYPE + MaxSduSize ULONG + MinimumPolicedSize ULONG +} +type FMTID GUID +type FONTDESC struct { + CbSizeofstruct UINT + LpstrName LPOLESTR + CySize CY + SWeight SHORT + SCharset SHORT + FItalic BOOL + FUnderline BOOL + FStrikethrough BOOL +} +type FONTENUMPROC func(unnamed0 /*const*/ *LOGFONT, unnamed1 /*const*/ *TEXTMETRIC, unnamed2 DWORD, unnamed3 LPARAM) int32 +type FONTINFO struct { + CjThis ULONG + FlCaps FLONG + CGlyphsSupported ULONG + CjMaxGlyph1 ULONG + CjMaxGlyph4 ULONG + CjMaxGlyph8 ULONG + CjMaxGlyph32 ULONG +} +type FONTOBJ struct { + IUniq ULONG + IFace ULONG + CxMax ULONG + FlFontType FLONG + ITTUniq ULONG_PTR + IFile ULONG_PTR + SizLogResPpi SIZE + UlStyleSize ULONG + PvConsumer PVOID + PvProducer PVOID +} +type FONTSIGNATURE struct { + FsUsb [4]DWORD + FsCsb [2]DWORD +} +type FORMATETC struct { + CfFormat CLIPFORMAT + Ptd *DVTARGETDEVICE + DwAspect DWORD + Lindex LONG + Tymed DWORD +} +type FOURCC DWORD +type FULL_PTR_XLAT_TABLES struct { + RefIdToPointer uintptr + PointerToRefId uintptr + NextRefId uint32 + XlatSide XLAT_SIDE +} +type FXPT2DOT30 int32 +type GCP_RESULTS struct { + LStructSize DWORD + LpOutString LPWSTR + LpOrder *UINT + LpDx *int32 + LpCaretPos *int32 + LpClass LPSTR + LpGlyphs LPWSTR + NGlyphs UINT + NMaxFit int32 +} +type GENERIC_BINDING_INFO struct { + PObj uintptr + Size uint32 + PfnBind uintptr // GENERIC_BINDING_ROUTINE + PfnUnbind uintptr // GENERIC_UNBIND_ROUTINE +} +type GENERIC_BINDING_ROUTINE func(unnamed0 uintptr) uintptr +type GENERIC_BINDING_ROUTINE_PAIR struct { + PfnBind uintptr // GENERIC_BINDING_ROUTINE + PfnUnbind uintptr // GENERIC_UNBIND_ROUTINE +} +type GENERIC_MAPPING struct { + GenericRead ACCESS_MASK + GenericWrite ACCESS_MASK + GenericExecute ACCESS_MASK + GenericAll ACCESS_MASK +} +type GENERIC_UNBIND_ROUTINE func(unnamed0 uintptr, unnamed1 *byte) +type GEOID LONG +type GESTURECONFIG struct { + DwID uint32 + DwWant uint32 + DwBlock uint32 +} +type GESTUREINFO struct { + CbSize uint32 // UINT + DwFlags uint32 + DwID uint32 + HwndTarget HWND + PtsLocation POINTS + DwInstanceID uint32 + DwSequenceID uint32 + padding1 [pad0for64_4for32]byte + UllArguments int64 // ULONGLONG + CbExtraArgs uint32 // UINT + padding2 [pad0for64_4for32]byte +} +type GLYPHBITS struct { + PtlOrigin POINTL + SizlBitmap SIZEL + Aj [1]BYTE +} +type GLYPHDEF struct { + p uintptr +} + +func (this *GLYPHDEF) Pgb() *GLYPHBITS { + return (*GLYPHBITS)(unsafe.Pointer(this)) +} +func (this *GLYPHDEF) Ppo() *PATHOBJ { + return (*PATHOBJ)(unsafe.Pointer(this)) +} + +type GLYPHMETRICS struct { + GmBlackBoxX UINT + GmBlackBoxY UINT + GmptGlyphOrigin POINT + GmCellIncX int16 + GmCellIncY int16 +} +type GLYPHMETRICSFLOAT struct { + GmfBlackBoxX float32 + GmfBlackBoxY float32 + GmfptGlyphOrigin POINTFLOAT + GmfCellIncX float32 + GmfCellIncY float32 +} +type GLYPHPOS struct { + Hg HGLYPH + Pgdf *GLYPHDEF + Ptl POINTL +} +type GLYPHSET struct { + CbThis DWORD + FlAccel DWORD + CGlyphsSupported DWORD + CRanges DWORD + Ranges [1]WCRANGE +} +type GLbitfield uint32 +type GLboolean byte +type GLbyte int8 +type GLclampd float64 +type GLclampf float32 +type GLdouble float64 +type GLenum uint32 +type GLfloat float32 +type GLint int32 +type GLshort int16 +type GLsizei uint32 +type GLubyte uint8 +type GLuint uint32 +type GLushort uint16 +type GOBJENUMPROC func(unnamed0 LPVOID, unnamed1 LPARAM) int32 +type GRAYSTRINGPROC func(hdc HDC, lParam LPARAM, cchData int) BOOL +type GROUP uint32 +type GUID struct { + Data1 uint32 + Data2 uint16 + Data3 uint16 + Data4 [8]byte +} +type GUITHREADINFO struct { + CbSize uint32 + Flags uint32 + HwndActive HWND + HwndFocus HWND + HwndCapture HWND + HwndMenuOwner HWND + HwndMoveSize HWND + HwndCaret HWND + RcCaret RECT +} +type GdiplusStartupInput struct { + GdiplusVersion uint32 + DebugEventCallback uintptr // DebugEventProc + SuppressBackgroundThread BOOL + SuppressExternalCodecs BOOL +} +type GdiplusStartupOutput struct { + storage [2]uintptr +} +type HACCEL HANDLE +type HANDLE uintptr +type HANDLER_FUNCTION_EX func(dwControl uint32, dwEventType uint32, lpEventData uintptr, lpContext uintptr) uint32 +type HANDLETABLE struct { + ObjectHandle [1]HGDIOBJ +} +type HANIMATIONBUFFER HANDLE +type HARDWAREINPUT struct { + UMsg uint32 + WParamL uint16 + WParamH uint16 +} +type HBITMAP HGDIOBJ +type HBRUSH HGDIOBJ +type HCERTSTORE uintptr +type HCOLORSPACE HANDLE +type HCONV HANDLE +type HCONVLIST HANDLE +type HCRYPTHASH uintptr +type HCRYPTKEY uintptr +type HCRYPTMSG uintptr +type HCRYPTPROV uintptr +type HCURSOR HANDLE +type HDC HANDLE +type HDDEDATA HANDLE +type HDESK HANDLE +type HDEV HANDLE +type HDEVNOTIFY uintptr +type HDPA uintptr +type HDROP HANDLE +type HDRVR HANDLE +type HDSA uintptr +type HDWP HANDLE +type HELPINFO struct { + CbSize UINT + IContextType int32 + ICtrlId int32 + HItemHandle HANDLE + DwContextId DWORD_PTR + MousePos POINT +} +type HENHMETAFILE HANDLE +type HFONT HGDIOBJ +type HGDIOBJ HANDLE +type HGESTUREINFO HANDLE +type HGLOBAL HANDLE +type HGLRC HANDLE +type HGLYPH ULONG +type HHOOK HANDLE +type HICON HANDLE +type HIMAGELIST uintptr +type HIMC HANDLE +type HIMCC HANDLE +type HINSTANCE HANDLE +type HKEY HANDLE +type HKL HANDLE +type HLOCAL HANDLE +type HMENU HANDLE +type HMETAFILE HANDLE +type HMETAFILEPICT uintptr +type HMIDI HANDLE +type HMIDIIN HANDLE +type HMIDIOUT HANDLE +type HMIDISTRM HANDLE +type HMIXER HANDLE +type HMIXEROBJ HANDLE +type HMMIO HANDLE +type HMODULE uintptr +type HMONITOR HANDLE +type HOLEMENU HGLOBAL +type HOOKPROC func(code int32, wParam WPARAM, lParam LPARAM) LRESULT +type HPAINTBUFFER HANDLE +type HPALETTE HGDIOBJ +type HPEN HGDIOBJ +type HPOWERNOTIFY uintptr +type HPROPSHEETPAGE uintptr +type HPSTR *CHAR +type HPSXA HANDLE +type HRAWINPUT HANDLE +type HRESULT int32 +type HRGN HANDLE +type HRSRC HANDLE +type HSEMAPHORE HANDLE +type HSURF HANDLE +type HSZ HANDLE +type HTASK HANDLE +type HTHEME HANDLE +type HTOUCHINPUT HANDLE +type HUSKEY HANDLE +type HWAVEIN HANDLE +type HWAVEOUT HANDLE +type HWCT uintptr +type HWINEVENTHOOK HANDLE +type HWINSTA HANDLE +type HWND HANDLE +type Handle_t RPC_BINDING_HANDLE +type IAdviseSink struct { + lpVtbl uintptr +} +type IBindCtx struct { + lpVtbl uintptr +} +type ICMENUMPROC func(unnamed0 LPWSTR, unnamed1 LPARAM) int32 +type ICONINFO struct { + FIcon BOOL + XHotspot uint32 + YHotspot uint32 + HbmMask HBITMAP + HbmColor HBITMAP +} +type IChannelHook struct { + lpVtbl uintptr +} +type IClassFactory struct { + lpVtbl uintptr +} +type IConnectionPoint struct { + lpVtbl uintptr +} +type IContextMenu struct { + lpVtbl uintptr +} +type IContextMenuCB struct { + lpVtbl uintptr +} +type ICreateErrorInfo struct { + lpVtbl uintptr +} +type ICreateTypeLib struct { + lpVtbl uintptr +} +type ICreateTypeLib2 struct { + lpVtbl uintptr +} +type IDataAdviseHolder struct { + lpVtbl uintptr +} +type IDataObject struct { + lpVtbl uintptr +} +type IDispatch struct { + lpVtbl uintptr +} +type IDropSource struct { + lpVtbl uintptr +} +type IDropTarget struct { + lpVtbl uintptr +} +type IEnumAssocHandlers struct { + lpVtbl uintptr +} +type IEnumFORMATETC struct { + lpVtbl uintptr +} +type IEnumOLEVERB struct { + lpVtbl uintptr +} +type IErrorInfo struct { + lpVtbl uintptr +} +type IFTYPE ULONG +type IF_INDEX NET_IFINDEX +type IF_LUID NET_LUID +type IID GUID +type IInitializeSpy struct { + lpVtbl uintptr +} +type ILockBytes struct { + lpVtbl uintptr +} +type IMAGEINFO struct { + HbmImage HBITMAP + HbmMask HBITMAP + Unused1 int32 + Unused2 int32 + RcImage RECT +} +type IMAGELISTDRAWPARAMS struct { + CbSize DWORD + Himl HIMAGELIST + I int32 + HdcDst HDC + X int32 + Y int32 + Cx int32 + Cy int32 + XBitmap int32 + YBitmap int32 + RgbBk COLORREF + RgbFg COLORREF + FStyle UINT + DwRop DWORD + FState DWORD + Frame DWORD + CrEffect COLORREF +} +type IMCENUMPROC func(unnamed0 HIMC, unnamed1 LPARAM) BOOL +type IMEMENUITEMINFO struct { + CbSize UINT + FType UINT + FState UINT + WID UINT + HbmpChecked HBITMAP + HbmpUnchecked HBITMAP + DwItemData DWORD + SzString [IMEMENUITEM_STRING_SIZE]WCHAR + HbmpItem HBITMAP +} +type IMEPRO struct { + HWnd HWND + InstDate DATETIME + WVersion uint32 // UINT + SzDescription [50]uint16 + SzName [80]uint16 + SzOptions [30]uint16 +} +type IMalloc struct { + lpVtbl uintptr +} +type IMallocSpy struct { + lpVtbl uintptr +} +type IMarshal struct { + lpVtbl uintptr +} +type IMessageFilter struct { + lpVtbl uintptr +} +type IMoniker struct { + lpVtbl uintptr +} +type IN6_ADDR struct { + U IN6_ADDR_U +} +type IN6_ADDR_U struct { + storage [16]byte +} + +func (this *IN6_ADDR_U) GetByte() [16]UCHAR { + var ret [16]UCHAR + for i := 0; i < 16; i++ { + ret[i] = UCHAR(this.storage[i]) + } + return ret +} +func (this *IN6_ADDR_U) SetByte(v [16]UCHAR) { + for i := 0; i < 16; i++ { + this.storage[i] = byte(v[i]) + } +} +func (this *IN6_ADDR_U) GetWord() [8]USHORT { + var ret [8]USHORT + for i := 0; i < 8; i++ { + ret[i] = *(*USHORT)(unsafe.Pointer(&this.storage[i*2])) + } + return ret +} +func (this *IN6_ADDR_U) SetWord(v [8]USHORT) { + for i := 0; i < 8; i++ { + ptr := (*USHORT)(unsafe.Pointer(&this.storage[i*2])) + *ptr = v[i] + } +} + +type INITCOMMONCONTROLSEX struct { + DwSize DWORD + DwICC DWORD +} +type INPUT struct { + Type uint32 + padding1 [pad4for64_0for32]byte + data [8 * pad4for64_3for32]byte +} + +func (this *INPUT) Mi() *MOUSEINPUT { + return (*MOUSEINPUT)(unsafe.Pointer(&this.data[0])) +} +func (this *INPUT) Ki() *KEYBDINPUT { + return (*KEYBDINPUT)(unsafe.Pointer(&this.data[0])) +} +func (this *INPUT) Hi() *HARDWAREINPUT { + return (*HARDWAREINPUT)(unsafe.Pointer(&this.data[0])) +} + +type INT int32 +type INTERFACEDATA struct { + Pmethdata *METHODDATA + CMembers UINT +} +type INTERFACE_HANDLE PVOID +type INTLIST struct { + IValueCount int32 + IValues [MAX_INTLIST_COUNT]int32 +} +type INT_PTR *int32 +type IN_ADDR struct { + S_un IN_ADDR_S_un +} +type IN_ADDR_S_un struct { + storage ULONG +} +type IN_ADDR_S_un_b struct { + s_b1, s_b2, s_b3, s_b4 UCHAR +} +type IN_ADDR_S_un_w struct { + s_w1, s_w2 USHORT +} + +func (this *IN_ADDR_S_un) S_un_b() *IN_ADDR_S_un_b { + return (*IN_ADDR_S_un_b)(unsafe.Pointer(&this.storage)) +} +func (this *IN_ADDR_S_un) S_un_w() *IN_ADDR_S_un_w { + return (*IN_ADDR_S_un_w)(unsafe.Pointer(&this.storage)) +} +func (this *IN_ADDR_S_un) S_addr() *ULONG { + return (*ULONG)(unsafe.Pointer(&this.storage)) +} +func (this *IN_ADDR) S_addr() ULONG { + return *this.S_un.S_addr() +} +func (this *IN_ADDR) S_host() UCHAR { + return this.S_un.S_un_b().s_b2 +} +func (this *IN_ADDR) S_net() UCHAR { + return this.S_un.S_un_b().s_b1 +} +func (this *IN_ADDR) S_imp() USHORT { + return this.S_un.S_un_w().s_w2 +} +func (this *IN_ADDR) S_impno() UCHAR { + return this.S_un.S_un_b().s_b4 +} +func (this *IN_ADDR) S_lh() UCHAR { + return this.S_un.S_un_b().s_b3 +} + +type IO_STATUS_BLOCK struct { + union1 uintptr + Information ULONG_PTR +} + +func (this *IO_STATUS_BLOCK) Status() *NTSTATUS { + return (*NTSTATUS)(unsafe.Pointer(&this.union1)) +} +func (this *IO_STATUS_BLOCK) Pointer() *PVOID { + return (*PVOID)(unsafe.Pointer(&this.union1)) +} + +type IOleAdviseHolder struct { + lpVtbl uintptr +} +type IOleClientSite struct { + lpVtbl uintptr +} +type IOleInPlaceActiveObject struct { + lpVtbl uintptr +} +type IOleInPlaceFrame struct { + lpVtbl uintptr +} +type IOleObject struct { + lpVtbl uintptr +} +type IPAddr ULONG +type IPMask ULONG + +func (this *IP_ADAPTER_ADDRESSES_LH) Alignment() *ULONGLONG { + return &this.union1 +} +func (this *IP_ADAPTER_ADDRESSES_LH) Length() *ULONG { + return (*ULONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_ADDRESSES_LH) IfIndex() *IF_INDEX { + return (*IF_INDEX)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1)) + uintptr(4))) +} +func (this *IP_ADAPTER_ADDRESSES_LH) Flags() *ULONG { + return (*ULONG)(unsafe.Pointer(&this.union2)) +} +func (this *IP_ADAPTER_ADDRESSES_LH) DdnsEnabled() bool { + return this.union2 == 0x80000000 +} +func (this *IP_ADAPTER_ADDRESSES_LH) RegisterAdapterSuffix() bool { + return this.union2 == 0x20000000 +} +func (this *IP_ADAPTER_ADDRESSES_LH) Dhcpv4Enabled() bool { + return this.union2 == 0x10000000 +} +func (this *IP_ADAPTER_ADDRESSES_LH) ReceiveOnly() bool { + return this.union2 == 0x8000000 +} +func (this *IP_ADAPTER_ADDRESSES_LH) NoMulticast() bool { + return this.union2 == 0x2000000 +} +func (this *IP_ADAPTER_ADDRESSES_LH) Ipv6OtherStatefulConfig() bool { + return this.union2 == 0x1000000 +} +func (this *IP_ADAPTER_ADDRESSES_LH) NetbiosOverTcpipEnabled() bool { + return this.union2 == 0x800000 +} +func (this *IP_ADAPTER_ADDRESSES_LH) Ipv4Enabled() bool { + return this.union2 == 0x200000 +} +func (this *IP_ADAPTER_ADDRESSES_LH) Ipv6Enabled() bool { + return this.union2 == 0x100000 +} +func (this *IP_ADAPTER_ADDRESSES_LH) Ipv6ManagedAddressConfigurationSupported() bool { + return this.union2 == 0x80000 +} +func (this *IP_ADAPTER_ANYCAST_ADDRESS_XP) Alignment() *ULONGLONG { + return (*ULONGLONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_ANYCAST_ADDRESS_XP) Length() *ULONG { + return (*ULONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_ANYCAST_ADDRESS_XP) Flags() *DWORD { + return (*DWORD)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1)) + uintptr(4))) +} +func (this *IP_ADAPTER_DNS_SERVER_ADDRESS_XP) Alignment() *ULONGLONG { + return (*ULONGLONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_DNS_SERVER_ADDRESS_XP) Length() *ULONG { + return (*ULONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_DNS_SERVER_ADDRESS_XP) Reserved() *DWORD { + return (*DWORD)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1)) + uintptr(4))) +} + +type IP_ADAPTER_DNS_SUFFIX struct { + Next *IP_ADAPTER_DNS_SUFFIX + String [MAX_DNS_SUFFIX_STRING_LENGTH]WCHAR +} + +func (this *IP_ADAPTER_GATEWAY_ADDRESS_LH) Alignment() *ULONGLONG { + return (*ULONGLONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_GATEWAY_ADDRESS_LH) Length() *ULONG { + return (*ULONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_GATEWAY_ADDRESS_LH) Reserved() *DWORD { + return (*DWORD)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1)) + uintptr(4))) +} + +type IP_ADAPTER_INDEX_MAP struct { + Index ULONG + Name [MAX_ADAPTER_NAME]WCHAR +} +type IP_ADAPTER_INFO struct { + Next *IP_ADAPTER_INFO + ComboIndex DWORD + AdapterName [MAX_ADAPTER_NAME_LENGTH + 4]CHAR + Description [MAX_ADAPTER_DESCRIPTION_LENGTH + 4]CHAR + AddressLength UINT + Address [MAX_ADAPTER_ADDRESS_LENGTH]BYTE + Index DWORD + Type UINT + DhcpEnabled UINT + CurrentIpAddress PIP_ADDR_STRING + IpAddressList IP_ADDR_STRING + GatewayList IP_ADDR_STRING + DhcpServer IP_ADDR_STRING + HaveWins BOOL + PrimaryWinsServer IP_ADDR_STRING + SecondaryWinsServer IP_ADDR_STRING + LeaseObtained Time_t + LeaseExpires Time_t +} + +func (this *IP_ADAPTER_MULTICAST_ADDRESS_XP) Alignment() *ULONGLONG { + return (*ULONGLONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_MULTICAST_ADDRESS_XP) Length() *ULONG { + return (*ULONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_MULTICAST_ADDRESS_XP) Flags() *DWORD { + return (*DWORD)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1)) + uintptr(4))) +} + +type IP_ADAPTER_ORDER_MAP struct { + NumAdapters ULONG + AdapterOrder [1]ULONG +} +type IP_ADAPTER_PREFIX_XP struct { + union1 ULONGLONG + Next *IP_ADAPTER_PREFIX_XP + Address SOCKET_ADDRESS + PrefixLength ULONG +} + +func (this *IP_ADAPTER_PREFIX_XP) Alignment() *ULONGLONG { + return (*ULONGLONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_PREFIX_XP) Length() *ULONG { + return (*ULONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_PREFIX_XP) Flags() *DWORD { + return (*DWORD)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1)) + uintptr(4))) +} + +type IP_ADAPTER_UNICAST_ADDRESS_LH struct { + union1 ULONGLONG + Next *IP_ADAPTER_UNICAST_ADDRESS_LH + Address SOCKET_ADDRESS + PrefixOrigin IP_PREFIX_ORIGIN + SuffixOrigin IP_SUFFIX_ORIGIN + DadState IP_DAD_STATE + ValidLifetime ULONG + PreferredLifetime ULONG + LeaseLifetime ULONG + OnLinkPrefixLength UINT8 +} + +func (this *IP_ADAPTER_UNICAST_ADDRESS_LH) Alignment() *ULONGLONG { + return (*ULONGLONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_UNICAST_ADDRESS_LH) Length() *ULONG { + return (*ULONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_UNICAST_ADDRESS_LH) Flags() *DWORD { + return (*DWORD)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1)) + uintptr(4))) +} +func (this *IP_ADAPTER_WINS_SERVER_ADDRESS_LH) Alignment() *ULONGLONG { + return (*ULONGLONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_WINS_SERVER_ADDRESS_LH) Length() *ULONG { + return (*ULONG)(unsafe.Pointer(&this.union1)) +} +func (this *IP_ADAPTER_WINS_SERVER_ADDRESS_LH) Reserved() *DWORD { + return (*DWORD)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1)) + uintptr(4))) +} + +type IP_ADDRESS_STRING struct { + String [4 * 4]CHAR +} +type IP_ADDR_STRING struct { + Next *IP_ADDR_STRING + IpAddress IP_ADDRESS_STRING + IpMask IP_MASK_STRING + Context DWORD +} +type IP_DAD_STATE NL_DAD_STATE +type IP_INTERFACE_INFO struct { + NumAdapters LONG + Adapter [1]IP_ADAPTER_INDEX_MAP +} +type IP_INTERFACE_NAME_INFO IP_INTERFACE_NAME_INFO_W2KSP1 +type IP_INTERFACE_NAME_INFO_W2KSP1 struct { + Index ULONG + MediaType ULONG + ConnectionType UCHAR + AccessType UCHAR + DeviceGuid GUID + InterfaceGuid GUID +} +type IP_MASK_STRING struct { + String [4 * 4]CHAR +} +type IP_OPTION_INFORMATION struct { + Ttl UCHAR + Tos UCHAR + Flags UCHAR + OptionsSize UCHAR + OptionsData PUCHAR +} +type IP_PER_ADAPTER_INFO_W2KSP1 struct { + AutoconfigEnabled UINT + AutoconfigActive UINT + CurrentDnsServer PIP_ADDR_STRING + DnsServerList IP_ADDR_STRING +} +type IP_PREFIX_ORIGIN NL_PREFIX_ORIGIN +type IP_STATUS ULONG +type IP_SUFFIX_ORIGIN NL_SUFFIX_ORIGIN +type IP_UNIDIRECTIONAL_ADAPTER_ADDRESS struct { + NumAdapters ULONG + Address [1]IPAddr +} +type IPersistStorage struct { + lpVtbl uintptr +} +type IPersistStream struct { + lpVtbl uintptr +} +type IPropertySetStorage struct { + lpVtbl uintptr +} +type IPropertyStorage struct { + lpVtbl uintptr +} +type IRecordInfo struct { + lpVtbl uintptr +} +type IRpcChannelBuffer struct { + lpVtbl uintptr +} +type IRpcStubBuffer struct { + lpVtbl uintptr +} +type IRunningObjectTable struct { + lpVtbl uintptr +} +type IShellFolder struct { + lpVtbl uintptr +} +type IShellFolderViewCB struct { + lpVtbl uintptr +} +type IShellItem struct { + lpVtbl uintptr +} +type IShellItemArray struct { + lpVtbl uintptr +} +type IShellView struct { + lpVtbl uintptr +} +type IStorage struct { + lpVtbl uintptr +} +type IStream struct { + lpVtbl uintptr +} +type ITEMIDLIST struct { + Mkid SHITEMID +} +type ITypeInfo struct { + lpVtbl uintptr +} +type ITypeLib struct { + lpVtbl uintptr +} +type IUnknown struct { + lpVtbl uintptr +} +type I_RPC_HANDLE uintptr +type JOYCAPS struct { + WMid WORD + WPid WORD + SzPname [MAXPNAMELEN]WCHAR + WXmin UINT + WXmax UINT + WYmin UINT + WYmax UINT + WZmin UINT + WZmax UINT + WNumButtons UINT + WPeriodMin UINT + WPeriodMax UINT + WRmin UINT + WRmax UINT + WUmin UINT + WUmax UINT + WVmin UINT + WVmax UINT + WCaps UINT + WMaxAxes UINT + WNumAxes UINT + WMaxButtons UINT + SzRegKey [MAXPNAMELEN]WCHAR + SzOEMVxD [MAX_JOYSTICKOEMVXDNAME]WCHAR +} +type JOYINFO struct { + WXpos UINT + WYpos UINT + WZpos UINT + WButtons UINT +} +type JOYINFOEX struct { + DwSize DWORD + DwFlags DWORD + DwXpos DWORD + DwYpos DWORD + DwZpos DWORD + DwRpos DWORD + DwUpos DWORD + DwVpos DWORD + DwButtons DWORD + DwButtonNumber DWORD + DwPOV DWORD + DwReserved1 DWORD + DwReserved2 DWORD +} +type KERNINGPAIR struct { + WFirst WORD + WSecond WORD + IKernAmount int32 +} +type KEYBDINPUT struct { + WVk uint16 + WScan uint16 + DwFlags uint32 + Time uint32 + DwExtraInfo uintptr // ULONG_PTR +} +type KNOWNFOLDERID GUID +type LANGID uint16 +type LARGE_INTEGER struct { + QuadPart int64 +} + +func (l *LARGE_INTEGER) LowPart() *uint32 { + return (*uint32)(unsafe.Pointer(&l.QuadPart)) +} +func (l *LARGE_INTEGER) HighPart() *int32 { + return (*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&l.QuadPart)) + uintptr(4))) +} + +type LASTINPUTINFO struct { + CbSize uint32 // UINT + DwTime uint32 +} +type LAYERPLANEDESCRIPTOR struct { + NSize uint16 + NVersion uint16 + DwFlags uint32 + IPixelType byte + CColorBits byte + CRedBits byte + CRedShift byte + CGreenBits byte + CGreenShift byte + CBlueBits byte + CBlueShift byte + CAlphaBits byte + CAlphaShift byte + CAccumBits byte + CAccumRedBits byte + CAccumGreenBits byte + CAccumBlueBits byte + CAccumAlphaBits byte + CDepthBits byte + CStencilBits byte + CAuxBuffers byte + ILayerPlane byte + BReserved byte + CrTransparent COLORREF +} +type LCID uint32 +type LCSCSTYPE LONG +type LCSGAMUTMATCH LONG +type LCTYPE uint32 +type LINEATTRS struct { + Fl FLONG + IJoin ULONG + IEndCap ULONG + ElWidth FLOAT_LONG + EMiterLimit FLOATL + Cstyle ULONG + Pstyle PFLOAT_LONG + ElStyleState FLOAT_LONG +} +type LINEDDAPROC func(unnamed0 int32, unnamed1 int32, unnamed LPARAM) +type LOGBRUSH struct { + LbStyle UINT + LbColor COLORREF + LbHatch ULONG_PTR +} +type LOGCOLORSPACE struct { + LcsSignature DWORD + LcsVersion DWORD + LcsSize DWORD + LcsCSType LCSCSTYPE + LcsIntent LCSGAMUTMATCH + LcsEndpoints CIEXYZTRIPLE + LcsGammaRed DWORD + LcsGammaGreen DWORD + LcsGammaBlue DWORD + LcsFilename [MAX_PATH]WCHAR +} +type LOGFONT struct { + LfHeight LONG + LfWidth LONG + LfEscapement LONG + LfOrientation LONG + LfWeight LONG + LfItalic byte + LfUnderline byte + LfStrikeOut byte + LfCharSet byte + LfOutPrecision byte + LfClipPrecision byte + LfQuality byte + LfPitchAndFamily byte + LfFaceName [LF_FACESIZE]WCHAR +} +type LOGPALETTE struct { + PalVersion WORD + PalNumEntries WORD + PalPalEntry [1]PALETTEENTRY +} +type LOGPEN struct { + LopnStyle UINT + LopnWidth POINT + LopnColor COLORREF +} +type LONG int32 +type LONG64 int64 +type LONGLONG int64 +type LONG_PTR *int32 +type LPAFPROTOCOLS *AFPROTOCOLS +type LPARAM uintptr +type LPBC *IBindCtx +type tagBLOB struct { + CbSize ULONG + PBlobData *BYTE +} +type LPBLOB *tagBLOB +type LPBROWSEINFO *BROWSEINFO +type LPBYTE *byte +type LPCFHOOKPROC func(unnamed0 HWND, unnamed1 UINT, unnamed2 WPARAM, unnamed3 LPARAM) UINT_PTR +type LPCHOOSEFONT *CHOOSEFONT +type LPCITEMIDLIST *ITEMIDLIST +type LPCOLESTR *OLECHAR +type LPCONDITIONPROC func(lpCallerId LPWSABUF, lpCallerData LPWSABUF, lpSQOS LPQOS, lpGQOS LPQOS, lpCalleeId LPWSABUF, lpCalleeData LPWSABUF, g *GROUP, dwCallbackData DWORD_PTR) int32 +type LPCPINFO *CPINFO +type LPCPINFOEX *CPINFOEX +type LPCSADDR_INFO *CSADDR_INFO +type LPCSFV *CSFV +type LPCSTR *byte +type LPCWSTR *uint16 +type LPDATAOBJECT *IDataObject +type LPDEVMODE *DEVMODE +type LPDISPATCH *IDispatch +type LPDROPSOURCE *IDropSource +type LPDROPTARGET *IDropTarget +type LPENUMFORMATETC *IEnumFORMATETC +type LPENUMOLEVERB *IEnumOLEVERB +type LPFINDREPLACE *FINDREPLACE +type LPFNADDPROPSHEETPAGE func(unnamed0 HPROPSHEETPAGE, unnamed1 LPARAM) BOOL +type LPFNDFMCALLBACK func(psf *IShellFolder, hwnd HWND, pdtobj *IDataObject, uMsg UINT, wParam WPARAM, lParam LPARAM) HRESULT +type LPFNVIEWCALLBACK func(psvOuter *IShellView, psf *IShellFolder, hwndMain HWND, uMsg UINT, wParam WPARAM, lParam LPARAM) HRESULT +type LPFRHOOKPROC func(unnamed0 HWND, unnamed1 UINT, unnamed2 WPARAM, unnamed3 LPARAM) UINT_PTR +type LPGCP_RESULTS *GCP_RESULTS +type LPGUID *GUID +type LPHELPINFO *HELPINFO +type LPIMEMENUITEMINFO *IMEMENUITEMINFO +type LPITEMIDLIST *ITEMIDLIST +type LPJOYCAPS *JOYCAPS +type LPJOYINFO *JOYINFO +type LPLOGCOLORSPACE *LOGCOLORSPACE +type LPLOGFONT *LOGFONT +type LPLOOKUPSERVICE_COMPLETION_ROUTINE func(dwError DWORD, dwBytes DWORD, lpOverlapped LPWSAOVERLAPPED) +type LPMALLOC *IMalloc +type LPMALLOCSPY *IMallocSpy +type LPMARSHAL *IMarshal +type LPMESSAGEFILTER *IMessageFilter +type LPMIDIOUTCAPS *MIDIOUTCAPS +type LPMIXERCAPS *MIXERCAPS +type LPMIXERCONTROL *MIXERCONTROL +type LPMIXERLINE *MIXERLINE +type LPMIXERLINECONTROLS *MIXERLINECONTROLS +type LPMMCKINFO *MMCKINFO +type LPMMIOINFO *MMIOINFO +type LPMONIKER *IMoniker +type LPOFNHOOKPROC func(unnamed0 HWND, unnamed1 UINT, unnamed2 WPARAM, unnamed3 LPARAM) UINT_PTR +type LPOLECLIENTSITE *IOleClientSite +type LPOLEINPLACEACTIVEOBJECT *IOleInPlaceActiveObject +type LPOLEINPLACEFRAME *IOleInPlaceFrame +type LPOLEINPLACEFRAMEINFO *OLEINPLACEFRAMEINFO +type LPOLEMENUGROUPWIDTHS *OLEMENUGROUPWIDTHS +type LPOLEOBJECT *IOleObject +type LPOLESTR *OLECHAR +type _OLESTREAM struct { + lpVtbl uintptr +} +type LPOLESTREAM *_OLESTREAM +type LPOPENFILENAME *OPENFILENAME +type LPOUTLINETEXTMETRIC *OUTLINETEXTMETRIC +type LPPAGEPAINTHOOK func(unnamed0 HWND, unnamed1 UINT, unnamed2 WPARAM, unnamed3 LPARAM) UINT_PTR +type LPPAGESETUPDLG *PAGESETUPDLG +type LPPAGESETUPHOOK func(unnamed0 HWND, unnamed1 UINT, unnamed2 WPARAM, unnamed3 LPARAM) UINT_PTR +type LPPERSISTSTORAGE *IPersistStorage +type LPPRINTDLG *PRINTDLG +type LPPRINTDLGEX *PRINTDLGEX +type LPPRINTHOOKPROC func(unnamed0 HWND, unnamed1 UINT, unnamed2 WPARAM, unnamed3 LPARAM) UINT_PTR +type LPPRINTPAGERANGE *PRINTPAGERANGE +type LPQOS *QOS +type LPRASTERIZER_STATUS *RASTERIZER_STATUS +type LPRECT *RECT +type LPRUNNINGOBJECTTABLE *IRunningObjectTable +type LPSAFEARRAY *SAFEARRAY +type LPSETUPHOOKPROC func(unnamed0 HWND, unnamed1 UINT, unnamed2 WPARAM, unnamed3 LPARAM) UINT_PTR +type LPSHELLFLAGSTATE *SHELLFLAGSTATE +type LPSHELLFOLDER *IShellFolder +type LPSHELLSTATE *SHELLSTATE +type LPSHFILEOPSTRUCT *SHFILEOPSTRUCT +type LPSHQUERYRBINFO *SHQUERYRBINFO +type LPSOCKADDR *SOCKADDR +type LPSTORAGE *IStorage +type LPSTR *CHAR +type LPSTREAM *IStream +type LPSTYLEBUF *STYLEBUF +type LPTEXTMETRIC *TEXTMETRIC +type LPTIMECAPS *TIMECAPS +type LPUNKNOWN *IUnknown +type LPVERSIONEDSTREAM *VERSIONEDSTREAM +type LPVOID uintptr +type LPWAVEHDR *WAVEHDR +type LPWAVEINCAPS *WAVEINCAPS +type LPWAVEOUTCAPS *WAVEOUTCAPS +type LPWPUPOSTMESSAGE func(unnamed0 HWND, unnamed1 UINT, unnamed2 WPARAM, unnamed3 LPARAM) BOOL +type LPWSABUF *WSABUF +type LPWSANAMESPACE_INFO *WSANAMESPACE_INFO +type LPWSANSCLASSINFO *WSANSCLASSINFO +type LPWSAOVERLAPPED *OVERLAPPED +type LPWSAOVERLAPPED_COMPLETION_ROUTINE func(dwError DWORD, cbTransferred DWORD, lpOverlapped LPWSAOVERLAPPED, dwFlags DWORD) +type LPWSAPROTOCOL_INFO *WSAPROTOCOL_INFO +type LPWSAQUERYSET *WSAQUERYSET +type LPWSASERVICECLASSINFO *WSASERVICECLASSINFO +type LPWSAVERSION *WSAVERSION +type LPWSTR *uint16 +type LRESULT uintptr +type LUID struct { + LowPart uint32 + HighPart int32 +} +type LUID_AND_ATTRIBUTES struct { + Luid LUID + Attributes ULONG +} +type MALLOC_FREE_STRUCT struct { + PfnAllocate uintptr // void* (__RPC_USER *pfnAllocate)(size_t) + PfnFree uintptr // void (__RPC_USER *pfnFree)(void *) +} +type MARGINS struct { + CxLeftWidth int32 + CxRightWidth int32 + CyTopHeight int32 + CyBottomHeight int32 +} +type MAT2 struct { + EM11 FIXED + EM12 FIXED + EM21 FIXED + EM22 FIXED +} +type MCIDEVICEID UINT +type MCIERROR DWORD +type MENUBARINFO struct { + CbSize uint32 + RcBar RECT + HMenu HMENU + HwndMenu HWND + bitfieldedFlags uint32 + // BOOL fBarFocused:1; + // BOOL fFocused:1; +} + +func (i *MENUBARINFO) FBarFocused() bool { + return (i.bitfieldedFlags & 1) == 1 +} +func (i *MENUBARINFO) FFocused() bool { + return (i.bitfieldedFlags & 2) == 2 +} + +type MENUINFO struct { + CbSize uint32 + FMask uint32 + DwStyle uint32 + CyMax uint32 + HbrBack HBRUSH + DwContextHelpID uint32 + DwMenuData uintptr +} +type MENUITEMINFO struct { + CbSize uint32 + FMask uint32 + FType uint32 + FState uint32 + WID uint32 + HSubMenu HMENU + HbmpChecked HBITMAP + HbmpUnchecked HBITMAP + DwItemData uintptr + DwTypeData *uint16 + Cch uint32 + HbmpItem HBITMAP +} +type METAFILEPICT struct { + Mm LONG + XExt LONG + YExt LONG + HMF HMETAFILE +} +type METARECORD struct { + RdSize DWORD + RdFunction WORD + RdParm [1]WORD +} +type METHODDATA struct { + SzName *OLECHAR + Ppdata *PARAMDATA + Dispid DISPID + IMeth UINT + Cc CALLCONV + CArgs UINT + WFlags WORD + VtReturn VARTYPE +} +type MFENUMPROC func(hdc HDC, lpht *HANDLETABLE, lpMR *METARECORD, nObj int32, param LPARAM) int32 +type MIBICMPINFO struct { + IcmpInStats MIBICMPSTATS + IcmpOutStats MIBICMPSTATS +} +type MIBICMPSTATS struct { + DwMsgs DWORD + DwErrors DWORD + DwDestUnreachs DWORD + DwTimeExcds DWORD + DwParmProbs DWORD + DwSrcQuenchs DWORD + DwRedirects DWORD + DwEchos DWORD + DwEchoReps DWORD + DwTimestamps DWORD + DwTimestampReps DWORD + DwAddrMasks DWORD + DwAddrMaskReps DWORD +} +type MIBICMPSTATS_EX MIBICMPSTATS_EX_XPSP1 +type MIBICMPSTATS_EX_XPSP1 struct { + DwMsgs DWORD + DwErrors DWORD + RgdwTypeCount [256]DWORD +} +type MIB_ICMP struct { + Stats MIBICMPINFO +} +type MIB_ICMP_EX_XPSP1 struct { + IcmpInStats MIBICMPSTATS_EX + IcmpOutStats MIBICMPSTATS_EX +} +type MIB_IFROW struct { + WszName [MAX_INTERFACE_NAME_LEN]WCHAR + DwIndex IF_INDEX + DwType IFTYPE + DwMtu DWORD + DwSpeed DWORD + DwPhysAddrLen DWORD + BPhysAddr [MAXLEN_PHYSADDR]UCHAR + DwAdminStatus DWORD + DwOperStatus INTERNAL_IF_OPER_STATUS + DwLastChange DWORD + DwInOctets DWORD + DwInUcastPkts DWORD + DwInNUcastPkts DWORD + DwInDiscards DWORD + DwInErrors DWORD + DwInUnknownProtos DWORD + DwOutOctets DWORD + DwOutUcastPkts DWORD + DwOutNUcastPkts DWORD + DwOutDiscards DWORD + DwOutErrors DWORD + DwOutQLen DWORD + DwDescrLen DWORD + BDescr [MAXLEN_IFDESCR]UCHAR +} +type MIB_IFTABLE struct { + DwNumEntries DWORD + Table [ANY_SIZE]MIB_IFROW +} +type MIB_IF_ROW2 struct { + InterfaceLuid NET_LUID + InterfaceIndex NET_IFINDEX + InterfaceGuid GUID + Alias [IF_MAX_STRING_SIZE + 1]WCHAR + Description [IF_MAX_STRING_SIZE + 1]WCHAR + PhysicalAddressLength ULONG + PhysicalAddress [IF_MAX_PHYS_ADDRESS_LENGTH]UCHAR + PermanentPhysicalAddress [IF_MAX_PHYS_ADDRESS_LENGTH]UCHAR + Mtu ULONG + Type IFTYPE + TunnelType TUNNEL_TYPE + MediaType NDIS_MEDIUM + PhysicalMediumType NDIS_PHYSICAL_MEDIUM + AccessType NET_IF_ACCESS_TYPE + DirectionType NET_IF_DIRECTION_TYPE + InterfaceAndOperStatusFlags BOOLEAN + OperStatus IF_OPER_STATUS + AdminStatus NET_IF_ADMIN_STATUS + MediaConnectState NET_IF_MEDIA_CONNECT_STATE + NetworkGuid NET_IF_NETWORK_GUID + ConnectionType NET_IF_CONNECTION_TYPE + padding1 [pad0for64_4for32]byte + TransmitLinkSpeed ULONG64 + ReceiveLinkSpeed ULONG64 + InOctets ULONG64 + InUcastPkts ULONG64 + InNUcastPkts ULONG64 + InDiscards ULONG64 + InErrors ULONG64 + InUnknownProtos ULONG64 + InUcastOctets ULONG64 + InMulticastOctets ULONG64 + InBroadcastOctets ULONG64 + OutOctets ULONG64 + OutUcastPkts ULONG64 + OutNUcastPkts ULONG64 + OutDiscards ULONG64 + OutErrors ULONG64 + OutUcastOctets ULONG64 + OutMulticastOctets ULONG64 + OutBroadcastOctets ULONG64 + OutQLen ULONG64 +} + +func (this *MIB_IF_ROW2) HardwareInterface() BOOLEAN { + return BOOLEAN(this.InterfaceAndOperStatusFlags & 0x1) +} +func (this *MIB_IF_ROW2) FilterInterface() BOOLEAN { + return BOOLEAN((this.InterfaceAndOperStatusFlags >> 1) & 0x1) +} +func (this *MIB_IF_ROW2) ConnectorPresent() BOOLEAN { + return BOOLEAN((this.InterfaceAndOperStatusFlags >> 2) & 0x1) +} +func (this *MIB_IF_ROW2) NotAuthenticated() BOOLEAN { + return BOOLEAN((this.InterfaceAndOperStatusFlags >> 3) & 0x1) +} +func (this *MIB_IF_ROW2) NotMediaConnected() BOOLEAN { + return BOOLEAN((this.InterfaceAndOperStatusFlags >> 4) & 0x1) +} +func (this *MIB_IF_ROW2) Paused() BOOLEAN { + return BOOLEAN((this.InterfaceAndOperStatusFlags >> 5) & 0x1) +} +func (this *MIB_IF_ROW2) LowPower() BOOLEAN { + return BOOLEAN((this.InterfaceAndOperStatusFlags >> 6) & 0x1) +} +func (this *MIB_IF_ROW2) EndPointInterface() BOOLEAN { + return BOOLEAN((this.InterfaceAndOperStatusFlags >> 7) & 0x1) +} + +type MIB_IF_TABLE2 struct { + NumEntries ULONG + padding1 [pad0for64_4for32]byte + Table [ANY_SIZE]MIB_IF_ROW2 +} +type MIB_IPADDRROW MIB_IPADDRROW_XP +type MIB_IPADDRROW_XP struct { + DwAddr DWORD + DwIndex IF_INDEX + DwMask DWORD + DwBCastAddr DWORD + DwReasmSize DWORD + Unused1 uint16 + WType uint16 +} +type MIB_IPADDRTABLE struct { + DwNumEntries DWORD + Table [ANY_SIZE]MIB_IPADDRROW +} +type MIB_IPFORWARDROW struct { + DwForwardDest DWORD + DwForwardMask DWORD + DwForwardPolicy DWORD + DwForwardNextHop DWORD + DwForwardIfIndex IF_INDEX + ForwardType MIB_IPFORWARD_TYPE + ForwardProto MIB_IPFORWARD_PROTO + DwForwardAge DWORD + DwForwardNextHopAS DWORD + DwForwardMetric1 DWORD + DwForwardMetric2 DWORD + DwForwardMetric3 DWORD + DwForwardMetric4 DWORD + DwForwardMetric5 DWORD +} +type MIB_IPFORWARDTABLE struct { + DwNumEntries DWORD + Table [ANY_SIZE]MIB_IPFORWARDROW +} +type MIB_IPFORWARD_PROTO NL_ROUTE_PROTOCOL +type MIB_IPNETROW MIB_IPNETROW_LH +type MIB_IPNETROW_LH struct { + DwIndex IF_INDEX + DwPhysAddrLen DWORD + BPhysAddr [MAXLEN_PHYSADDR]UCHAR + DwAddr DWORD + Type MIB_IPNET_TYPE +} +type MIB_IPNETTABLE struct { + DwNumEntries DWORD + Table [ANY_SIZE]MIB_IPNETROW +} +type MIB_IPSTATS_LH struct { + Forwarding MIB_IPSTATS_FORWARDING + DwDefaultTTL DWORD + DwInReceives DWORD + DwInHdrErrors DWORD + DwInAddrErrors DWORD + DwForwDatagrams DWORD + DwInUnknownProtos DWORD + DwInDiscards DWORD + DwInDelivers DWORD + DwOutRequests DWORD + DwRoutingDiscards DWORD + DwOutDiscards DWORD + DwOutNoRoutes DWORD + DwReasmTimeout DWORD + DwReasmReqds DWORD + DwReasmOks DWORD + DwReasmFails DWORD + DwFragOks DWORD + DwFragFails DWORD + DwFragCreates DWORD + DwNumIf DWORD + DwNumAddr DWORD + DwNumRoutes DWORD +} +type MIB_TCP6ROW struct { + State MIB_TCP_STATE + LocalAddr IN6_ADDR + DwLocalScopeId DWORD + DwLocalPort DWORD + RemoteAddr IN6_ADDR + DwRemoteScopeId DWORD + DwRemotePort DWORD +} +type MIB_TCP6ROW2 struct { + LocalAddr IN6_ADDR + DwLocalScopeId DWORD + DwLocalPort DWORD + RemoteAddr IN6_ADDR + DwRemoteScopeId DWORD + DwRemotePort DWORD + State MIB_TCP_STATE + DwOwningPid DWORD + DwOffloadState TCP_CONNECTION_OFFLOAD_STATE +} +type MIB_TCP6ROW_OWNER_MODULE struct { + UcLocalAddr [16]UCHAR + DwLocalScopeId DWORD + DwLocalPort DWORD + UcRemoteAddr [16]UCHAR + DwRemoteScopeId DWORD + DwRemotePort DWORD + DwState DWORD + DwOwningPid DWORD + LiCreateTimestamp LARGE_INTEGER + OwningModuleInfo [TCPIP_OWNING_MODULE_SIZE]ULONGLONG +} +type MIB_TCP6TABLE struct { + DwNumEntries DWORD + Table [ANY_SIZE]MIB_TCP6ROW +} +type MIB_TCP6TABLE2 struct { + DwNumEntries DWORD + Table [ANY_SIZE]MIB_TCP6ROW2 +} +type MIB_TCPROW MIB_TCPROW_LH +type MIB_TCPROW2 struct { + DwState DWORD + DwLocalAddr DWORD + DwLocalPort DWORD + DwRemoteAddr DWORD + DwRemotePort DWORD + DwOwningPid DWORD + DwOffloadState TCP_CONNECTION_OFFLOAD_STATE +} +type MIB_TCPROW_LH struct { + State MIB_TCP_STATE + DwLocalAddr DWORD + DwLocalPort DWORD + DwRemoteAddr DWORD + DwRemotePort DWORD +} +type MIB_TCPROW_OWNER_MODULE struct { + DwState DWORD + DwLocalAddr DWORD + DwLocalPort DWORD + DwRemoteAddr DWORD + DwRemotePort DWORD + DwOwningPid DWORD + LiCreateTimestamp LARGE_INTEGER + OwningModuleInfo [TCPIP_OWNING_MODULE_SIZE]ULONGLONG +} +type MIB_TCPSTATS_LH struct { + storage1 DWORD + DwRtoMin DWORD + DwRtoMax DWORD + DwMaxConn DWORD + DwActiveOpens DWORD + DwPassiveOpens DWORD + DwAttemptFails DWORD + DwEstabResets DWORD + DwCurrEstab DWORD + DwInSegs DWORD + DwOutSegs DWORD + DwRetransSegs DWORD + DwInErrs DWORD + DwOutRsts DWORD + DwNumConns DWORD +} + +func (this *MIB_TCPSTATS_LH) DwRtoAlgorithm() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage1)) +} +func (this *MIB_TCPSTATS_LH) RtoAlgorithm() *TCP_RTO_ALGORITHM { + return (*TCP_RTO_ALGORITHM)(unsafe.Pointer(&this.storage1)) +} + +type MIB_TCPTABLE struct { + DwNumEntries DWORD + Table [ANY_SIZE]MIB_TCPROW +} +type MIB_TCPTABLE2 struct { + DwNumEntries DWORD + Table [ANY_SIZE]MIB_TCPROW2 +} +type MIB_UDP6ROW struct { + DwLocalAddr IN6_ADDR + DwLocalScopeId DWORD + DwLocalPort DWORD +} +type MIB_UDP6ROW_OWNER_MODULE struct { + UcLocalAddr [16]UCHAR + DwLocalScopeId DWORD + DwLocalPort DWORD + DwOwningPid DWORD + padding1 [pad0for64_4for32]byte + LiCreateTimestamp LARGE_INTEGER + dwFlags int32 + padding2 [pad0for64_4for32]byte + OwningModuleInfo [TCPIP_OWNING_MODULE_SIZE]ULONGLONG +} + +func (this *MIB_UDP6ROW_OWNER_MODULE) DwFlags() *int32 { + return &this.dwFlags +} +func (this *MIB_UDP6ROW_OWNER_MODULE) SpecificPortBind() int32 { + return this.dwFlags & 0x1 +} + +type MIB_UDP6TABLE struct { + DwNumEntries DWORD + Table [ANY_SIZE]MIB_UDP6ROW +} +type MIB_UDPROW struct { + DwLocalAddr DWORD + DwLocalPort DWORD +} +type MIB_UDPROW_OWNER_MODULE struct { + DwLocalAddr DWORD + DwLocalPort DWORD + DwOwningPid DWORD + padding1 [pad0for64_4for32]byte + LiCreateTimestamp LARGE_INTEGER + dwFlags int32 + padding2 [pad0for64_4for32]byte + OwningModuleInfo [TCPIP_OWNING_MODULE_SIZE]ULONGLONG +} + +func (this *MIB_UDPROW_OWNER_MODULE) DwFlags() *int32 { + return &this.dwFlags +} +func (this *MIB_UDPROW_OWNER_MODULE) SpecificPortBind() int32 { + return this.dwFlags & 0x1 +} + +type MIB_UDPSTATS struct { + DwInDatagrams DWORD + DwNoPorts DWORD + DwInErrors DWORD + DwOutDatagrams DWORD + DwNumAddrs DWORD +} +type MIB_UDPTABLE struct { + DwNumEntries DWORD + Table [ANY_SIZE]MIB_UDPROW +} +type MIDIINCAPS struct { + WMid WORD + WPid WORD + VDriverVersion MMVERSION + SzPname [MAXPNAMELEN]WCHAR + DwSupport DWORD +} +type MIDIOUTCAPS struct { + WMid WORD + WPid WORD + VDriverVersion MMVERSION + SzPname [MAXPNAMELEN]WCHAR + WTechnology WORD + WVoices WORD + WNotes WORD + WChannelMask WORD + DwSupport DWORD +} +type MIDL_STUB_DESC struct { + RpcInterfaceInformation uintptr + PfnAllocate uintptr // void* (__RPC_API *pfnAllocate)(size_t) + PfnFree uintptr // void (__RPC_API *pfnFree)(void *) + IMPLICIT_HANDLE_INFO MIDL_STUB_DESC__IMPLICIT_HANDLE_INFO + ApfnNdrRundownRoutines uintptr // const NDR_RUNDOWN* + AGenericBindingRoutinePairs uintptr // const GENERIC_BINDING_ROUTINE_PAIR* + ApfnExprEval uintptr // const EXPR_EVAL* + AXmitQuintuple uintptr // const XMIT_ROUTINE_QUINTUPLE* + PFormatTypes/*const*/ *byte + FCheckBounds int32 + Version uint32 + PMallocFreeStruct uintptr // MALLOC_FREE_STRUCT* + MIDLVersion int32 + CommFaultOffsets/*const*/ *COMM_FAULT_OFFSETS + AUserMarshalQuadruple uintptr // const USER_MARSHAL_ROUTINE_QUADRUPLE* + NotifyRoutineTable uintptr // const NDR_NOTIFY_ROUTINE* + MFlags ULONG_PTR + CsRoutineTables/*const*/ *NDR_CS_ROUTINES + ProxyServerInfo uintptr + PExprInfo/*const*/ *NDR_EXPR_DESC +} +type MIDL_STUB_DESC__IMPLICIT_HANDLE_INFO struct { + storage uintptr +} + +func (this *MIDL_STUB_DESC__IMPLICIT_HANDLE_INFO) PAutoHandle() *Handle_t { + return (*Handle_t)(unsafe.Pointer(&this.storage)) +} +func (this *MIDL_STUB_DESC__IMPLICIT_HANDLE_INFO) PPrimitiveHandle() *Handle_t { + return (*Handle_t)(unsafe.Pointer(&this.storage)) +} +func (this *MIDL_STUB_DESC__IMPLICIT_HANDLE_INFO) PGenericBindingInfo() *PGENERIC_BINDING_INFO { + return (*PGENERIC_BINDING_INFO)(unsafe.Pointer(&this.storage)) +} + +type MIDL_STUB_MESSAGE struct { + RpcMsg PRPC_MESSAGE + Buffer *byte + BufferStart *byte + BufferEnd *byte + BufferMark *byte + BufferLength uint32 + MemorySize uint32 + Memory *byte + IsClient byte + Pad byte + UFlags2 uint16 + ReuseBuffer int32 + PAllocAllNodesContext uintptr // struct NDR_ALLOC_ALL_NODES_CONTEXT* + PPointerQueueState uintptr // struct NDR_POINTER_QUEUE_STATE* + IgnoreEmbeddedPointers int32 + PointerBufferMark *byte + CorrDespIncrement byte + uFlags byte + UniquePtrCount uint16 + MaxCount ULONG_PTR + Offset uint32 + ActualCount uint32 + PfnAllocate uintptr // void*(__RPC_API *pfnAllocate)(size_t) + PfnFree uintptr // void(__RPC_API *pfnFree)(void*) + StackTop *byte + PPresentedType *byte + PTransmitType *byte + SavedHandle Handle_t + StubDesc/*const*/ *MIDL_STUB_DESC + FullPtrXlatTables *FULL_PTR_XLAT_TABLES + FullPtrRefId uint32 + PointerLength uint32 + fBitField32 uint32 + /* + int fInDontFree :1; + int fDontCallFreeInst :1; + int fInOnlyParam :1; + int fHasReturn :1; + int fHasExtensions :1; + int fHasNewCorrDesc :1; + int fIsIn :1; + int fIsOut :1; + int fIsOicf :1; + int fBufferValid :1; + int fHasMemoryValidateCallback: 1; + int fInFree :1; + int fNeedMCCP :1; + int fUnused :3; + int fUnused2 :16; + */ + DwDestContext uint32 + PvDestContext uintptr + SavedContextHandles *NDR_SCONTEXT + ParamNumber int32 + PRpcChannelBuffer *IRpcChannelBuffer + PArrayInfo PARRAY_INFO + SizePtrCountArray *uint32 + SizePtrOffsetArray *uint32 + SizePtrLengthArray *uint32 + PArgQueue uintptr + DwStubPhase uint32 + LowStackMark uintptr + PAsyncMsg uintptr // PNDR_ASYNC_MESSAGE + PCorrInfo uintptr // PNDR_CORRELATION_INFO + PCorrMemory *byte + PMemoryList uintptr + PCSInfo INT_PTR + ConformanceMark *byte + VarianceMark *byte + Unused INT_PTR + PContext uintptr // struct _NDR_PROC_CONTEXT* + ContextHandleHash uintptr + PUserMarshalList uintptr + Reserved51_3 INT_PTR + Reserved51_4 INT_PTR + Reserved51_5 INT_PTR +} +type MIX ULONG +type MIXERCAPS struct { + WMid WORD + WPid WORD + VDriverVersion MMVERSION + SzPname [MAXPNAMELEN]WCHAR + FdwSupport DWORD + CDestinations DWORD +} +type MIXERCONTROL struct { + cbStruct DWORD + dwControlID DWORD + dwControlType DWORD + fdwControl DWORD + cMultipleItems DWORD + szShortName [MIXER_SHORT_NAME_CHARS]WCHAR + szName [MIXER_LONG_NAME_CHARS]WCHAR + Bounds MIXERLINECONTROL_Bounds + Metrics MIXERLINECONTROL_Metrics +} +type MIXERLINECONTROL_Bounds struct { + storage [24]byte +} + +func (this *MIXERLINECONTROL_Bounds) DwReserved() *[6]DWORD { + return (*[6]DWORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *MIXERLINECONTROL_Bounds) LMinimum() *LONG { + return (*LONG)(unsafe.Pointer(&this.storage[0])) +} +func (this *MIXERLINECONTROL_Bounds) LMaximum() *LONG { + return (*LONG)(unsafe.Pointer(&this.storage[4])) +} +func (this *MIXERLINECONTROL_Bounds) DwMinimum() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *MIXERLINECONTROL_Bounds) DwMaximum() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[4])) +} + +type MIXERLINECONTROL_Metrics struct { + storage [24]byte +} + +func (this *MIXERLINECONTROL_Metrics) CSteps() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *MIXERLINECONTROL_Metrics) CbCustomData() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *MIXERLINECONTROL_Metrics) DwReserved() *[6]DWORD { + return (*[6]DWORD)(unsafe.Pointer(&this.storage[0])) +} + +type MIXERCONTROLDETAILS struct { + CbStruct DWORD + DwControlID DWORD + CChannels DWORD + storage1 [4]byte + pad1 [pad4for64_0for32]byte + CbDetails DWORD + PaDetails LPVOID +} + +func (this *MIXERCONTROLDETAILS) HwndOwner() *HWND { + return (*HWND)(unsafe.Pointer(&this.storage1[0])) +} +func (this *MIXERCONTROLDETAILS) CMultipleItems() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage1[0])) +} + +type MIXERLINE struct { + CbStruct DWORD + DwDestination DWORD + DwSource DWORD + DwLineID DWORD + FdwLine DWORD + // DwUser DWORD_PTR + storage1 [4]byte + storage2 [pad4for64_0for32]byte + DwComponentType DWORD + CChannels DWORD + CConnections DWORD + CControls DWORD + SzShortName [MIXER_SHORT_NAME_CHARS]WCHAR + SzName [MIXER_LONG_NAME_CHARS]WCHAR + Target MIXERLINE_Target +} +type MIXERLINE_Target struct { + DwType DWORD + DwDeviceID DWORD + WMid WORD + WPid WORD + VDriverVersion MMVERSION + SzPname [MAXPNAMELEN]WCHAR +} + +func (this *MIXERLINE) DwUser() *DWORD_PTR { + return (*DWORD_PTR)(unsafe.Pointer(&this.storage1[0])) +} +func (this *MIXERLINECONTROLS) DwControlID() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.union1)) +} +func (this *MIXERLINECONTROLS) DwControlType() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.union1)) +} +func (this *MIXERLINECONTROLS) Pamxctrl() *LPMIXERCONTROL { + return (*LPMIXERCONTROL)(unsafe.Pointer(&this.storage1[0])) +} + +type MMCKINFO struct { + Ckid FOURCC + Cksize DWORD + FccType FOURCC + DwDataOffset DWORD + DwFlags DWORD +} +type MMIOINFO struct { + storage [44 + ptrsize*7]byte +} + +func (this *MMIOINFO) DwFlags() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *MMIOINFO) FccIOProc() *FOURCC { + return (*FOURCC)(unsafe.Pointer(&this.storage[4])) +} +func (this *MMIOINFO) PIOProc() *uintptr { + return (*uintptr)(unsafe.Pointer(&this.storage[8])) +} +func (this *MMIOINFO) WErrorRet() *UINT { + return (*UINT)(unsafe.Pointer(&this.storage[8+ptrsize])) +} +func (this *MMIOINFO) Htask() *HTASK { + return (*HTASK)(unsafe.Pointer(&this.storage[12+ptrsize])) +} +func (this *MMIOINFO) CchBuffer() *LONG { + return (*LONG)(unsafe.Pointer(&this.storage[12+ptrsize*2])) +} +func (this *MMIOINFO) PchBuffer() *HPSTR { + return (*HPSTR)(unsafe.Pointer(&this.storage[16+ptrsize*2])) +} +func (this *MMIOINFO) PchNext() *HPSTR { + return (*HPSTR)(unsafe.Pointer(&this.storage[16+ptrsize*3])) +} +func (this *MMIOINFO) PchEndRead() *HPSTR { + return (*HPSTR)(unsafe.Pointer(&this.storage[16+ptrsize*4])) +} +func (this *MMIOINFO) PchEndWrite() *HPSTR { + return (*HPSTR)(unsafe.Pointer(&this.storage[16+ptrsize*5])) +} +func (this *MMIOINFO) LBufOffset() *LONG { + return (*LONG)(unsafe.Pointer(&this.storage[16+ptrsize*6])) +} +func (this *MMIOINFO) LDiskOffset() *LONG { + return (*LONG)(unsafe.Pointer(&this.storage[20+ptrsize*6])) +} +func (this *MMIOINFO) AdwInfo() *[3]DWORD { + return (*[3]DWORD)(unsafe.Pointer(&this.storage[24+ptrsize*6])) +} +func (this *MMIOINFO) DwReserved1() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[36+ptrsize*6])) +} +func (this *MMIOINFO) DwReserved2() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[40+ptrsize*6])) +} +func (this *MMIOINFO) Hmmio() *HMMIO { + return (*HMMIO)(unsafe.Pointer(&this.storage[44+ptrsize*6])) +} + +type MMIOPROC func(lpmmioinfo LPSTR, uMsg UINT, lParam1 LPARAM, lParam2 LPARAM) LRESULT +type MMRESULT uint32 +type MMTIME struct { + WType UINT + U MMTIME_U +} +type MMTIME_U struct { + storage [8]byte +} +type MMTIME_Smpte struct { + Hour BYTE + Min BYTE + Sec BYTE + Frame BYTE + Fps BYTE + Dummy BYTE + Pad [2]BYTE +} +type MMTIME_Midi struct { + Songptrpos DWORD +} + +func (this *MMTIME_U) Ms() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *MMTIME_U) Sample() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *MMTIME_U) Cb() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *MMTIME_U) Ticks() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *MMTIME_U) Smpte() *MMTIME_Smpte { + return (*MMTIME_Smpte)(unsafe.Pointer(&this.storage[0])) +} +func (this *MMTIME_U) Midi() *MMTIME_Midi { + return (*MMTIME_Midi)(unsafe.Pointer(&this.storage[0])) +} + +type MMVERSION UINT +type MODULEINFO struct { + LpBaseOfDll LPVOID + SizeOfImage DWORD + EntryPoint LPVOID +} +type MONITORENUMPROC func(hMonitor HMONITOR, hdcMonitor HDC, lprcMonitor *RECT, dwData uintptr) BOOL +type MONITORINFO struct { + CbSize uint32 + RcMonitor RECT + RcWork RECT + DwFlags uint32 +} +type MOUSEINPUT struct { + Dx int32 // LONG + Dy int32 // LONG + MouseData uint32 + DwFlags uint32 + Time uint32 + DwExtraInfo uintptr // ULONG_PTR +} +type MOUSEMOVEPOINT struct { + X int32 + Y int32 + Time uint32 + DwExtraInfo uintptr // ULONG_PTR +} +type MRUCMPPROC func(pString1 string, pString2 string) int32 +type MRUINFO struct { + CbSize DWORD + UMax UINT + FFlags UINT + HKey HKEY + LpszSubKey LPCWSTR + LpfnCompare uintptr // MRUCMPPROC +} +type MSG struct { + Hwnd HWND + Message uint32 + WParam uintptr + LParam uintptr + Time uint32 + Pt POINT +} +type MSGBOXCALLBACK func(lpHelpInfo LPHELPINFO) +type MSGBOXPARAMS struct { + CbSize uint32 + HwndOwner HWND + HInstance HINSTANCE + LpszText *uint16 // LPCWSTR + LpszCaption *uint16 // LPCWSTR + DwStyle uint32 + LpszIcon *uint16 // LPCWSTR + DwContextHelpId *uint32 // DWORD_PTR + LpfnMsgBoxCallback uintptr // MSGBOXCALLBACK + DwLanguageId uint32 +} +type MULTI_QI struct { + PIID/*const*/ *IID + PItf *IUnknown + Hr HRESULT +} +type NDR_CS_ROUTINES struct { + PSizeConvertRoutines *NDR_CS_SIZE_CONVERT_ROUTINES // NDR_CS_SIZE_CONVERT_ROUTINES + PTagGettingRoutines uintptr // CS_TAG_GETTING_ROUTINE +} +type NDR_CS_SIZE_CONVERT_ROUTINES struct { + PfnNetSize uintptr // CS_TYPE_NET_SIZE_ROUTINE + PfnToNetCs uintptr // CS_TYPE_TO_NETCS_ROUTINE + PfnLocalSize uintptr // CS_TYPE_LOCAL_SIZE_ROUTINE + PfnFromNetCs uintptr // CS_TYPE_FROM_NETCS_ROUTINE +} +type NDR_EXPR_DESC struct { + POffset/*const*/ *uint16 + PFormatExpr PFORMAT_STRING +} +type NDR_RUNDOWN func(context uintptr) +type NDR_SCONTEXT *NDR_SCONTEXT_ +type NDR_SCONTEXT_ struct { + Pad [2]uintptr + UserContext uintptr +} +type NET_ADDRESS_INFO struct { + Format NET_ADDRESS_FORMAT + storage [524]byte +} +type NET_ADDRESS_INFO_NamedAddress struct { + Address [DNS_MAX_NAME_BUFFER_LENGTH]WCHAR + Port [6]WCHAR +} + +func (this *NET_ADDRESS_INFO) NamedAddress() *NET_ADDRESS_INFO_NamedAddress { + return (*NET_ADDRESS_INFO_NamedAddress)(unsafe.Pointer(&this.storage[0])) +} +func (this *NET_ADDRESS_INFO) Ipv4Address() *SOCKADDR_IN { + return (*SOCKADDR_IN)(unsafe.Pointer(&this.storage[0])) +} +func (this *NET_ADDRESS_INFO) Ipv6Address() *SOCKADDR_IN6 { + return (*SOCKADDR_IN6)(unsafe.Pointer(&this.storage[0])) +} +func (this *NET_ADDRESS_INFO) IpAddress() *SOCKADDR { + return (*SOCKADDR)(unsafe.Pointer(&this.storage[0])) +} + +type NET_IFINDEX ULONG +type NET_IF_NETWORK_GUID GUID +type NET_LUID NET_LUID_LH +type NET_LUID_LH struct { + Value ULONG64 +} + +func (this *NET_LUID_LH) Reserved() ULONG64 { + v := this.Value + return (v & 0xFFFFFF0000000000) >> (64 - 24) +} +func (this *NET_LUID_LH) NetLuidIndex() ULONG64 { + v := this.Value + return (v & 0xFFFFFF0000) >> 16 +} +func (this *NET_LUID_LH) IfType() ULONG64 { + v := this.Value + return v & 0xFFFF +} + +type NOTIFYICONDATA struct { + CbSize DWORD + HWnd HWND + UID UINT + UFlags UINT + UCallbackMessage UINT + HIcon HICON + SzTip [128]WCHAR + DwState DWORD + DwStateMask DWORD + SzInfo [256]WCHAR + union1 UINT + SzInfoTitle [64]WCHAR + DwInfoFlags DWORD + GuidItem GUID + HBalloonIcon HICON +} + +func (this *NOTIFYICONDATA) GetUTimeout() UINT { + return this.union1 +} +func (this *NOTIFYICONDATA) SetUTimeout(v UINT) { + this.union1 = v +} +func (this *NOTIFYICONDATA) GetUVersion() UINT { + return this.union1 +} +func (this *NOTIFYICONDATA) SetUVersion(v UINT) { + this.union1 = v +} + +type NTSTATUS LONG +type NUMPARSE struct { + CDig INT + DwInFlags ULONG + DwOutFlags ULONG + CchUsed INT + NBaseShift INT + NPwr10 INT +} +type OBJECTS_AND_NAME struct { + ObjectsPresent DWORD + ObjectType SE_OBJECT_TYPE + ObjectTypeName LPWSTR + InheritedObjectTypeName LPWSTR + PtstrName LPWSTR +} +type OBJECTS_AND_SID struct { + ObjectsPresent DWORD + ObjectTypeGuid GUID + InheritedObjectTypeGuid GUID + PSid *SID +} +type OBJECT_TYPE_LIST struct { + Level USHORT + Sbz USHORT + ObjectType *GUID +} +type OCPFIPARAMS struct { + CbStructSize ULONG + HWndOwner HWND + X int32 + Y int32 + LpszCaption LPCOLESTR + CObjects ULONG + LplpUnk *LPUNKNOWN + CPages ULONG + LpPages *CLSID + Lcid LCID + DispidInitialProperty DISPID +} +type OLECHAR WCHAR +type OLEINPLACEFRAMEINFO struct { + Cb UINT + FMDIApp BOOL + HwndFrame HWND + Haccel HACCEL + CAccelEntries UINT +} +type OLEMENUGROUPWIDTHS struct { + Width [6]LONG +} +type OLE_COLOR DWORD +type OPENFILENAME struct { + LStructSize DWORD + HwndOwner HWND + HInstance HINSTANCE + LpstrFilter LPCWSTR + LpstrCustomFilter LPWSTR + NMaxCustFilter DWORD + NFilterIndex DWORD + LpstrFile LPWSTR + NMaxFile DWORD + LpstrFileTitle LPWSTR + NMaxFileTitle DWORD + LpstrInitialDir LPCWSTR + LpstrTitle LPCWSTR + Flags DWORD + NFileOffset WORD + NFileExtension WORD + LpstrDefExt LPCWSTR + LCustData LPARAM + LpfnHook LPOFNHOOKPROC + LpTemplateName LPCWSTR + PvReserved uintptr + DwReserved DWORD + FlagsEx DWORD +} +type OUTLINETEXTMETRIC struct { + OtmSize UINT + OtmTextMetrics TEXTMETRIC + OtmFiller BYTE + OtmPanoseNumber PANOSE + OtmfsSelection UINT + OtmfsType UINT + OtmsCharSlopeRise int32 + OtmsCharSlopeRun int32 + OtmItalicAngle int32 + OtmEMSquare UINT + OtmAscent int32 + OtmDescent int32 + OtmLineGap UINT + OtmsCapEmHeight UINT + OtmsXHeight UINT + OtmrcFontBox RECT + OtmMacAscent int32 + OtmMacDescent int32 + OtmMacLineGap UINT + OtmusMinimumPPEM UINT + OtmptSubscriptSize POINT + OtmptSubscriptOffset POINT + OtmptSuperscriptSize POINT + OtmptSuperscriptOffset POINT + OtmsStrikeoutSize UINT + OtmsStrikeoutPosition int32 + OtmsUnderscoreSize int32 + OtmsUnderscorePosition int32 + OtmpFamilyName PSTR + OtmpFaceName PSTR + OtmpStyleName PSTR + OtmpFullName PSTR +} +type OVERLAPPED struct { + Internal ULONG_PTR + InternalHigh ULONG_PTR + union1 [8]byte + HEvent HANDLE +} + +func (this *OVERLAPPED) Offset() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.union1[0])) +} +func (this *OVERLAPPED) OffsetHigh() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.union1[4])) +} +func (this *OVERLAPPED) Pointer() *PVOID { + return (*PVOID)(unsafe.Pointer(&this.union1[0])) +} + +type PADDRINFO *ADDRINFO +type PAGESETUPDLG struct { + LStructSize DWORD + HwndOwner HWND + HDevMode HGLOBAL + HDevNames HGLOBAL + Flags DWORD + PtPaperSize POINT + RtMinMargin RECT + RtMargin RECT + HInstance HINSTANCE + LCustData LPARAM + LpfnPageSetupHook LPPAGESETUPHOOK + LpfnPagePaintHook LPPAGEPAINTHOOK + LpPageSetupTemplateName LPCWSTR + HPageSetupTemplate HGLOBAL +} +type PAINTSTRUCT struct { + Hdc HDC + FErase BOOL + RcPaint RECT + FRestore BOOL + FIncUpdate BOOL + RgbReserved [32]byte +} +type PALETTEENTRY struct { + PeRed byte + PeGreen byte + PeBlue byte + PeFlags byte +} +type PANOSE struct { + BFamilyType BYTE + BSerifStyle BYTE + BWeight BYTE + BProportion BYTE + BContrast BYTE + BStrokeVariation BYTE + BArmStyle BYTE + BLetterform BYTE + BMidline BYTE + BXHeight BYTE +} +type PAPPBARDATA *APPBARDATA +type PARAMDATA struct { + SzName *OLECHAR + Vt VARTYPE +} +type PARRAY_INFO *ARRAY_INFO +type PARSEDURL struct { + CbSize DWORD + PszProtocol LPCWSTR + CchProtocol UINT + PszSuffix LPCWSTR + CchSuffix UINT + NScheme UINT +} +type PATHDATA struct { + Flags FLONG + Count ULONG + Pptfx *POINTFIX +} +type PATHOBJ struct { + Fl FLONG + CCurves ULONG +} +type PAUDIT_POLICY_INFORMATION *AUDIT_POLICY_INFORMATION +type PBYTE *byte +type PCCERT_CONTEXT /*const*/ *CERT_CONTEXT +type PCCRL_CONTEXT /*const*/ *CRL_CONTEXT +type PCCTL_CONTEXT /*const*/ *CTL_CONTEXT +type PCERT_EXTENSION *CERT_EXTENSION +type PCERT_INFO *CERT_INFO +type PCERT_NAME_BLOB *CERT_NAME_BLOB +type PCERT_RDN_VALUE_BLOB *CERT_RDN_VALUE_BLOB +type PCHAR *CHAR +type PCIDLIST_ABSOLUTE LPCITEMIDLIST +type PCIDLIST_ABSOLUTE_ARRAY *LPCITEMIDLIST +type PCONSOLE_SCREEN_BUFFER_INFO *CONSOLE_SCREEN_BUFFER_INFO +type PCONSOLE_SCREEN_BUFFER_INFOEX *CONSOLE_SCREEN_BUFFER_INFOEX +type PCRL_ENTRY *CRL_ENTRY +type PCRL_INFO *CRL_INFO +type PCRYPT_ATTRIBUTE *CRYPT_ATTRIBUTE +type PCRYPT_ATTR_BLOB *CRYPT_ATTR_BLOB +type PCRYPT_DATA_BLOB *CRYPT_DATA_BLOB +type PCRYPT_DER_BLOB *CRYPT_DER_BLOB +type PCRYPT_INTEGER_BLOB *CRYPT_INTEGER_BLOB +type PCTL_ENTRY *CTL_ENTRY +type PCTL_INFO *CTL_INFO +type PCUITEMID_CHILD_ARRAY *LPCITEMIDLIST +type PCWSTR *uint16 +type PCZZWSTR /*const*/ *WCHAR +type PDH_COUNTER_INFO struct { + DwLength DWORD + DwType DWORD + CVersion DWORD + CStatus DWORD + LScale LONG + LDefaultScale LONG + DwUserData DWORD_PTR + DwQueryUserData DWORD_PTR + SzFullPath LPWSTR + union1 [4 * pad11for64_7for32]byte + SzExplainText LPWSTR + DataBuffer [1]DWORD +} + +func (this *PDH_COUNTER_INFO) DataItemPath() *PDH_DATA_ITEM_PATH_ELEMENTS { + return (*PDH_DATA_ITEM_PATH_ELEMENTS)(unsafe.Pointer(&this.union1[0])) +} +func (this *PDH_COUNTER_INFO) CounterPath() *PDH_COUNTER_PATH_ELEMENTS { + return (*PDH_COUNTER_PATH_ELEMENTS)(unsafe.Pointer(&this.union1[0])) +} +func (this *PDH_COUNTER_INFO) SzMachineName() *LPWSTR { + return (*LPWSTR)(unsafe.Pointer(&this.union1[0])) +} +func (this *PDH_COUNTER_INFO) SzObjectName() *LPWSTR { + var ptr LPWSTR + return (*LPWSTR)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1[0])) + unsafe.Sizeof(ptr))) +} +func (this *PDH_COUNTER_INFO) SzInstanceName() *LPWSTR { + var ptr LPWSTR + return (*LPWSTR)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1[0])) + unsafe.Sizeof(ptr)*2)) +} +func (this *PDH_COUNTER_INFO) SzParentInstance() *LPWSTR { + var ptr LPWSTR + return (*LPWSTR)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1[0])) + unsafe.Sizeof(ptr)*3)) +} +func (this *PDH_COUNTER_INFO) DwInstanceIndex() *DWORD { + var ptr LPWSTR + return (*DWORD)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1[0])) + unsafe.Sizeof(ptr)*4)) +} +func (this *PDH_COUNTER_INFO) SzCounterName() *LPWSTR { + var ptr LPWSTR + pad := 4 + if is64 { + pad = 8 + } + return (*LPWSTR)(unsafe.Pointer(uintptr(unsafe.Pointer(&this.union1[0])) + unsafe.Sizeof(ptr)*4 + uintptr(pad))) +} + +type PDH_COUNTER_PATH_ELEMENTS struct { + SzMachineName LPWSTR + SzObjectName LPWSTR + SzInstanceName LPWSTR + SzParentInstance LPWSTR + DwInstanceIndex DWORD + SzCounterName LPWSTR +} +type PDH_DATA_ITEM_PATH_ELEMENTS struct { + SzMachineName LPWSTR + ObjectGUID GUID + wItemId DWORD + SzInstanceName LPWSTR +} + +const ( + PDH_FMT_LONG = (DWORD(0x00000100)) + PDH_FMT_DOUBLE = (DWORD(0x00000200)) + PDH_FMT_LARGE = (DWORD(0x00000400)) +) + +type PDH_FMT_COUNTERVALUE struct { + storage [16]byte +} + +func (this *PDH_FMT_COUNTERVALUE) CStatus() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *PDH_FMT_COUNTERVALUE) LongValue() *LONG { + return (*LONG)(unsafe.Pointer(&this.storage[8])) +} +func (this *PDH_FMT_COUNTERVALUE) DoubleValue() *float64 { + return (*float64)(unsafe.Pointer(&this.storage[8])) +} +func (this *PDH_FMT_COUNTERVALUE) LargeValue() *LONGLONG { + return (*LONGLONG)(unsafe.Pointer(&this.storage[8])) +} +func (this *PDH_FMT_COUNTERVALUE) AnsiStringValue() *LPCSTR { + return (*LPCSTR)(unsafe.Pointer(&this.storage[8])) +} +func (this *PDH_FMT_COUNTERVALUE) WideStringValue() *LPCWSTR { + return (*LPCWSTR)(unsafe.Pointer(&this.storage[8])) +} + +type PDH_HCOUNTER HANDLE +type PDH_HLOG HANDLE +type PDH_HQUERY HANDLE +type PDH_RAW_COUNTER struct { + CStatus DWORD + TimeStamp FILETIME + padding1 [pad0for64_4for32]byte + FirstValue LONGLONG + SecondValue LONGLONG + MultiCount DWORD + padding2 [pad0for64_4for32]byte +} +type PDH_STATUS LONG +type PENCRYPTION_CERTIFICATE *ENCRYPTION_CERTIFICATE +type PENG_TIME_FIELDS *ENG_TIME_FIELDS +type PENUM_PAGE_FILE_CALLBACK func(pContext LPVOID, pPageFileInfo PENUM_PAGE_FILE_INFORMATION, lpFilename string) BOOL +type PENUM_PAGE_FILE_INFORMATION *ENUM_PAGE_FILE_INFORMATION +type PERFORMANCE_INFORMATION struct { + Cb DWORD + CommitTotal SIZE_T + CommitLimit SIZE_T + CommitPeak SIZE_T + PhysicalTotal SIZE_T + PhysicalAvailable SIZE_T + SystemCache SIZE_T + KernelTotal SIZE_T + KernelPaged SIZE_T + KernelNonpaged SIZE_T + PageSize SIZE_T + HandleCount DWORD + ProcessCount DWORD + ThreadCount DWORD +} +type PERF_COUNTERSET_INSTANCE struct { + CounterSetGuid GUID + DwSize ULONG + InstanceId ULONG + InstanceNameOffset ULONG + InstanceNameSize ULONG +} +type PFD_GLYPHATTR *FD_GLYPHATTR +type PFIXED_INFO *FIXED_INFO_W2KSP1 +type PFLOAT_LONG *FLOAT_LONG +type PFNCALLBACK func(wType uint32, wFmt uint32, hConv HCONV, hsz1 HSZ, hsz2 HSZ, hData HDDEDATA, dwData1 uintptr, dwData2 uintptr) HDDEDATA +type PFORMAT_STRING *byte +type PGENERIC_BINDING_INFO *GENERIC_BINDING_INFO +type PGLYPHPOS *GLYPHPOS +type PHUSKEY *HUSKEY +type PICTDESC struct { + CbSizeofstruct UINT + PicType UINT + union1 uintptr + union2 int32 + union3 int32 +} + +func (this *PICTDESC) Hbitmap() HBITMAP { + return HBITMAP(this.union1) +} +func (this *PICTDESC) Hpal() HPALETTE { + var ptr uintptr + if is64 { + *(*int32)(unsafe.Pointer(&ptr)) = this.union2 + *(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&ptr)) + 4)) = this.union3 + } else { + *(*int32)(unsafe.Pointer(&ptr)) = this.union2 + } + return HPALETTE(ptr) +} +func (this *PICTDESC) Hmeta() HMETAFILE { + return HMETAFILE(this.union1) +} +func (this *PICTDESC) XExt() int32 { + return this.union2 +} +func (this *PICTDESC) YExt() int32 { + return this.union3 +} +func (this *PICTDESC) Hicon() HICON { + return HICON(this.union1) +} +func (this *PICTDESC) Hemf() HENHMETAFILE { + return HENHMETAFILE(this.union1) +} + +type PIDLIST_ABSOLUTE LPITEMIDLIST +type PINT_PTR *INT_PTR +type PIO_APC_ROUTINE func(ApcContext PVOID, IoStatusBlock PIO_STATUS_BLOCK, Reserved ULONG) +type PIO_STATUS_BLOCK *IO_STATUS_BLOCK +type PIP_ADAPTER_ADDRESSES *IP_ADAPTER_ADDRESSES_LH +type PIP_ADAPTER_ANYCAST_ADDRESS_XP *IP_ADAPTER_ANYCAST_ADDRESS_XP +type PIP_ADAPTER_DNS_SERVER_ADDRESS_XP *IP_ADAPTER_DNS_SERVER_ADDRESS_XP +type PIP_ADAPTER_DNS_SUFFIX *IP_ADAPTER_DNS_SUFFIX +type PIP_ADAPTER_GATEWAY_ADDRESS_LH *IP_ADAPTER_GATEWAY_ADDRESS_LH +type PIP_ADAPTER_INDEX_MAP *IP_ADAPTER_INDEX_MAP +type PIP_ADAPTER_INFO *IP_ADAPTER_INFO +type PIP_ADAPTER_MULTICAST_ADDRESS_XP *IP_ADAPTER_MULTICAST_ADDRESS_XP +type PIP_ADAPTER_ORDER_MAP *IP_ADAPTER_ORDER_MAP +type PIP_ADAPTER_PREFIX_XP *IP_ADAPTER_PREFIX_XP +type PIP_ADAPTER_UNICAST_ADDRESS_LH *IP_ADAPTER_UNICAST_ADDRESS_LH +type PIP_ADAPTER_WINS_SERVER_ADDRESS_LH *IP_ADAPTER_WINS_SERVER_ADDRESS_LH +type PIP_ADDR_STRING *IP_ADDR_STRING +type PIP_INTERFACE_INFO *IP_INTERFACE_INFO +type PIP_OPTION_INFORMATION *IP_OPTION_INFORMATION +type PIP_PER_ADAPTER_INFO *IP_PER_ADAPTER_INFO_W2KSP1 +type PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS *IP_UNIDIRECTIONAL_ADAPTER_ADDRESS +type PIXELFORMATDESCRIPTOR struct { + NSize uint16 + NVersion uint16 + DwFlags uint32 + IPixelType byte + CColorBits byte + CRedBits byte + CRedShift byte + CGreenBits byte + CGreenShift byte + CBlueBits byte + CBlueShift byte + CAlphaBits byte + CAlphaShift byte + CAccumBits byte + CAccumRedBits byte + CAccumGreenBits byte + CAccumBlueBits byte + CAccumAlphaBits byte + CDepthBits byte + CStencilBits byte + CAuxBuffers byte + ILayerType byte + BReserved byte + DwLayerMask uint32 + DwVisibleMask uint32 + DwDamageMask uint32 +} +type PMIB_ICMP *MIB_ICMP +type PMIB_ICMP_EX *MIB_ICMP_EX_XPSP1 +type PMIB_IFROW *MIB_IFROW +type PMIB_IFTABLE *MIB_IFTABLE +type PMIB_IPADDRTABLE *MIB_IPADDRTABLE +type PMIB_IPFORWARDROW *MIB_IPFORWARDROW +type PMIB_IPFORWARDTABLE *MIB_IPFORWARDTABLE +type PMIB_IPNETROW *MIB_IPNETROW_LH +type PMIB_IPNETTABLE *MIB_IPNETTABLE +type PMIB_IPSTATS *MIB_IPSTATS_LH +type PMIB_TCP6ROW *MIB_TCP6ROW +type PMIB_TCP6ROW_OWNER_MODULE *MIB_TCP6ROW_OWNER_MODULE +type PMIB_TCP6TABLE *MIB_TCP6TABLE +type PMIB_TCP6TABLE2 *MIB_TCP6TABLE2 +type PMIB_TCPROW *MIB_TCPROW_LH +type PMIB_TCPROW_OWNER_MODULE *MIB_TCPROW_OWNER_MODULE +type PMIB_TCPSTATS *MIB_TCPSTATS_LH +type PMIB_TCPTABLE *MIB_TCPTABLE +type PMIB_TCPTABLE2 *MIB_TCPTABLE2 +type PMIB_UDP6ROW_OWNER_MODULE *MIB_UDP6ROW_OWNER_MODULE +type PMIB_UDP6TABLE *MIB_UDP6TABLE +type PMIB_UDPROW_OWNER_MODULE *MIB_UDPROW_OWNER_MODULE +type PMIB_UDPSTATS *MIB_UDPSTATS +type PMIB_UDPTABLE *MIB_UDPTABLE +type PMIDL_STUB_MESSAGE *MIDL_STUB_MESSAGE +type PNET_ADDRESS_INFO *NET_ADDRESS_INFO +type PNOTIFYICONDATA *NOTIFYICONDATA +type POINT struct { + X, Y int32 +} +type POINTFIX struct { + X FIX + Y FIX +} +type POINTFLOAT struct { + X float32 + Y float32 +} +type POINTL struct { + X LONG + Y LONG +} +type POINTQF struct { + X LARGE_INTEGER + Y LARGE_INTEGER +} +type POINTS struct { + X int16 // SHORT + Y int16 // SHORT +} +type POLICY_AUDIT_SID_ARRAY struct { + UsersCount ULONG + UserSidArray *PSID +} +type POLYTEXT struct { + X int32 + Y int32 + N UINT + Lpstr LPCWSTR + UiFlags UINT + Rcl RECT + Pdx *int32 +} +type PPERFORMACE_INFORMATION *PERFORMANCE_INFORMATION +type PPOLICY_AUDIT_EVENT_TYPE *POLICY_AUDIT_EVENT_TYPE +type PPOLICY_AUDIT_SID_ARRAY *POLICY_AUDIT_SID_ARRAY +type PPROCESS_MEMORY_COUNTERS *PROCESS_MEMORY_COUNTERS +type PPSAPI_WS_WATCH_INFORMATION *PSAPI_WS_WATCH_INFORMATION +type PPSAPI_WS_WATCH_INFORMATION_EX *PSAPI_WS_WATCH_INFORMATION_EX +type PRECTFX *RECTFX +type PRINTDLGEX struct { + LStructSize DWORD + HwndOwner HWND + HDevMode HGLOBAL + HDevNames HGLOBAL + HDC HDC + Flags DWORD + Flags2 DWORD + ExclusionFlags DWORD + NPageRanges DWORD + NMaxPageRanges DWORD + LpPageRanges LPPRINTPAGERANGE + NMinPage DWORD + NMaxPage DWORD + NCopies DWORD + HInstance HINSTANCE + LpPrintTemplateName LPCWSTR + LpCallback LPUNKNOWN + NPropertyPages DWORD + LphPropertyPages *HPROPSHEETPAGE + NStartPage DWORD + DwResultAction DWORD +} +type PRINTPAGERANGE struct { + NFromPage DWORD + NToPage DWORD +} +type PRIVILEGE_SET struct { + PrivilegeCount ULONG + Control ULONG + Privilege [ANYSIZE_ARRAY]LUID_AND_ATTRIBUTES +} +type PROC uintptr +type PROCESS_INFORMATION struct { + HProcess HANDLE + HThread HANDLE + DwProcessId DWORD + DwThreadId DWORD +} +type PROCESS_MEMORY_COUNTERS struct { + Cb DWORD + PageFaultCount DWORD + PeakWorkingSetSize SIZE_T + WorkingSetSize SIZE_T + QuotaPeakPagedPoolUsage SIZE_T + QuotaPagedPoolUsage SIZE_T + QuotaPeakNonPagedPoolUsage SIZE_T + QuotaNonPagedPoolUsage SIZE_T + PagefileUsage SIZE_T + PeakPagefileUsage SIZE_T +} +type PROPENUMPROC func(hWnd HWND, lpszString string, hData HANDLE) BOOL +type PROPENUMPROCEX func(hwnd HWND, lpszString LPWSTR, hData HANDLE, dwData uintptr) BOOL +type PROPID ULONG +type PROPSHEETCALLBACK func(unnamed0 HWND, unnamed1 UINT, unnamed2 LPARAM) int32 +type PROPSHEETHEADER PROPSHEETHEADER_V2 +type PROPSHEETHEADER_V2 struct { + dwSize DWORD + dwFlags DWORD + hwndParent HWND + hInstance HINSTANCE + union1 uintptr + PszCaption LPCWSTR + NPages UINT + union2 uintptr + union3 uintptr + PfnCallback uintptr // PFNPROPSHEETCALLBACK + union4 uintptr + HplWatermark HPALETTE + union5 uintptr +} + +func (this *PROPSHEETHEADER_V2) HIcon() HICON { + return HICON(this.union1) +} +func (this *PROPSHEETHEADER_V2) PszIcon() string { + return stringFromUnicode16((*uint16)(unsafe.Pointer(this.union1))) +} +func (this *PROPSHEETHEADER_V2) NStartPage() UINT { + return *(*UINT)(unsafe.Pointer(&this.union2)) +} +func (this *PROPSHEETHEADER_V2) PStartPage() string { + return stringFromUnicode16((*uint16)(unsafe.Pointer(this.union2))) +} +func (this *PROPSHEETHEADER_V2) Ppsp() /*const*/ **PROPSHEETPAGE { + return (**PROPSHEETPAGE)(unsafe.Pointer(&this.union3)) +} +func (this *PROPSHEETHEADER_V2) Phpage() *HPROPSHEETPAGE { + return (*HPROPSHEETPAGE)(unsafe.Pointer(&this.union3)) +} +func (this *PROPSHEETHEADER_V2) HbmWatermark() HBITMAP { + return HBITMAP(this.union4) +} +func (this *PROPSHEETHEADER_V2) PszbmWatermark() string { + return stringFromUnicode16((*uint16)(unsafe.Pointer(this.union4))) +} +func (this *PROPSHEETHEADER_V2) HbmHeader() HBITMAP { + return HBITMAP(this.union5) +} +func (this *PROPSHEETHEADER_V2) PszbmHeader() string { + return stringFromUnicode16((*uint16)(unsafe.Pointer(this.union5))) +} + +type PROPSHEETPAGE PROPSHEETPAGE_V4 +type PROPSHEETPAGE_RESOURCE *DLGTEMPLATE // const DLGTEMPLATE* +type PROPSHEETPAGE_V4 struct { + DwSize DWORD + DwFlags DWORD + HInstance HINSTANCE + union1 uintptr + union2 uintptr + PszTitle LPCWSTR + PfnDlgProc uintptr // DLGPROC + LParam uintptr + PfnCallback uintptr // PSPCALLBACK + PcRefParent *UINT + PszHeaderTitle LPCWSTR + PszHeaderSubTitle LPCWSTR + HActCtx HANDLE + union3 uintptr +} + +func (this *PROPSHEETPAGE_V4) PszTemplate() *LPCWSTR { + return (*LPCWSTR)(unsafe.Pointer(&this.union1)) +} +func (this *PROPSHEETPAGE_V4) PResource() *PROPSHEETPAGE_RESOURCE { + return (*PROPSHEETPAGE_RESOURCE)(unsafe.Pointer(&this.union1)) +} +func (this *PROPSHEETPAGE_V4) HIcon() *HICON { + return (*HICON)(unsafe.Pointer(&this.union2)) +} +func (this *PROPSHEETPAGE_V4) PszIcon() *LPCWSTR { + return (*LPCWSTR)(unsafe.Pointer(&this.union2)) +} +func (this *PROPSHEETPAGE_V4) HbmHeader() *HBITMAP { + return (*HBITMAP)(unsafe.Pointer(&this.union3)) +} +func (this *PROPSHEETPAGE_V4) PszbmHeader() *LPCWSTR { + return (*LPCWSTR)(unsafe.Pointer(&this.union3)) +} + +type PROPSPEC struct { + ulKind ULONG + union1 uintptr +} + +func (this *PROPSPEC) Propid() *PROPID { + return (*PROPID)(unsafe.Pointer(&this.union1)) +} +func (this *PROPSPEC) Lpwstr() *LPOLESTR { + return (*LPOLESTR)(unsafe.Pointer(&this.union1)) +} + +type PROPVARIANT struct { + Vt VARTYPE + WReserved1 WORD + WReserved2 WORD + WReserved3 WORD + storage1 [ptrsize * 2]byte +} + +func (this *PROPVARIANT) CVal() *CHAR { return (*CHAR)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) BVal() *UCHAR { return (*UCHAR)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) IVal() *SHORT { return (*SHORT)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) UiVal() *USHORT { return (*USHORT)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) LVal() *LONG { return (*LONG)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) UlVal() *ULONG { return (*ULONG)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) IntVal() *INT { return (*INT)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) UintVal() *UINT { return (*UINT)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) HVal() *LARGE_INTEGER { + return (*LARGE_INTEGER)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) UhVal() *ULARGE_INTEGER { + return (*ULARGE_INTEGER)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) FltVal() *FLOAT { return (*FLOAT)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) DblVal() *DOUBLE { return (*DOUBLE)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) BoolVal() *VARIANT_BOOL { + return (*VARIANT_BOOL)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) Scode() *SCODE { return (*SCODE)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) CyVal() *CY { return (*CY)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Date() *DATE { return (*DATE)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Filetime() *FILETIME { return (*FILETIME)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Puuid() **CLSID { return (**CLSID)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Pclipdata() **CLIPDATA { + return (**CLIPDATA)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) BstrVal() *BSTR { return (*BSTR)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) BstrblobVal() *BSTRBLOB { + return (*BSTRBLOB)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) Blob() *BLOB { return (*BLOB)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PszVal() *LPSTR { return (*LPSTR)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PwszVal() *LPWSTR { return (*LPWSTR)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PunkVal() **IUnknown { return (**IUnknown)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PdispVal() **IDispatch { + return (**IDispatch)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) PStream() **IStream { return (**IStream)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PStorage() **IStorage { return (**IStorage)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PVersionedStream() *LPVERSIONEDSTREAM { + return (*LPVERSIONEDSTREAM)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) Parray() *LPSAFEARRAY { + return (*LPSAFEARRAY)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) Cac() *CAC { return (*CAC)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Caub() *CAUB { return (*CAUB)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Cai() *CAI { return (*CAI)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Caui() *CAUI { return (*CAUI)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Cal() *CAL { return (*CAL)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Caul() *CAUL { return (*CAUL)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Cah() *CAH { return (*CAH)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Cauh() *CAUH { return (*CAUH)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Caflt() *CAFLT { return (*CAFLT)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Cadbl() *CADBL { return (*CADBL)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Cabool() *CABOOL { return (*CABOOL)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Cascode() *CASCODE { return (*CASCODE)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Cacy() *CACY { return (*CACY)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Cadate() *CADATE { return (*CADATE)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Cafiletime() *CAFILETIME { + return (*CAFILETIME)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) Cauuid() *CACLSID { return (*CACLSID)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Caclipdata() *CACLIPDATA { + return (*CACLIPDATA)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) Cabstr() *CABSTR { return (*CABSTR)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Cabstrblob() *CABSTRBLOB { + return (*CABSTRBLOB)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) Calpstr() *CALPSTR { return (*CALPSTR)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Calpwstr() *CALPWSTR { return (*CALPWSTR)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Capropvar() *CAPROPVARIANT { + return (*CAPROPVARIANT)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) PcVal() **CHAR { return (**CHAR)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PbVal() **UCHAR { return (**UCHAR)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PiVal() **SHORT { return (**SHORT)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PuiVal() **USHORT { return (**USHORT)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PlVal() **LONG { return (**LONG)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PulVal() **ULONG { return (**ULONG)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PintVal() **INT { return (**INT)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PuintVal() **UINT { return (**UINT)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PfltVal() **FLOAT { return (**FLOAT)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PdblVal() **DOUBLE { return (**DOUBLE)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PboolVal() **VARIANT_BOOL { + return (**VARIANT_BOOL)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) PdecVal() **DECIMAL { return (**DECIMAL)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Pscode() **SCODE { return (**SCODE)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PcyVal() **CY { return (**CY)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) Pdate() **DATE { return (**DATE)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PbstrVal() **BSTR { return (**BSTR)(unsafe.Pointer(&this.storage1[0])) } +func (this *PROPVARIANT) PpunkVal() ***IUnknown { + return (***IUnknown)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) PpdispVal() ***IDispatch { + return (***IDispatch)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) Pparray() **LPSAFEARRAY { + return (**LPSAFEARRAY)(unsafe.Pointer(&this.storage1[0])) +} +func (this *PROPVARIANT) PvarVal() **PROPVARIANT { + return (**PROPVARIANT)(unsafe.Pointer(&this.storage1[0])) +} + +type PRPC_MESSAGE *RPC_MESSAGE +type PRPC_SYNTAX_IDENTIFIER *RPC_SYNTAX_IDENTIFIER +type PSAPI_WS_WATCH_INFORMATION struct { + FaultingPc LPVOID + FaultingVa LPVOID +} +type PSAPI_WS_WATCH_INFORMATION_EX struct { + BasicInfo PSAPI_WS_WATCH_INFORMATION + FaultingThreadId ULONG_PTR + Flags ULONG_PTR +} +type PSECURE_MEMORY_CACHE_CALLBACK func(Addr PVOID, Range SIZE_T) BOOLEAN +type PSECURITY_DESCRIPTOR *SECURITY_DESCRIPTOR +type PSID uintptr +type PSOCKADDR_IN6 *SOCKADDR_IN6_LH +type PSOCKADDR_IN6_PAIR *SOCKADDR_IN6_PAIR +type PSPCALLBACK func(hwnd HWND, uMsg UINT, ppsp *PROPSHEETPAGE) UINT +type PSRWLOCK *RTL_SRWLOCK +type PSTR *CHAR +type PTRIVERTEX *TRIVERTEX +type PUCHAR *UCHAR +type PULONG64 *ULONG64 +type PUSHORT *USHORT +type PVOID uintptr +type PWCHAR *WCHAR +type PWSTR *WCHAR +type QITAB struct { + Piid/*const*/ *IID + DwOffset int32 +} +type QOS struct { + SendingFlowspec FLOWSPEC + ReceivingFlowspec FLOWSPEC + ProviderSpecific WSABUF +} +type RASTERIZER_STATUS struct { + NSize int16 + WFlags int16 + NLanguageID int16 +} +type RAWHID struct { + DwSizeHid uint32 + DwCount uint32 + BRawData [1]byte +} +type RAWINPUT struct { + Header RAWINPUTHEADER + Data RAWINPUT_data +} +type RAWINPUT_data struct { + storage [24]byte +} + +func (this *RAWINPUT_data) Mouse() *RAWMOUSE { + return (*RAWMOUSE)(unsafe.Pointer(this)) +} +func (this *RAWINPUT_data) Keyboard() *RAWKEYBOARD { + return (*RAWKEYBOARD)(unsafe.Pointer(this)) +} +func (this *RAWINPUT_data) HID() *RAWHID { + return (*RAWHID)(unsafe.Pointer(this)) +} + +type RAWINPUTDEVICE struct { + UsUsagePage uint16 + UsUsage uint16 + DwFlags uint32 + HwndTarget HWND +} +type RAWINPUTDEVICELIST struct { + HDevice HANDLE + DwType uint32 +} +type RAWINPUTHEADER struct { + DwType uint32 + DwSize uint32 + HDevice HANDLE + WParam uintptr +} +type RAWKEYBOARD struct { + MakeCode uint16 + Flags uint16 + Reserved int16 + VKey uint16 + Message uint32 + ExtraInformation uint32 +} +type RAWMOUSE struct { + UsFlags uint16 + padding [2]byte + UsButtonFlags uint16 + UsButtonData uint16 + UlRawButtons uint32 + LLastX int32 + LLastY int32 + UlExtraInformation uint32 +} +type RECT struct { + Left, Top, Right, Bottom int32 +} +type RECTFX struct { + XLeft FIX + YTop FIX + XRight FIX + YBottom FIX +} +type RECTL struct { + Left LONG + Top LONG + Right LONG + Bottom LONG +} +type REFCLSID /*const*/ *IID +type REFFMTID /*const*/ *IID +type REFGUID /*const*/ *GUID +type REFIID /*const*/ *IID +type REFKNOWNFOLDERID *KNOWNFOLDERID +type REFPROPVARIANT *PROPVARIANT +type REGISTERWORDENUMPROC func(lpszReading string, unnamed1 DWORD, lpszString string, unnamed3 LPVOID) int32 +type REGSAM uint32 +type RGBQUAD struct { + RgbBlue BYTE + RgbGreen BYTE + RgbRed BYTE + RgbReserved BYTE +} +type RGNDATA struct { + Rdh RGNDATAHEADER + Buffer [1]byte +} +type RGNDATAHEADER struct { + DwSize DWORD + IType DWORD + NCount DWORD + NRgnSize DWORD + RcBound RECT +} +type ROP4 ULONG +type RPC_AUTHZ_HANDLE uintptr +type RPC_BINDING_HANDLE I_RPC_HANDLE +type RPC_MESSAGE struct { + Handle RPC_BINDING_HANDLE + DataRepresentation uint32 + Buffer uintptr + BufferLength uint32 + ProcNum uint32 + TransferSyntax PRPC_SYNTAX_IDENTIFIER + RpcInterfaceInformation uintptr + ReservedForRuntime uintptr + ManagerEpv uintptr + ImportContext uintptr + RpcFlags uint32 +} +type RPC_STATUS int32 +type RPC_SYNTAX_IDENTIFIER struct { + SyntaxGUID GUID + SyntaxVersion RPC_VERSION +} +type RPC_VERSION struct { + MajorVersion uint16 + MinorVersion uint16 +} +type RTL_SRWLOCK struct { + Ptr PVOID +} +type RUN struct { + IStart LONG + IStop LONG +} +type SAFEARRAY struct { + CDims USHORT + FFeatures USHORT + CbElements ULONG + CLocks ULONG + PvData PVOID + Rgsabound [1]SAFEARRAYBOUND +} +type SAFEARRAYBOUND struct { + CElements ULONG + LLbound LONG +} +type SAFER_LEVEL_HANDLE HANDLE +type SCODE LONG +type SCOPE_ID struct { + Value ULONG +} + +func (this *SCOPE_ID) Zone() ULONG { + return 0xFFFFFFF & this.Value +} +func (this *SCOPE_ID) Level() ULONG { + return (0xF000000 & this.Value) >> (32 - 4) +} +func (this *SCOPE_ID) SetZone(v ULONG) { + this.Value = this.Value | (0x0FFFFFFF & v) +} +func (this *SCOPE_ID) SetLevel(v ULONG) { + this.Value = this.Value | (0xF0000000 & (v << (32 - 4))) +} + +type SCROLLBARINFO struct { + CbSize uint32 + RcScrollBar RECT + DxyLineButton int32 + XyThumbTop int32 + XyThumbBottom int32 + Reserved int32 + Rgstate [CCHILDREN_SCROLLBAR + 1]uint32 +} +type SCROLLINFO struct { + CbSize uint32 + FMask uint32 + NMin int32 + NMax int32 + NPage uint32 + NPos int32 + NTrackPos int32 +} +type SC_HANDLE HANDLE +type SC_LOCK uintptr +type SECURITY_ATTRIBUTES struct { + NLength uint32 + LpSecurityDescriptor uintptr + BInheritHandle BOOL +} +type SECURITY_CONTEXT_TRACKING_MODE BOOLEAN +type SECURITY_DESCRIPTOR struct { + Revision byte + Sbz1 byte + Control SECURITY_DESCRIPTOR_CONTROL + Owner PSID + Group PSID + Sacl *ACL + Dacl *ACL +} +type SECURITY_DESCRIPTOR_CONTROL uint16 +type SECURITY_INFORMATION ULONG +type SECURITY_QUALITY_OF_SERVICE struct { + storage [12]byte +} + +func (this *SECURITY_QUALITY_OF_SERVICE) Length() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *SECURITY_QUALITY_OF_SERVICE) ImpersonationLevel() *SECURITY_IMPERSONATION_LEVEL { + return (*SECURITY_IMPERSONATION_LEVEL)(unsafe.Pointer(&this.storage[4])) +} +func (this *SECURITY_QUALITY_OF_SERVICE) ContextTrackingMode() *SECURITY_CONTEXT_TRACKING_MODE { + return (*SECURITY_CONTEXT_TRACKING_MODE)(unsafe.Pointer(&this.storage[8])) +} +func (this *SECURITY_QUALITY_OF_SERVICE) EffectiveOnly() *BOOLEAN { + return (*BOOLEAN)(unsafe.Pointer(&this.storage[9])) +} + +type SENDASYNCPROC func(hwnd HWND, uMsg uint32, dwData uintptr, lResult LRESULT) +type SERVICE_STATUS struct { + DwServiceType DWORD + DwCurrentState DWORD + DwControlsAccepted DWORD + DwWin32ExitCode DWORD + DwServiceSpecificExitCode DWORD + DwCheckPoint DWORD + DwWaitHint DWORD +} +type SERVICE_STATUS_HANDLE HANDLE +type SFV_CREATE struct { + CbSize UINT + Pshf *IShellFolder + PsvOuter *IShellView + Psfvcb *IShellFolderViewCB +} +type SHChangeNotifyEntry struct { + storage1 [ptrsize + 4]byte +} + +func (this *SHChangeNotifyEntry) Pidl() *PCIDLIST_ABSOLUTE { + return (*PCIDLIST_ABSOLUTE)(unsafe.Pointer(&this.storage1[0])) +} +func (this *SHChangeNotifyEntry) FRecursive() *BOOL { + return (*BOOL)(unsafe.Pointer(&this.storage1[ptrsize])) +} + +type SHELLFLAGSTATE struct { + storage1 BOOL +} + +func (this *SHELLFLAGSTATE) FShowAllObjects() BOOL { + return BOOL(0x1 & (this.storage1 >> 31)) +} +func (this *SHELLFLAGSTATE) FShowExtensions() BOOL { + return BOOL(0x1 & (this.storage1 >> 30)) +} +func (this *SHELLFLAGSTATE) FNoConfirmRecycle() BOOL { + return BOOL(0x1 & (this.storage1 >> 29)) +} +func (this *SHELLFLAGSTATE) FShowSysFiles() BOOL { + return BOOL(0x1 & (this.storage1 >> 28)) +} +func (this *SHELLFLAGSTATE) FShowCompColor() BOOL { + return BOOL(0x1 & (this.storage1 >> 27)) +} +func (this *SHELLFLAGSTATE) FDoubleClickInWebView() BOOL { + return BOOL(0x1 & (this.storage1 >> 26)) +} +func (this *SHELLFLAGSTATE) FDesktopHTML() BOOL { + return BOOL(0x1 & (this.storage1 >> 25)) +} +func (this *SHELLFLAGSTATE) FWin95Classic() BOOL { + return BOOL(0x1 & (this.storage1 >> 24)) +} +func (this *SHELLFLAGSTATE) FDontPrettyPath() BOOL { + return BOOL(0x1 & (this.storage1 >> 23)) +} +func (this *SHELLFLAGSTATE) FShowAttribCol() BOOL { + return BOOL(0x1 & (this.storage1 >> 22)) +} +func (this *SHELLFLAGSTATE) FMapNetDrvBtn() BOOL { + return BOOL(0x1 & (this.storage1 >> 21)) +} +func (this *SHELLFLAGSTATE) FShowInfoTip() BOOL { + return BOOL(0x1 & (this.storage1 >> 20)) +} +func (this *SHELLFLAGSTATE) FHideIcons() BOOL { + return BOOL(0x1 & (this.storage1 >> 19)) +} +func (this *SHELLFLAGSTATE) FAutoCheckSelect() BOOL { + return BOOL(0x1 & (this.storage1 >> 18)) +} +func (this *SHELLFLAGSTATE) FIconsOnly() BOOL { + return BOOL(0x1 & (this.storage1 >> 17)) +} + +type SHELLSTATE struct { + storage1 BOOL + DwWin95Unused DWORD + UWin95Unused UINT + LParamSort LONG + ISortDirection int32 + Version UINT + UNotUsed UINT + storage2 uint8 + storage3 uint16 +} + +func (this *SHELLSTATE) FShowAllObjects() BOOL { + return BOOL(0x1 & (this.storage1 >> 31)) +} +func (this *SHELLSTATE) FShowExtensions() BOOL { + return BOOL(0x1 & (this.storage1 >> 30)) +} +func (this *SHELLSTATE) FNoConfirmRecycle() BOOL { + return BOOL(0x1 & (this.storage1 >> 29)) +} +func (this *SHELLSTATE) FShowSysFiles() BOOL { + return BOOL(0x1 & (this.storage1 >> 28)) +} +func (this *SHELLSTATE) FShowCompColor() BOOL { + return BOOL(0x1 & (this.storage1 >> 27)) +} +func (this *SHELLSTATE) FDoubleClickInWebView() BOOL { + return BOOL(0x1 & (this.storage1 >> 26)) +} +func (this *SHELLSTATE) FDesktopHTML() BOOL { + return BOOL(0x1 & (this.storage1 >> 25)) +} +func (this *SHELLSTATE) FWin95Classic() BOOL { + return BOOL(0x1 & (this.storage1 >> 24)) +} +func (this *SHELLSTATE) FDontPrettyPath() BOOL { + return BOOL(0x1 & (this.storage1 >> 23)) +} +func (this *SHELLSTATE) FShowAttribCol() BOOL { + return BOOL(0x1 & (this.storage1 >> 22)) +} +func (this *SHELLSTATE) FMapNetDrvBtn() BOOL { + return BOOL(0x1 & (this.storage1 >> 21)) +} +func (this *SHELLSTATE) FShowInfoTip() BOOL { + return BOOL(0x1 & (this.storage1 >> 20)) +} +func (this *SHELLSTATE) FHideIcons() BOOL { + return BOOL(0x1 & (this.storage1 >> 19)) +} +func (this *SHELLSTATE) FWebView() BOOL { + return BOOL(0x1 & (this.storage1 >> 18)) +} +func (this *SHELLSTATE) FFilter() BOOL { + return BOOL(0x1 & (this.storage1 >> 17)) +} +func (this *SHELLSTATE) FShowSuperHidden() BOOL { + return BOOL(0x1 & (this.storage1 >> 16)) +} +func (this *SHELLSTATE) FNoNetCrawling() BOOL { + return BOOL(0x1 & (this.storage1 >> 15)) +} +func (this *SHELLSTATE) FSepProcess() BOOL { + return BOOL(0x1 & (this.storage2 >> 15)) +} +func (this *SHELLSTATE) FStartPanelOn() BOOL { + return BOOL(0x1 & (this.storage2 >> 14)) +} +func (this *SHELLSTATE) FShowStartPage() BOOL { + return BOOL(0x1 & (this.storage2 >> 13)) +} +func (this *SHELLSTATE) FAutoCheckSelect() BOOL { + return BOOL(0x1 & (this.storage2 >> 12)) +} +func (this *SHELLSTATE) FIconsOnly() BOOL { + return BOOL(0x1 & (this.storage2 >> 11)) +} +func (this *SHELLSTATE) FShowTypeOverlay() BOOL { + return BOOL(0x1 & (this.storage2 >> 10)) +} +func (this *SHELLSTATE) FShowStatusBar() BOOL { + return BOOL(0x1 & (this.storage2 >> 9)) +} +func (this *SHELLSTATE) FSpareFlags() UINT { + return UINT(0x1FF & (this.storage3 >> 7)) +} + +type SHFILEINFO struct { + HIcon HICON + IIcon int32 + DwAttributes DWORD + SzDisplayName [MAX_PATH]WCHAR + SzTypeName [80]WCHAR +} +type SHFILEOPSTRUCT struct { + storage [ptrsize*5 + 10 + pad6for64_0for32]byte +} + +func (this *SHFILEOPSTRUCT) Hwnd() *HWND { + return (*HWND)(unsafe.Pointer(&this.storage[0])) +} +func (this *SHFILEOPSTRUCT) WFunc() *UINT { + return (*UINT)(unsafe.Pointer(&this.storage[ptrsize])) +} +func (this *SHFILEOPSTRUCT) PFrom() *PCZZWSTR { + return (*PCZZWSTR)(unsafe.Pointer(&this.storage[ptrsize+4+pad4for64_0for32])) +} +func (this *SHFILEOPSTRUCT) PTo() *PCZZWSTR { + return (*PCZZWSTR)(unsafe.Pointer(&this.storage[ptrsize*2+4+pad4for64_0for32])) +} +func (this *SHFILEOPSTRUCT) FFlags() *FILEOP_FLAGS { + return (*FILEOP_FLAGS)(unsafe.Pointer(&this.storage[ptrsize*3+4+pad4for64_0for32])) +} +func (this *SHFILEOPSTRUCT) FAnyOperationsAborted() *BOOL { + return (*BOOL)(unsafe.Pointer(&this.storage[ptrsize*3+6+pad6for64_0for32])) +} +func (this *SHFILEOPSTRUCT) HNameMappings() *LPVOID { + return (*LPVOID)(unsafe.Pointer(&this.storage[ptrsize*3+10+pad6for64_0for32])) +} +func (this *SHFILEOPSTRUCT) LpszProgressTitle() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[ptrsize*4+10+pad6for64_0for32])) +} + +type SHITEMID struct { + storage [3]byte +} + +func (this *SHITEMID) Cb() *USHORT { + return (*USHORT)(unsafe.Pointer(&this.storage[0])) +} +func (this *SHITEMID) AbID() *BYTE { + return (*BYTE)(unsafe.Pointer(&this.storage[2])) +} + +type SHORT int16 +type SHQUERYRBINFO struct { + CbSize DWORD + I64Size int64 + I64NumItems int64 +} +type SHSTOCKICONINFO struct { + CbSize DWORD + HIcon HICON + ISysImageIndex int32 + IIcon int32 + SzPath [MAX_PATH]WCHAR +} +type SID struct { + Revision UCHAR + SubAuthorityCount UCHAR + IdentifierAuthority SID_IDENTIFIER_AUTHORITY + SubAuthority [ANYSIZE_ARRAY]ULONG +} +type SID_AND_ATTRIBUTES struct { + Sid PSID + Attributes ULONG +} +type SID_IDENTIFIER_AUTHORITY struct { + Value [6]UCHAR +} +type SFGAOF ULONG +type SIZE struct { + Cx, Cy int32 +} +type SIZEL SIZE +type SMALL_RECT struct { + Left SHORT + Top SHORT + Right SHORT + Bottom SHORT +} +type SOCKADDR struct { + Sa_family ADDRESS_FAMILY + Sa_data [14]CHAR +} +type SOCKADDR_IN struct { + Sin_family ADDRESS_FAMILY + Sin_port USHORT + Sin_addr IN_ADDR + Sin_zero [8]CHAR +} +type SOCKADDR_IN6 SOCKADDR_IN6_LH +type SOCKADDR_IN6_LH struct { + sin6_family ADDRESS_FAMILY + sin6_port USHORT + sin6_flowinfo ULONG + sin6_addr IN6_ADDR + union1 ULONG +} + +func (this *SOCKADDR_IN6_LH) Sin6_scope_id() *ULONG { + return (*ULONG)(unsafe.Pointer(&this.union1)) +} +func (this *SOCKADDR_IN6_LH) Sin6_scope_struct() *SCOPE_ID { + return (*SCOPE_ID)(unsafe.Pointer(&this.union1)) +} + +type SOCKADDR_IN6_PAIR struct { + SourceAddress PSOCKADDR_IN6 + DestinationAddress PSOCKADDR_IN6 +} +type SOCKET UINT_PTR +type SOCKET_ADDRESS struct { + LpSockaddr LPSOCKADDR + ISockaddrLength INT +} +type SOLE_AUTHENTICATION_SERVICE struct { + DwAuthnSvc DWORD + DwAuthzSvc DWORD + PPrincipalName *OLECHAR + Hr HRESULT +} +type STARTUPINFO struct { + Cb DWORD + LpReserved LPWSTR + LpDesktop LPWSTR + LpTitle LPWSTR + DwX DWORD + DwY DWORD + DwXSize DWORD + DwYSize DWORD + DwXCountChars DWORD + DwYCountChars DWORD + DwFillAttribute DWORD + DwFlags DWORD + WShowWindow WORD + CbReserved2 WORD + LpReserved2 LPBYTE + HStdInput HANDLE + HStdOutput HANDLE + HStdError HANDLE +} +type STGMEDIUM struct { + Tymed DWORD + union1 uintptr + PUnkForRelease *IUnknown +} + +func (this *STGMEDIUM) GetHBitmap() HBITMAP { + return *(*HBITMAP)(unsafe.Pointer(&this.union1)) +} +func (this *STGMEDIUM) SetHBitmap(v HBITMAP) { + *(*HBITMAP)(unsafe.Pointer(&this.union1)) = v +} +func (this *STGMEDIUM) GetHMetaFilePict() HMETAFILEPICT { + return *(*HMETAFILEPICT)(unsafe.Pointer(&this.union1)) +} +func (this *STGMEDIUM) SetHMetaFilePict(v HMETAFILEPICT) { + *(*HMETAFILEPICT)(unsafe.Pointer(&this.union1)) = v +} +func (this *STGMEDIUM) GetHEnhMetaFile() HENHMETAFILE { + return *(*HENHMETAFILE)(unsafe.Pointer(&this.union1)) +} +func (this *STGMEDIUM) SetHEnhMetaFile(v HENHMETAFILE) { + *(*HENHMETAFILE)(unsafe.Pointer(&this.union1)) = v +} +func (this *STGMEDIUM) GetHGlobal() HGLOBAL { + return *(*HGLOBAL)(unsafe.Pointer(&this.union1)) +} +func (this *STGMEDIUM) SetHGlobal(v HGLOBAL) { + *(*HGLOBAL)(unsafe.Pointer(&this.union1)) = v +} +func (this *STGMEDIUM) GetLpszFileName() LPOLESTR { + return *(*LPOLESTR)(unsafe.Pointer(&this.union1)) +} +func (this *STGMEDIUM) SetLpszFileName(v LPOLESTR) { + *(*LPOLESTR)(unsafe.Pointer(&this.union1)) = v +} +func (this *STGMEDIUM) GetPstm() *IStream { + return *(**IStream)(unsafe.Pointer(&this.union1)) +} +func (this *STGMEDIUM) SetPstm(v *IStream) { + *(**IStream)(unsafe.Pointer(&this.union1)) = v +} +func (this *STGMEDIUM) GetPstg() *IStorage { + return *(**IStorage)(unsafe.Pointer(&this.union1)) +} +func (this *STGMEDIUM) SetPstg(v *IStorage) { + *(**IStorage)(unsafe.Pointer(&this.union1)) = v +} + +type STROBJ struct { + CGlyphs ULONG + FlAccel FLONG + UlCharInc ULONG + RclBkGround RECTL + Pgp *GLYPHPOS + PwszOrg LPWSTR +} + +func (this *STRRET) POleStr() *LPWSTR { + return (*LPWSTR)(unsafe.Pointer(&this.cStr[0])) +} +func (this *STRRET) UOffset() *UINT { + return (*UINT)(unsafe.Pointer(&this.cStr[0])) +} +func (this *STRRET) CStr() **byte { + return (**byte)(unsafe.Pointer(&this.cStr[0])) +} + +type STYLEBUF struct { + DwStyle DWORD + SzDescription [STYLE_DESCRIPTION_SIZE]WCHAR +} +type SUBCLASSPROC func(hWnd HWND, uMsg UINT, wParam WPARAM, lParam LPARAM, uIdSubclass UINT_PTR, dwRefData DWORD_PTR) LRESULT +type SURFOBJ struct { + Dhsurf DHSURF + Hsurf HSURF + Dhpdev DHPDEV + Hdev HDEV + SizlBitmap SIZEL + CjBits ULONG + PvBits PVOID + PvScan0 PVOID + LDelta LONG + IUniq ULONG + IBitmapFormat ULONG + IType USHORT + FjBitmap USHORT +} +type SYSTEMTIME struct { + WYear WORD + WMonth WORD + WDayOfWeek WORD + WDay WORD + WHour WORD + WMinute WORD + WSecond WORD + WMilliseconds WORD +} +type SYSTEM_INFO struct { + WProcessorArchitecture uint16 + WReserved uint16 + DwPageSize uint32 + LpMinimumApplicationAddress uintptr + LpMaximumApplicationAddress uintptr + DwActiveProcessorMask uintptr + DwNumberOfProcessors uint32 + DwProcessorType uint32 + DwAllocationGranularity uint32 + WProcessorLevel uint16 + WProcessorRevision uint16 +} +type Sockaddr struct { + Sa_family uint16 + Sa_data [14]CHAR +} +type Socklen_t int32 +type Status GpStatus +type TASKCALLBACK func(dwInst DWORD_PTR) +type TASKDIALOGCALLBACK func(hwnd HWND, msg UINT, wParam WPARAM, lParam LPARAM, lpRefData LONG_PTR) HRESULT +type TASKDIALOG_BUTTON struct { + storage [4 * pad3for64_2for32]byte +} + +func (this *TASKDIALOG_BUTTON) NButtonID() *int32 { + return (*int32)(unsafe.Pointer(&this.storage[0])) +} +func (this *TASKDIALOG_BUTTON) PszButtonText() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[4])) +} + +type TBBUTTON struct { + IBitmap int32 + IdCommand int32 + FsState byte + FsStyle byte + BReserved [2 * pad3for64_1for32]byte + DwData *DWORD + IString uintptr +} +type TEXTMETRIC struct { + TmHeight LONG + TmAscent LONG + TmDescent LONG + TmInternalLeading LONG + TmExternalLeading LONG + TmAveCharWidth LONG + TmMaxCharWidth LONG + TmWeight LONG + TmOverhang LONG + TmDigitizedAspectX LONG + TmDigitizedAspectY LONG + TmFirstChar WCHAR + TmLastChar WCHAR + TmDefaultChar WCHAR + TmBreakChar WCHAR + TmItalic BYTE + TmUnderlined BYTE + TmStruckOut BYTE + TmPitchAndFamily BYTE + TmCharSet BYTE +} +type THREAD_START_ROUTINE func(lpThreadParameter LPVOID) DWORD +type TIMECALLBACK func(uTimerID UINT, uMsg UINT, dwUser DWORD_PTR, dw1 DWORD_PTR, dw2 DWORD_PTR) +type TIMECAPS struct { + WPeriodMin UINT + WPeriodMax UINT +} +type TIMERPROC func(hwnd HWND, uMsg uint32, idEvent uintptr, dwTime uint32) +type TITLEBARINFO struct { + CbSize uint32 + RcTitleBar RECT + Rgstate [CCHILDREN_TITLEBAR + 1]uint32 +} +type TOKEN_GROUPS struct { + GroupCount ULONG + Groups [ANYSIZE_ARRAY]SID_AND_ATTRIBUTES +} +type TOKEN_PRIVILEGES struct { + PrivilegeCount ULONG + Privileges [ANYSIZE_ARRAY]LUID_AND_ATTRIBUTES +} +type TOUCHINPUT struct { + X int32 // LONG + Y int32 // LONG + HSource HANDLE + DwID uint32 + DwFlags uint32 + DwMask uint32 + DwTime uint32 + DwExtraInfo uintptr // ULONG_PTR + CxContact uint32 + CyContact uint32 +} +type TPMPARAMS struct { + CbSize uint32 + RcExclude RECT +} +type TRACKMOUSEEVENT struct { + CbSize uint32 + DwFlags uint32 + HwndTrack HWND + DwHoverTime uint32 +} +type TRIVERTEX struct { + X LONG + Y LONG + Red COLOR16 + Green COLOR16 + Blue COLOR16 + Alpha COLOR16 +} +type TRUSTEE struct { + PMultipleTrustee *TRUSTEE + MultipleTrusteeOperation MULTIPLE_TRUSTEE_OPERATION + TrusteeForm TRUSTEE_FORM + TrusteeType TRUSTEE_TYPE + PtstrName LPWSTR +} +type Time_t int64 +type Timeval struct { + Tv_sec int32 + Tv_usec int32 +} +type UCHAR byte +type UDATE struct { + St SYSTEMTIME + WDayOfYear USHORT +} +type UINT uint32 +type UINT8 uint8 +type UINT_PTR uintptr +type ULARGE_INTEGER struct { + QuadPart ULONGLONG +} +type ULONG uint32 +type ULONG64 uint64 +type ULONGLONG uint64 +type ULONG_PTR *uint32 +type UPDATELAYEREDWINDOWINFO struct { + CbSize uint32 + HdcDst HDC + PptDst *POINT // const POINT* + Psize *SIZE // const SIZE* + HdcSrc HDC + PptSrc *POINT // const POINT* + CrKey COLORREF + Pblend uintptr // const BLENDFUNCTION* + DwFlags uint32 + PrcDirty *RECT // const RECT* +} +type USER_MARSHAL_FREEING_ROUTINE func(unnamed0 *uint32, unnamed1 uintptr) +type USER_MARSHAL_MARSHALLING_ROUTINE func(unnamed0 *uint32, unnamed1 *byte, unnamed2 uintptr) *byte +type USER_MARSHAL_ROUTINE_QUADRUPLE struct { + PfnBufferSize uintptr // USER_MARSHAL_SIZING_ROUTINE + PfnMarshall uintptr // USER_MARSHAL_MARSHALLING_ROUTINE + PfnUnmarshall uintptr // USER_MARSHAL_UNMARSHALLING_ROUTINE + PfnFree uintptr // USER_MARSHAL_FREEING_ROUTINE +} +type USER_MARSHAL_SIZING_ROUTINE func(unnamed0 *uint32, unnamed1 uint32, unnamed2 uintptr) uint32 +type USER_MARSHAL_UNMARSHALLING_ROUTINE func(unnamed0 *uint32, unnamed1 *byte, unnamed2 uintptr) *byte +type USHORT uint16 + +func (this *VARIANT) Vt() *VARTYPE { + return (*VARTYPE)(unsafe.Pointer(&this.union1[0])) +} +func (this *VARIANT) WReserved1() *WORD { + return (*WORD)(unsafe.Pointer(&this.union1[2])) +} +func (this *VARIANT) WReserved2() *WORD { + return (*WORD)(unsafe.Pointer(&this.union1[4])) +} +func (this *VARIANT) WReserved3() *WORD { + return (*WORD)(unsafe.Pointer(&this.union1[6])) +} +func (this *VARIANT) LlVal() *LONGLONG { return (*LONGLONG)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) LVal() *LONG { return (*LONG)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) BVal() *BYTE { return (*BYTE)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) IVal() *SHORT { return (*SHORT)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) FltVal() *FLOAT { return (*FLOAT)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) DblVal() *DOUBLE { return (*DOUBLE)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) BoolVal() *VARIANT_BOOL { return (*VARIANT_BOOL)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) Scode() *SCODE { return (*SCODE)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) CyVal() *CY { return (*CY)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) Date() *DATE { return (*DATE)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) BstrVal() *BSTR { return (*BSTR)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PunkVal() *IUnknown { return (*IUnknown)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PdispVal() *IDispatch { return (*IDispatch)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) Parray() *SAFEARRAY { return (*SAFEARRAY)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PbVal() *BYTE { return (*BYTE)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PiVal() *SHORT { return (*SHORT)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PlVal() *LONG { return (*LONG)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PllVal() *LONGLONG { return (*LONGLONG)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PfltVal() *FLOAT { return (*FLOAT)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PdblVal() *DOUBLE { return (*DOUBLE)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PboolVal() *VARIANT_BOOL { return (*VARIANT_BOOL)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) Pscode() *SCODE { return (*SCODE)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PcyVal() *CY { return (*CY)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) Pdate() *DATE { return (*DATE)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PbstrVal() *BSTR { return (*BSTR)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PpunkVal() **IUnknown { return (**IUnknown)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PpdispVal() **IDispatch { return (**IDispatch)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) Pparray() **SAFEARRAY { return (**SAFEARRAY)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PvarVal() *VARIANT { return (*VARIANT)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) Byref() PVOID { return (PVOID)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) CVal() CHAR { return *(*CHAR)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) UiVal() USHORT { return *(*USHORT)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) UlVal() ULONG { return *(*ULONG)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) UllVal() ULONGLONG { return *(*ULONGLONG)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) IntVal() INT { return *(*INT)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) UintVal() UINT { return *(*UINT)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PdecVal() *DECIMAL { return (*DECIMAL)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PcVal() *CHAR { return (*CHAR)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PuiVal() *USHORT { return (*USHORT)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PulVal() *ULONG { return (*ULONG)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PullVal() *ULONGLONG { return (*ULONGLONG)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PintVal() *INT { return (*INT)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PuintVal() *UINT { return (*UINT)(unsafe.Pointer(&this.union1[8])) } +func (this *VARIANT) PvRecord() PVOID { + return (PVOID)(unsafe.Pointer(&this.union1[8])) +} +func (this *VARIANT) DecVal() DECIMAL { + return *(*DECIMAL)(unsafe.Pointer(&this.union1[0])) +} +func unpackVARIANT(v VARIANT) []uintptr { + size := int(unsafe.Sizeof(v)) + size += size % 4 + step := 4 + n := size / step + ret := []uintptr{} + ptr := uintptr(unsafe.Pointer(&v)) + for i := 0; i < n; i++ { + ret = append(ret, *(*uintptr)(unsafe.Pointer(ptr + uintptr(step*i)))) + } + return ret +} + +type VARIANTARG VARIANT +type VARIANT_BOOL int16 +type VARTYPE uint16 +type VERSIONEDSTREAM struct { + GuidVersion GUID + PStream *IStream +} +type WAVEFORMATEX struct { + storage [18]byte +} + +func (this *WAVEFORMATEX) WFormatTag() *WORD { + return (*WORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *WAVEFORMATEX) NChannels() *WORD { + return (*WORD)(unsafe.Pointer(&this.storage[2])) +} +func (this *WAVEFORMATEX) NSamplesPerSec() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[4])) +} +func (this *WAVEFORMATEX) NAvgBytesPerSec() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[8])) +} +func (this *WAVEFORMATEX) NBlockAlign() *WORD { + return (*WORD)(unsafe.Pointer(&this.storage[12])) +} +func (this *WAVEFORMATEX) WBitsPerSample() *WORD { + return (*WORD)(unsafe.Pointer(&this.storage[14])) +} +func (this *WAVEFORMATEX) CbSize() *WORD { + return (*WORD)(unsafe.Pointer(&this.storage[16])) +} + +type WAVEHDR struct { + LpData LPSTR + DwBufferLength DWORD + DwBytesRecorded DWORD + DwUser DWORD_PTR + DwFlags DWORD + DwLoops DWORD + LpNext *WAVEHDR + Reserved DWORD_PTR +} +type WAVEINCAPS struct { + WMid WORD + WPid WORD + VDriverVersion MMVERSION + SzPname [MAXPNAMELEN]WCHAR + DwFormats DWORD + WChannels WORD + WReserved1 WORD +} +type WAVEOUTCAPS struct { + WMid WORD + WPid WORD + VDriverVersion MMVERSION + SzPname [MAXPNAMELEN]WCHAR + DwFormats DWORD + WChannels WORD + WReserved1 WORD + DwSupport DWORD +} +type WCHAR uint16 +type WCRANGE struct { + WcLow WCHAR + CGlyphs USHORT +} +type WGLSWAP struct { + Hdc HDC + UiFlags uint32 // UINT +} +type WINDOWINFO struct { + CbSize uint32 // DWORD + RcWindow RECT + RcClient RECT + DwStyle uint32 // DWORD + DwExStyle uint32 // DWORD + DwWindowStatus uint32 // DWORD + CxWindowBorders uint32 // UINT + CyWindowBorders uint32 // UINT + AtomWindowType ATOM + WCreatorVersion uint16 // WORD +} +type WINDOWPLACEMENT struct { + Length uint32 + Flags uint32 + ShowCmd uint32 + PtMinPosition POINT + PtMaxPosition POINT + RcNormalPosition RECT +} +type WINEVENTPROC func(hWinEventHook HWINEVENTHOOK, event uint32, hwnd HWND, idObject int32, idChild int32, idEventThread uint32, dwmsEventTime uint32) +type WINSTAENUMPROC func(lpszWindowStation LPWSTR, lParam LPARAM) BOOL +type WNDCLASS struct { + Style uint32 + LpfnWndProc uintptr // WNDPROC + CbClsExtra int32 + CbWndExtra int32 + HInstance HINSTANCE + HIcon HICON + HCursor HCURSOR + HbrBackground HBRUSH + LpszMenuName *uint16 // LPCWSTR + LpszClassName *uint16 // LPCWSTR +} +type WNDCLASSEX struct { + CbSize uint32 + Style uint32 + LpfnWndProc uintptr + CbClsExtra int32 + CbWndExtra int32 + HInstance HINSTANCE + HIcon HICON + HCursor HCURSOR + HbrBackground HBRUSH + LpszMenuName *uint16 + LpszClassName *uint16 + HIconSm HICON +} +type WNDENUMPROC func(hWnd HWND, lParam LPARAM) BOOL +type WNDPROC func(unnamed0 HWND, unnamed1 UINT, unnamed2 WPARAM, unnamed3 LPARAM) LRESULT +type WORD uint16 +type WPARAM uintptr +type WSABUF struct { + Len ULONG + Buf *CHAR +} +type WSACOMPLETION struct { + Type WSACOMPLETIONTYPE + padding1 [pad4for64_0for32]byte + Parameters WSACOMPLETION_Parameters +} +type WSACOMPLETION_Parameters struct { + storage [4 * pad6for64_3for32]byte +} +type WSACOMPLETION_Parameters_WindowMessage struct { + HWnd HWND + UMsg UINT + Context WPARAM +} +type WSACOMPLETION_Parameters_Event struct { + LpOverlapped LPWSAOVERLAPPED +} +type WSACOMPLETION_Parameters_Apc struct { + LpOverlapped LPWSAOVERLAPPED + LpfnCompletionProc uintptr // LPWSAOVERLAPPED_COMPLETION_ROUTINE +} +type WSACOMPLETION_Parameters_Port struct { + LpOverlapped LPWSAOVERLAPPED + HPort HANDLE + Key ULONG_PTR +} + +func (this *WSACOMPLETION_Parameters) WindowMessage() *WSACOMPLETION_Parameters_WindowMessage { + return (*WSACOMPLETION_Parameters_WindowMessage)(unsafe.Pointer(this)) +} +func (this *WSACOMPLETION_Parameters) Event() *WSACOMPLETION_Parameters_Event { + return (*WSACOMPLETION_Parameters_Event)(unsafe.Pointer(this)) +} +func (this *WSACOMPLETION_Parameters) Apc() *WSACOMPLETION_Parameters_Apc { + return (*WSACOMPLETION_Parameters_Apc)(unsafe.Pointer(this)) +} +func (this *WSACOMPLETION_Parameters) Port() *WSACOMPLETION_Parameters_Port { + return (*WSACOMPLETION_Parameters_Port)(unsafe.Pointer(this)) +} + +type WSAEVENT HANDLE +type WSAMSG struct { + Name LPSOCKADDR + Namelen INT + LpBuffers LPWSABUF + DwBufferCount ULONG + Control WSABUF + DwFlags ULONG +} +type WSANAMESPACE_INFO struct { + NSProviderId GUID + DwNameSpace DWORD + FActive BOOL + DwVersion DWORD + LpszIdentifier LPWSTR +} +type WSANETWORKEVENTS struct { + LNetworkEvents int32 + IErrorCode [FD_MAX_EVENTS]int32 +} +type WSANSCLASSINFO struct { + LpszName LPWSTR + DwNameSpace DWORD + DwValueType DWORD + DwValueSize DWORD + LpValue LPVOID +} +type WSAPOLLFD struct { + Fd SOCKET + Events SHORT + Revents SHORT +} +type WSAPROTOCOLCHAIN struct { + ChainLen int32 + ChainEntries [MAX_PROTOCOL_CHAIN]DWORD +} +type WSAPROTOCOL_INFO struct { + DwServiceFlags1 DWORD + DwServiceFlags2 DWORD + DwServiceFlags3 DWORD + DwServiceFlags4 DWORD + DwProviderFlags DWORD + ProviderId GUID + DwCatalogEntryId DWORD + ProtocolChain WSAPROTOCOLCHAIN + IVersion int32 + IAddressFamily int32 + IMaxSockAddr int32 + IMinSockAddr int32 + ISocketType int32 + IProtocol int32 + IProtocolMaxOffset int32 + INetworkByteOrder int32 + ISecurityScheme int32 + DwMessageSize DWORD + DwProviderReserved DWORD + SzProtocol [WSAPROTOCOL_LEN + 1]WCHAR +} +type WSAQUERYSET struct { + DwSize DWORD + LpszServiceInstanceName LPWSTR + LpServiceClassId LPGUID + LpVersion LPWSAVERSION + LpszComment LPWSTR + DwNameSpace DWORD + LpNSProviderId LPGUID + LpszContext LPWSTR + DwNumberOfProtocols DWORD + LpafpProtocols LPAFPROTOCOLS + LpszQueryString LPWSTR + DwNumberOfCsAddrs DWORD + LpcsaBuffer LPCSADDR_INFO + DwOutputFlags DWORD + LpBlob LPBLOB +} +type WSASERVICECLASSINFO struct { + LpServiceClassId LPGUID + LpszServiceClassName LPWSTR + DwCount DWORD + LpClassInfos LPWSANSCLASSINFO +} +type WSAVERSION struct { + DwVersion DWORD + EcHow WSAECOMPARATOR +} +type XFORM struct { + EM11 FLOAT + EM12 FLOAT + EM21 FLOAT + EM22 FLOAT + EDx FLOAT + EDy FLOAT +} +type XFORML struct { + EM11 FLOATL + EM12 FLOATL + EM21 FLOATL + EM22 FLOATL + EDx FLOATL + EDy FLOATL +} +type XFORMOBJ struct { + UlReserved ULONG +} +type XLATEOBJ struct { + IUniq ULONG + FlXlate FLONG + ISrcType USHORT + IDstType USHORT + CEntries ULONG + PulXlate *ULONG +} +type XMIT_HELPER_ROUTINE func(unnamed PMIDL_STUB_MESSAGE) +type XMIT_ROUTINE_QUINTUPLE struct { + PfnTranslateToXmit uintptr // XMIT_HELPER_ROUTINE + PfnTranslateFromXmit uintptr // XMIT_HELPER_ROUTINE + PfnFreeXmit uintptr // XMIT_HELPER_ROUTINE + PfnFreeInst uintptr // XMIT_HELPER_ROUTINE +} +type YIELDPROC func(mciId MCIDEVICEID, dwYieldData DWORD) UINT + +func Typeof(name string) reflect.Type { + return types[name] +} + +func TypeNames() []string { + ret := make([]string, len(types)) + i := 0 + for name, _ := range types { + ret[i] = name + i++ + } + return ret +} + +type MEMORYSTATUSEX struct { + CbSize DWORD + DwMemoryLoad DWORD + UllTotalPhys uint64 // in bytes + UllAvailPhys uint64 + UllTotalPageFile uint64 + UllAvailPageFile uint64 + UllTotalVirtual uint64 + UllAvailVirtual uint64 + UllAvailExtendedVirtual uint64 +} + +type LPPROCESSENTRY32 struct { + DwSize DWORD + CntUsage DWORD + Th32ProcessID DWORD + Th32DefaultHeapID ULONG_PTR + Th32ModuleID DWORD + CntThreads DWORD + Th32ParentProcessID DWORD + PcPriClassBase LONG + DwFlags DWORD + SzExeFile [MAX_PATH]CHAR +} diff --git a/grdp/win/types_386.go b/grdp/win/types_386.go new file mode 100644 index 0000000..f720603 --- /dev/null +++ b/grdp/win/types_386.go @@ -0,0 +1,340 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go + +package win + +import ( + "unsafe" +) + +type INPUTCONTEXT struct { + storage [320]byte +} + +func (this *INPUTCONTEXT) HWnd() *HWND { // 4 + return (*HWND)(unsafe.Pointer(&this.storage[0])) +} +func (this *INPUTCONTEXT) FOpen() *BOOL { // 4 + return (*BOOL)(unsafe.Pointer(&this.storage[4])) +} +func (this *INPUTCONTEXT) PtStatusWndPos() *POINT { // 8 + return (*POINT)(unsafe.Pointer(&this.storage[8])) +} +func (this *INPUTCONTEXT) PtSoftKbdPos() *POINT { // 8 + return (*POINT)(unsafe.Pointer(&this.storage[16])) +} +func (this *INPUTCONTEXT) FdwConversion() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[24])) +} +func (this *INPUTCONTEXT) FdwSentence() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[28])) +} +func (this *INPUTCONTEXT) LfFont() *LOGFONT { // 92 + return (*LOGFONT)(unsafe.Pointer(&this.storage[32])) +} +func (this *INPUTCONTEXT) CfCompForm() *COMPOSITIONFORM { // 28 + return (*COMPOSITIONFORM)(unsafe.Pointer(&this.storage[124])) +} +func (this *INPUTCONTEXT) CfCandForm() *[4]CANDIDATEFORM { // 128 + return (*[4]CANDIDATEFORM)(unsafe.Pointer(&this.storage[152])) +} +func (this *INPUTCONTEXT) HCompStr() *HIMCC { // 4 + return (*HIMCC)(unsafe.Pointer(&this.storage[280])) +} +func (this *INPUTCONTEXT) HCandInfo() *HIMCC { // 4 + return (*HIMCC)(unsafe.Pointer(&this.storage[284])) +} +func (this *INPUTCONTEXT) HGuideLine() *HIMCC { // 4 + return (*HIMCC)(unsafe.Pointer(&this.storage[288])) +} +func (this *INPUTCONTEXT) HPrivate() *HIMCC { // 4 + return (*HIMCC)(unsafe.Pointer(&this.storage[292])) +} +func (this *INPUTCONTEXT) DwNumMsgBuf() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[296])) +} +func (this *INPUTCONTEXT) HMsgBuf() *HIMCC { // 4 + return (*HIMCC)(unsafe.Pointer(&this.storage[300])) +} +func (this *INPUTCONTEXT) FdwInit() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[304])) +} +func (this *INPUTCONTEXT) DwReserve() *[3]DWORD { // 12 + return (*[3]DWORD)(unsafe.Pointer(&this.storage[308])) +} + +type IP_ADAPTER_ADDRESSES_LH struct { + union1 ULONGLONG + Next *IP_ADAPTER_ADDRESSES_LH + AdapterName PCHAR + FirstUnicastAddress PIP_ADAPTER_UNICAST_ADDRESS_LH + FirstAnycastAddress PIP_ADAPTER_ANYCAST_ADDRESS_XP + FirstMulticastAddress PIP_ADAPTER_MULTICAST_ADDRESS_XP + FirstDnsServerAddress PIP_ADAPTER_DNS_SERVER_ADDRESS_XP + DnsSuffix PWCHAR + Description PWCHAR + FriendlyName PWCHAR + PhysicalAddress [MAX_ADAPTER_ADDRESS_LENGTH]BYTE + PhysicalAddressLength ULONG + union2 ULONG + Mtu ULONG + IfType IFTYPE + OperStatus IF_OPER_STATUS + Ipv6IfIndex IF_INDEX + ZoneIndices [16]ULONG + FirstPrefix PIP_ADAPTER_PREFIX_XP + TransmitLinkSpeed ULONG64 + ReceiveLinkSpeed ULONG64 + FirstWinsServerAddress PIP_ADAPTER_WINS_SERVER_ADDRESS_LH + FirstGatewayAddress PIP_ADAPTER_GATEWAY_ADDRESS_LH + Ipv4Metric ULONG + Ipv6Metric ULONG + Luid IF_LUID + Dhcpv4Server SOCKET_ADDRESS + CompartmentId NET_IF_COMPARTMENT_ID + NetworkGuid NET_IF_NETWORK_GUID + ConnectionType NET_IF_CONNECTION_TYPE + TunnelType TUNNEL_TYPE + Dhcpv6Server SOCKET_ADDRESS + Dhcpv6ClientDuid [MAX_DHCPV6_DUID_LENGTH]BYTE + Dhcpv6ClientDuidLength ULONG + Dhcpv6Iaid ULONG + FirstDnsSuffix PIP_ADAPTER_DNS_SUFFIX + padding1 [4]byte +} +type IP_ADAPTER_ANYCAST_ADDRESS_XP struct { + union1 ULONGLONG + Next *IP_ADAPTER_ANYCAST_ADDRESS_XP + Address SOCKET_ADDRESS + padding1 [4]byte +} +type IP_ADAPTER_DNS_SERVER_ADDRESS_XP struct { + union1 ULONGLONG + Next *IP_ADAPTER_DNS_SERVER_ADDRESS_XP + Address SOCKET_ADDRESS + padding1 [4]byte +} +type IP_ADAPTER_GATEWAY_ADDRESS_LH struct { + union1 ULONGLONG + Next *IP_ADAPTER_GATEWAY_ADDRESS_LH + Address SOCKET_ADDRESS + padding1 [4]byte +} +type IP_ADAPTER_MULTICAST_ADDRESS_XP struct { + union1 ULONGLONG + Next *IP_ADAPTER_MULTICAST_ADDRESS_XP + Address SOCKET_ADDRESS + padding1 [4]byte +} +type IP_ADAPTER_WINS_SERVER_ADDRESS_LH struct { + union1 ULONGLONG + Next *IP_ADAPTER_WINS_SERVER_ADDRESS_LH + Address SOCKET_ADDRESS + padding1 [4]byte +} +type MIDIHDR struct { + storage [64]byte +} + +func (this *MIDIHDR) LpData() *LPSTR { // 4 + return (*LPSTR)(unsafe.Pointer(&this.storage[0])) +} +func (this *MIDIHDR) DwBufferLength() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[4])) +} +func (this *MIDIHDR) DwBytesRecorded() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[8])) +} +func (this *MIDIHDR) DwUser() *DWORD_PTR { // 4 + return (*DWORD_PTR)(unsafe.Pointer(&this.storage[12])) +} +func (this *MIDIHDR) DwFlags() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[16])) +} +func (this *MIDIHDR) LpNext() **MIDIHDR { // 4 + return (**MIDIHDR)(unsafe.Pointer(&this.storage[20])) +} +func (this *MIDIHDR) Reserved() *DWORD_PTR { // 4 + return (*DWORD_PTR)(unsafe.Pointer(&this.storage[24])) +} +func (this *MIDIHDR) DwOffset() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[28])) +} +func (this *MIDIHDR) DwReserved() *[8]DWORD_PTR { // 32 + return (*[8]DWORD_PTR)(unsafe.Pointer(&this.storage[32])) +} + +type MIXERLINECONTROLS struct { + CbStruct DWORD + DwLineID DWORD + union1 DWORD + CControls DWORD + Cbmxctrl DWORD + storage1 [4]byte +} +type PRINTDLG struct { + storage [66]byte +} + +func (this *PRINTDLG) LStructSize() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *PRINTDLG) HwndOwner() *HWND { // 4 + return (*HWND)(unsafe.Pointer(&this.storage[4])) +} +func (this *PRINTDLG) HDevMode() *HGLOBAL { // 4 + return (*HGLOBAL)(unsafe.Pointer(&this.storage[8])) +} +func (this *PRINTDLG) HDevNames() *HGLOBAL { // 4 + return (*HGLOBAL)(unsafe.Pointer(&this.storage[12])) +} +func (this *PRINTDLG) HDC() *HDC { // 4 + return (*HDC)(unsafe.Pointer(&this.storage[16])) +} +func (this *PRINTDLG) Flags() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[20])) +} +func (this *PRINTDLG) NFromPage() *WORD { // 2 + return (*WORD)(unsafe.Pointer(&this.storage[24])) +} +func (this *PRINTDLG) NToPage() *WORD { // 2 + return (*WORD)(unsafe.Pointer(&this.storage[26])) +} +func (this *PRINTDLG) NMinPage() *WORD { // 2 + return (*WORD)(unsafe.Pointer(&this.storage[28])) +} +func (this *PRINTDLG) NMaxPage() *WORD { // 2 + return (*WORD)(unsafe.Pointer(&this.storage[30])) +} +func (this *PRINTDLG) NCopies() *WORD { // 2 + return (*WORD)(unsafe.Pointer(&this.storage[32])) +} +func (this *PRINTDLG) HInstance() *HINSTANCE { // 4 + return (*HINSTANCE)(unsafe.Pointer(&this.storage[34])) +} +func (this *PRINTDLG) LCustData() *LPARAM { // 4 + return (*LPARAM)(unsafe.Pointer(&this.storage[38])) +} +func (this *PRINTDLG) LpfnPrintHook() *uintptr { // 4 + return (*uintptr)(unsafe.Pointer(&this.storage[42])) +} +func (this *PRINTDLG) LpfnSetupHook() *uintptr { // 4 + return (*uintptr)(unsafe.Pointer(&this.storage[46])) +} +func (this *PRINTDLG) LpPrintTemplateName() *LPCWSTR { // 4 + return (*LPCWSTR)(unsafe.Pointer(&this.storage[50])) +} +func (this *PRINTDLG) LpSetupTemplateName() *LPCWSTR { // 4 + return (*LPCWSTR)(unsafe.Pointer(&this.storage[54])) +} +func (this *PRINTDLG) HPrintTemplate() *HGLOBAL { // 4 + return (*HGLOBAL)(unsafe.Pointer(&this.storage[58])) +} +func (this *PRINTDLG) HSetupTemplate() *HGLOBAL { // 4 + return (*HGLOBAL)(unsafe.Pointer(&this.storage[62])) +} + +type SIZE_T uint32 +type STRRET struct { + UType UINT + cStr [260]byte +} +type TASKDIALOGCONFIG struct { + storage [96]byte +} + +func (this *TASKDIALOGCONFIG) CbSize() *UINT { + return (*UINT)(unsafe.Pointer(&this.storage[0])) +} +func (this *TASKDIALOGCONFIG) HwndParent() *HWND { + return (*HWND)(unsafe.Pointer(&this.storage[4])) +} +func (this *TASKDIALOGCONFIG) HInstance() *HINSTANCE { + return (*HINSTANCE)(unsafe.Pointer(&this.storage[8])) +} +func (this *TASKDIALOGCONFIG) DwFlags() *TASKDIALOG_FLAGS { + return (*TASKDIALOG_FLAGS)(unsafe.Pointer(&this.storage[12])) +} +func (this *TASKDIALOGCONFIG) DwCommonButtons() *TASKDIALOG_COMMON_BUTTON_FLAGS { + return (*TASKDIALOG_COMMON_BUTTON_FLAGS)(unsafe.Pointer(&this.storage[16])) +} +func (this *TASKDIALOGCONFIG) PszWindowTitle() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[20])) +} +func (this *TASKDIALOGCONFIG) HMainIcon() *HICON { + return (*HICON)(unsafe.Pointer(&this.storage[24])) +} +func (this *TASKDIALOGCONFIG) PszMainIcon() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[24])) +} +func (this *TASKDIALOGCONFIG) PszMainInstruction() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[28])) +} +func (this *TASKDIALOGCONFIG) PszContent() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[32])) +} +func (this *TASKDIALOGCONFIG) CButtons() *UINT { + return (*UINT)(unsafe.Pointer(&this.storage[36])) +} +func (this *TASKDIALOGCONFIG) PButtons() **TASKDIALOG_BUTTON { + return (**TASKDIALOG_BUTTON)(unsafe.Pointer(&this.storage[40])) +} +func (this *TASKDIALOGCONFIG) NDefaultButton() *int32 { + return (*int32)(unsafe.Pointer(&this.storage[44])) +} +func (this *TASKDIALOGCONFIG) CRadioButtons() *UINT { + return (*UINT)(unsafe.Pointer(&this.storage[48])) +} +func (this *TASKDIALOGCONFIG) PRadioButtons() **TASKDIALOG_BUTTON { + return (**TASKDIALOG_BUTTON)(unsafe.Pointer(&this.storage[52])) +} +func (this *TASKDIALOGCONFIG) NDefaultRadioButton() *int32 { + return (*int32)(unsafe.Pointer(&this.storage[56])) +} +func (this *TASKDIALOGCONFIG) PszVerificationText() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[60])) +} +func (this *TASKDIALOGCONFIG) PszExpandedInformation() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[64])) +} +func (this *TASKDIALOGCONFIG) PszExpandedControlText() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[68])) +} +func (this *TASKDIALOGCONFIG) PszCollapsedControlText() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[72])) +} +func (this *TASKDIALOGCONFIG) HFooterIcon() *HICON { + return (*HICON)(unsafe.Pointer(&this.storage[76])) +} +func (this *TASKDIALOGCONFIG) PszFooterIcon() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[76])) +} +func (this *TASKDIALOGCONFIG) PszFooter() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[80])) +} +func (this *TASKDIALOGCONFIG) PfCallback() *uintptr { + return (*uintptr)(unsafe.Pointer(&this.storage[84])) +} +func (this *TASKDIALOGCONFIG) LpCallbackData() *LONG_PTR { + return (*LONG_PTR)(unsafe.Pointer(&this.storage[88])) +} +func (this *TASKDIALOGCONFIG) CxWidth() *UINT { + return (*UINT)(unsafe.Pointer(&this.storage[92])) +} + +type VARIANT struct { + union1 [16]byte +} + +func (this *VARIANT) PRecInfo() *IRecordInfo { + return (*IRecordInfo)(unsafe.Pointer(&this.union1[12])) +} + +type WSADATA struct { + WVersion uint16 + WHighVersion uint16 + SzDescription [WSADESCRIPTION_LEN + 1]byte + SzSystemStatus [WSASYS_STATUS_LEN + 1]byte + IMaxSockets uint16 + IMaxUdpDg uint16 + LpVendorInfo *byte +} diff --git a/grdp/win/types_amd64.go b/grdp/win/types_amd64.go new file mode 100644 index 0000000..30e881b --- /dev/null +++ b/grdp/win/types_amd64.go @@ -0,0 +1,337 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go + +package win + +import ( + "unsafe" +) + +type INPUTCONTEXT struct { + storage [352]byte +} + +func (this *INPUTCONTEXT) HWnd() *HWND { // 8 + return (*HWND)(unsafe.Pointer(&this.storage[0])) +} +func (this *INPUTCONTEXT) FOpen() *BOOL { // 4 + return (*BOOL)(unsafe.Pointer(&this.storage[8])) +} +func (this *INPUTCONTEXT) PtStatusWndPos() *POINT { // 8 + return (*POINT)(unsafe.Pointer(&this.storage[12])) +} +func (this *INPUTCONTEXT) PtSoftKbdPos() *POINT { // 8 + return (*POINT)(unsafe.Pointer(&this.storage[20])) +} +func (this *INPUTCONTEXT) FdwConversion() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[28])) +} +func (this *INPUTCONTEXT) FdwSentence() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[32])) +} +func (this *INPUTCONTEXT) LfFont() *LOGFONT { // 92 + return (*LOGFONT)(unsafe.Pointer(&this.storage[36])) +} +func (this *INPUTCONTEXT) CfCompForm() *COMPOSITIONFORM { // 28 + return (*COMPOSITIONFORM)(unsafe.Pointer(&this.storage[128])) +} +func (this *INPUTCONTEXT) CfCandForm() *[4]CANDIDATEFORM { // 128 + return (*[4]CANDIDATEFORM)(unsafe.Pointer(&this.storage[156])) +} +func (this *INPUTCONTEXT) HCompStr() *HIMCC { // 8 + return (*HIMCC)(unsafe.Pointer(&this.storage[288])) +} +func (this *INPUTCONTEXT) HCandInfo() *HIMCC { // 8 + return (*HIMCC)(unsafe.Pointer(&this.storage[296])) +} +func (this *INPUTCONTEXT) HGuideLine() *HIMCC { // 8 + return (*HIMCC)(unsafe.Pointer(&this.storage[304])) +} +func (this *INPUTCONTEXT) HPrivate() *HIMCC { // 8 + return (*HIMCC)(unsafe.Pointer(&this.storage[312])) +} +func (this *INPUTCONTEXT) DwNumMsgBuf() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[320])) +} +func (this *INPUTCONTEXT) HMsgBuf() *HIMCC { // 8 + return (*HIMCC)(unsafe.Pointer(&this.storage[328])) +} +func (this *INPUTCONTEXT) FdwInit() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[336])) +} +func (this *INPUTCONTEXT) DwReserve() *[3]DWORD { // 12 + return (*[3]DWORD)(unsafe.Pointer(&this.storage[340])) +} + +type IP_ADAPTER_ADDRESSES_LH struct { + union1 ULONGLONG + Next *IP_ADAPTER_ADDRESSES_LH + AdapterName PCHAR + FirstUnicastAddress PIP_ADAPTER_UNICAST_ADDRESS_LH + FirstAnycastAddress PIP_ADAPTER_ANYCAST_ADDRESS_XP + FirstMulticastAddress PIP_ADAPTER_MULTICAST_ADDRESS_XP + FirstDnsServerAddress PIP_ADAPTER_DNS_SERVER_ADDRESS_XP + DnsSuffix PWCHAR + Description PWCHAR + FriendlyName PWCHAR + PhysicalAddress [MAX_ADAPTER_ADDRESS_LENGTH]BYTE + PhysicalAddressLength ULONG + union2 ULONG + Mtu ULONG + IfType IFTYPE + OperStatus IF_OPER_STATUS + Ipv6IfIndex IF_INDEX + ZoneIndices [16]ULONG + FirstPrefix PIP_ADAPTER_PREFIX_XP + TransmitLinkSpeed ULONG64 + ReceiveLinkSpeed ULONG64 + FirstWinsServerAddress PIP_ADAPTER_WINS_SERVER_ADDRESS_LH + FirstGatewayAddress PIP_ADAPTER_GATEWAY_ADDRESS_LH + Ipv4Metric ULONG + Ipv6Metric ULONG + Luid IF_LUID + Dhcpv4Server SOCKET_ADDRESS + CompartmentId NET_IF_COMPARTMENT_ID + NetworkGuid NET_IF_NETWORK_GUID + ConnectionType NET_IF_CONNECTION_TYPE + TunnelType TUNNEL_TYPE + Dhcpv6Server SOCKET_ADDRESS + Dhcpv6ClientDuid [MAX_DHCPV6_DUID_LENGTH]BYTE + Dhcpv6ClientDuidLength ULONG + Dhcpv6Iaid ULONG + FirstDnsSuffix PIP_ADAPTER_DNS_SUFFIX +} +type IP_ADAPTER_ANYCAST_ADDRESS_XP struct { + union1 ULONGLONG + Next *IP_ADAPTER_ANYCAST_ADDRESS_XP + Address SOCKET_ADDRESS +} +type IP_ADAPTER_DNS_SERVER_ADDRESS_XP struct { + union1 ULONGLONG + Next *IP_ADAPTER_DNS_SERVER_ADDRESS_XP + Address SOCKET_ADDRESS +} +type IP_ADAPTER_GATEWAY_ADDRESS_LH struct { + union1 ULONGLONG + Next *IP_ADAPTER_GATEWAY_ADDRESS_LH + Address SOCKET_ADDRESS +} +type IP_ADAPTER_MULTICAST_ADDRESS_XP struct { + union1 ULONGLONG + Next *IP_ADAPTER_MULTICAST_ADDRESS_XP + Address SOCKET_ADDRESS +} +type IP_ADAPTER_WINS_SERVER_ADDRESS_LH struct { + union1 ULONGLONG + Next *IP_ADAPTER_WINS_SERVER_ADDRESS_LH + Address SOCKET_ADDRESS +} +type MIDIHDR struct { + storage [112]byte +} + +func (this *MIDIHDR) LpData() *LPSTR { + return (*LPSTR)(unsafe.Pointer(&this.storage[0])) +} +func (this *MIDIHDR) DwBufferLength() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[8])) +} +func (this *MIDIHDR) DwBytesRecorded() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[12])) +} +func (this *MIDIHDR) DwUser() *DWORD_PTR { + return (*DWORD_PTR)(unsafe.Pointer(&this.storage[16])) +} +func (this *MIDIHDR) DwFlags() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[24])) +} +func (this *MIDIHDR) LpNext() **MIDIHDR { + return (**MIDIHDR)(unsafe.Pointer(&this.storage[28])) +} +func (this *MIDIHDR) Reserved() *DWORD_PTR { + return (*DWORD_PTR)(unsafe.Pointer(&this.storage[36])) +} +func (this *MIDIHDR) DwOffset() *DWORD { + return (*DWORD)(unsafe.Pointer(&this.storage[44])) +} +func (this *MIDIHDR) DwReserved() *[8]DWORD_PTR { + return (*[8]DWORD_PTR)(unsafe.Pointer(&this.storage[48])) +} + +type MIXERLINECONTROLS struct { + CbStruct DWORD + DwLineID DWORD + union1 DWORD + CControls DWORD + Cbmxctrl DWORD + storage1 [4]byte + storage2 [4]byte +} +type PRINTDLG struct { + storage [120]byte +} + +func (this *PRINTDLG) LStructSize() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[0])) +} +func (this *PRINTDLG) HwndOwner() *HWND { // 8 + return (*HWND)(unsafe.Pointer(&this.storage[8])) +} +func (this *PRINTDLG) HDevMode() *HGLOBAL { // 8 + return (*HGLOBAL)(unsafe.Pointer(&this.storage[16])) +} +func (this *PRINTDLG) HDevNames() *HGLOBAL { // 8 + return (*HGLOBAL)(unsafe.Pointer(&this.storage[24])) +} +func (this *PRINTDLG) HDC() *HDC { // 8 + return (*HDC)(unsafe.Pointer(&this.storage[32])) +} +func (this *PRINTDLG) Flags() *DWORD { // 4 + return (*DWORD)(unsafe.Pointer(&this.storage[40])) +} +func (this *PRINTDLG) NFromPage() *WORD { // 2 + return (*WORD)(unsafe.Pointer(&this.storage[44])) +} +func (this *PRINTDLG) NToPage() *WORD { // 2 + return (*WORD)(unsafe.Pointer(&this.storage[46])) +} +func (this *PRINTDLG) NMinPage() *WORD { // 2 + return (*WORD)(unsafe.Pointer(&this.storage[48])) +} +func (this *PRINTDLG) NMaxPage() *WORD { // 2 + return (*WORD)(unsafe.Pointer(&this.storage[50])) +} +func (this *PRINTDLG) NCopies() *WORD { // 2 + return (*WORD)(unsafe.Pointer(&this.storage[52])) +} +func (this *PRINTDLG) HInstance() *HINSTANCE { // 8 + return (*HINSTANCE)(unsafe.Pointer(&this.storage[56])) +} +func (this *PRINTDLG) LCustData() *LPARAM { // 8 + return (*LPARAM)(unsafe.Pointer(&this.storage[64])) +} +func (this *PRINTDLG) LpfnPrintHook() *uintptr { // 8 + return (*uintptr)(unsafe.Pointer(&this.storage[72])) +} +func (this *PRINTDLG) LpfnSetupHook() *uintptr { // 8 + return (*uintptr)(unsafe.Pointer(&this.storage[80])) +} +func (this *PRINTDLG) LpPrintTemplateName() *LPCWSTR { // 8 + return (*LPCWSTR)(unsafe.Pointer(&this.storage[88])) +} +func (this *PRINTDLG) LpSetupTemplateName() *LPCWSTR { // 8 + return (*LPCWSTR)(unsafe.Pointer(&this.storage[96])) +} +func (this *PRINTDLG) HPrintTemplate() *HGLOBAL { // 8 + return (*HGLOBAL)(unsafe.Pointer(&this.storage[104])) +} +func (this *PRINTDLG) HSetupTemplate() *HGLOBAL { // 8 + return (*HGLOBAL)(unsafe.Pointer(&this.storage[112])) +} + +type SIZE_T uint64 +type STRRET struct { + UType UINT + padding1 [4]byte + cStr [260]byte + padding2 [4]byte +} +type TASKDIALOGCONFIG struct { + storage [160]byte +} + +func (this *TASKDIALOGCONFIG) CbSize() *UINT { + return (*UINT)(unsafe.Pointer(&this.storage[0])) +} +func (this *TASKDIALOGCONFIG) HwndParent() *HWND { + return (*HWND)(unsafe.Pointer(&this.storage[4])) +} +func (this *TASKDIALOGCONFIG) HInstance() *HINSTANCE { + return (*HINSTANCE)(unsafe.Pointer(&this.storage[12])) +} +func (this *TASKDIALOGCONFIG) DwFlags() *TASKDIALOG_FLAGS { + return (*TASKDIALOG_FLAGS)(unsafe.Pointer(&this.storage[20])) +} +func (this *TASKDIALOGCONFIG) DwCommonButtons() *TASKDIALOG_COMMON_BUTTON_FLAGS { + return (*TASKDIALOG_COMMON_BUTTON_FLAGS)(unsafe.Pointer(&this.storage[24])) +} +func (this *TASKDIALOGCONFIG) PszWindowTitle() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[28])) +} +func (this *TASKDIALOGCONFIG) HMainIcon() *HICON { + return (*HICON)(unsafe.Pointer(&this.storage[36])) +} +func (this *TASKDIALOGCONFIG) PszMainIcon() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[36])) +} +func (this *TASKDIALOGCONFIG) PszMainInstruction() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[44])) +} +func (this *TASKDIALOGCONFIG) PszContent() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[52])) +} +func (this *TASKDIALOGCONFIG) CButtons() *UINT { + return (*UINT)(unsafe.Pointer(&this.storage[60])) +} +func (this *TASKDIALOGCONFIG) PButtons() **TASKDIALOG_BUTTON { + return (**TASKDIALOG_BUTTON)(unsafe.Pointer(&this.storage[64])) +} +func (this *TASKDIALOGCONFIG) NDefaultButton() *int32 { + return (*int32)(unsafe.Pointer(&this.storage[72])) +} +func (this *TASKDIALOGCONFIG) CRadioButtons() *UINT { + return (*UINT)(unsafe.Pointer(&this.storage[76])) +} +func (this *TASKDIALOGCONFIG) PRadioButtons() **TASKDIALOG_BUTTON { + return (**TASKDIALOG_BUTTON)(unsafe.Pointer(&this.storage[80])) +} +func (this *TASKDIALOGCONFIG) NDefaultRadioButton() *int32 { + return (*int32)(unsafe.Pointer(&this.storage[88])) +} +func (this *TASKDIALOGCONFIG) PszVerificationText() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[92])) +} +func (this *TASKDIALOGCONFIG) PszExpandedInformation() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[100])) +} +func (this *TASKDIALOGCONFIG) PszExpandedControlText() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[108])) +} +func (this *TASKDIALOGCONFIG) PszCollapsedControlText() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[116])) +} +func (this *TASKDIALOGCONFIG) HFooterIcon() *HICON { + return (*HICON)(unsafe.Pointer(&this.storage[124])) +} +func (this *TASKDIALOGCONFIG) PszFooterIcon() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[124])) +} +func (this *TASKDIALOGCONFIG) PszFooter() *PCWSTR { + return (*PCWSTR)(unsafe.Pointer(&this.storage[132])) +} +func (this *TASKDIALOGCONFIG) PfCallback() *uintptr { + return (*uintptr)(unsafe.Pointer(&this.storage[140])) +} +func (this *TASKDIALOGCONFIG) LpCallbackData() *LONG_PTR { + return (*LONG_PTR)(unsafe.Pointer(&this.storage[148])) +} +func (this *TASKDIALOGCONFIG) CxWidth() *UINT { + return (*UINT)(unsafe.Pointer(&this.storage[156])) +} + +type VARIANT struct { + union1 [24]byte +} + +func (this *VARIANT) PRecInfo() *IRecordInfo { + return (*IRecordInfo)(unsafe.Pointer(&this.union1[16])) +} + +type WSADATA struct { + WVersion uint16 + WHighVersion uint16 + IMaxSockets uint16 + IMaxUdpDg uint16 + LpVendorInfo *byte + SzDescription [WSADESCRIPTION_LEN + 1]byte + SzSystemStatus [WSASYS_STATUS_LEN + 1]byte +} diff --git a/grdp/win/user32.go b/grdp/win/user32.go new file mode 100644 index 0000000..ac8c0e6 --- /dev/null +++ b/grdp/win/user32.go @@ -0,0 +1,6144 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "syscall" + "unsafe" +) + +var ( + // Library + libuser32 uintptr + + // Functions + activateKeyboardLayout uintptr + adjustWindowRect uintptr + adjustWindowRectEx uintptr + allowSetForegroundWindow uintptr + animateWindow uintptr + anyPopup uintptr + appendMenu uintptr + arrangeIconicWindows uintptr + attachThreadInput uintptr + beginDeferWindowPos uintptr + beginPaint uintptr + blockInput uintptr + bringWindowToTop uintptr + broadcastSystemMessageEx uintptr + broadcastSystemMessage uintptr + callMsgFilter uintptr + callNextHookEx uintptr + callWindowProc uintptr + cascadeWindows uintptr + changeClipboardChain uintptr + changeDisplaySettingsEx uintptr + changeDisplaySettings uintptr + changeMenu uintptr + charLowerBuff uintptr + charLower uintptr + charNextExA uintptr + charNext uintptr + charPrevExA uintptr + charPrev uintptr + charToOemBuff uintptr + charToOem uintptr + charUpperBuff uintptr + charUpper uintptr + checkDlgButton uintptr + checkMenuItem uintptr + checkMenuRadioItem uintptr + checkRadioButton uintptr + childWindowFromPoint uintptr + childWindowFromPointEx uintptr + clientToScreen uintptr + clipCursor uintptr + closeClipboard uintptr + closeDesktop uintptr + closeGestureInfoHandle uintptr + closeTouchInputHandle uintptr + closeWindow uintptr + closeWindowStation uintptr + copyAcceleratorTable uintptr + copyIcon uintptr + copyImage uintptr + copyRect uintptr + countClipboardFormats uintptr + createAcceleratorTable uintptr + createCaret uintptr + createCursor uintptr + createDesktop uintptr + createDialogIndirectParam uintptr + createDialogParam uintptr + createIcon uintptr + createIconFromResource uintptr + createIconFromResourceEx uintptr + createIconIndirect uintptr + createMDIWindow uintptr + createMenu uintptr + createPopupMenu uintptr + createWindowEx uintptr + createWindowStation uintptr + ddeAbandonTransaction uintptr + ddeAccessData uintptr + ddeAddData uintptr + ddeClientTransaction uintptr + ddeCmpStringHandles uintptr + ddeConnect uintptr + ddeConnectList uintptr + ddeCreateDataHandle uintptr + ddeCreateStringHandle uintptr + ddeDisconnect uintptr + ddeDisconnectList uintptr + ddeEnableCallback uintptr + ddeFreeDataHandle uintptr + ddeFreeStringHandle uintptr + ddeGetData uintptr + ddeGetLastError uintptr + ddeImpersonateClient uintptr + ddeInitialize uintptr + ddeKeepStringHandle uintptr + ddeNameService uintptr + ddePostAdvise uintptr + ddeQueryConvInfo uintptr + ddeQueryNextServer uintptr + ddeQueryString uintptr + ddeReconnect uintptr + ddeSetQualityOfService uintptr + ddeSetUserHandle uintptr + ddeUnaccessData uintptr + ddeUninitialize uintptr + defDlgProc uintptr + defFrameProc uintptr + defMDIChildProc uintptr + defRawInputProc uintptr + defWindowProc uintptr + deferWindowPos uintptr + deleteMenu uintptr + deregisterShellHookWindow uintptr + destroyAcceleratorTable uintptr + destroyCaret uintptr + destroyCursor uintptr + destroyIcon uintptr + destroyMenu uintptr + destroyWindow uintptr + dialogBoxIndirectParam uintptr + dialogBoxParam uintptr + disableProcessWindowsGhosting uintptr + dispatchMessage uintptr + dlgDirListComboBox uintptr + dlgDirList uintptr + dlgDirSelectComboBoxEx uintptr + dlgDirSelectEx uintptr + dragDetect uintptr + dragObject uintptr + drawAnimatedRects uintptr + drawCaption uintptr + drawEdge uintptr + drawFocusRect uintptr + drawFrameControl uintptr + drawIcon uintptr + drawIconEx uintptr + drawMenuBar uintptr + drawState uintptr + drawTextEx uintptr + drawText uintptr + emptyClipboard uintptr + enableMenuItem uintptr + enableScrollBar uintptr + enableWindow uintptr + endDeferWindowPos uintptr + endDialog uintptr + endMenu uintptr + endPaint uintptr + endTask uintptr + enumChildWindows uintptr + enumClipboardFormats uintptr + enumDesktopWindows uintptr + enumDesktops uintptr + enumDisplayDevices uintptr + enumDisplayMonitors uintptr + enumDisplaySettingsEx uintptr + enumDisplaySettings uintptr + enumPropsEx uintptr + enumProps uintptr + enumThreadWindows uintptr + enumWindowStations uintptr + enumWindows uintptr + equalRect uintptr + excludeUpdateRgn uintptr + exitWindowsEx uintptr + fillRect uintptr + findWindowEx uintptr + findWindow uintptr + flashWindow uintptr + flashWindowEx uintptr + frameRect uintptr + freeDDElParam uintptr + getActiveWindow uintptr + getAltTabInfo uintptr + getAncestor uintptr + getAsyncKeyState uintptr + getCapture uintptr + getCaretBlinkTime uintptr + getCaretPos uintptr + getClassInfoEx uintptr + getClassInfo uintptr + getClassLongPtr uintptr + getClassLong uintptr + getClassName uintptr + getClassWord uintptr + getClientRect uintptr + getClipCursor uintptr + getClipboardData uintptr + getClipboardFormatName uintptr + getClipboardOwner uintptr + getClipboardSequenceNumber uintptr + getClipboardViewer uintptr + getComboBoxInfo uintptr + getCursor uintptr + getCursorInfo uintptr + getCursorPos uintptr + getDC uintptr + getDCEx uintptr + getDesktopWindow uintptr + getDialogBaseUnits uintptr + getDlgCtrlID uintptr + getDlgItem uintptr + getDlgItemInt uintptr + getDlgItemText uintptr + getDoubleClickTime uintptr + getFocus uintptr + getForegroundWindow uintptr + getGUIThreadInfo uintptr + getGestureConfig uintptr + getGestureExtraArgs uintptr + getGestureInfo uintptr + getGuiResources uintptr + getIconInfo uintptr + getInputState uintptr + getKBCodePage uintptr + getKeyNameText uintptr + getKeyState uintptr + getKeyboardLayout uintptr + getKeyboardLayoutList uintptr + getKeyboardLayoutName uintptr + getKeyboardState uintptr + getKeyboardType uintptr + getLastActivePopup uintptr + getLastInputInfo uintptr + getLayeredWindowAttributes uintptr + getListBoxInfo uintptr + getMenu uintptr + getMenuBarInfo uintptr + getMenuCheckMarkDimensions uintptr + getMenuContextHelpId uintptr + getMenuDefaultItem uintptr + getMenuInfo uintptr + getMenuItemCount uintptr + getMenuItemID uintptr + getMenuItemInfo uintptr + getMenuItemRect uintptr + getMenuState uintptr + getMenuString uintptr + getMessageExtraInfo uintptr + getMessagePos uintptr + getMessageTime uintptr + getMessage uintptr + getMonitorInfo uintptr + getMouseMovePointsEx uintptr + getNextDlgGroupItem uintptr + getNextDlgTabItem uintptr + getOpenClipboardWindow uintptr + getParent uintptr + getPriorityClipboardFormat uintptr + getProcessDefaultLayout uintptr + getProcessWindowStation uintptr + getProp uintptr + getQueueStatus uintptr + getRawInputBuffer uintptr + getRawInputData uintptr + getRawInputDeviceInfo uintptr + getRawInputDeviceList uintptr + getRegisteredRawInputDevices uintptr + getScrollBarInfo uintptr + getScrollInfo uintptr + getScrollPos uintptr + getScrollRange uintptr + getShellWindow uintptr + getSubMenu uintptr + getSysColor uintptr + getSysColorBrush uintptr + getSystemMenu uintptr + getSystemMetrics uintptr + getTabbedTextExtent uintptr + getThreadDesktop uintptr + getTitleBarInfo uintptr + getTopWindow uintptr + getTouchInputInfo uintptr + getUpdateRect uintptr + getUpdateRgn uintptr + getUserObjectInformation uintptr + getUserObjectSecurity uintptr + getWindow uintptr + getWindowContextHelpId uintptr + getWindowDC uintptr + getWindowInfo uintptr + getWindowLongPtr uintptr + getWindowLong uintptr + getWindowModuleFileName uintptr + getWindowPlacement uintptr + getWindowRect uintptr + getWindowRgn uintptr + getWindowRgnBox uintptr + getWindowTextLength uintptr + getWindowText uintptr + getWindowThreadProcessId uintptr + getWindowWord uintptr + grayString uintptr + hideCaret uintptr + hiliteMenuItem uintptr + iMPGetIME uintptr + iMPQueryIME uintptr + iMPSetIME uintptr + impersonateDdeClientWindow uintptr + inSendMessage uintptr + inSendMessageEx uintptr + inflateRect uintptr + insertMenuItem uintptr + insertMenu uintptr + internalGetWindowText uintptr + intersectRect uintptr + invalidateRect uintptr + invalidateRgn uintptr + invertRect uintptr + isCharAlphaNumeric uintptr + isCharAlpha uintptr + isCharLower uintptr + isCharUpper uintptr + isChild uintptr + isClipboardFormatAvailable uintptr + isDialogMessage uintptr + isDlgButtonChecked uintptr + isGUIThread uintptr + isHungAppWindow uintptr + isIconic uintptr + isMenu uintptr + isRectEmpty uintptr + isTouchWindow uintptr + isWinEventHookInstalled uintptr + isWindow uintptr + isWindowEnabled uintptr + isWindowUnicode uintptr + isWindowVisible uintptr + isWow64Message uintptr + isZoomed uintptr + killTimer uintptr + loadAccelerators uintptr + loadBitmap uintptr + loadCursorFromFile uintptr + loadCursor uintptr + loadIcon uintptr + loadImage uintptr + loadKeyboardLayout uintptr + loadMenuIndirect uintptr + loadMenu uintptr + loadString uintptr + lockSetForegroundWindow uintptr + lockWindowUpdate uintptr + lockWorkStation uintptr + lookupIconIdFromDirectory uintptr + lookupIconIdFromDirectoryEx uintptr + mapDialogRect uintptr + mapVirtualKeyEx uintptr + mapVirtualKey uintptr + mapWindowPoints uintptr + menuItemFromPoint uintptr + messageBeep uintptr + messageBoxEx uintptr + messageBoxIndirect uintptr + messageBox uintptr + modifyMenu uintptr + monitorFromPoint uintptr + monitorFromRect uintptr + monitorFromWindow uintptr + moveWindow uintptr + msgWaitForMultipleObjects uintptr + msgWaitForMultipleObjectsEx uintptr + notifyWinEvent uintptr + oemKeyScan uintptr + oemToCharBuff uintptr + oemToChar uintptr + offsetRect uintptr + openClipboard uintptr + openDesktop uintptr + openIcon uintptr + openInputDesktop uintptr + openWindowStation uintptr + packDDElParam uintptr + paintDesktop uintptr + peekMessage uintptr + postMessage uintptr + postQuitMessage uintptr + postThreadMessage uintptr + printWindow uintptr + privateExtractIcons uintptr + ptInRect uintptr + realChildWindowFromPoint uintptr + realGetWindowClass uintptr + redrawWindow uintptr + registerClassEx uintptr + registerClass uintptr + registerClipboardFormat uintptr + registerDeviceNotification uintptr + registerHotKey uintptr + registerPowerSettingNotification uintptr + registerRawInputDevices uintptr + registerShellHookWindow uintptr + registerTouchWindow uintptr + registerWindowMessage uintptr + releaseCapture uintptr + releaseDC uintptr + removeMenu uintptr + removeProp uintptr + replyMessage uintptr + reuseDDElParam uintptr + screenToClient uintptr + scrollDC uintptr + scrollWindow uintptr + scrollWindowEx uintptr + sendDlgItemMessage uintptr + sendIMEMessageEx uintptr + sendInput uintptr + sendMessageCallback uintptr + sendMessageTimeout uintptr + sendMessage uintptr + sendNotifyMessage uintptr + setActiveWindow uintptr + setCapture uintptr + setCaretBlinkTime uintptr + setCaretPos uintptr + setClassLongPtr uintptr + setClassLong uintptr + setClassWord uintptr + setClipboardData uintptr + setClipboardViewer uintptr + setCursor uintptr + setCursorPos uintptr + setDebugErrorLevel uintptr + setDlgItemInt uintptr + setDlgItemText uintptr + setDoubleClickTime uintptr + setFocus uintptr + setForegroundWindow uintptr + setGestureConfig uintptr + setKeyboardState uintptr + setLastErrorEx uintptr + setLayeredWindowAttributes uintptr + setMenu uintptr + setMenuContextHelpId uintptr + setMenuDefaultItem uintptr + setMenuInfo uintptr + setMenuItemBitmaps uintptr + setMenuItemInfo uintptr + setMessageExtraInfo uintptr + setMessageQueue uintptr + setParent uintptr + setProcessDefaultLayout uintptr + setProcessWindowStation uintptr + setProp uintptr + setRect uintptr + setRectEmpty uintptr + setScrollInfo uintptr + setScrollPos uintptr + setScrollRange uintptr + setSysColors uintptr + setSystemCursor uintptr + setThreadDesktop uintptr + setTimer uintptr + setUserObjectInformation uintptr + setUserObjectSecurity uintptr + setWinEventHook uintptr + setWindowContextHelpId uintptr + setWindowLongPtr uintptr + setWindowLong uintptr + setWindowPlacement uintptr + setWindowPos uintptr + setWindowRgn uintptr + setWindowText uintptr + setWindowWord uintptr + setWindowsHookEx uintptr + setWindowsHook uintptr + showCaret uintptr + showCursor uintptr + showOwnedPopups uintptr + showScrollBar uintptr + showWindow uintptr + showWindowAsync uintptr + subtractRect uintptr + swapMouseButton uintptr + switchDesktop uintptr + switchToThisWindow uintptr + systemParametersInfo uintptr + tabbedTextOut uintptr + tileWindows uintptr + toAscii uintptr + toAsciiEx uintptr + toUnicode uintptr + toUnicodeEx uintptr + trackMouseEvent uintptr + trackPopupMenu uintptr + trackPopupMenuEx uintptr + translateAccelerator uintptr + translateMDISysAccel uintptr + translateMessage uintptr + unhookWinEvent uintptr + unhookWindowsHook uintptr + unhookWindowsHookEx uintptr + unionRect uintptr + unloadKeyboardLayout uintptr + unpackDDElParam uintptr + unregisterClass uintptr + unregisterDeviceNotification uintptr + unregisterHotKey uintptr + unregisterPowerSettingNotification uintptr + unregisterTouchWindow uintptr + updateLayeredWindow uintptr + updateLayeredWindowIndirect uintptr + updateWindow uintptr + userHandleGrantAccess uintptr + validateRect uintptr + validateRgn uintptr + vkKeyScanEx uintptr + vkKeyScan uintptr + wINNLSEnableIME uintptr + wINNLSGetEnableStatus uintptr + wINNLSGetIMEHotkey uintptr + waitForInputIdle uintptr + waitMessage uintptr + winHelp uintptr + windowFromDC uintptr + windowFromPoint uintptr + keybd_event uintptr + mouse_event uintptr + alignRects uintptr + cascadeChildWindows uintptr + createDialogIndirectParamAorW uintptr + dialogBoxIndirectParamAorW uintptr + drawCaptionTemp uintptr + drawMenuBarTemp uintptr + getAppCompatFlags uintptr + getAppCompatFlags2 uintptr + getCursorFrameInfo uintptr + getInternalWindowPos uintptr + getProgmanWindow uintptr + getTaskmanWindow uintptr + killSystemTimer uintptr + loadLocalFonts uintptr + messageBoxTimeout uintptr + privateExtractIconEx uintptr + registerLogonProcess uintptr + registerServicesProcess uintptr + registerSystemThread uintptr + registerTasklist uintptr + scrollChildren uintptr + setInternalWindowPos uintptr + setLogonNotifyWindow uintptr + setProgmanWindow uintptr + setShellWindow uintptr + setShellWindowEx uintptr + setSysColorsTemp uintptr + setSystemMenu uintptr + setSystemTimer uintptr + setTaskmanWindow uintptr + setWindowStationUser uintptr + tileChildWindows uintptr + user32InitializeImmEntryTable uintptr + userRealizePalette uintptr + userRegisterWowHandlers uintptr + addClipboardFormatListener uintptr + removeClipboardFormatListener uintptr +) + +func init() { + // Library + libuser32 = doLoadLibrary("user32.dll") + + // Functions + activateKeyboardLayout = doGetProcAddress(libuser32, "ActivateKeyboardLayout") + adjustWindowRect = doGetProcAddress(libuser32, "AdjustWindowRect") + adjustWindowRectEx = doGetProcAddress(libuser32, "AdjustWindowRectEx") + allowSetForegroundWindow = doGetProcAddress(libuser32, "AllowSetForegroundWindow") + animateWindow = doGetProcAddress(libuser32, "AnimateWindow") + anyPopup = doGetProcAddress(libuser32, "AnyPopup") + appendMenu = doGetProcAddress(libuser32, "AppendMenuW") + arrangeIconicWindows = doGetProcAddress(libuser32, "ArrangeIconicWindows") + attachThreadInput = doGetProcAddress(libuser32, "AttachThreadInput") + beginDeferWindowPos = doGetProcAddress(libuser32, "BeginDeferWindowPos") + beginPaint = doGetProcAddress(libuser32, "BeginPaint") + blockInput = doGetProcAddress(libuser32, "BlockInput") + bringWindowToTop = doGetProcAddress(libuser32, "BringWindowToTop") + broadcastSystemMessageEx = doGetProcAddress(libuser32, "BroadcastSystemMessageExW") + broadcastSystemMessage = doGetProcAddress(libuser32, "BroadcastSystemMessageW") + callMsgFilter = doGetProcAddress(libuser32, "CallMsgFilterW") + callNextHookEx = doGetProcAddress(libuser32, "CallNextHookEx") + callWindowProc = doGetProcAddress(libuser32, "CallWindowProcW") + cascadeWindows = doGetProcAddress(libuser32, "CascadeWindows") + changeClipboardChain = doGetProcAddress(libuser32, "ChangeClipboardChain") + changeDisplaySettingsEx = doGetProcAddress(libuser32, "ChangeDisplaySettingsExW") + changeDisplaySettings = doGetProcAddress(libuser32, "ChangeDisplaySettingsW") + changeMenu = doGetProcAddress(libuser32, "ChangeMenuW") + charLowerBuff = doGetProcAddress(libuser32, "CharLowerBuffW") + charLower = doGetProcAddress(libuser32, "CharLowerW") + charNextExA = doGetProcAddress(libuser32, "CharNextExA") + charNext = doGetProcAddress(libuser32, "CharNextW") + charPrevExA = doGetProcAddress(libuser32, "CharPrevExA") + charPrev = doGetProcAddress(libuser32, "CharPrevW") + charToOemBuff = doGetProcAddress(libuser32, "CharToOemBuffW") + charToOem = doGetProcAddress(libuser32, "CharToOemW") + charUpperBuff = doGetProcAddress(libuser32, "CharUpperBuffW") + charUpper = doGetProcAddress(libuser32, "CharUpperW") + checkDlgButton = doGetProcAddress(libuser32, "CheckDlgButton") + checkMenuItem = doGetProcAddress(libuser32, "CheckMenuItem") + checkMenuRadioItem = doGetProcAddress(libuser32, "CheckMenuRadioItem") + checkRadioButton = doGetProcAddress(libuser32, "CheckRadioButton") + childWindowFromPoint = doGetProcAddress(libuser32, "ChildWindowFromPoint") + childWindowFromPointEx = doGetProcAddress(libuser32, "ChildWindowFromPointEx") + clientToScreen = doGetProcAddress(libuser32, "ClientToScreen") + clipCursor = doGetProcAddress(libuser32, "ClipCursor") + closeClipboard = doGetProcAddress(libuser32, "CloseClipboard") + closeDesktop = doGetProcAddress(libuser32, "CloseDesktop") + closeGestureInfoHandle = doGetProcAddress(libuser32, "CloseGestureInfoHandle") + closeTouchInputHandle = doGetProcAddress(libuser32, "CloseTouchInputHandle") + closeWindow = doGetProcAddress(libuser32, "CloseWindow") + closeWindowStation = doGetProcAddress(libuser32, "CloseWindowStation") + copyAcceleratorTable = doGetProcAddress(libuser32, "CopyAcceleratorTableW") + copyIcon = doGetProcAddress(libuser32, "CopyIcon") + copyImage = doGetProcAddress(libuser32, "CopyImage") + copyRect = doGetProcAddress(libuser32, "CopyRect") + countClipboardFormats = doGetProcAddress(libuser32, "CountClipboardFormats") + createAcceleratorTable = doGetProcAddress(libuser32, "CreateAcceleratorTableW") + createCaret = doGetProcAddress(libuser32, "CreateCaret") + createCursor = doGetProcAddress(libuser32, "CreateCursor") + createDesktop = doGetProcAddress(libuser32, "CreateDesktopW") + createDialogIndirectParam = doGetProcAddress(libuser32, "CreateDialogIndirectParamW") + createDialogParam = doGetProcAddress(libuser32, "CreateDialogParamW") + createIcon = doGetProcAddress(libuser32, "CreateIcon") + createIconFromResource = doGetProcAddress(libuser32, "CreateIconFromResource") + createIconFromResourceEx = doGetProcAddress(libuser32, "CreateIconFromResourceEx") + createIconIndirect = doGetProcAddress(libuser32, "CreateIconIndirect") + createMDIWindow = doGetProcAddress(libuser32, "CreateMDIWindowW") + createMenu = doGetProcAddress(libuser32, "CreateMenu") + createPopupMenu = doGetProcAddress(libuser32, "CreatePopupMenu") + createWindowEx = doGetProcAddress(libuser32, "CreateWindowExW") + createWindowStation = doGetProcAddress(libuser32, "CreateWindowStationW") + ddeAbandonTransaction = doGetProcAddress(libuser32, "DdeAbandonTransaction") + ddeAccessData = doGetProcAddress(libuser32, "DdeAccessData") + ddeAddData = doGetProcAddress(libuser32, "DdeAddData") + ddeClientTransaction = doGetProcAddress(libuser32, "DdeClientTransaction") + ddeCmpStringHandles = doGetProcAddress(libuser32, "DdeCmpStringHandles") + ddeConnect = doGetProcAddress(libuser32, "DdeConnect") + ddeConnectList = doGetProcAddress(libuser32, "DdeConnectList") + ddeCreateDataHandle = doGetProcAddress(libuser32, "DdeCreateDataHandle") + ddeCreateStringHandle = doGetProcAddress(libuser32, "DdeCreateStringHandleW") + ddeDisconnect = doGetProcAddress(libuser32, "DdeDisconnect") + ddeDisconnectList = doGetProcAddress(libuser32, "DdeDisconnectList") + ddeEnableCallback = doGetProcAddress(libuser32, "DdeEnableCallback") + ddeFreeDataHandle = doGetProcAddress(libuser32, "DdeFreeDataHandle") + ddeFreeStringHandle = doGetProcAddress(libuser32, "DdeFreeStringHandle") + ddeGetData = doGetProcAddress(libuser32, "DdeGetData") + ddeGetLastError = doGetProcAddress(libuser32, "DdeGetLastError") + ddeImpersonateClient = doGetProcAddress(libuser32, "DdeImpersonateClient") + ddeInitialize = doGetProcAddress(libuser32, "DdeInitializeW") + ddeKeepStringHandle = doGetProcAddress(libuser32, "DdeKeepStringHandle") + ddeNameService = doGetProcAddress(libuser32, "DdeNameService") + ddePostAdvise = doGetProcAddress(libuser32, "DdePostAdvise") + ddeQueryConvInfo = doGetProcAddress(libuser32, "DdeQueryConvInfo") + ddeQueryNextServer = doGetProcAddress(libuser32, "DdeQueryNextServer") + ddeQueryString = doGetProcAddress(libuser32, "DdeQueryStringW") + ddeReconnect = doGetProcAddress(libuser32, "DdeReconnect") + ddeSetQualityOfService = doGetProcAddress(libuser32, "DdeSetQualityOfService") + ddeSetUserHandle = doGetProcAddress(libuser32, "DdeSetUserHandle") + ddeUnaccessData = doGetProcAddress(libuser32, "DdeUnaccessData") + ddeUninitialize = doGetProcAddress(libuser32, "DdeUninitialize") + defDlgProc = doGetProcAddress(libuser32, "DefDlgProcW") + defFrameProc = doGetProcAddress(libuser32, "DefFrameProcW") + defMDIChildProc = doGetProcAddress(libuser32, "DefMDIChildProcW") + defRawInputProc = doGetProcAddress(libuser32, "DefRawInputProc") + defWindowProc = doGetProcAddress(libuser32, "DefWindowProcW") + deferWindowPos = doGetProcAddress(libuser32, "DeferWindowPos") + deleteMenu = doGetProcAddress(libuser32, "DeleteMenu") + deregisterShellHookWindow = doGetProcAddress(libuser32, "DeregisterShellHookWindow") + destroyAcceleratorTable = doGetProcAddress(libuser32, "DestroyAcceleratorTable") + destroyCaret = doGetProcAddress(libuser32, "DestroyCaret") + destroyCursor = doGetProcAddress(libuser32, "DestroyCursor") + destroyIcon = doGetProcAddress(libuser32, "DestroyIcon") + destroyMenu = doGetProcAddress(libuser32, "DestroyMenu") + destroyWindow = doGetProcAddress(libuser32, "DestroyWindow") + dialogBoxIndirectParam = doGetProcAddress(libuser32, "DialogBoxIndirectParamW") + dialogBoxParam = doGetProcAddress(libuser32, "DialogBoxParamW") + disableProcessWindowsGhosting = doGetProcAddress(libuser32, "DisableProcessWindowsGhosting") + dispatchMessage = doGetProcAddress(libuser32, "DispatchMessageW") + dlgDirListComboBox = doGetProcAddress(libuser32, "DlgDirListComboBoxW") + dlgDirList = doGetProcAddress(libuser32, "DlgDirListW") + dlgDirSelectComboBoxEx = doGetProcAddress(libuser32, "DlgDirSelectComboBoxExW") + dlgDirSelectEx = doGetProcAddress(libuser32, "DlgDirSelectExW") + dragDetect = doGetProcAddress(libuser32, "DragDetect") + dragObject = doGetProcAddress(libuser32, "DragObject") + drawAnimatedRects = doGetProcAddress(libuser32, "DrawAnimatedRects") + drawCaption = doGetProcAddress(libuser32, "DrawCaption") + drawEdge = doGetProcAddress(libuser32, "DrawEdge") + drawFocusRect = doGetProcAddress(libuser32, "DrawFocusRect") + drawFrameControl = doGetProcAddress(libuser32, "DrawFrameControl") + drawIcon = doGetProcAddress(libuser32, "DrawIcon") + drawIconEx = doGetProcAddress(libuser32, "DrawIconEx") + drawMenuBar = doGetProcAddress(libuser32, "DrawMenuBar") + drawState = doGetProcAddress(libuser32, "DrawStateW") + drawTextEx = doGetProcAddress(libuser32, "DrawTextExW") + drawText = doGetProcAddress(libuser32, "DrawTextW") + emptyClipboard = doGetProcAddress(libuser32, "EmptyClipboard") + enableMenuItem = doGetProcAddress(libuser32, "EnableMenuItem") + enableScrollBar = doGetProcAddress(libuser32, "EnableScrollBar") + enableWindow = doGetProcAddress(libuser32, "EnableWindow") + endDeferWindowPos = doGetProcAddress(libuser32, "EndDeferWindowPos") + endDialog = doGetProcAddress(libuser32, "EndDialog") + endMenu = doGetProcAddress(libuser32, "EndMenu") + endPaint = doGetProcAddress(libuser32, "EndPaint") + endTask = doGetProcAddress(libuser32, "EndTask") + enumChildWindows = doGetProcAddress(libuser32, "EnumChildWindows") + enumClipboardFormats = doGetProcAddress(libuser32, "EnumClipboardFormats") + enumDesktopWindows = doGetProcAddress(libuser32, "EnumDesktopWindows") + enumDesktops = doGetProcAddress(libuser32, "EnumDesktopsW") + enumDisplayDevices = doGetProcAddress(libuser32, "EnumDisplayDevicesW") + enumDisplayMonitors = doGetProcAddress(libuser32, "EnumDisplayMonitors") + enumDisplaySettingsEx = doGetProcAddress(libuser32, "EnumDisplaySettingsExW") + enumDisplaySettings = doGetProcAddress(libuser32, "EnumDisplaySettingsW") + enumPropsEx = doGetProcAddress(libuser32, "EnumPropsExW") + enumProps = doGetProcAddress(libuser32, "EnumPropsW") + enumThreadWindows = doGetProcAddress(libuser32, "EnumThreadWindows") + enumWindowStations = doGetProcAddress(libuser32, "EnumWindowStationsW") + enumWindows = doGetProcAddress(libuser32, "EnumWindows") + equalRect = doGetProcAddress(libuser32, "EqualRect") + excludeUpdateRgn = doGetProcAddress(libuser32, "ExcludeUpdateRgn") + exitWindowsEx = doGetProcAddress(libuser32, "ExitWindowsEx") + fillRect = doGetProcAddress(libuser32, "FillRect") + findWindowEx = doGetProcAddress(libuser32, "FindWindowExW") + findWindow = doGetProcAddress(libuser32, "FindWindowW") + flashWindow = doGetProcAddress(libuser32, "FlashWindow") + flashWindowEx = doGetProcAddress(libuser32, "FlashWindowEx") + frameRect = doGetProcAddress(libuser32, "FrameRect") + freeDDElParam = doGetProcAddress(libuser32, "FreeDDElParam") + getActiveWindow = doGetProcAddress(libuser32, "GetActiveWindow") + getAltTabInfo = doGetProcAddress(libuser32, "GetAltTabInfoW") + getAncestor = doGetProcAddress(libuser32, "GetAncestor") + getAsyncKeyState = doGetProcAddress(libuser32, "GetAsyncKeyState") + getCapture = doGetProcAddress(libuser32, "GetCapture") + getCaretBlinkTime = doGetProcAddress(libuser32, "GetCaretBlinkTime") + getCaretPos = doGetProcAddress(libuser32, "GetCaretPos") + getClassInfoEx = doGetProcAddress(libuser32, "GetClassInfoExW") + getClassInfo = doGetProcAddress(libuser32, "GetClassInfoW") + getClassLongPtr = doGetProcAddress(libuser32, "GetClassLongPtrW") + getClassLong = doGetProcAddress(libuser32, "GetClassLongW") + getClassName = doGetProcAddress(libuser32, "GetClassNameW") + getClassWord = doGetProcAddress(libuser32, "GetClassWord") + getClientRect = doGetProcAddress(libuser32, "GetClientRect") + getClipCursor = doGetProcAddress(libuser32, "GetClipCursor") + getClipboardData = doGetProcAddress(libuser32, "GetClipboardData") + getClipboardFormatName = doGetProcAddress(libuser32, "GetClipboardFormatNameW") + getClipboardOwner = doGetProcAddress(libuser32, "GetClipboardOwner") + getClipboardSequenceNumber = doGetProcAddress(libuser32, "GetClipboardSequenceNumber") + getClipboardViewer = doGetProcAddress(libuser32, "GetClipboardViewer") + getComboBoxInfo = doGetProcAddress(libuser32, "GetComboBoxInfo") + getCursor = doGetProcAddress(libuser32, "GetCursor") + getCursorInfo = doGetProcAddress(libuser32, "GetCursorInfo") + getCursorPos = doGetProcAddress(libuser32, "GetCursorPos") + getDC = doGetProcAddress(libuser32, "GetDC") + getDCEx = doGetProcAddress(libuser32, "GetDCEx") + getDesktopWindow = doGetProcAddress(libuser32, "GetDesktopWindow") + getDialogBaseUnits = doGetProcAddress(libuser32, "GetDialogBaseUnits") + getDlgCtrlID = doGetProcAddress(libuser32, "GetDlgCtrlID") + getDlgItem = doGetProcAddress(libuser32, "GetDlgItem") + getDlgItemInt = doGetProcAddress(libuser32, "GetDlgItemInt") + getDlgItemText = doGetProcAddress(libuser32, "GetDlgItemTextW") + getDoubleClickTime = doGetProcAddress(libuser32, "GetDoubleClickTime") + getFocus = doGetProcAddress(libuser32, "GetFocus") + getForegroundWindow = doGetProcAddress(libuser32, "GetForegroundWindow") + getGUIThreadInfo = doGetProcAddress(libuser32, "GetGUIThreadInfo") + getGestureConfig = doGetProcAddress(libuser32, "GetGestureConfig") + getGestureExtraArgs = doGetProcAddress(libuser32, "GetGestureExtraArgs") + getGestureInfo = doGetProcAddress(libuser32, "GetGestureInfo") + getGuiResources = doGetProcAddress(libuser32, "GetGuiResources") + getIconInfo = doGetProcAddress(libuser32, "GetIconInfo") + getInputState = doGetProcAddress(libuser32, "GetInputState") + getKBCodePage = doGetProcAddress(libuser32, "GetKBCodePage") + getKeyNameText = doGetProcAddress(libuser32, "GetKeyNameTextW") + getKeyState = doGetProcAddress(libuser32, "GetKeyState") + getKeyboardLayout = doGetProcAddress(libuser32, "GetKeyboardLayout") + getKeyboardLayoutList = doGetProcAddress(libuser32, "GetKeyboardLayoutList") + getKeyboardLayoutName = doGetProcAddress(libuser32, "GetKeyboardLayoutNameW") + getKeyboardState = doGetProcAddress(libuser32, "GetKeyboardState") + getKeyboardType = doGetProcAddress(libuser32, "GetKeyboardType") + getLastActivePopup = doGetProcAddress(libuser32, "GetLastActivePopup") + getLastInputInfo = doGetProcAddress(libuser32, "GetLastInputInfo") + getLayeredWindowAttributes = doGetProcAddress(libuser32, "GetLayeredWindowAttributes") + getListBoxInfo = doGetProcAddress(libuser32, "GetListBoxInfo") + getMenu = doGetProcAddress(libuser32, "GetMenu") + getMenuBarInfo = doGetProcAddress(libuser32, "GetMenuBarInfo") + getMenuCheckMarkDimensions = doGetProcAddress(libuser32, "GetMenuCheckMarkDimensions") + getMenuContextHelpId = doGetProcAddress(libuser32, "GetMenuContextHelpId") + getMenuDefaultItem = doGetProcAddress(libuser32, "GetMenuDefaultItem") + getMenuInfo = doGetProcAddress(libuser32, "GetMenuInfo") + getMenuItemCount = doGetProcAddress(libuser32, "GetMenuItemCount") + getMenuItemID = doGetProcAddress(libuser32, "GetMenuItemID") + getMenuItemInfo = doGetProcAddress(libuser32, "GetMenuItemInfoW") + getMenuItemRect = doGetProcAddress(libuser32, "GetMenuItemRect") + getMenuState = doGetProcAddress(libuser32, "GetMenuState") + getMenuString = doGetProcAddress(libuser32, "GetMenuStringW") + getMessageExtraInfo = doGetProcAddress(libuser32, "GetMessageExtraInfo") + getMessagePos = doGetProcAddress(libuser32, "GetMessagePos") + getMessageTime = doGetProcAddress(libuser32, "GetMessageTime") + getMessage = doGetProcAddress(libuser32, "GetMessageW") + getMonitorInfo = doGetProcAddress(libuser32, "GetMonitorInfoW") + getMouseMovePointsEx = doGetProcAddress(libuser32, "GetMouseMovePointsEx") + getNextDlgGroupItem = doGetProcAddress(libuser32, "GetNextDlgGroupItem") + getNextDlgTabItem = doGetProcAddress(libuser32, "GetNextDlgTabItem") + getOpenClipboardWindow = doGetProcAddress(libuser32, "GetOpenClipboardWindow") + getParent = doGetProcAddress(libuser32, "GetParent") + getPriorityClipboardFormat = doGetProcAddress(libuser32, "GetPriorityClipboardFormat") + getProcessDefaultLayout = doGetProcAddress(libuser32, "GetProcessDefaultLayout") + getProcessWindowStation = doGetProcAddress(libuser32, "GetProcessWindowStation") + getProp = doGetProcAddress(libuser32, "GetPropW") + getQueueStatus = doGetProcAddress(libuser32, "GetQueueStatus") + getRawInputBuffer = doGetProcAddress(libuser32, "GetRawInputBuffer") + getRawInputData = doGetProcAddress(libuser32, "GetRawInputData") + getRawInputDeviceInfo = doGetProcAddress(libuser32, "GetRawInputDeviceInfoW") + getRawInputDeviceList = doGetProcAddress(libuser32, "GetRawInputDeviceList") + getRegisteredRawInputDevices = doGetProcAddress(libuser32, "GetRegisteredRawInputDevices") + getScrollBarInfo = doGetProcAddress(libuser32, "GetScrollBarInfo") + getScrollInfo = doGetProcAddress(libuser32, "GetScrollInfo") + getScrollPos = doGetProcAddress(libuser32, "GetScrollPos") + getScrollRange = doGetProcAddress(libuser32, "GetScrollRange") + getShellWindow = doGetProcAddress(libuser32, "GetShellWindow") + getSubMenu = doGetProcAddress(libuser32, "GetSubMenu") + getSysColor = doGetProcAddress(libuser32, "GetSysColor") + getSysColorBrush = doGetProcAddress(libuser32, "GetSysColorBrush") + getSystemMenu = doGetProcAddress(libuser32, "GetSystemMenu") + getSystemMetrics = doGetProcAddress(libuser32, "GetSystemMetrics") + getTabbedTextExtent = doGetProcAddress(libuser32, "GetTabbedTextExtentW") + getThreadDesktop = doGetProcAddress(libuser32, "GetThreadDesktop") + getTitleBarInfo = doGetProcAddress(libuser32, "GetTitleBarInfo") + getTopWindow = doGetProcAddress(libuser32, "GetTopWindow") + getTouchInputInfo = doGetProcAddress(libuser32, "GetTouchInputInfo") + getUpdateRect = doGetProcAddress(libuser32, "GetUpdateRect") + getUpdateRgn = doGetProcAddress(libuser32, "GetUpdateRgn") + getUserObjectInformation = doGetProcAddress(libuser32, "GetUserObjectInformationW") + getUserObjectSecurity = doGetProcAddress(libuser32, "GetUserObjectSecurity") + getWindow = doGetProcAddress(libuser32, "GetWindow") + getWindowContextHelpId = doGetProcAddress(libuser32, "GetWindowContextHelpId") + getWindowDC = doGetProcAddress(libuser32, "GetWindowDC") + getWindowInfo = doGetProcAddress(libuser32, "GetWindowInfo") + getWindowLongPtr = doGetProcAddress(libuser32, "GetWindowLongPtrW") + getWindowLong = doGetProcAddress(libuser32, "GetWindowLongW") + getWindowModuleFileName = doGetProcAddress(libuser32, "GetWindowModuleFileNameW") + getWindowPlacement = doGetProcAddress(libuser32, "GetWindowPlacement") + getWindowRect = doGetProcAddress(libuser32, "GetWindowRect") + getWindowRgn = doGetProcAddress(libuser32, "GetWindowRgn") + getWindowRgnBox = doGetProcAddress(libuser32, "GetWindowRgnBox") + getWindowTextLength = doGetProcAddress(libuser32, "GetWindowTextLengthW") + getWindowText = doGetProcAddress(libuser32, "GetWindowTextW") + getWindowThreadProcessId = doGetProcAddress(libuser32, "GetWindowThreadProcessId") + getWindowWord = doGetProcAddress(libuser32, "GetWindowWord") + grayString = doGetProcAddress(libuser32, "GrayStringW") + hideCaret = doGetProcAddress(libuser32, "HideCaret") + hiliteMenuItem = doGetProcAddress(libuser32, "HiliteMenuItem") + iMPGetIME = doGetProcAddress(libuser32, "IMPGetIMEW") + iMPQueryIME = doGetProcAddress(libuser32, "IMPQueryIMEW") + iMPSetIME = doGetProcAddress(libuser32, "IMPSetIMEW") + impersonateDdeClientWindow = doGetProcAddress(libuser32, "ImpersonateDdeClientWindow") + inSendMessage = doGetProcAddress(libuser32, "InSendMessage") + inSendMessageEx = doGetProcAddress(libuser32, "InSendMessageEx") + inflateRect = doGetProcAddress(libuser32, "InflateRect") + insertMenuItem = doGetProcAddress(libuser32, "InsertMenuItemW") + insertMenu = doGetProcAddress(libuser32, "InsertMenuW") + internalGetWindowText = doGetProcAddress(libuser32, "InternalGetWindowText") + intersectRect = doGetProcAddress(libuser32, "IntersectRect") + invalidateRect = doGetProcAddress(libuser32, "InvalidateRect") + invalidateRgn = doGetProcAddress(libuser32, "InvalidateRgn") + invertRect = doGetProcAddress(libuser32, "InvertRect") + isCharAlphaNumeric = doGetProcAddress(libuser32, "IsCharAlphaNumericW") + isCharAlpha = doGetProcAddress(libuser32, "IsCharAlphaW") + isCharLower = doGetProcAddress(libuser32, "IsCharLowerW") + isCharUpper = doGetProcAddress(libuser32, "IsCharUpperW") + isChild = doGetProcAddress(libuser32, "IsChild") + isClipboardFormatAvailable = doGetProcAddress(libuser32, "IsClipboardFormatAvailable") + isDialogMessage = doGetProcAddress(libuser32, "IsDialogMessageW") + isDlgButtonChecked = doGetProcAddress(libuser32, "IsDlgButtonChecked") + isGUIThread = doGetProcAddress(libuser32, "IsGUIThread") + isHungAppWindow = doGetProcAddress(libuser32, "IsHungAppWindow") + isIconic = doGetProcAddress(libuser32, "IsIconic") + isMenu = doGetProcAddress(libuser32, "IsMenu") + isRectEmpty = doGetProcAddress(libuser32, "IsRectEmpty") + isTouchWindow = doGetProcAddress(libuser32, "IsTouchWindow") + isWinEventHookInstalled = doGetProcAddress(libuser32, "IsWinEventHookInstalled") + isWindow = doGetProcAddress(libuser32, "IsWindow") + isWindowEnabled = doGetProcAddress(libuser32, "IsWindowEnabled") + isWindowUnicode = doGetProcAddress(libuser32, "IsWindowUnicode") + isWindowVisible = doGetProcAddress(libuser32, "IsWindowVisible") + isWow64Message = doGetProcAddress(libuser32, "IsWow64Message") + isZoomed = doGetProcAddress(libuser32, "IsZoomed") + killTimer = doGetProcAddress(libuser32, "KillTimer") + loadAccelerators = doGetProcAddress(libuser32, "LoadAcceleratorsW") + loadBitmap = doGetProcAddress(libuser32, "LoadBitmapW") + loadCursorFromFile = doGetProcAddress(libuser32, "LoadCursorFromFileW") + loadCursor = doGetProcAddress(libuser32, "LoadCursorW") + loadIcon = doGetProcAddress(libuser32, "LoadIconW") + loadImage = doGetProcAddress(libuser32, "LoadImageW") + loadKeyboardLayout = doGetProcAddress(libuser32, "LoadKeyboardLayoutW") + loadMenuIndirect = doGetProcAddress(libuser32, "LoadMenuIndirectW") + loadMenu = doGetProcAddress(libuser32, "LoadMenuW") + loadString = doGetProcAddress(libuser32, "LoadStringW") + lockSetForegroundWindow = doGetProcAddress(libuser32, "LockSetForegroundWindow") + lockWindowUpdate = doGetProcAddress(libuser32, "LockWindowUpdate") + lockWorkStation = doGetProcAddress(libuser32, "LockWorkStation") + lookupIconIdFromDirectory = doGetProcAddress(libuser32, "LookupIconIdFromDirectory") + lookupIconIdFromDirectoryEx = doGetProcAddress(libuser32, "LookupIconIdFromDirectoryEx") + mapDialogRect = doGetProcAddress(libuser32, "MapDialogRect") + mapVirtualKeyEx = doGetProcAddress(libuser32, "MapVirtualKeyExW") + mapVirtualKey = doGetProcAddress(libuser32, "MapVirtualKeyW") + mapWindowPoints = doGetProcAddress(libuser32, "MapWindowPoints") + menuItemFromPoint = doGetProcAddress(libuser32, "MenuItemFromPoint") + messageBeep = doGetProcAddress(libuser32, "MessageBeep") + messageBoxEx = doGetProcAddress(libuser32, "MessageBoxExW") + messageBoxIndirect = doGetProcAddress(libuser32, "MessageBoxIndirectW") + messageBox = doGetProcAddress(libuser32, "MessageBoxW") + modifyMenu = doGetProcAddress(libuser32, "ModifyMenuW") + monitorFromPoint = doGetProcAddress(libuser32, "MonitorFromPoint") + monitorFromRect = doGetProcAddress(libuser32, "MonitorFromRect") + monitorFromWindow = doGetProcAddress(libuser32, "MonitorFromWindow") + moveWindow = doGetProcAddress(libuser32, "MoveWindow") + msgWaitForMultipleObjects = doGetProcAddress(libuser32, "MsgWaitForMultipleObjects") + msgWaitForMultipleObjectsEx = doGetProcAddress(libuser32, "MsgWaitForMultipleObjectsEx") + notifyWinEvent = doGetProcAddress(libuser32, "NotifyWinEvent") + oemKeyScan = doGetProcAddress(libuser32, "OemKeyScan") + oemToCharBuff = doGetProcAddress(libuser32, "OemToCharBuffW") + oemToChar = doGetProcAddress(libuser32, "OemToCharW") + offsetRect = doGetProcAddress(libuser32, "OffsetRect") + openClipboard = doGetProcAddress(libuser32, "OpenClipboard") + openDesktop = doGetProcAddress(libuser32, "OpenDesktopW") + openIcon = doGetProcAddress(libuser32, "OpenIcon") + openInputDesktop = doGetProcAddress(libuser32, "OpenInputDesktop") + openWindowStation = doGetProcAddress(libuser32, "OpenWindowStationW") + packDDElParam = doGetProcAddress(libuser32, "PackDDElParam") + paintDesktop = doGetProcAddress(libuser32, "PaintDesktop") + peekMessage = doGetProcAddress(libuser32, "PeekMessageW") + postMessage = doGetProcAddress(libuser32, "PostMessageW") + postQuitMessage = doGetProcAddress(libuser32, "PostQuitMessage") + postThreadMessage = doGetProcAddress(libuser32, "PostThreadMessageW") + printWindow = doGetProcAddress(libuser32, "PrintWindow") + privateExtractIcons = doGetProcAddress(libuser32, "PrivateExtractIconsW") + ptInRect = doGetProcAddress(libuser32, "PtInRect") + realChildWindowFromPoint = doGetProcAddress(libuser32, "RealChildWindowFromPoint") + realGetWindowClass = doGetProcAddress(libuser32, "RealGetWindowClassW") + redrawWindow = doGetProcAddress(libuser32, "RedrawWindow") + registerClassEx = doGetProcAddress(libuser32, "RegisterClassExW") + registerClass = doGetProcAddress(libuser32, "RegisterClassW") + registerClipboardFormat = doGetProcAddress(libuser32, "RegisterClipboardFormatW") + registerDeviceNotification = doGetProcAddress(libuser32, "RegisterDeviceNotificationW") + registerHotKey = doGetProcAddress(libuser32, "RegisterHotKey") + registerPowerSettingNotification = doGetProcAddress(libuser32, "RegisterPowerSettingNotification") + registerRawInputDevices = doGetProcAddress(libuser32, "RegisterRawInputDevices") + registerShellHookWindow = doGetProcAddress(libuser32, "RegisterShellHookWindow") + registerTouchWindow = doGetProcAddress(libuser32, "RegisterTouchWindow") + registerWindowMessage = doGetProcAddress(libuser32, "RegisterWindowMessageW") + releaseCapture = doGetProcAddress(libuser32, "ReleaseCapture") + releaseDC = doGetProcAddress(libuser32, "ReleaseDC") + removeMenu = doGetProcAddress(libuser32, "RemoveMenu") + removeProp = doGetProcAddress(libuser32, "RemovePropW") + replyMessage = doGetProcAddress(libuser32, "ReplyMessage") + reuseDDElParam = doGetProcAddress(libuser32, "ReuseDDElParam") + screenToClient = doGetProcAddress(libuser32, "ScreenToClient") + scrollDC = doGetProcAddress(libuser32, "ScrollDC") + scrollWindow = doGetProcAddress(libuser32, "ScrollWindow") + scrollWindowEx = doGetProcAddress(libuser32, "ScrollWindowEx") + sendDlgItemMessage = doGetProcAddress(libuser32, "SendDlgItemMessageW") + sendIMEMessageEx = doGetProcAddress(libuser32, "SendIMEMessageExW") + sendInput = doGetProcAddress(libuser32, "SendInput") + sendMessageCallback = doGetProcAddress(libuser32, "SendMessageCallbackW") + sendMessageTimeout = doGetProcAddress(libuser32, "SendMessageTimeoutW") + sendMessage = doGetProcAddress(libuser32, "SendMessageW") + sendNotifyMessage = doGetProcAddress(libuser32, "SendNotifyMessageW") + setActiveWindow = doGetProcAddress(libuser32, "SetActiveWindow") + setCapture = doGetProcAddress(libuser32, "SetCapture") + setCaretBlinkTime = doGetProcAddress(libuser32, "SetCaretBlinkTime") + setCaretPos = doGetProcAddress(libuser32, "SetCaretPos") + setClassLongPtr = doGetProcAddress(libuser32, "SetClassLongPtrW") + setClassLong = doGetProcAddress(libuser32, "SetClassLongW") + setClassWord = doGetProcAddress(libuser32, "SetClassWord") + setClipboardData = doGetProcAddress(libuser32, "SetClipboardData") + setClipboardViewer = doGetProcAddress(libuser32, "SetClipboardViewer") + setCursor = doGetProcAddress(libuser32, "SetCursor") + setCursorPos = doGetProcAddress(libuser32, "SetCursorPos") + setDebugErrorLevel = doGetProcAddress(libuser32, "SetDebugErrorLevel") + setDlgItemInt = doGetProcAddress(libuser32, "SetDlgItemInt") + setDlgItemText = doGetProcAddress(libuser32, "SetDlgItemTextW") + setDoubleClickTime = doGetProcAddress(libuser32, "SetDoubleClickTime") + setFocus = doGetProcAddress(libuser32, "SetFocus") + setForegroundWindow = doGetProcAddress(libuser32, "SetForegroundWindow") + setGestureConfig = doGetProcAddress(libuser32, "SetGestureConfig") + setKeyboardState = doGetProcAddress(libuser32, "SetKeyboardState") + setLastErrorEx = doGetProcAddress(libuser32, "SetLastErrorEx") + setLayeredWindowAttributes = doGetProcAddress(libuser32, "SetLayeredWindowAttributes") + setMenu = doGetProcAddress(libuser32, "SetMenu") + setMenuContextHelpId = doGetProcAddress(libuser32, "SetMenuContextHelpId") + setMenuDefaultItem = doGetProcAddress(libuser32, "SetMenuDefaultItem") + setMenuInfo = doGetProcAddress(libuser32, "SetMenuInfo") + setMenuItemBitmaps = doGetProcAddress(libuser32, "SetMenuItemBitmaps") + setMenuItemInfo = doGetProcAddress(libuser32, "SetMenuItemInfoW") + setMessageExtraInfo = doGetProcAddress(libuser32, "SetMessageExtraInfo") + setMessageQueue = doGetProcAddress(libuser32, "SetMessageQueue") + setParent = doGetProcAddress(libuser32, "SetParent") + setProcessDefaultLayout = doGetProcAddress(libuser32, "SetProcessDefaultLayout") + setProcessWindowStation = doGetProcAddress(libuser32, "SetProcessWindowStation") + setProp = doGetProcAddress(libuser32, "SetPropW") + setRect = doGetProcAddress(libuser32, "SetRect") + setRectEmpty = doGetProcAddress(libuser32, "SetRectEmpty") + setScrollInfo = doGetProcAddress(libuser32, "SetScrollInfo") + setScrollPos = doGetProcAddress(libuser32, "SetScrollPos") + setScrollRange = doGetProcAddress(libuser32, "SetScrollRange") + setSysColors = doGetProcAddress(libuser32, "SetSysColors") + setSystemCursor = doGetProcAddress(libuser32, "SetSystemCursor") + setThreadDesktop = doGetProcAddress(libuser32, "SetThreadDesktop") + setTimer = doGetProcAddress(libuser32, "SetTimer") + setUserObjectInformation = doGetProcAddress(libuser32, "SetUserObjectInformationW") + setUserObjectSecurity = doGetProcAddress(libuser32, "SetUserObjectSecurity") + setWinEventHook = doGetProcAddress(libuser32, "SetWinEventHook") + setWindowContextHelpId = doGetProcAddress(libuser32, "SetWindowContextHelpId") + setWindowLongPtr = doGetProcAddress(libuser32, "SetWindowLongPtrW") + setWindowLong = doGetProcAddress(libuser32, "SetWindowLongW") + setWindowPlacement = doGetProcAddress(libuser32, "SetWindowPlacement") + setWindowPos = doGetProcAddress(libuser32, "SetWindowPos") + setWindowRgn = doGetProcAddress(libuser32, "SetWindowRgn") + setWindowText = doGetProcAddress(libuser32, "SetWindowTextW") + setWindowWord = doGetProcAddress(libuser32, "SetWindowWord") + setWindowsHookEx = doGetProcAddress(libuser32, "SetWindowsHookExW") + setWindowsHook = doGetProcAddress(libuser32, "SetWindowsHookW") + showCaret = doGetProcAddress(libuser32, "ShowCaret") + showCursor = doGetProcAddress(libuser32, "ShowCursor") + showOwnedPopups = doGetProcAddress(libuser32, "ShowOwnedPopups") + showScrollBar = doGetProcAddress(libuser32, "ShowScrollBar") + showWindow = doGetProcAddress(libuser32, "ShowWindow") + showWindowAsync = doGetProcAddress(libuser32, "ShowWindowAsync") + subtractRect = doGetProcAddress(libuser32, "SubtractRect") + swapMouseButton = doGetProcAddress(libuser32, "SwapMouseButton") + switchDesktop = doGetProcAddress(libuser32, "SwitchDesktop") + switchToThisWindow = doGetProcAddress(libuser32, "SwitchToThisWindow") + systemParametersInfo = doGetProcAddress(libuser32, "SystemParametersInfoW") + tabbedTextOut = doGetProcAddress(libuser32, "TabbedTextOutW") + tileWindows = doGetProcAddress(libuser32, "TileWindows") + toAscii = doGetProcAddress(libuser32, "ToAscii") + toAsciiEx = doGetProcAddress(libuser32, "ToAsciiEx") + toUnicode = doGetProcAddress(libuser32, "ToUnicode") + toUnicodeEx = doGetProcAddress(libuser32, "ToUnicodeEx") + trackMouseEvent = doGetProcAddress(libuser32, "TrackMouseEvent") + trackPopupMenu = doGetProcAddress(libuser32, "TrackPopupMenu") + trackPopupMenuEx = doGetProcAddress(libuser32, "TrackPopupMenuEx") + translateAccelerator = doGetProcAddress(libuser32, "TranslateAcceleratorW") + translateMDISysAccel = doGetProcAddress(libuser32, "TranslateMDISysAccel") + translateMessage = doGetProcAddress(libuser32, "TranslateMessage") + unhookWinEvent = doGetProcAddress(libuser32, "UnhookWinEvent") + unhookWindowsHook = doGetProcAddress(libuser32, "UnhookWindowsHook") + unhookWindowsHookEx = doGetProcAddress(libuser32, "UnhookWindowsHookEx") + unionRect = doGetProcAddress(libuser32, "UnionRect") + unloadKeyboardLayout = doGetProcAddress(libuser32, "UnloadKeyboardLayout") + unpackDDElParam = doGetProcAddress(libuser32, "UnpackDDElParam") + unregisterClass = doGetProcAddress(libuser32, "UnregisterClassW") + unregisterDeviceNotification = doGetProcAddress(libuser32, "UnregisterDeviceNotification") + unregisterHotKey = doGetProcAddress(libuser32, "UnregisterHotKey") + unregisterPowerSettingNotification = doGetProcAddress(libuser32, "UnregisterPowerSettingNotification") + unregisterTouchWindow = doGetProcAddress(libuser32, "UnregisterTouchWindow") + updateLayeredWindow = doGetProcAddress(libuser32, "UpdateLayeredWindow") + updateLayeredWindowIndirect = doGetProcAddress(libuser32, "UpdateLayeredWindowIndirect") + updateWindow = doGetProcAddress(libuser32, "UpdateWindow") + userHandleGrantAccess = doGetProcAddress(libuser32, "UserHandleGrantAccess") + validateRect = doGetProcAddress(libuser32, "ValidateRect") + validateRgn = doGetProcAddress(libuser32, "ValidateRgn") + vkKeyScanEx = doGetProcAddress(libuser32, "VkKeyScanExW") + vkKeyScan = doGetProcAddress(libuser32, "VkKeyScanW") + wINNLSEnableIME = doGetProcAddress(libuser32, "WINNLSEnableIME") + wINNLSGetEnableStatus = doGetProcAddress(libuser32, "WINNLSGetEnableStatus") + wINNLSGetIMEHotkey = doGetProcAddress(libuser32, "WINNLSGetIMEHotkey") + waitForInputIdle = doGetProcAddress(libuser32, "WaitForInputIdle") + waitMessage = doGetProcAddress(libuser32, "WaitMessage") + winHelp = doGetProcAddress(libuser32, "WinHelpW") + windowFromDC = doGetProcAddress(libuser32, "WindowFromDC") + windowFromPoint = doGetProcAddress(libuser32, "WindowFromPoint") + keybd_event = doGetProcAddress(libuser32, "keybd_event") + mouse_event = doGetProcAddress(libuser32, "mouse_event") + alignRects = doGetProcAddress(libuser32, "AlignRects") + cascadeChildWindows = doGetProcAddress(libuser32, "CascadeChildWindows") + createDialogIndirectParamAorW = doGetProcAddress(libuser32, "CreateDialogIndirectParamAorW") + dialogBoxIndirectParamAorW = doGetProcAddress(libuser32, "DialogBoxIndirectParamAorW") + drawCaptionTemp = doGetProcAddress(libuser32, "DrawCaptionTempW") + drawMenuBarTemp = doGetProcAddress(libuser32, "DrawMenuBarTemp") + getAppCompatFlags = doGetProcAddress(libuser32, "GetAppCompatFlags") + getAppCompatFlags2 = doGetProcAddress(libuser32, "GetAppCompatFlags2") + getCursorFrameInfo = doGetProcAddress(libuser32, "GetCursorFrameInfo") + getInternalWindowPos = doGetProcAddress(libuser32, "GetInternalWindowPos") + getProgmanWindow = doGetProcAddress(libuser32, "GetProgmanWindow") + getTaskmanWindow = doGetProcAddress(libuser32, "GetTaskmanWindow") + killSystemTimer = doGetProcAddress(libuser32, "KillSystemTimer") + loadLocalFonts = doGetProcAddress(libuser32, "LoadLocalFonts") + messageBoxTimeout = doGetProcAddress(libuser32, "MessageBoxTimeoutW") + privateExtractIconEx = doGetProcAddress(libuser32, "PrivateExtractIconExW") + registerLogonProcess = doGetProcAddress(libuser32, "RegisterLogonProcess") + registerServicesProcess = doGetProcAddress(libuser32, "RegisterServicesProcess") + registerSystemThread = doGetProcAddress(libuser32, "RegisterSystemThread") + registerTasklist = doGetProcAddress(libuser32, "RegisterTasklist") + scrollChildren = doGetProcAddress(libuser32, "ScrollChildren") + setInternalWindowPos = doGetProcAddress(libuser32, "SetInternalWindowPos") + setLogonNotifyWindow = doGetProcAddress(libuser32, "SetLogonNotifyWindow") + setProgmanWindow = doGetProcAddress(libuser32, "SetProgmanWindow") + setShellWindow = doGetProcAddress(libuser32, "SetShellWindow") + setShellWindowEx = doGetProcAddress(libuser32, "SetShellWindowEx") + setSysColorsTemp = doGetProcAddress(libuser32, "SetSysColorsTemp") + setSystemMenu = doGetProcAddress(libuser32, "SetSystemMenu") + setSystemTimer = doGetProcAddress(libuser32, "SetSystemTimer") + setTaskmanWindow = doGetProcAddress(libuser32, "SetTaskmanWindow") + setWindowStationUser = doGetProcAddress(libuser32, "SetWindowStationUser") + tileChildWindows = doGetProcAddress(libuser32, "TileChildWindows") + user32InitializeImmEntryTable = doGetProcAddress(libuser32, "User32InitializeImmEntryTable") + userRealizePalette = doGetProcAddress(libuser32, "UserRealizePalette") + userRegisterWowHandlers = doGetProcAddress(libuser32, "UserRegisterWowHandlers") + addClipboardFormatListener = doGetProcAddress(libuser32, "AddClipboardFormatListener") + removeClipboardFormatListener = doGetProcAddress(libuser32, "RemoveClipboardFormatListener") +} + +func ActivateKeyboardLayout(hkl HKL, flags UINT) HKL { + ret1 := syscall3(activateKeyboardLayout, 2, + uintptr(hkl), + uintptr(flags), + 0) + return HKL(ret1) +} + +func AdjustWindowRect(lpRect *RECT, dwStyle DWORD, bMenu bool) bool { + ret1 := syscall3(adjustWindowRect, 3, + uintptr(unsafe.Pointer(lpRect)), + uintptr(dwStyle), + getUintptrFromBool(bMenu)) + return ret1 != 0 +} + +func AdjustWindowRectEx(lpRect *RECT, dwStyle DWORD, bMenu bool, dwExStyle DWORD) bool { + ret1 := syscall6(adjustWindowRectEx, 4, + uintptr(unsafe.Pointer(lpRect)), + uintptr(dwStyle), + getUintptrFromBool(bMenu), + uintptr(dwExStyle), + 0, + 0) + return ret1 != 0 +} + +func AllowSetForegroundWindow(dwProcessId DWORD) bool { + ret1 := syscall3(allowSetForegroundWindow, 1, + uintptr(dwProcessId), + 0, + 0) + return ret1 != 0 +} + +func AnimateWindow(hWnd HWND, dwTime DWORD, dwFlags DWORD) bool { + ret1 := syscall3(animateWindow, 3, + uintptr(hWnd), + uintptr(dwTime), + uintptr(dwFlags)) + return ret1 != 0 +} + +func AnyPopup() bool { + ret1 := syscall3(anyPopup, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func AppendMenu(hMenu HMENU, uFlags UINT, uIDNewItem *uint32, lpNewItem string) bool { + lpNewItemStr := unicode16FromString(lpNewItem) + ret1 := syscall6(appendMenu, 4, + uintptr(hMenu), + uintptr(uFlags), + uintptr(unsafe.Pointer(uIDNewItem)), + uintptr(unsafe.Pointer(&lpNewItemStr[0])), + 0, + 0) + return ret1 != 0 +} + +func ArrangeIconicWindows(hWnd HWND) UINT { + ret1 := syscall3(arrangeIconicWindows, 1, + uintptr(hWnd), + 0, + 0) + return UINT(ret1) +} + +func AttachThreadInput(idAttach DWORD, idAttachTo DWORD, fAttach bool) bool { + ret1 := syscall3(attachThreadInput, 3, + uintptr(idAttach), + uintptr(idAttachTo), + getUintptrFromBool(fAttach)) + return ret1 != 0 +} + +func BeginDeferWindowPos(nNumWindows int32) HDWP { + ret1 := syscall3(beginDeferWindowPos, 1, + uintptr(nNumWindows), + 0, + 0) + return HDWP(ret1) +} + +func BeginPaint(hWnd HWND, lpPaint *PAINTSTRUCT) HDC { + ret1 := syscall3(beginPaint, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpPaint)), + 0) + return HDC(ret1) +} + +func BlockInput(fBlockIt bool) bool { + ret1 := syscall3(blockInput, 1, + getUintptrFromBool(fBlockIt), + 0, + 0) + return ret1 != 0 +} + +func BringWindowToTop(hWnd HWND) bool { + ret1 := syscall3(bringWindowToTop, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func BroadcastSystemMessageEx(flags DWORD, lpInfo *uint32, msg UINT, wParam WPARAM, lParam LPARAM, pbsmInfo *BSMINFO) int32 { + ret1 := syscall6(broadcastSystemMessageEx, 6, + uintptr(flags), + uintptr(unsafe.Pointer(lpInfo)), + uintptr(msg), + uintptr(wParam), + uintptr(lParam), + uintptr(unsafe.Pointer(pbsmInfo))) + return int32(ret1) +} + +func BroadcastSystemMessage(flags DWORD, lpInfo *uint32, msg UINT, wParam WPARAM, lParam LPARAM) int32 { + ret1 := syscall6(broadcastSystemMessage, 5, + uintptr(flags), + uintptr(unsafe.Pointer(lpInfo)), + uintptr(msg), + uintptr(wParam), + uintptr(lParam), + 0) + return int32(ret1) +} + +func CallMsgFilter(lpMsg *MSG, nCode int32) bool { + ret1 := syscall3(callMsgFilter, 2, + uintptr(unsafe.Pointer(lpMsg)), + uintptr(nCode), + 0) + return ret1 != 0 +} + +func CallNextHookEx(hhk HHOOK, nCode int32, wParam WPARAM, lParam LPARAM) LRESULT { + ret1 := syscall6(callNextHookEx, 4, + uintptr(hhk), + uintptr(nCode), + uintptr(wParam), + uintptr(lParam), + 0, + 0) + return LRESULT(ret1) +} + +func CallWindowProc(lpPrevWndFunc WNDPROC, hWnd HWND, msg UINT, wParam WPARAM, lParam LPARAM) LRESULT { + lpPrevWndFuncCallback := syscall.NewCallback(func(unnamed0RawArg HWND, unnamed1RawArg UINT, unnamed2RawArg WPARAM, unnamed3RawArg LPARAM) uintptr { + ret := lpPrevWndFunc(unnamed0RawArg, unnamed1RawArg, unnamed2RawArg, unnamed3RawArg) + return uintptr(ret) + }) + ret1 := syscall6(callWindowProc, 5, + lpPrevWndFuncCallback, + uintptr(hWnd), + uintptr(msg), + uintptr(wParam), + uintptr(lParam), + 0) + return LRESULT(ret1) +} + +func CascadeWindows(hwndParent HWND, wHow UINT, lpRect /*const*/ *RECT, cKids UINT, lpKids /*const*/ *HWND) WORD { + ret1 := syscall6(cascadeWindows, 5, + uintptr(hwndParent), + uintptr(wHow), + uintptr(unsafe.Pointer(lpRect)), + uintptr(cKids), + uintptr(unsafe.Pointer(lpKids)), + 0) + return WORD(ret1) +} + +func ChangeClipboardChain(hWndRemove HWND, hWndNewNext HWND) bool { + ret1 := syscall3(changeClipboardChain, 2, + uintptr(hWndRemove), + uintptr(hWndNewNext), + 0) + return ret1 != 0 +} + +func ChangeDisplaySettingsEx(lpszDeviceName string, lpDevMode LPDEVMODE, hwnd HWND, dwflags DWORD, lParam LPVOID) LONG { + lpszDeviceNameStr := unicode16FromString(lpszDeviceName) + ret1 := syscall6(changeDisplaySettingsEx, 5, + uintptr(unsafe.Pointer(&lpszDeviceNameStr[0])), + uintptr(unsafe.Pointer(lpDevMode)), + uintptr(hwnd), + uintptr(dwflags), + uintptr(unsafe.Pointer(lParam)), + 0) + return LONG(ret1) +} + +func ChangeDisplaySettings(lpDevMode LPDEVMODE, dwFlags DWORD) LONG { + ret1 := syscall3(changeDisplaySettings, 2, + uintptr(unsafe.Pointer(lpDevMode)), + uintptr(dwFlags), + 0) + return LONG(ret1) +} + +func ChangeMenu(hMenu HMENU, cmd UINT, lpszNewItem string, cmdInsert UINT, flags UINT) bool { + lpszNewItemStr := unicode16FromString(lpszNewItem) + ret1 := syscall6(changeMenu, 5, + uintptr(hMenu), + uintptr(cmd), + uintptr(unsafe.Pointer(&lpszNewItemStr[0])), + uintptr(cmdInsert), + uintptr(flags), + 0) + return ret1 != 0 +} + +func CharLowerBuff(lpsz LPWSTR, cchLength DWORD) DWORD { + ret1 := syscall3(charLowerBuff, 2, + uintptr(unsafe.Pointer(lpsz)), + uintptr(cchLength), + 0) + return DWORD(ret1) +} + +func CharLower(lpsz LPWSTR) LPWSTR { + ret1 := syscall3(charLower, 1, + uintptr(unsafe.Pointer(lpsz)), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func CharNextExA(codePage WORD, lpCurrentChar /*const*/ LPCSTR, dwFlags DWORD) LPSTR { + ret1 := syscall3(charNextExA, 3, + uintptr(codePage), + uintptr(unsafe.Pointer(lpCurrentChar)), + uintptr(dwFlags)) + return (LPSTR)(unsafe.Pointer(ret1)) +} + +func CharNext(lpsz string) LPWSTR { + lpszStr := unicode16FromString(lpsz) + ret1 := syscall3(charNext, 1, + uintptr(unsafe.Pointer(&lpszStr[0])), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func CharPrevExA(codePage WORD, lpStart /*const*/ LPCSTR, lpCurrentChar /*const*/ LPCSTR, dwFlags DWORD) LPSTR { + ret1 := syscall6(charPrevExA, 4, + uintptr(codePage), + uintptr(unsafe.Pointer(lpStart)), + uintptr(unsafe.Pointer(lpCurrentChar)), + uintptr(dwFlags), + 0, + 0) + return (LPSTR)(unsafe.Pointer(ret1)) +} + +func CharPrev(lpszStart string, lpszCurrent string) LPWSTR { + lpszStartStr := unicode16FromString(lpszStart) + lpszCurrentStr := unicode16FromString(lpszCurrent) + ret1 := syscall3(charPrev, 2, + uintptr(unsafe.Pointer(&lpszStartStr[0])), + uintptr(unsafe.Pointer(&lpszCurrentStr[0])), + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func CharToOemBuff(lpszSrc string, lpszDst LPSTR, cchDstLength DWORD) bool { + lpszSrcStr := unicode16FromString(lpszSrc) + ret1 := syscall3(charToOemBuff, 3, + uintptr(unsafe.Pointer(&lpszSrcStr[0])), + uintptr(unsafe.Pointer(lpszDst)), + uintptr(cchDstLength)) + return ret1 != 0 +} + +func CharToOem(lpszSrc string, lpszDst LPSTR) bool { + lpszSrcStr := unicode16FromString(lpszSrc) + ret1 := syscall3(charToOem, 2, + uintptr(unsafe.Pointer(&lpszSrcStr[0])), + uintptr(unsafe.Pointer(lpszDst)), + 0) + return ret1 != 0 +} + +func CharUpperBuff(lpsz LPWSTR, cchLength DWORD) DWORD { + ret1 := syscall3(charUpperBuff, 2, + uintptr(unsafe.Pointer(lpsz)), + uintptr(cchLength), + 0) + return DWORD(ret1) +} + +func CharUpper(lpsz LPWSTR) LPWSTR { + ret1 := syscall3(charUpper, 1, + uintptr(unsafe.Pointer(lpsz)), + 0, + 0) + return (LPWSTR)(unsafe.Pointer(ret1)) +} + +func CheckDlgButton(hDlg HWND, nIDButton int32, uCheck UINT) bool { + ret1 := syscall3(checkDlgButton, 3, + uintptr(hDlg), + uintptr(nIDButton), + uintptr(uCheck)) + return ret1 != 0 +} + +func CheckMenuItem(hMenu HMENU, uIDCheckItem UINT, uCheck UINT) DWORD { + ret1 := syscall3(checkMenuItem, 3, + uintptr(hMenu), + uintptr(uIDCheckItem), + uintptr(uCheck)) + return DWORD(ret1) +} + +func CheckMenuRadioItem(hmenu HMENU, first UINT, last UINT, check UINT, flags UINT) bool { + ret1 := syscall6(checkMenuRadioItem, 5, + uintptr(hmenu), + uintptr(first), + uintptr(last), + uintptr(check), + uintptr(flags), + 0) + return ret1 != 0 +} + +func CheckRadioButton(hDlg HWND, nIDFirstButton int32, nIDLastButton int32, nIDCheckButton int32) bool { + ret1 := syscall6(checkRadioButton, 4, + uintptr(hDlg), + uintptr(nIDFirstButton), + uintptr(nIDLastButton), + uintptr(nIDCheckButton), + 0, + 0) + return ret1 != 0 +} + +func ChildWindowFromPoint(hWndParent HWND, point POINT) HWND { + ret1 := syscall3(childWindowFromPoint, 3, + uintptr(hWndParent), + uintptr(point.X), + uintptr(point.Y)) + return HWND(ret1) +} + +func ChildWindowFromPointEx(hwnd HWND, pt POINT, flags UINT) HWND { + ret1 := syscall6(childWindowFromPointEx, 4, + uintptr(hwnd), + uintptr(pt.X), + uintptr(pt.Y), + uintptr(flags), + 0, + 0) + return HWND(ret1) +} + +func ClientToScreen(hWnd HWND, lpPoint *POINT) bool { + ret1 := syscall3(clientToScreen, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpPoint)), + 0) + return ret1 != 0 +} + +func ClipCursor(lpRect /*const*/ *RECT) bool { + ret1 := syscall3(clipCursor, 1, + uintptr(unsafe.Pointer(lpRect)), + 0, + 0) + return ret1 != 0 +} + +func CloseClipboard() bool { + ret1 := syscall3(closeClipboard, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func CloseDesktop(hDesktop HDESK) bool { + ret1 := syscall3(closeDesktop, 1, + uintptr(hDesktop), + 0, + 0) + return ret1 != 0 +} + +func CloseGestureInfoHandle(hGestureInfo HGESTUREINFO) bool { + ret1 := syscall3(closeGestureInfoHandle, 1, + uintptr(hGestureInfo), + 0, + 0) + return ret1 != 0 +} + +func CloseTouchInputHandle(hTouchInput HTOUCHINPUT) bool { + ret1 := syscall3(closeTouchInputHandle, 1, + uintptr(hTouchInput), + 0, + 0) + return ret1 != 0 +} + +func CloseWindow(hWnd HWND) bool { + ret1 := syscall3(closeWindow, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func CloseWindowStation(hWinSta HWINSTA) bool { + ret1 := syscall3(closeWindowStation, 1, + uintptr(hWinSta), + 0, + 0) + return ret1 != 0 +} + +func CopyAcceleratorTable(hAccelSrc HACCEL, lpAccelDst *ACCEL, cAccelEntries int32) int32 { + ret1 := syscall3(copyAcceleratorTable, 3, + uintptr(hAccelSrc), + uintptr(unsafe.Pointer(lpAccelDst)), + uintptr(cAccelEntries)) + return int32(ret1) +} + +func CopyIcon(hIcon HICON) HICON { + ret1 := syscall3(copyIcon, 1, + uintptr(hIcon), + 0, + 0) + return HICON(ret1) +} + +func CopyImage(h HANDLE, aType UINT, cx int32, cy int32, flags UINT) HANDLE { + ret1 := syscall6(copyImage, 5, + uintptr(h), + uintptr(aType), + uintptr(cx), + uintptr(cy), + uintptr(flags), + 0) + return HANDLE(ret1) +} + +func CopyRect(lprcDst *RECT, lprcSrc /*const*/ *RECT) bool { + ret1 := syscall3(copyRect, 2, + uintptr(unsafe.Pointer(lprcDst)), + uintptr(unsafe.Pointer(lprcSrc)), + 0) + return ret1 != 0 +} + +func CountClipboardFormats() int32 { + ret1 := syscall3(countClipboardFormats, 0, + 0, + 0, + 0) + return int32(ret1) +} + +func CreateAcceleratorTable(paccel *ACCEL, cAccel int32) HACCEL { + ret1 := syscall3(createAcceleratorTable, 2, + uintptr(unsafe.Pointer(paccel)), + uintptr(cAccel), + 0) + return HACCEL(ret1) +} + +func CreateCaret(hWnd HWND, hBitmap HBITMAP, nWidth int32, nHeight int32) bool { + ret1 := syscall6(createCaret, 4, + uintptr(hWnd), + uintptr(hBitmap), + uintptr(nWidth), + uintptr(nHeight), + 0, + 0) + return ret1 != 0 +} + +func CreateCursor(hInst HINSTANCE, xHotSpot int32, yHotSpot int32, nWidth int32, nHeight int32, pvANDPlane /*const*/ uintptr, pvXORPlane /*const*/ uintptr) HCURSOR { + ret1 := syscall9(createCursor, 7, + uintptr(hInst), + uintptr(xHotSpot), + uintptr(yHotSpot), + uintptr(nWidth), + uintptr(nHeight), + pvANDPlane, + pvXORPlane, + 0, + 0) + return HCURSOR(ret1) +} + +func CreateDesktop(lpszDesktop string, lpszDevice string, pDevmode LPDEVMODE, dwFlags DWORD, dwDesiredAccess ACCESS_MASK, lpsa *SECURITY_ATTRIBUTES) HDESK { + lpszDesktopStr := unicode16FromString(lpszDesktop) + lpszDeviceStr := unicode16FromString(lpszDevice) + ret1 := syscall6(createDesktop, 6, + uintptr(unsafe.Pointer(&lpszDesktopStr[0])), + uintptr(unsafe.Pointer(&lpszDeviceStr[0])), + uintptr(unsafe.Pointer(pDevmode)), + uintptr(dwFlags), + uintptr(dwDesiredAccess), + uintptr(unsafe.Pointer(lpsa))) + return HDESK(ret1) +} + +func CreateDialogIndirectParam(hInstance HINSTANCE, lpTemplate /*const*/ *DLGTEMPLATE, hWndParent HWND, lpDialogFunc DLGPROC, dwInitParam LPARAM) HWND { + lpDialogFuncCallback := syscall.NewCallback(func(hwndDlgRawArg HWND, uMsgRawArg uint32, wParamRawArg WPARAM, lParamRawArg LPARAM) uintptr { + ret := lpDialogFunc(hwndDlgRawArg, uMsgRawArg, wParamRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall6(createDialogIndirectParam, 5, + uintptr(hInstance), + uintptr(unsafe.Pointer(lpTemplate)), + uintptr(hWndParent), + lpDialogFuncCallback, + uintptr(dwInitParam), + 0) + return HWND(ret1) +} + +func CreateDialogParam(hInstance HINSTANCE, lpTemplateName string, hWndParent HWND, lpDialogFunc DLGPROC, dwInitParam LPARAM) HWND { + lpTemplateNameStr := unicode16FromString(lpTemplateName) + lpDialogFuncCallback := syscall.NewCallback(func(hwndDlgRawArg HWND, uMsgRawArg uint32, wParamRawArg WPARAM, lParamRawArg LPARAM) uintptr { + ret := lpDialogFunc(hwndDlgRawArg, uMsgRawArg, wParamRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall6(createDialogParam, 5, + uintptr(hInstance), + uintptr(unsafe.Pointer(&lpTemplateNameStr[0])), + uintptr(hWndParent), + lpDialogFuncCallback, + uintptr(dwInitParam), + 0) + return HWND(ret1) +} + +func CreateIcon(hInstance HINSTANCE, nWidth int32, nHeight int32, cPlanes BYTE, cBitsPixel BYTE, lpbANDbits /*const*/ *byte, lpbXORbits /*const*/ *byte) HICON { + ret1 := syscall9(createIcon, 7, + uintptr(hInstance), + uintptr(nWidth), + uintptr(nHeight), + uintptr(cPlanes), + uintptr(cBitsPixel), + uintptr(unsafe.Pointer(lpbANDbits)), + uintptr(unsafe.Pointer(lpbXORbits)), + 0, + 0) + return HICON(ret1) +} + +func CreateIconFromResource(presbits *byte, dwResSize DWORD, fIcon bool, dwVer DWORD) HICON { + ret1 := syscall6(createIconFromResource, 4, + uintptr(unsafe.Pointer(presbits)), + uintptr(dwResSize), + getUintptrFromBool(fIcon), + uintptr(dwVer), + 0, + 0) + return HICON(ret1) +} + +func CreateIconFromResourceEx(presbits *byte, dwResSize DWORD, fIcon bool, dwVer DWORD, cxDesired int32, cyDesired int32, flags UINT) HICON { + ret1 := syscall9(createIconFromResourceEx, 7, + uintptr(unsafe.Pointer(presbits)), + uintptr(dwResSize), + getUintptrFromBool(fIcon), + uintptr(dwVer), + uintptr(cxDesired), + uintptr(cyDesired), + uintptr(flags), + 0, + 0) + return HICON(ret1) +} + +func CreateIconIndirect(piconinfo *ICONINFO) HICON { + ret1 := syscall3(createIconIndirect, 1, + uintptr(unsafe.Pointer(piconinfo)), + 0, + 0) + return HICON(ret1) +} + +func CreateMDIWindow(lpClassName string, lpWindowName string, dwStyle DWORD, x int32, y int32, nWidth int32, nHeight int32, hWndParent HWND, hInstance HINSTANCE, lParam LPARAM) HWND { + lpClassNameStr := unicode16FromString(lpClassName) + lpWindowNameStr := unicode16FromString(lpWindowName) + ret1 := syscall12(createMDIWindow, 10, + uintptr(unsafe.Pointer(&lpClassNameStr[0])), + uintptr(unsafe.Pointer(&lpWindowNameStr[0])), + uintptr(dwStyle), + uintptr(x), + uintptr(y), + uintptr(nWidth), + uintptr(nHeight), + uintptr(hWndParent), + uintptr(hInstance), + uintptr(lParam), + 0, + 0) + return HWND(ret1) +} + +func CreateMenu() HMENU { + ret1 := syscall3(createMenu, 0, + 0, + 0, + 0) + return HMENU(ret1) +} + +func CreatePopupMenu() HMENU { + ret1 := syscall3(createPopupMenu, 0, + 0, + 0, + 0) + return HMENU(ret1) +} + +func CreateWindowEx(dwExStyle DWORD, lpClassName string, lpWindowName string, dwStyle DWORD, x int32, y int32, nWidth int32, nHeight int32, hWndParent HWND, hMenu HMENU, hInstance HINSTANCE, lpParam LPVOID) HWND { + lpClassNameStr := unicode16FromString(lpClassName) + lpWindowNameStr := unicode16FromString(lpWindowName) + ret1 := syscall12(createWindowEx, 12, + uintptr(dwExStyle), + uintptr(unsafe.Pointer(&lpClassNameStr[0])), + uintptr(unsafe.Pointer(&lpWindowNameStr[0])), + uintptr(dwStyle), + uintptr(x), + uintptr(y), + uintptr(nWidth), + uintptr(nHeight), + uintptr(hWndParent), + uintptr(hMenu), + uintptr(hInstance), + uintptr(unsafe.Pointer(lpParam))) + return HWND(ret1) +} + +func CreateWindowStation(lpwinsta string, dwFlags DWORD, dwDesiredAccess ACCESS_MASK, lpsa *SECURITY_ATTRIBUTES) HWINSTA { + lpwinstaStr := unicode16FromString(lpwinsta) + ret1 := syscall6(createWindowStation, 4, + uintptr(unsafe.Pointer(&lpwinstaStr[0])), + uintptr(dwFlags), + uintptr(dwDesiredAccess), + uintptr(unsafe.Pointer(lpsa)), + 0, + 0) + return HWINSTA(ret1) +} + +func DdeAbandonTransaction(idInst DWORD, hConv HCONV, idTransaction DWORD) bool { + ret1 := syscall3(ddeAbandonTransaction, 3, + uintptr(idInst), + uintptr(hConv), + uintptr(idTransaction)) + return ret1 != 0 +} + +func DdeAccessData(hData HDDEDATA, pcbDataSize *uint32) *byte { + ret1 := syscall3(ddeAccessData, 2, + uintptr(hData), + uintptr(unsafe.Pointer(pcbDataSize)), + 0) + return (*byte)(unsafe.Pointer(ret1)) +} + +func DdeAddData(hData HDDEDATA, pSrc *byte, cb DWORD, cbOff DWORD) HDDEDATA { + ret1 := syscall6(ddeAddData, 4, + uintptr(hData), + uintptr(unsafe.Pointer(pSrc)), + uintptr(cb), + uintptr(cbOff), + 0, + 0) + return HDDEDATA(ret1) +} + +func DdeClientTransaction(pData *byte, cbData DWORD, hConv HCONV, hszItem HSZ, wFmt UINT, wType UINT, dwTimeout DWORD, pdwResult *uint32) HDDEDATA { + ret1 := syscall9(ddeClientTransaction, 8, + uintptr(unsafe.Pointer(pData)), + uintptr(cbData), + uintptr(hConv), + uintptr(hszItem), + uintptr(wFmt), + uintptr(wType), + uintptr(dwTimeout), + uintptr(unsafe.Pointer(pdwResult)), + 0) + return HDDEDATA(ret1) +} + +func DdeCmpStringHandles(hsz1 HSZ, hsz2 HSZ) int32 { + ret1 := syscall3(ddeCmpStringHandles, 2, + uintptr(hsz1), + uintptr(hsz2), + 0) + return int32(ret1) +} + +func DdeConnect(idInst DWORD, hszService HSZ, hszTopic HSZ, pCC *CONVCONTEXT) HCONV { + ret1 := syscall6(ddeConnect, 4, + uintptr(idInst), + uintptr(hszService), + uintptr(hszTopic), + uintptr(unsafe.Pointer(pCC)), + 0, + 0) + return HCONV(ret1) +} + +func DdeConnectList(idInst DWORD, hszService HSZ, hszTopic HSZ, hConvList HCONVLIST, pCC *CONVCONTEXT) HCONVLIST { + ret1 := syscall6(ddeConnectList, 5, + uintptr(idInst), + uintptr(hszService), + uintptr(hszTopic), + uintptr(hConvList), + uintptr(unsafe.Pointer(pCC)), + 0) + return HCONVLIST(ret1) +} + +func DdeCreateDataHandle(idInst DWORD, pSrc *byte, cb DWORD, cbOff DWORD, hszItem HSZ, wFmt UINT, afCmd UINT) HDDEDATA { + ret1 := syscall9(ddeCreateDataHandle, 7, + uintptr(idInst), + uintptr(unsafe.Pointer(pSrc)), + uintptr(cb), + uintptr(cbOff), + uintptr(hszItem), + uintptr(wFmt), + uintptr(afCmd), + 0, + 0) + return HDDEDATA(ret1) +} + +func DdeCreateStringHandle(idInst DWORD, psz string, iCodePage int32) HSZ { + pszStr := unicode16FromString(psz) + ret1 := syscall3(ddeCreateStringHandle, 3, + uintptr(idInst), + uintptr(unsafe.Pointer(&pszStr[0])), + uintptr(iCodePage)) + return HSZ(ret1) +} + +func DdeDisconnect(hConv HCONV) bool { + ret1 := syscall3(ddeDisconnect, 1, + uintptr(hConv), + 0, + 0) + return ret1 != 0 +} + +func DdeDisconnectList(hConvList HCONVLIST) bool { + ret1 := syscall3(ddeDisconnectList, 1, + uintptr(hConvList), + 0, + 0) + return ret1 != 0 +} + +func DdeEnableCallback(idInst DWORD, hConv HCONV, wCmd UINT) bool { + ret1 := syscall3(ddeEnableCallback, 3, + uintptr(idInst), + uintptr(hConv), + uintptr(wCmd)) + return ret1 != 0 +} + +func DdeFreeDataHandle(hData HDDEDATA) bool { + ret1 := syscall3(ddeFreeDataHandle, 1, + uintptr(hData), + 0, + 0) + return ret1 != 0 +} + +func DdeFreeStringHandle(idInst DWORD, hsz HSZ) bool { + ret1 := syscall3(ddeFreeStringHandle, 2, + uintptr(idInst), + uintptr(hsz), + 0) + return ret1 != 0 +} + +func DdeGetData(hData HDDEDATA, pDst *byte, cbMax DWORD, cbOff DWORD) DWORD { + ret1 := syscall6(ddeGetData, 4, + uintptr(hData), + uintptr(unsafe.Pointer(pDst)), + uintptr(cbMax), + uintptr(cbOff), + 0, + 0) + return DWORD(ret1) +} + +func DdeGetLastError(idInst DWORD) UINT { + ret1 := syscall3(ddeGetLastError, 1, + uintptr(idInst), + 0, + 0) + return UINT(ret1) +} + +func DdeImpersonateClient(hConv HCONV) bool { + ret1 := syscall3(ddeImpersonateClient, 1, + uintptr(hConv), + 0, + 0) + return ret1 != 0 +} + +func DdeInitialize(pidInst *uint32, pfnCallback PFNCALLBACK, afCmd DWORD, ulRes DWORD) UINT { + pfnCallbackCallback := syscall.NewCallback(func(wTypeRawArg uint32, wFmtRawArg uint32, hConvRawArg HCONV, hsz1RawArg HSZ, hsz2RawArg HSZ, hDataRawArg HDDEDATA, dwData1RawArg uintptr, dwData2RawArg uintptr) uintptr { + ret := pfnCallback(wTypeRawArg, wFmtRawArg, hConvRawArg, hsz1RawArg, hsz2RawArg, hDataRawArg, dwData1RawArg, dwData2RawArg) + return uintptr(ret) + }) + ret1 := syscall6(ddeInitialize, 4, + uintptr(unsafe.Pointer(pidInst)), + pfnCallbackCallback, + uintptr(afCmd), + uintptr(ulRes), + 0, + 0) + return UINT(ret1) +} + +func DdeKeepStringHandle(idInst DWORD, hsz HSZ) bool { + ret1 := syscall3(ddeKeepStringHandle, 2, + uintptr(idInst), + uintptr(hsz), + 0) + return ret1 != 0 +} + +func DdeNameService(idInst DWORD, hsz1 HSZ, hsz2 HSZ, afCmd UINT) HDDEDATA { + ret1 := syscall6(ddeNameService, 4, + uintptr(idInst), + uintptr(hsz1), + uintptr(hsz2), + uintptr(afCmd), + 0, + 0) + return HDDEDATA(ret1) +} + +func DdePostAdvise(idInst DWORD, hszTopic HSZ, hszItem HSZ) bool { + ret1 := syscall3(ddePostAdvise, 3, + uintptr(idInst), + uintptr(hszTopic), + uintptr(hszItem)) + return ret1 != 0 +} + +func DdeQueryConvInfo(hConv HCONV, idTransaction DWORD, pConvInfo *CONVINFO) UINT { + ret1 := syscall3(ddeQueryConvInfo, 3, + uintptr(hConv), + uintptr(idTransaction), + uintptr(unsafe.Pointer(pConvInfo))) + return UINT(ret1) +} + +func DdeQueryNextServer(hConvList HCONVLIST, hConvPrev HCONV) HCONV { + ret1 := syscall3(ddeQueryNextServer, 2, + uintptr(hConvList), + uintptr(hConvPrev), + 0) + return HCONV(ret1) +} + +func DdeQueryString(idInst DWORD, hsz HSZ, psz LPWSTR, cchMax DWORD, iCodePage int32) DWORD { + ret1 := syscall6(ddeQueryString, 5, + uintptr(idInst), + uintptr(hsz), + uintptr(unsafe.Pointer(psz)), + uintptr(cchMax), + uintptr(iCodePage), + 0) + return DWORD(ret1) +} + +func DdeReconnect(hConv HCONV) HCONV { + ret1 := syscall3(ddeReconnect, 1, + uintptr(hConv), + 0, + 0) + return HCONV(ret1) +} + +func DdeSetQualityOfService(hwndClient HWND, pqosNew /*const*/ *SECURITY_QUALITY_OF_SERVICE, pqosPrev *SECURITY_QUALITY_OF_SERVICE) bool { + ret1 := syscall3(ddeSetQualityOfService, 3, + uintptr(hwndClient), + uintptr(unsafe.Pointer(pqosNew)), + uintptr(unsafe.Pointer(pqosPrev))) + return ret1 != 0 +} + +func DdeSetUserHandle(hConv HCONV, id DWORD, hUser *uint32) bool { + ret1 := syscall3(ddeSetUserHandle, 3, + uintptr(hConv), + uintptr(id), + uintptr(unsafe.Pointer(hUser))) + return ret1 != 0 +} + +func DdeUnaccessData(hData HDDEDATA) bool { + ret1 := syscall3(ddeUnaccessData, 1, + uintptr(hData), + 0, + 0) + return ret1 != 0 +} + +func DdeUninitialize(idInst DWORD) bool { + ret1 := syscall3(ddeUninitialize, 1, + uintptr(idInst), + 0, + 0) + return ret1 != 0 +} + +func DefDlgProc(hDlg HWND, msg UINT, wParam WPARAM, lParam LPARAM) LRESULT { + ret1 := syscall6(defDlgProc, 4, + uintptr(hDlg), + uintptr(msg), + uintptr(wParam), + uintptr(lParam), + 0, + 0) + return LRESULT(ret1) +} + +func DefFrameProc(hWnd HWND, hWndMDIClient HWND, uMsg UINT, wParam WPARAM, lParam LPARAM) LRESULT { + ret1 := syscall6(defFrameProc, 5, + uintptr(hWnd), + uintptr(hWndMDIClient), + uintptr(uMsg), + uintptr(wParam), + uintptr(lParam), + 0) + return LRESULT(ret1) +} + +func DefMDIChildProc(hWnd HWND, uMsg UINT, wParam WPARAM, lParam LPARAM) LRESULT { + ret1 := syscall6(defMDIChildProc, 4, + uintptr(hWnd), + uintptr(uMsg), + uintptr(wParam), + uintptr(lParam), + 0, + 0) + return LRESULT(ret1) +} + +func DefRawInputProc(paRawInput uintptr, nInput INT, cbSizeHeader UINT) LRESULT { + ret1 := syscall3(defRawInputProc, 3, + paRawInput, + uintptr(nInput), + uintptr(cbSizeHeader)) + return LRESULT(ret1) +} + +func DefWindowProc(hWnd HWND, msg UINT, wParam WPARAM, lParam LPARAM) LRESULT { + ret1 := syscall6(defWindowProc, 4, + uintptr(hWnd), + uintptr(msg), + uintptr(wParam), + uintptr(lParam), + 0, + 0) + return LRESULT(ret1) +} + +func DeferWindowPos(hWinPosInfo HDWP, hWnd HWND, hWndInsertAfter HWND, x int32, y int32, cx int32, cy int32, uFlags UINT) HDWP { + ret1 := syscall9(deferWindowPos, 8, + uintptr(hWinPosInfo), + uintptr(hWnd), + uintptr(hWndInsertAfter), + uintptr(x), + uintptr(y), + uintptr(cx), + uintptr(cy), + uintptr(uFlags), + 0) + return HDWP(ret1) +} + +func DeleteMenu(hMenu HMENU, uPosition UINT, uFlags UINT) bool { + ret1 := syscall3(deleteMenu, 3, + uintptr(hMenu), + uintptr(uPosition), + uintptr(uFlags)) + return ret1 != 0 +} + +func DeregisterShellHookWindow(hwnd HWND) bool { + ret1 := syscall3(deregisterShellHookWindow, 1, + uintptr(hwnd), + 0, + 0) + return ret1 != 0 +} + +func DestroyAcceleratorTable(hAccel HACCEL) bool { + ret1 := syscall3(destroyAcceleratorTable, 1, + uintptr(hAccel), + 0, + 0) + return ret1 != 0 +} + +func DestroyCaret() bool { + ret1 := syscall3(destroyCaret, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func DestroyCursor(hCursor HCURSOR) bool { + ret1 := syscall3(destroyCursor, 1, + uintptr(hCursor), + 0, + 0) + return ret1 != 0 +} + +func DestroyIcon(hIcon HICON) bool { + ret1 := syscall3(destroyIcon, 1, + uintptr(hIcon), + 0, + 0) + return ret1 != 0 +} + +func DestroyMenu(hMenu HMENU) bool { + ret1 := syscall3(destroyMenu, 1, + uintptr(hMenu), + 0, + 0) + return ret1 != 0 +} + +func DestroyWindow(hWnd HWND) bool { + ret1 := syscall3(destroyWindow, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func DialogBoxIndirectParam(hInstance HINSTANCE, hDialogTemplate /*const*/ *DLGTEMPLATE, hWndParent HWND, lpDialogFunc DLGPROC, dwInitParam LPARAM) INT_PTR { + lpDialogFuncCallback := syscall.NewCallback(func(hwndDlgRawArg HWND, uMsgRawArg uint32, wParamRawArg WPARAM, lParamRawArg LPARAM) uintptr { + ret := lpDialogFunc(hwndDlgRawArg, uMsgRawArg, wParamRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall6(dialogBoxIndirectParam, 5, + uintptr(hInstance), + uintptr(unsafe.Pointer(hDialogTemplate)), + uintptr(hWndParent), + lpDialogFuncCallback, + uintptr(dwInitParam), + 0) + return (INT_PTR)(unsafe.Pointer(ret1)) +} + +func DialogBoxParam(hInstance HINSTANCE, lpTemplateName string, hWndParent HWND, lpDialogFunc DLGPROC, dwInitParam LPARAM) INT_PTR { + lpTemplateNameStr := unicode16FromString(lpTemplateName) + lpDialogFuncCallback := syscall.NewCallback(func(hwndDlgRawArg HWND, uMsgRawArg uint32, wParamRawArg WPARAM, lParamRawArg LPARAM) uintptr { + ret := lpDialogFunc(hwndDlgRawArg, uMsgRawArg, wParamRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall6(dialogBoxParam, 5, + uintptr(hInstance), + uintptr(unsafe.Pointer(&lpTemplateNameStr[0])), + uintptr(hWndParent), + lpDialogFuncCallback, + uintptr(dwInitParam), + 0) + return (INT_PTR)(unsafe.Pointer(ret1)) +} + +func DisableProcessWindowsGhosting() { + syscall3(disableProcessWindowsGhosting, 0, + 0, + 0, + 0) +} + +func DispatchMessage(lpMsg /*const*/ *MSG) LRESULT { + ret1 := syscall3(dispatchMessage, 1, + uintptr(unsafe.Pointer(lpMsg)), + 0, + 0) + return LRESULT(ret1) +} + +func DlgDirListComboBox(hDlg HWND, lpPathSpec LPWSTR, nIDComboBox int32, nIDStaticPath int32, uFiletype UINT) int32 { + ret1 := syscall6(dlgDirListComboBox, 5, + uintptr(hDlg), + uintptr(unsafe.Pointer(lpPathSpec)), + uintptr(nIDComboBox), + uintptr(nIDStaticPath), + uintptr(uFiletype), + 0) + return int32(ret1) +} + +func DlgDirList(hDlg HWND, lpPathSpec LPWSTR, nIDListBox int32, nIDStaticPath int32, uFileType UINT) int32 { + ret1 := syscall6(dlgDirList, 5, + uintptr(hDlg), + uintptr(unsafe.Pointer(lpPathSpec)), + uintptr(nIDListBox), + uintptr(nIDStaticPath), + uintptr(uFileType), + 0) + return int32(ret1) +} + +func DlgDirSelectComboBoxEx(hwndDlg HWND, lpString LPWSTR, cchOut int32, idComboBox int32) bool { + ret1 := syscall6(dlgDirSelectComboBoxEx, 4, + uintptr(hwndDlg), + uintptr(unsafe.Pointer(lpString)), + uintptr(cchOut), + uintptr(idComboBox), + 0, + 0) + return ret1 != 0 +} + +func DlgDirSelectEx(hwndDlg HWND, lpString LPWSTR, chCount int32, idListBox int32) bool { + ret1 := syscall6(dlgDirSelectEx, 4, + uintptr(hwndDlg), + uintptr(unsafe.Pointer(lpString)), + uintptr(chCount), + uintptr(idListBox), + 0, + 0) + return ret1 != 0 +} + +func DragDetect(hwnd HWND, pt POINT) bool { + ret1 := syscall3(dragDetect, 3, + uintptr(hwnd), + uintptr(pt.X), + uintptr(pt.Y)) + return ret1 != 0 +} + +func DragObject(hwndParent HWND, hwndFrom HWND, fmt UINT, data *uint32, hcur HCURSOR) DWORD { + ret1 := syscall6(dragObject, 5, + uintptr(hwndParent), + uintptr(hwndFrom), + uintptr(fmt), + uintptr(unsafe.Pointer(data)), + uintptr(hcur), + 0) + return DWORD(ret1) +} + +func DrawAnimatedRects(hwnd HWND, idAni int32, lprcFrom /*const*/ *RECT, lprcTo /*const*/ *RECT) bool { + ret1 := syscall6(drawAnimatedRects, 4, + uintptr(hwnd), + uintptr(idAni), + uintptr(unsafe.Pointer(lprcFrom)), + uintptr(unsafe.Pointer(lprcTo)), + 0, + 0) + return ret1 != 0 +} + +func DrawCaption(hwnd HWND, hdc HDC, lprect /*const*/ *RECT, flags UINT) bool { + ret1 := syscall6(drawCaption, 4, + uintptr(hwnd), + uintptr(hdc), + uintptr(unsafe.Pointer(lprect)), + uintptr(flags), + 0, + 0) + return ret1 != 0 +} + +func DrawEdge(hdc HDC, qrc *RECT, edge UINT, grfFlags UINT) bool { + ret1 := syscall6(drawEdge, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(qrc)), + uintptr(edge), + uintptr(grfFlags), + 0, + 0) + return ret1 != 0 +} + +func DrawFocusRect(hDC HDC, lprc /*const*/ *RECT) bool { + ret1 := syscall3(drawFocusRect, 2, + uintptr(hDC), + uintptr(unsafe.Pointer(lprc)), + 0) + return ret1 != 0 +} + +func DrawFrameControl(unnamed0 HDC, unnamed1 *RECT, unnamed2 UINT, unnamed3 UINT) bool { + ret1 := syscall6(drawFrameControl, 4, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + uintptr(unnamed2), + uintptr(unnamed3), + 0, + 0) + return ret1 != 0 +} + +func DrawIcon(hDC HDC, x int32, y int32, hIcon HICON) bool { + ret1 := syscall6(drawIcon, 4, + uintptr(hDC), + uintptr(x), + uintptr(y), + uintptr(hIcon), + 0, + 0) + return ret1 != 0 +} + +func DrawIconEx(hdc HDC, xLeft int32, yTop int32, hIcon HICON, cxWidth int32, cyWidth int32, istepIfAniCur UINT, hbrFlickerFreeDraw HBRUSH, diFlags UINT) bool { + ret1 := syscall9(drawIconEx, 9, + uintptr(hdc), + uintptr(xLeft), + uintptr(yTop), + uintptr(hIcon), + uintptr(cxWidth), + uintptr(cyWidth), + uintptr(istepIfAniCur), + uintptr(hbrFlickerFreeDraw), + uintptr(diFlags)) + return ret1 != 0 +} + +func DrawMenuBar(hWnd HWND) bool { + ret1 := syscall3(drawMenuBar, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func DrawState(hdc HDC, hbrFore HBRUSH, qfnCallBack DRAWSTATEPROC, lData LPARAM, wData WPARAM, x int32, y int32, cx int32, cy int32, uFlags UINT) bool { + qfnCallBackCallback := syscall.NewCallback(func(hdcRawArg HDC, lDataRawArg uintptr, wDataRawArg uintptr, cxRawArg int32, cyRawArg int32) uintptr { + ret := qfnCallBack(hdcRawArg, lDataRawArg, wDataRawArg, cxRawArg, cyRawArg) + return uintptr(ret) + }) + ret1 := syscall12(drawState, 10, + uintptr(hdc), + uintptr(hbrFore), + qfnCallBackCallback, + uintptr(lData), + uintptr(wData), + uintptr(x), + uintptr(y), + uintptr(cx), + uintptr(cy), + uintptr(uFlags), + 0, + 0) + return ret1 != 0 +} + +func DrawTextEx(hdc HDC, lpchText LPWSTR, cchText int32, lprc *RECT, format UINT, lpdtp *DRAWTEXTPARAMS) int32 { + ret1 := syscall6(drawTextEx, 6, + uintptr(hdc), + uintptr(unsafe.Pointer(lpchText)), + uintptr(cchText), + uintptr(unsafe.Pointer(lprc)), + uintptr(format), + uintptr(unsafe.Pointer(lpdtp))) + return int32(ret1) +} + +func DrawText(hdc HDC, lpchText string, cchText int32, lprc *RECT, format UINT) int32 { + lpchTextStr := unicode16FromString(lpchText) + ret1 := syscall6(drawText, 5, + uintptr(hdc), + uintptr(unsafe.Pointer(&lpchTextStr[0])), + uintptr(cchText), + uintptr(unsafe.Pointer(lprc)), + uintptr(format), + 0) + return int32(ret1) +} + +func EmptyClipboard() bool { + ret1 := syscall3(emptyClipboard, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func EnableMenuItem(hMenu HMENU, uIDEnableItem UINT, uEnable UINT) bool { + ret1 := syscall3(enableMenuItem, 3, + uintptr(hMenu), + uintptr(uIDEnableItem), + uintptr(uEnable)) + return ret1 != 0 +} + +func EnableScrollBar(hWnd HWND, wSBflags UINT, wArrows UINT) bool { + ret1 := syscall3(enableScrollBar, 3, + uintptr(hWnd), + uintptr(wSBflags), + uintptr(wArrows)) + return ret1 != 0 +} + +func EnableWindow(hWnd HWND, bEnable bool) bool { + ret1 := syscall3(enableWindow, 2, + uintptr(hWnd), + getUintptrFromBool(bEnable), + 0) + return ret1 != 0 +} + +func EndDeferWindowPos(hWinPosInfo HDWP) bool { + ret1 := syscall3(endDeferWindowPos, 1, + uintptr(hWinPosInfo), + 0, + 0) + return ret1 != 0 +} + +func EndDialog(hDlg HWND, nResult INT_PTR) bool { + ret1 := syscall3(endDialog, 2, + uintptr(hDlg), + uintptr(unsafe.Pointer(nResult)), + 0) + return ret1 != 0 +} + +func EndMenu() bool { + ret1 := syscall3(endMenu, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func EndPaint(hWnd HWND, lpPaint /*const*/ *PAINTSTRUCT) bool { + ret1 := syscall3(endPaint, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpPaint)), + 0) + return ret1 != 0 +} + +func EndTask(hWnd HWND, fShutDown bool, fForce bool) bool { + ret1 := syscall3(endTask, 3, + uintptr(hWnd), + getUintptrFromBool(fShutDown), + getUintptrFromBool(fForce)) + return ret1 != 0 +} + +func EnumChildWindows(hWndParent HWND, lpEnumFunc WNDENUMPROC, lParam LPARAM) bool { + lpEnumFuncCallback := syscall.NewCallback(func(hWndRawArg HWND, lParamRawArg LPARAM) uintptr { + ret := lpEnumFunc(hWndRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall3(enumChildWindows, 3, + uintptr(hWndParent), + lpEnumFuncCallback, + uintptr(lParam)) + return ret1 != 0 +} + +func EnumClipboardFormats(format UINT) UINT { + ret1 := syscall3(enumClipboardFormats, 1, + uintptr(format), + 0, + 0) + return UINT(ret1) +} + +func EnumDesktopWindows(hDesktop HDESK, lpfn WNDENUMPROC, lParam LPARAM) bool { + lpfnCallback := syscall.NewCallback(func(hWndRawArg HWND, lParamRawArg LPARAM) uintptr { + ret := lpfn(hWndRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall3(enumDesktopWindows, 3, + uintptr(hDesktop), + lpfnCallback, + uintptr(lParam)) + return ret1 != 0 +} + +func EnumDesktops(hwinsta HWINSTA, lpEnumFunc DESKTOPENUMPROC, lParam LPARAM) bool { + lpEnumFuncCallback := syscall.NewCallback(func(lpszDesktopRawArg LPWSTR, lParamRawArg LPARAM) uintptr { + ret := lpEnumFunc(lpszDesktopRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall3(enumDesktops, 3, + uintptr(hwinsta), + lpEnumFuncCallback, + uintptr(lParam)) + return ret1 != 0 +} + +func EnumDisplayDevices(lpDevice string, iDevNum DWORD, lpDisplayDevice *DISPLAY_DEVICE, dwFlags DWORD) bool { + lpDeviceStr := unicode16FromString(lpDevice) + ret1 := syscall6(enumDisplayDevices, 4, + uintptr(unsafe.Pointer(&lpDeviceStr[0])), + uintptr(iDevNum), + uintptr(unsafe.Pointer(lpDisplayDevice)), + uintptr(dwFlags), + 0, + 0) + return ret1 != 0 +} + +func EnumDisplayMonitors(hdc HDC, lprcClip /*const*/ *RECT, lpfnEnum MONITORENUMPROC, dwData LPARAM) bool { + lpfnEnumCallback := syscall.NewCallback(func(hMonitorRawArg HMONITOR, hdcMonitorRawArg HDC, lprcMonitorRawArg *RECT, dwDataRawArg uintptr) uintptr { + ret := lpfnEnum(hMonitorRawArg, hdcMonitorRawArg, lprcMonitorRawArg, dwDataRawArg) + return uintptr(ret) + }) + ret1 := syscall6(enumDisplayMonitors, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(lprcClip)), + lpfnEnumCallback, + uintptr(dwData), + 0, + 0) + return ret1 != 0 +} + +func EnumDisplaySettingsEx(lpszDeviceName string, iModeNum DWORD, lpDevMode LPDEVMODE, dwFlags DWORD) bool { + lpszDeviceNameStr := unicode16FromString(lpszDeviceName) + ret1 := syscall6(enumDisplaySettingsEx, 4, + uintptr(unsafe.Pointer(&lpszDeviceNameStr[0])), + uintptr(iModeNum), + uintptr(unsafe.Pointer(lpDevMode)), + uintptr(dwFlags), + 0, + 0) + return ret1 != 0 +} + +func EnumDisplaySettings(lpszDeviceName string, iModeNum DWORD, lpDevMode LPDEVMODE) bool { + lpszDeviceNameStr := unicode16FromString(lpszDeviceName) + ret1 := syscall3(enumDisplaySettings, 3, + uintptr(unsafe.Pointer(&lpszDeviceNameStr[0])), + uintptr(iModeNum), + uintptr(unsafe.Pointer(lpDevMode))) + return ret1 != 0 +} + +func EnumPropsEx(hWnd HWND, lpEnumFunc PROPENUMPROCEX, lParam LPARAM) int32 { + lpEnumFuncCallback := syscall.NewCallback(func(hwndRawArg HWND, lpszStringRawArg LPWSTR, hDataRawArg HANDLE, dwDataRawArg uintptr) uintptr { + ret := lpEnumFunc(hwndRawArg, lpszStringRawArg, hDataRawArg, dwDataRawArg) + return uintptr(ret) + }) + ret1 := syscall3(enumPropsEx, 3, + uintptr(hWnd), + lpEnumFuncCallback, + uintptr(lParam)) + return int32(ret1) +} + +func EnumProps(hWnd HWND, lpEnumFunc PROPENUMPROC) int32 { + lpEnumFuncCallback := syscall.NewCallback(func(hWndRawArg HWND, lpszStringRawArg /*const*/ *uint16, hDataRawArg HANDLE) uintptr { + lpszString := stringFromUnicode16(lpszStringRawArg) + ret := lpEnumFunc(hWndRawArg, lpszString, hDataRawArg) + return uintptr(ret) + }) + ret1 := syscall3(enumProps, 2, + uintptr(hWnd), + lpEnumFuncCallback, + 0) + return int32(ret1) +} + +func EnumThreadWindows(dwThreadId DWORD, lpfn WNDENUMPROC, lParam LPARAM) bool { + lpfnCallback := syscall.NewCallback(func(hWndRawArg HWND, lParamRawArg LPARAM) uintptr { + ret := lpfn(hWndRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall3(enumThreadWindows, 3, + uintptr(dwThreadId), + lpfnCallback, + uintptr(lParam)) + return ret1 != 0 +} + +func EnumWindowStations(lpEnumFunc WINSTAENUMPROC, lParam LPARAM) bool { + lpEnumFuncCallback := syscall.NewCallback(func(lpszWindowStationRawArg LPWSTR, lParamRawArg LPARAM) uintptr { + ret := lpEnumFunc(lpszWindowStationRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall3(enumWindowStations, 2, + lpEnumFuncCallback, + uintptr(lParam), + 0) + return ret1 != 0 +} + +func EnumWindows(lpEnumFunc WNDENUMPROC, lParam LPARAM) bool { + lpEnumFuncCallback := syscall.NewCallback(func(hWndRawArg HWND, lParamRawArg LPARAM) uintptr { + ret := lpEnumFunc(hWndRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall3(enumWindows, 2, + lpEnumFuncCallback, + uintptr(lParam), + 0) + return ret1 != 0 +} + +func EqualRect(lprc1 /*const*/ *RECT, lprc2 /*const*/ *RECT) bool { + ret1 := syscall3(equalRect, 2, + uintptr(unsafe.Pointer(lprc1)), + uintptr(unsafe.Pointer(lprc2)), + 0) + return ret1 != 0 +} + +func ExcludeUpdateRgn(hDC HDC, hWnd HWND) int32 { + ret1 := syscall3(excludeUpdateRgn, 2, + uintptr(hDC), + uintptr(hWnd), + 0) + return int32(ret1) +} + +func ExitWindowsEx(uFlags UINT, dwReason DWORD) bool { + ret1 := syscall3(exitWindowsEx, 2, + uintptr(uFlags), + uintptr(dwReason), + 0) + return ret1 != 0 +} + +func FillRect(hDC HDC, lprc /*const*/ *RECT, hbr HBRUSH) int32 { + ret1 := syscall3(fillRect, 3, + uintptr(hDC), + uintptr(unsafe.Pointer(lprc)), + uintptr(hbr)) + return int32(ret1) +} + +func FindWindowEx(hWndParent HWND, hWndChildAfter HWND, lpszClass string, lpszWindow string) HWND { + lpszClassStr := unicode16FromString(lpszClass) + lpszWindowStr := unicode16FromString(lpszWindow) + ret1 := syscall6(findWindowEx, 4, + uintptr(hWndParent), + uintptr(hWndChildAfter), + uintptr(unsafe.Pointer(&lpszClassStr[0])), + uintptr(unsafe.Pointer(&lpszWindowStr[0])), + 0, + 0) + return HWND(ret1) +} + +func FindWindow(lpClassName string, lpWindowName string) HWND { + lpClassNameStr := unicode16FromString(lpClassName) + lpWindowNameStr := unicode16FromString(lpWindowName) + ret1 := syscall3(findWindow, 2, + uintptr(unsafe.Pointer(&lpClassNameStr[0])), + uintptr(unsafe.Pointer(&lpWindowNameStr[0])), + 0) + return HWND(ret1) +} + +func FlashWindow(hWnd HWND, bInvert bool) bool { + ret1 := syscall3(flashWindow, 2, + uintptr(hWnd), + getUintptrFromBool(bInvert), + 0) + return ret1 != 0 +} + +func FlashWindowEx(pfwi *FLASHWINFO) bool { + ret1 := syscall3(flashWindowEx, 1, + uintptr(unsafe.Pointer(pfwi)), + 0, + 0) + return ret1 != 0 +} + +func FrameRect(hDC HDC, lprc /*const*/ *RECT, hbr HBRUSH) int32 { + ret1 := syscall3(frameRect, 3, + uintptr(hDC), + uintptr(unsafe.Pointer(lprc)), + uintptr(hbr)) + return int32(ret1) +} + +func FreeDDElParam(msg UINT, lParam LPARAM) bool { + ret1 := syscall3(freeDDElParam, 2, + uintptr(msg), + uintptr(lParam), + 0) + return ret1 != 0 +} + +func GetActiveWindow() HWND { + ret1 := syscall3(getActiveWindow, 0, + 0, + 0, + 0) + return HWND(ret1) +} + +func GetAltTabInfo(hwnd HWND, iItem int32, pati *ALTTABINFO, pszItemText LPWSTR, cchItemText UINT) bool { + ret1 := syscall6(getAltTabInfo, 5, + uintptr(hwnd), + uintptr(iItem), + uintptr(unsafe.Pointer(pati)), + uintptr(unsafe.Pointer(pszItemText)), + uintptr(cchItemText), + 0) + return ret1 != 0 +} + +func GetAncestor(hwnd HWND, gaFlags UINT) HWND { + ret1 := syscall3(getAncestor, 2, + uintptr(hwnd), + uintptr(gaFlags), + 0) + return HWND(ret1) +} + +func GetAsyncKeyState(vKey int32) SHORT { + ret1 := syscall3(getAsyncKeyState, 1, + uintptr(vKey), + 0, + 0) + return SHORT(ret1) +} + +func GetCapture() HWND { + ret1 := syscall3(getCapture, 0, + 0, + 0, + 0) + return HWND(ret1) +} + +func GetCaretBlinkTime() UINT { + ret1 := syscall3(getCaretBlinkTime, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func GetCaretPos(lpPoint *POINT) bool { + ret1 := syscall3(getCaretPos, 1, + uintptr(unsafe.Pointer(lpPoint)), + 0, + 0) + return ret1 != 0 +} + +func GetClassInfoEx(hInstance HINSTANCE, lpszClass string, lpwcx *WNDCLASSEX) bool { + lpszClassStr := unicode16FromString(lpszClass) + ret1 := syscall3(getClassInfoEx, 3, + uintptr(hInstance), + uintptr(unsafe.Pointer(&lpszClassStr[0])), + uintptr(unsafe.Pointer(lpwcx))) + return ret1 != 0 +} + +func GetClassInfo(hInstance HINSTANCE, lpClassName string, lpWndClass *WNDCLASS) bool { + lpClassNameStr := unicode16FromString(lpClassName) + ret1 := syscall3(getClassInfo, 3, + uintptr(hInstance), + uintptr(unsafe.Pointer(&lpClassNameStr[0])), + uintptr(unsafe.Pointer(lpWndClass))) + return ret1 != 0 +} + +func GetClassLongPtr(hWnd HWND, nIndex int32) *uint32 { + ret1 := syscall3(getClassLongPtr, 2, + uintptr(hWnd), + uintptr(nIndex), + 0) + return (*uint32)(unsafe.Pointer(ret1)) +} + +func GetClassLong(hWnd HWND, nIndex int32) DWORD { + ret1 := syscall3(getClassLong, 2, + uintptr(hWnd), + uintptr(nIndex), + 0) + return DWORD(ret1) +} + +func GetClassName(hWnd HWND, lpClassName LPWSTR, nMaxCount int32) int32 { + ret1 := syscall3(getClassName, 3, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpClassName)), + uintptr(nMaxCount)) + return int32(ret1) +} + +func GetClassWord(hWnd HWND, nIndex int32) WORD { + ret1 := syscall3(getClassWord, 2, + uintptr(hWnd), + uintptr(nIndex), + 0) + return WORD(ret1) +} + +func GetClientRect(hWnd HWND, lpRect *RECT) bool { + ret1 := syscall3(getClientRect, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpRect)), + 0) + return ret1 != 0 +} + +func GetClipCursor(lpRect *RECT) bool { + ret1 := syscall3(getClipCursor, 1, + uintptr(unsafe.Pointer(lpRect)), + 0, + 0) + return ret1 != 0 +} + +func GetClipboardData(uFormat UINT) HANDLE { + ret1 := syscall3(getClipboardData, 1, + uintptr(uFormat), + 0, + 0) + return HANDLE(ret1) +} + +func GetClipboardFormatName(format UINT, lpszFormatName LPWSTR, cchMaxCount int32) int32 { + ret1 := syscall3(getClipboardFormatName, 3, + uintptr(format), + uintptr(unsafe.Pointer(lpszFormatName)), + uintptr(cchMaxCount)) + return int32(ret1) +} + +func GetClipboardOwner() HWND { + ret1 := syscall3(getClipboardOwner, 0, + 0, + 0, + 0) + return HWND(ret1) +} + +func GetClipboardSequenceNumber() DWORD { + ret1 := syscall3(getClipboardSequenceNumber, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func GetClipboardViewer() HWND { + ret1 := syscall3(getClipboardViewer, 0, + 0, + 0, + 0) + return HWND(ret1) +} + +func GetComboBoxInfo(hwndCombo HWND, pcbi *COMBOBOXINFO) bool { + ret1 := syscall3(getComboBoxInfo, 2, + uintptr(hwndCombo), + uintptr(unsafe.Pointer(pcbi)), + 0) + return ret1 != 0 +} + +func GetCursor() HCURSOR { + ret1 := syscall3(getCursor, 0, + 0, + 0, + 0) + return HCURSOR(ret1) +} + +func GetCursorInfo(pci *CURSORINFO) bool { + ret1 := syscall3(getCursorInfo, 1, + uintptr(unsafe.Pointer(pci)), + 0, + 0) + return ret1 != 0 +} + +func GetCursorPos(lpPoint *POINT) bool { + ret1 := syscall3(getCursorPos, 1, + uintptr(unsafe.Pointer(lpPoint)), + 0, + 0) + return ret1 != 0 +} + +func GetDC(hWnd HWND) HDC { + ret1 := syscall3(getDC, 1, + uintptr(hWnd), + 0, + 0) + return HDC(ret1) +} + +func GetDCEx(hWnd HWND, hrgnClip HRGN, flags DWORD) HDC { + ret1 := syscall3(getDCEx, 3, + uintptr(hWnd), + uintptr(hrgnClip), + uintptr(flags)) + return HDC(ret1) +} + +func GetDesktopWindow() HWND { + ret1 := syscall3(getDesktopWindow, 0, + 0, + 0, + 0) + return HWND(ret1) +} + +func GetDialogBaseUnits() int32 { + ret1 := syscall3(getDialogBaseUnits, 0, + 0, + 0, + 0) + return int32(ret1) +} + +func GetDlgCtrlID(hWnd HWND) int32 { + ret1 := syscall3(getDlgCtrlID, 1, + uintptr(hWnd), + 0, + 0) + return int32(ret1) +} + +func GetDlgItem(hDlg HWND, nIDDlgItem int32) HWND { + ret1 := syscall3(getDlgItem, 2, + uintptr(hDlg), + uintptr(nIDDlgItem), + 0) + return HWND(ret1) +} + +func GetDlgItemInt(hDlg HWND, nIDDlgItem int32, lpTranslated *BOOL, bSigned bool) UINT { + ret1 := syscall6(getDlgItemInt, 4, + uintptr(hDlg), + uintptr(nIDDlgItem), + uintptr(unsafe.Pointer(lpTranslated)), + getUintptrFromBool(bSigned), + 0, + 0) + return UINT(ret1) +} + +func GetDlgItemText(hDlg HWND, nIDDlgItem int32, lpString LPWSTR, cchMax int32) UINT { + ret1 := syscall6(getDlgItemText, 4, + uintptr(hDlg), + uintptr(nIDDlgItem), + uintptr(unsafe.Pointer(lpString)), + uintptr(cchMax), + 0, + 0) + return UINT(ret1) +} + +func GetDoubleClickTime() UINT { + ret1 := syscall3(getDoubleClickTime, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func GetFocus() HWND { + ret1 := syscall3(getFocus, 0, + 0, + 0, + 0) + return HWND(ret1) +} + +func GetForegroundWindow() HWND { + ret1 := syscall3(getForegroundWindow, 0, + 0, + 0, + 0) + return HWND(ret1) +} + +func GetGUIThreadInfo(idThread DWORD, pgui *GUITHREADINFO) bool { + ret1 := syscall3(getGUIThreadInfo, 2, + uintptr(idThread), + uintptr(unsafe.Pointer(pgui)), + 0) + return ret1 != 0 +} + +func GetGestureConfig(hwnd HWND, dwReserved DWORD, dwFlags DWORD, pcIDs *uint32, pGestureConfig *GESTURECONFIG, cbSize UINT) bool { + ret1 := syscall6(getGestureConfig, 6, + uintptr(hwnd), + uintptr(dwReserved), + uintptr(dwFlags), + uintptr(unsafe.Pointer(pcIDs)), + uintptr(unsafe.Pointer(pGestureConfig)), + uintptr(cbSize)) + return ret1 != 0 +} + +func GetGestureExtraArgs(hGestureInfo HGESTUREINFO, cbExtraArgs UINT, pExtraArgs *byte) bool { + ret1 := syscall3(getGestureExtraArgs, 3, + uintptr(hGestureInfo), + uintptr(cbExtraArgs), + uintptr(unsafe.Pointer(pExtraArgs))) + return ret1 != 0 +} + +func GetGestureInfo(hGestureInfo HGESTUREINFO, pGestureInfo *GESTUREINFO) bool { + ret1 := syscall3(getGestureInfo, 2, + uintptr(hGestureInfo), + uintptr(unsafe.Pointer(pGestureInfo)), + 0) + return ret1 != 0 +} + +func GetGuiResources(hProcess HANDLE, uiFlags DWORD) DWORD { + ret1 := syscall3(getGuiResources, 2, + uintptr(hProcess), + uintptr(uiFlags), + 0) + return DWORD(ret1) +} + +func GetIconInfo(hIcon HICON, piconinfo *ICONINFO) bool { + ret1 := syscall3(getIconInfo, 2, + uintptr(hIcon), + uintptr(unsafe.Pointer(piconinfo)), + 0) + return ret1 != 0 +} + +func GetInputState() bool { + ret1 := syscall3(getInputState, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func GetKBCodePage() UINT { + ret1 := syscall3(getKBCodePage, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func GetKeyNameText(lParam LONG, lpString LPWSTR, cchSize int32) int32 { + ret1 := syscall3(getKeyNameText, 3, + uintptr(lParam), + uintptr(unsafe.Pointer(lpString)), + uintptr(cchSize)) + return int32(ret1) +} + +func GetKeyState(nVirtKey int32) SHORT { + ret1 := syscall3(getKeyState, 1, + uintptr(nVirtKey), + 0, + 0) + return SHORT(ret1) +} + +func GetKeyboardLayout(idThread DWORD) HKL { + ret1 := syscall3(getKeyboardLayout, 1, + uintptr(idThread), + 0, + 0) + return HKL(ret1) +} + +func GetKeyboardLayoutList(nBuff int32, lpList *HKL) int32 { + ret1 := syscall3(getKeyboardLayoutList, 2, + uintptr(nBuff), + uintptr(unsafe.Pointer(lpList)), + 0) + return int32(ret1) +} + +func GetKeyboardLayoutName(pwszKLID LPWSTR) bool { + ret1 := syscall3(getKeyboardLayoutName, 1, + uintptr(unsafe.Pointer(pwszKLID)), + 0, + 0) + return ret1 != 0 +} + +func GetKeyboardState(lpKeyState *byte) bool { + ret1 := syscall3(getKeyboardState, 1, + uintptr(unsafe.Pointer(lpKeyState)), + 0, + 0) + return ret1 != 0 +} + +func GetKeyboardType(nTypeFlag int32) int32 { + ret1 := syscall3(getKeyboardType, 1, + uintptr(nTypeFlag), + 0, + 0) + return int32(ret1) +} + +func GetLastActivePopup(hWnd HWND) HWND { + ret1 := syscall3(getLastActivePopup, 1, + uintptr(hWnd), + 0, + 0) + return HWND(ret1) +} + +func GetLastInputInfo(plii *LASTINPUTINFO) bool { + ret1 := syscall3(getLastInputInfo, 1, + uintptr(unsafe.Pointer(plii)), + 0, + 0) + return ret1 != 0 +} + +func GetLayeredWindowAttributes(hwnd HWND, pcrKey *COLORREF, pbAlpha *byte, pdwFlags *uint32) bool { + ret1 := syscall6(getLayeredWindowAttributes, 4, + uintptr(hwnd), + uintptr(unsafe.Pointer(pcrKey)), + uintptr(unsafe.Pointer(pbAlpha)), + uintptr(unsafe.Pointer(pdwFlags)), + 0, + 0) + return ret1 != 0 +} + +func GetListBoxInfo(hwnd HWND) DWORD { + ret1 := syscall3(getListBoxInfo, 1, + uintptr(hwnd), + 0, + 0) + return DWORD(ret1) +} + +func GetMenu(hWnd HWND) HMENU { + ret1 := syscall3(getMenu, 1, + uintptr(hWnd), + 0, + 0) + return HMENU(ret1) +} + +func GetMenuBarInfo(hwnd HWND, idObject LONG, idItem LONG, pmbi *MENUBARINFO) bool { + ret1 := syscall6(getMenuBarInfo, 4, + uintptr(hwnd), + uintptr(idObject), + uintptr(idItem), + uintptr(unsafe.Pointer(pmbi)), + 0, + 0) + return ret1 != 0 +} + +func GetMenuCheckMarkDimensions() LONG { + ret1 := syscall3(getMenuCheckMarkDimensions, 0, + 0, + 0, + 0) + return LONG(ret1) +} + +func GetMenuContextHelpId(unnamed0 HMENU) DWORD { + ret1 := syscall3(getMenuContextHelpId, 1, + uintptr(unnamed0), + 0, + 0) + return DWORD(ret1) +} + +func GetMenuDefaultItem(hMenu HMENU, fByPos UINT, gmdiFlags UINT) UINT { + ret1 := syscall3(getMenuDefaultItem, 3, + uintptr(hMenu), + uintptr(fByPos), + uintptr(gmdiFlags)) + return UINT(ret1) +} + +func GetMenuInfo(unnamed0 HMENU, unnamed1 *MENUINFO) bool { + ret1 := syscall3(getMenuInfo, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + 0) + return ret1 != 0 +} + +func GetMenuItemCount(hMenu HMENU) int32 { + ret1 := syscall3(getMenuItemCount, 1, + uintptr(hMenu), + 0, + 0) + return int32(ret1) +} + +func GetMenuItemID(hMenu HMENU, nPos int32) UINT { + ret1 := syscall3(getMenuItemID, 2, + uintptr(hMenu), + uintptr(nPos), + 0) + return UINT(ret1) +} + +func GetMenuItemInfo(hmenu HMENU, item UINT, fByPosition bool, lpmii *MENUITEMINFO) bool { + ret1 := syscall6(getMenuItemInfo, 4, + uintptr(hmenu), + uintptr(item), + getUintptrFromBool(fByPosition), + uintptr(unsafe.Pointer(lpmii)), + 0, + 0) + return ret1 != 0 +} + +func GetMenuItemRect(hWnd HWND, hMenu HMENU, uItem UINT, lprcItem *RECT) bool { + ret1 := syscall6(getMenuItemRect, 4, + uintptr(hWnd), + uintptr(hMenu), + uintptr(uItem), + uintptr(unsafe.Pointer(lprcItem)), + 0, + 0) + return ret1 != 0 +} + +func GetMenuState(hMenu HMENU, uId UINT, uFlags UINT) UINT { + ret1 := syscall3(getMenuState, 3, + uintptr(hMenu), + uintptr(uId), + uintptr(uFlags)) + return UINT(ret1) +} + +func GetMenuString(hMenu HMENU, uIDItem UINT, lpString LPWSTR, cchMax int32, flags UINT) int32 { + ret1 := syscall6(getMenuString, 5, + uintptr(hMenu), + uintptr(uIDItem), + uintptr(unsafe.Pointer(lpString)), + uintptr(cchMax), + uintptr(flags), + 0) + return int32(ret1) +} + +func GetMessageExtraInfo() LPARAM { + ret1 := syscall3(getMessageExtraInfo, 0, + 0, + 0, + 0) + return LPARAM(ret1) +} + +func GetMessagePos() DWORD { + ret1 := syscall3(getMessagePos, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func GetMessageTime() LONG { + ret1 := syscall3(getMessageTime, 0, + 0, + 0, + 0) + return LONG(ret1) +} + +func GetMessage(lpMsg *MSG, hWnd HWND, wMsgFilterMin UINT, wMsgFilterMax UINT) bool { + ret1 := syscall6(getMessage, 4, + uintptr(unsafe.Pointer(lpMsg)), + uintptr(hWnd), + uintptr(wMsgFilterMin), + uintptr(wMsgFilterMax), + 0, + 0) + return ret1 != 0 +} + +func GetMonitorInfo(hMonitor HMONITOR, lpmi *MONITORINFO) bool { + ret1 := syscall3(getMonitorInfo, 2, + uintptr(hMonitor), + uintptr(unsafe.Pointer(lpmi)), + 0) + return ret1 != 0 +} + +func GetMouseMovePointsEx(cbSize UINT, lppt *MOUSEMOVEPOINT, lpptBuf *MOUSEMOVEPOINT, nBufPoints int32, resolution DWORD) int32 { + ret1 := syscall6(getMouseMovePointsEx, 5, + uintptr(cbSize), + uintptr(unsafe.Pointer(lppt)), + uintptr(unsafe.Pointer(lpptBuf)), + uintptr(nBufPoints), + uintptr(resolution), + 0) + return int32(ret1) +} + +func GetNextDlgGroupItem(hDlg HWND, hCtl HWND, bPrevious bool) HWND { + ret1 := syscall3(getNextDlgGroupItem, 3, + uintptr(hDlg), + uintptr(hCtl), + getUintptrFromBool(bPrevious)) + return HWND(ret1) +} + +func GetNextDlgTabItem(hDlg HWND, hCtl HWND, bPrevious bool) HWND { + ret1 := syscall3(getNextDlgTabItem, 3, + uintptr(hDlg), + uintptr(hCtl), + getUintptrFromBool(bPrevious)) + return HWND(ret1) +} + +func GetOpenClipboardWindow() HWND { + ret1 := syscall3(getOpenClipboardWindow, 0, + 0, + 0, + 0) + return HWND(ret1) +} + +func GetParent(hWnd HWND) HWND { + ret1 := syscall3(getParent, 1, + uintptr(hWnd), + 0, + 0) + return HWND(ret1) +} + +func GetPriorityClipboardFormat(paFormatPriorityList *UINT, cFormats int32) int32 { + ret1 := syscall3(getPriorityClipboardFormat, 2, + uintptr(unsafe.Pointer(paFormatPriorityList)), + uintptr(cFormats), + 0) + return int32(ret1) +} + +func GetProcessDefaultLayout(pdwDefaultLayout *uint32) bool { + ret1 := syscall3(getProcessDefaultLayout, 1, + uintptr(unsafe.Pointer(pdwDefaultLayout)), + 0, + 0) + return ret1 != 0 +} + +func GetProcessWindowStation() HWINSTA { + ret1 := syscall3(getProcessWindowStation, 0, + 0, + 0, + 0) + return HWINSTA(ret1) +} + +func GetProp(hWnd HWND, lpString string) HANDLE { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(getProp, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(&lpStringStr[0])), + 0) + return HANDLE(ret1) +} + +func GetQueueStatus(flags UINT) DWORD { + ret1 := syscall3(getQueueStatus, 1, + uintptr(flags), + 0, + 0) + return DWORD(ret1) +} + +func GetRawInputBuffer(pData *RAWINPUT, pcbSize *uint32, cbSizeHeader UINT) UINT { + ret1 := syscall3(getRawInputBuffer, 3, + uintptr(unsafe.Pointer(pData)), + uintptr(unsafe.Pointer(pcbSize)), + uintptr(cbSizeHeader)) + return UINT(ret1) +} + +func GetRawInputData(hRawInput HRAWINPUT, uiCommand UINT, pData LPVOID, pcbSize *uint32, cbSizeHeader UINT) UINT { + ret1 := syscall6(getRawInputData, 5, + uintptr(hRawInput), + uintptr(uiCommand), + uintptr(unsafe.Pointer(pData)), + uintptr(unsafe.Pointer(pcbSize)), + uintptr(cbSizeHeader), + 0) + return UINT(ret1) +} + +func GetRawInputDeviceInfo(hDevice HANDLE, uiCommand UINT, pData LPVOID, pcbSize *uint32) UINT { + ret1 := syscall6(getRawInputDeviceInfo, 4, + uintptr(hDevice), + uintptr(uiCommand), + uintptr(unsafe.Pointer(pData)), + uintptr(unsafe.Pointer(pcbSize)), + 0, + 0) + return UINT(ret1) +} + +func GetRawInputDeviceList(pRawInputDeviceList *RAWINPUTDEVICELIST, puiNumDevices *uint32, cbSize UINT) UINT { + ret1 := syscall3(getRawInputDeviceList, 3, + uintptr(unsafe.Pointer(pRawInputDeviceList)), + uintptr(unsafe.Pointer(puiNumDevices)), + uintptr(cbSize)) + return UINT(ret1) +} + +func GetRegisteredRawInputDevices(pRawInputDevices *RAWINPUTDEVICE, puiNumDevices *uint32, cbSize UINT) UINT { + ret1 := syscall3(getRegisteredRawInputDevices, 3, + uintptr(unsafe.Pointer(pRawInputDevices)), + uintptr(unsafe.Pointer(puiNumDevices)), + uintptr(cbSize)) + return UINT(ret1) +} + +func GetScrollBarInfo(hwnd HWND, idObject LONG, psbi *SCROLLBARINFO) bool { + ret1 := syscall3(getScrollBarInfo, 3, + uintptr(hwnd), + uintptr(idObject), + uintptr(unsafe.Pointer(psbi))) + return ret1 != 0 +} + +func GetScrollInfo(hwnd HWND, nBar int32, lpsi *SCROLLINFO) bool { + ret1 := syscall3(getScrollInfo, 3, + uintptr(hwnd), + uintptr(nBar), + uintptr(unsafe.Pointer(lpsi))) + return ret1 != 0 +} + +func GetScrollPos(hWnd HWND, nBar int32) int32 { + ret1 := syscall3(getScrollPos, 2, + uintptr(hWnd), + uintptr(nBar), + 0) + return int32(ret1) +} + +func GetScrollRange(hWnd HWND, nBar int32, lpMinPos *int32, lpMaxPos *int32) bool { + ret1 := syscall6(getScrollRange, 4, + uintptr(hWnd), + uintptr(nBar), + uintptr(unsafe.Pointer(lpMinPos)), + uintptr(unsafe.Pointer(lpMaxPos)), + 0, + 0) + return ret1 != 0 +} + +func GetShellWindow() HWND { + ret1 := syscall3(getShellWindow, 0, + 0, + 0, + 0) + return HWND(ret1) +} + +func GetSubMenu(hMenu HMENU, nPos int32) HMENU { + ret1 := syscall3(getSubMenu, 2, + uintptr(hMenu), + uintptr(nPos), + 0) + return HMENU(ret1) +} + +func GetSysColor(nIndex int32) DWORD { + ret1 := syscall3(getSysColor, 1, + uintptr(nIndex), + 0, + 0) + return DWORD(ret1) +} + +func GetSysColorBrush(nIndex int32) HBRUSH { + ret1 := syscall3(getSysColorBrush, 1, + uintptr(nIndex), + 0, + 0) + return HBRUSH(ret1) +} + +func GetSystemMenu(hWnd HWND, bRevert bool) HMENU { + ret1 := syscall3(getSystemMenu, 2, + uintptr(hWnd), + getUintptrFromBool(bRevert), + 0) + return HMENU(ret1) +} + +func GetSystemMetrics(nIndex int32) int32 { + ret1 := syscall3(getSystemMetrics, 1, + uintptr(nIndex), + 0, + 0) + return int32(ret1) +} + +func GetTabbedTextExtent(hdc HDC, lpString string, chCount int32, nTabPositions int32, lpnTabStopPositions /*const*/ *int32) DWORD { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall6(getTabbedTextExtent, 5, + uintptr(hdc), + uintptr(unsafe.Pointer(&lpStringStr[0])), + uintptr(chCount), + uintptr(nTabPositions), + uintptr(unsafe.Pointer(lpnTabStopPositions)), + 0) + return DWORD(ret1) +} + +func GetThreadDesktop(dwThreadId DWORD) HDESK { + ret1 := syscall3(getThreadDesktop, 1, + uintptr(dwThreadId), + 0, + 0) + return HDESK(ret1) +} + +func GetTitleBarInfo(hwnd HWND, pti *TITLEBARINFO) bool { + ret1 := syscall3(getTitleBarInfo, 2, + uintptr(hwnd), + uintptr(unsafe.Pointer(pti)), + 0) + return ret1 != 0 +} + +func GetTopWindow(hWnd HWND) HWND { + ret1 := syscall3(getTopWindow, 1, + uintptr(hWnd), + 0, + 0) + return HWND(ret1) +} + +func GetTouchInputInfo(hTouchInput HTOUCHINPUT, cInputs UINT, pInputs *TOUCHINPUT, cbSize int32) bool { + ret1 := syscall6(getTouchInputInfo, 4, + uintptr(hTouchInput), + uintptr(cInputs), + uintptr(unsafe.Pointer(pInputs)), + uintptr(cbSize), + 0, + 0) + return ret1 != 0 +} + +func GetUpdateRect(hWnd HWND, lpRect *RECT, bErase bool) bool { + ret1 := syscall3(getUpdateRect, 3, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpRect)), + getUintptrFromBool(bErase)) + return ret1 != 0 +} + +func GetUpdateRgn(hWnd HWND, hRgn HRGN, bErase bool) int32 { + ret1 := syscall3(getUpdateRgn, 3, + uintptr(hWnd), + uintptr(hRgn), + getUintptrFromBool(bErase)) + return int32(ret1) +} + +func GetUserObjectInformation(hObj HANDLE, nIndex int32, pvInfo uintptr, nLength DWORD, lpnLengthNeeded *uint32) bool { + ret1 := syscall6(getUserObjectInformation, 5, + uintptr(hObj), + uintptr(nIndex), + pvInfo, + uintptr(nLength), + uintptr(unsafe.Pointer(lpnLengthNeeded)), + 0) + return ret1 != 0 +} + +func GetUserObjectSecurity(hObj HANDLE, pSIRequested *SECURITY_INFORMATION, pSID PSECURITY_DESCRIPTOR, nLength DWORD, lpnLengthNeeded *uint32) bool { + ret1 := syscall6(getUserObjectSecurity, 5, + uintptr(hObj), + uintptr(unsafe.Pointer(pSIRequested)), + uintptr(unsafe.Pointer(pSID)), + uintptr(nLength), + uintptr(unsafe.Pointer(lpnLengthNeeded)), + 0) + return ret1 != 0 +} + +func GetWindow(hWnd HWND, uCmd UINT) HWND { + ret1 := syscall3(getWindow, 2, + uintptr(hWnd), + uintptr(uCmd), + 0) + return HWND(ret1) +} + +func GetWindowContextHelpId(unnamed0 HWND) DWORD { + ret1 := syscall3(getWindowContextHelpId, 1, + uintptr(unnamed0), + 0, + 0) + return DWORD(ret1) +} + +func GetWindowDC(hWnd HWND) HDC { + ret1 := syscall3(getWindowDC, 1, + uintptr(hWnd), + 0, + 0) + return HDC(ret1) +} + +func GetWindowInfo(hwnd HWND, pwi *WINDOWINFO) bool { + ret1 := syscall3(getWindowInfo, 2, + uintptr(hwnd), + uintptr(unsafe.Pointer(pwi)), + 0) + return ret1 != 0 +} + +func GetWindowLongPtr(hWnd HWND, nIndex int32) uintptr { + ret1 := syscall3(getWindowLongPtr, 2, + uintptr(hWnd), + uintptr(nIndex), + 0) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func GetWindowLong(hWnd HWND, nIndex int32) LONG { + ret1 := syscall3(getWindowLong, 2, + uintptr(hWnd), + uintptr(nIndex), + 0) + return LONG(ret1) +} + +func GetWindowModuleFileName(hwnd HWND, pszFileName LPWSTR, cchFileNameMax UINT) UINT { + ret1 := syscall3(getWindowModuleFileName, 3, + uintptr(hwnd), + uintptr(unsafe.Pointer(pszFileName)), + uintptr(cchFileNameMax)) + return UINT(ret1) +} + +func GetWindowPlacement(hWnd HWND, lpwndpl *WINDOWPLACEMENT) bool { + ret1 := syscall3(getWindowPlacement, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpwndpl)), + 0) + return ret1 != 0 +} + +func GetWindowRect(hWnd HWND, lpRect *RECT) bool { + ret1 := syscall3(getWindowRect, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpRect)), + 0) + return ret1 != 0 +} + +func GetWindowRgn(hWnd HWND, hRgn HRGN) int32 { + ret1 := syscall3(getWindowRgn, 2, + uintptr(hWnd), + uintptr(hRgn), + 0) + return int32(ret1) +} + +func GetWindowRgnBox(hWnd HWND, lprc *RECT) int32 { + ret1 := syscall3(getWindowRgnBox, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(lprc)), + 0) + return int32(ret1) +} + +func GetWindowTextLength(hWnd HWND) int32 { + ret1 := syscall3(getWindowTextLength, 1, + uintptr(hWnd), + 0, + 0) + return int32(ret1) +} + +func GetWindowText(hWnd HWND, lpString LPWSTR, nMaxCount int32) int32 { + ret1 := syscall3(getWindowText, 3, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpString)), + uintptr(nMaxCount)) + return int32(ret1) +} + +func GetWindowThreadProcessId(hWnd HWND, lpdwProcessId *uint32) DWORD { + ret1 := syscall3(getWindowThreadProcessId, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpdwProcessId)), + 0) + return DWORD(ret1) +} + +func GetWindowWord(hWnd HWND, nIndex int32) WORD { + ret1 := syscall3(getWindowWord, 2, + uintptr(hWnd), + uintptr(nIndex), + 0) + return WORD(ret1) +} + +func GrayString(hDC HDC, hBrush HBRUSH, lpOutputFunc GRAYSTRINGPROC, lpData LPARAM, nCount int32, x int32, y int32, nWidth int32, nHeight int32) bool { + lpOutputFuncCallback := syscall.NewCallback(func(hdcRawArg HDC, lParamRawArg LPARAM, cchDataRawArg int) uintptr { + ret := lpOutputFunc(hdcRawArg, lParamRawArg, cchDataRawArg) + return uintptr(ret) + }) + ret1 := syscall9(grayString, 9, + uintptr(hDC), + uintptr(hBrush), + lpOutputFuncCallback, + uintptr(lpData), + uintptr(nCount), + uintptr(x), + uintptr(y), + uintptr(nWidth), + uintptr(nHeight)) + return ret1 != 0 +} + +func HideCaret(hWnd HWND) bool { + ret1 := syscall3(hideCaret, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func HiliteMenuItem(hWnd HWND, hMenu HMENU, uIDHiliteItem UINT, uHilite UINT) bool { + ret1 := syscall6(hiliteMenuItem, 4, + uintptr(hWnd), + uintptr(hMenu), + uintptr(uIDHiliteItem), + uintptr(uHilite), + 0, + 0) + return ret1 != 0 +} + +func IMPGetIME(unnamed0 HWND, unnamed1 *IMEPRO) bool { + ret1 := syscall3(iMPGetIME, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + 0) + return ret1 != 0 +} + +func IMPQueryIME(unnamed0 *IMEPRO) bool { + ret1 := syscall3(iMPQueryIME, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return ret1 != 0 +} + +func IMPSetIME(unnamed0 HWND, unnamed1 *IMEPRO) bool { + ret1 := syscall3(iMPSetIME, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + 0) + return ret1 != 0 +} + +func ImpersonateDdeClientWindow(hWndClient HWND, hWndServer HWND) bool { + ret1 := syscall3(impersonateDdeClientWindow, 2, + uintptr(hWndClient), + uintptr(hWndServer), + 0) + return ret1 != 0 +} + +func InSendMessage() bool { + ret1 := syscall3(inSendMessage, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func InSendMessageEx(lpReserved LPVOID) DWORD { + ret1 := syscall3(inSendMessageEx, 1, + uintptr(unsafe.Pointer(lpReserved)), + 0, + 0) + return DWORD(ret1) +} + +func InflateRect(lprc *RECT, dx int32, dy int32) bool { + ret1 := syscall3(inflateRect, 3, + uintptr(unsafe.Pointer(lprc)), + uintptr(dx), + uintptr(dy)) + return ret1 != 0 +} + +func InsertMenuItem(hmenu HMENU, item UINT, fByPosition bool, lpmi /*const*/ *MENUITEMINFO) bool { + ret1 := syscall6(insertMenuItem, 4, + uintptr(hmenu), + uintptr(item), + getUintptrFromBool(fByPosition), + uintptr(unsafe.Pointer(lpmi)), + 0, + 0) + return ret1 != 0 +} + +func InsertMenu(hMenu HMENU, uPosition UINT, uFlags UINT, uIDNewItem *uint32, lpNewItem string) bool { + lpNewItemStr := unicode16FromString(lpNewItem) + ret1 := syscall6(insertMenu, 5, + uintptr(hMenu), + uintptr(uPosition), + uintptr(uFlags), + uintptr(unsafe.Pointer(uIDNewItem)), + uintptr(unsafe.Pointer(&lpNewItemStr[0])), + 0) + return ret1 != 0 +} + +func InternalGetWindowText(hWnd HWND, pString LPWSTR, cchMaxCount int32) int32 { + ret1 := syscall3(internalGetWindowText, 3, + uintptr(hWnd), + uintptr(unsafe.Pointer(pString)), + uintptr(cchMaxCount)) + return int32(ret1) +} + +func IntersectRect(lprcDst *RECT, lprcSrc1 /*const*/ *RECT, lprcSrc2 /*const*/ *RECT) bool { + ret1 := syscall3(intersectRect, 3, + uintptr(unsafe.Pointer(lprcDst)), + uintptr(unsafe.Pointer(lprcSrc1)), + uintptr(unsafe.Pointer(lprcSrc2))) + return ret1 != 0 +} + +func InvalidateRect(hWnd HWND, lpRect /*const*/ *RECT, bErase bool) bool { + ret1 := syscall3(invalidateRect, 3, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpRect)), + getUintptrFromBool(bErase)) + return ret1 != 0 +} + +func InvalidateRgn(hWnd HWND, hRgn HRGN, bErase bool) bool { + ret1 := syscall3(invalidateRgn, 3, + uintptr(hWnd), + uintptr(hRgn), + getUintptrFromBool(bErase)) + return ret1 != 0 +} + +func InvertRect(hDC HDC, lprc /*const*/ *RECT) bool { + ret1 := syscall3(invertRect, 2, + uintptr(hDC), + uintptr(unsafe.Pointer(lprc)), + 0) + return ret1 != 0 +} + +func IsCharAlphaNumeric(ch WCHAR) bool { + ret1 := syscall3(isCharAlphaNumeric, 1, + uintptr(ch), + 0, + 0) + return ret1 != 0 +} + +func IsCharAlpha(ch WCHAR) bool { + ret1 := syscall3(isCharAlpha, 1, + uintptr(ch), + 0, + 0) + return ret1 != 0 +} + +func IsCharLower(ch WCHAR) bool { + ret1 := syscall3(isCharLower, 1, + uintptr(ch), + 0, + 0) + return ret1 != 0 +} + +func IsCharUpper(ch WCHAR) bool { + ret1 := syscall3(isCharUpper, 1, + uintptr(ch), + 0, + 0) + return ret1 != 0 +} + +func IsChild(hWndParent HWND, hWnd HWND) bool { + ret1 := syscall3(isChild, 2, + uintptr(hWndParent), + uintptr(hWnd), + 0) + return ret1 != 0 +} + +func IsClipboardFormatAvailable(format UINT) bool { + ret1 := syscall3(isClipboardFormatAvailable, 1, + uintptr(format), + 0, + 0) + return ret1 != 0 +} + +func IsDialogMessage(hDlg HWND, lpMsg *MSG) bool { + ret1 := syscall3(isDialogMessage, 2, + uintptr(hDlg), + uintptr(unsafe.Pointer(lpMsg)), + 0) + return ret1 != 0 +} + +func IsDlgButtonChecked(hDlg HWND, nIDButton int32) UINT { + ret1 := syscall3(isDlgButtonChecked, 2, + uintptr(hDlg), + uintptr(nIDButton), + 0) + return UINT(ret1) +} + +func IsGUIThread(bConvert bool) bool { + ret1 := syscall3(isGUIThread, 1, + getUintptrFromBool(bConvert), + 0, + 0) + return ret1 != 0 +} + +func IsHungAppWindow(hwnd HWND) bool { + ret1 := syscall3(isHungAppWindow, 1, + uintptr(hwnd), + 0, + 0) + return ret1 != 0 +} + +func IsIconic(hWnd HWND) bool { + ret1 := syscall3(isIconic, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func IsMenu(hMenu HMENU) bool { + ret1 := syscall3(isMenu, 1, + uintptr(hMenu), + 0, + 0) + return ret1 != 0 +} + +func IsRectEmpty(lprc /*const*/ *RECT) bool { + ret1 := syscall3(isRectEmpty, 1, + uintptr(unsafe.Pointer(lprc)), + 0, + 0) + return ret1 != 0 +} + +func IsTouchWindow(hwnd HWND, pulFlags *uint32) bool { + ret1 := syscall3(isTouchWindow, 2, + uintptr(hwnd), + uintptr(unsafe.Pointer(pulFlags)), + 0) + return ret1 != 0 +} + +func IsWinEventHookInstalled(event DWORD) bool { + ret1 := syscall3(isWinEventHookInstalled, 1, + uintptr(event), + 0, + 0) + return ret1 != 0 +} + +func IsWindow(hWnd HWND) bool { + ret1 := syscall3(isWindow, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func IsWindowEnabled(hWnd HWND) bool { + ret1 := syscall3(isWindowEnabled, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func IsWindowUnicode(hWnd HWND) bool { + ret1 := syscall3(isWindowUnicode, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func IsWindowVisible(hWnd HWND) bool { + ret1 := syscall3(isWindowVisible, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func IsWow64Message() bool { + ret1 := syscall3(isWow64Message, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func IsZoomed(hWnd HWND) bool { + ret1 := syscall3(isZoomed, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func KillTimer(hWnd HWND, uIDEvent *uint32) bool { + ret1 := syscall3(killTimer, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(uIDEvent)), + 0) + return ret1 != 0 +} + +func LoadAccelerators(hInstance HINSTANCE, lpTableName string) HACCEL { + lpTableNameStr := unicode16FromString(lpTableName) + ret1 := syscall3(loadAccelerators, 2, + uintptr(hInstance), + uintptr(unsafe.Pointer(&lpTableNameStr[0])), + 0) + return HACCEL(ret1) +} + +func LoadBitmap(hInstance HINSTANCE, lpBitmapName string) HBITMAP { + lpBitmapNameStr := unicode16FromString(lpBitmapName) + ret1 := syscall3(loadBitmap, 2, + uintptr(hInstance), + uintptr(unsafe.Pointer(&lpBitmapNameStr[0])), + 0) + return HBITMAP(ret1) +} + +func LoadCursorFromFile(lpFileName string) HCURSOR { + lpFileNameStr := unicode16FromString(lpFileName) + ret1 := syscall3(loadCursorFromFile, 1, + uintptr(unsafe.Pointer(&lpFileNameStr[0])), + 0, + 0) + return HCURSOR(ret1) +} + +func LoadCursor(hInstance HINSTANCE, lpCursorName string) HCURSOR { + lpCursorNameStr := unicode16FromString(lpCursorName) + ret1 := syscall3(loadCursor, 2, + uintptr(hInstance), + uintptr(unsafe.Pointer(&lpCursorNameStr[0])), + 0) + return HCURSOR(ret1) +} + +func LoadIcon(hInstance HINSTANCE, lpIconName string) HICON { + lpIconNameStr := unicode16FromString(lpIconName) + ret1 := syscall3(loadIcon, 2, + uintptr(hInstance), + uintptr(unsafe.Pointer(&lpIconNameStr[0])), + 0) + return HICON(ret1) +} + +func LoadImage(hInst HINSTANCE, name string, aType UINT, cx int32, cy int32, fuLoad UINT) HANDLE { + nameStr := unicode16FromString(name) + ret1 := syscall6(loadImage, 6, + uintptr(hInst), + uintptr(unsafe.Pointer(&nameStr[0])), + uintptr(aType), + uintptr(cx), + uintptr(cy), + uintptr(fuLoad)) + return HANDLE(ret1) +} + +func LoadKeyboardLayout(pwszKLID string, flags UINT) HKL { + pwszKLIDStr := unicode16FromString(pwszKLID) + ret1 := syscall3(loadKeyboardLayout, 2, + uintptr(unsafe.Pointer(&pwszKLIDStr[0])), + uintptr(flags), + 0) + return HKL(ret1) +} + +func LoadMenuIndirect(lpMenuTemplate /*const*/ uintptr) HMENU { + ret1 := syscall3(loadMenuIndirect, 1, + lpMenuTemplate, + 0, + 0) + return HMENU(ret1) +} + +func LoadMenu(hInstance HINSTANCE, lpMenuName string) HMENU { + lpMenuNameStr := unicode16FromString(lpMenuName) + ret1 := syscall3(loadMenu, 2, + uintptr(hInstance), + uintptr(unsafe.Pointer(&lpMenuNameStr[0])), + 0) + return HMENU(ret1) +} + +func LoadString(hInstance HINSTANCE, uID UINT, lpBuffer LPWSTR, cchBufferMax int32) int32 { + ret1 := syscall6(loadString, 4, + uintptr(hInstance), + uintptr(uID), + uintptr(unsafe.Pointer(lpBuffer)), + uintptr(cchBufferMax), + 0, + 0) + return int32(ret1) +} + +func LockSetForegroundWindow(uLockCode UINT) bool { + ret1 := syscall3(lockSetForegroundWindow, 1, + uintptr(uLockCode), + 0, + 0) + return ret1 != 0 +} + +func LockWindowUpdate(hWndLock HWND) bool { + ret1 := syscall3(lockWindowUpdate, 1, + uintptr(hWndLock), + 0, + 0) + return ret1 != 0 +} + +func LockWorkStation() bool { + ret1 := syscall3(lockWorkStation, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func LookupIconIdFromDirectory(presbits *byte, fIcon bool) int32 { + ret1 := syscall3(lookupIconIdFromDirectory, 2, + uintptr(unsafe.Pointer(presbits)), + getUintptrFromBool(fIcon), + 0) + return int32(ret1) +} + +func LookupIconIdFromDirectoryEx(presbits *byte, fIcon bool, cxDesired int32, cyDesired int32, flags UINT) int32 { + ret1 := syscall6(lookupIconIdFromDirectoryEx, 5, + uintptr(unsafe.Pointer(presbits)), + getUintptrFromBool(fIcon), + uintptr(cxDesired), + uintptr(cyDesired), + uintptr(flags), + 0) + return int32(ret1) +} + +func MapDialogRect(hDlg HWND, lpRect *RECT) bool { + ret1 := syscall3(mapDialogRect, 2, + uintptr(hDlg), + uintptr(unsafe.Pointer(lpRect)), + 0) + return ret1 != 0 +} + +func MapVirtualKeyEx(uCode UINT, uMapType UINT, dwhkl HKL) UINT { + ret1 := syscall3(mapVirtualKeyEx, 3, + uintptr(uCode), + uintptr(uMapType), + uintptr(dwhkl)) + return UINT(ret1) +} + +func MapVirtualKey(uCode UINT, uMapType UINT) UINT { + ret1 := syscall3(mapVirtualKey, 2, + uintptr(uCode), + uintptr(uMapType), + 0) + return UINT(ret1) +} + +func MapWindowPoints(hWndFrom HWND, hWndTo HWND, lpPoints *POINT, cPoints UINT) int32 { + ret1 := syscall6(mapWindowPoints, 4, + uintptr(hWndFrom), + uintptr(hWndTo), + uintptr(unsafe.Pointer(lpPoints)), + uintptr(cPoints), + 0, + 0) + return int32(ret1) +} + +func MenuItemFromPoint(hWnd HWND, hMenu HMENU, ptScreen POINT) int32 { + ret1 := syscall6(menuItemFromPoint, 4, + uintptr(hWnd), + uintptr(hMenu), + uintptr(ptScreen.X), + uintptr(ptScreen.Y), + 0, + 0) + return int32(ret1) +} + +func MessageBeep(uType UINT) bool { + ret1 := syscall3(messageBeep, 1, + uintptr(uType), + 0, + 0) + return ret1 != 0 +} + +func MessageBoxEx(hWnd HWND, lpText string, lpCaption string, uType UINT, wLanguageId WORD) int32 { + lpTextStr := unicode16FromString(lpText) + lpCaptionStr := unicode16FromString(lpCaption) + ret1 := syscall6(messageBoxEx, 5, + uintptr(hWnd), + uintptr(unsafe.Pointer(&lpTextStr[0])), + uintptr(unsafe.Pointer(&lpCaptionStr[0])), + uintptr(uType), + uintptr(wLanguageId), + 0) + return int32(ret1) +} + +func MessageBoxIndirect(lpmbp /*const*/ *MSGBOXPARAMS) int32 { + ret1 := syscall3(messageBoxIndirect, 1, + uintptr(unsafe.Pointer(lpmbp)), + 0, + 0) + return int32(ret1) +} + +func MessageBox(hWnd HWND, lpText string, lpCaption string, uType UINT) int32 { + lpTextStr := unicode16FromString(lpText) + lpCaptionStr := unicode16FromString(lpCaption) + ret1 := syscall6(messageBox, 4, + uintptr(hWnd), + uintptr(unsafe.Pointer(&lpTextStr[0])), + uintptr(unsafe.Pointer(&lpCaptionStr[0])), + uintptr(uType), + 0, + 0) + return int32(ret1) +} + +func ModifyMenu(hMnu HMENU, uPosition UINT, uFlags UINT, uIDNewItem *uint32, lpNewItem string) bool { + lpNewItemStr := unicode16FromString(lpNewItem) + ret1 := syscall6(modifyMenu, 5, + uintptr(hMnu), + uintptr(uPosition), + uintptr(uFlags), + uintptr(unsafe.Pointer(uIDNewItem)), + uintptr(unsafe.Pointer(&lpNewItemStr[0])), + 0) + return ret1 != 0 +} + +func MonitorFromPoint(pt POINT, dwFlags DWORD) HMONITOR { + ret1 := syscall3(monitorFromPoint, 3, + uintptr(pt.X), + uintptr(pt.Y), + uintptr(dwFlags)) + return HMONITOR(ret1) +} + +func MonitorFromRect(lprc /*const*/ *RECT, dwFlags DWORD) HMONITOR { + ret1 := syscall3(monitorFromRect, 2, + uintptr(unsafe.Pointer(lprc)), + uintptr(dwFlags), + 0) + return HMONITOR(ret1) +} + +func MonitorFromWindow(hwnd HWND, dwFlags DWORD) HMONITOR { + ret1 := syscall3(monitorFromWindow, 2, + uintptr(hwnd), + uintptr(dwFlags), + 0) + return HMONITOR(ret1) +} + +func MoveWindow(hWnd HWND, x int32, y int32, nWidth int32, nHeight int32, bRepaint bool) bool { + ret1 := syscall6(moveWindow, 6, + uintptr(hWnd), + uintptr(x), + uintptr(y), + uintptr(nWidth), + uintptr(nHeight), + getUintptrFromBool(bRepaint)) + return ret1 != 0 +} + +func MsgWaitForMultipleObjects(nCount DWORD, pHandles /*const*/ *HANDLE, fWaitAll bool, dwMilliseconds DWORD, dwWakeMask DWORD) DWORD { + ret1 := syscall6(msgWaitForMultipleObjects, 5, + uintptr(nCount), + uintptr(unsafe.Pointer(pHandles)), + getUintptrFromBool(fWaitAll), + uintptr(dwMilliseconds), + uintptr(dwWakeMask), + 0) + return DWORD(ret1) +} + +func MsgWaitForMultipleObjectsEx(nCount DWORD, pHandles /*const*/ *HANDLE, dwMilliseconds DWORD, dwWakeMask DWORD, dwFlags DWORD) DWORD { + ret1 := syscall6(msgWaitForMultipleObjectsEx, 5, + uintptr(nCount), + uintptr(unsafe.Pointer(pHandles)), + uintptr(dwMilliseconds), + uintptr(dwWakeMask), + uintptr(dwFlags), + 0) + return DWORD(ret1) +} + +func NotifyWinEvent(event DWORD, hwnd HWND, idObject LONG, idChild LONG) { + syscall6(notifyWinEvent, 4, + uintptr(event), + uintptr(hwnd), + uintptr(idObject), + uintptr(idChild), + 0, + 0) +} + +func OemKeyScan(wOemChar WORD) DWORD { + ret1 := syscall3(oemKeyScan, 1, + uintptr(wOemChar), + 0, + 0) + return DWORD(ret1) +} + +func OemToCharBuff(lpszSrc /*const*/ LPCSTR, lpszDst LPWSTR, cchDstLength DWORD) bool { + ret1 := syscall3(oemToCharBuff, 3, + uintptr(unsafe.Pointer(lpszSrc)), + uintptr(unsafe.Pointer(lpszDst)), + uintptr(cchDstLength)) + return ret1 != 0 +} + +func OemToChar(lpszSrc /*const*/ LPCSTR, lpszDst LPWSTR) bool { + ret1 := syscall3(oemToChar, 2, + uintptr(unsafe.Pointer(lpszSrc)), + uintptr(unsafe.Pointer(lpszDst)), + 0) + return ret1 != 0 +} + +func OffsetRect(lprc *RECT, dx int32, dy int32) bool { + ret1 := syscall3(offsetRect, 3, + uintptr(unsafe.Pointer(lprc)), + uintptr(dx), + uintptr(dy)) + return ret1 != 0 +} + +func OpenClipboard(hWndNewOwner HWND) bool { + ret1 := syscall3(openClipboard, 1, + uintptr(hWndNewOwner), + 0, + 0) + return ret1 != 0 +} + +func OpenDesktop(lpszDesktop string, dwFlags DWORD, fInherit bool, dwDesiredAccess ACCESS_MASK) HDESK { + lpszDesktopStr := unicode16FromString(lpszDesktop) + ret1 := syscall6(openDesktop, 4, + uintptr(unsafe.Pointer(&lpszDesktopStr[0])), + uintptr(dwFlags), + getUintptrFromBool(fInherit), + uintptr(dwDesiredAccess), + 0, + 0) + return HDESK(ret1) +} + +func OpenIcon(hWnd HWND) bool { + ret1 := syscall3(openIcon, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func OpenInputDesktop(dwFlags DWORD, fInherit bool, dwDesiredAccess ACCESS_MASK) HDESK { + ret1 := syscall3(openInputDesktop, 3, + uintptr(dwFlags), + getUintptrFromBool(fInherit), + uintptr(dwDesiredAccess)) + return HDESK(ret1) +} + +func OpenWindowStation(lpszWinSta string, fInherit bool, dwDesiredAccess ACCESS_MASK) HWINSTA { + lpszWinStaStr := unicode16FromString(lpszWinSta) + ret1 := syscall3(openWindowStation, 3, + uintptr(unsafe.Pointer(&lpszWinStaStr[0])), + getUintptrFromBool(fInherit), + uintptr(dwDesiredAccess)) + return HWINSTA(ret1) +} + +func PackDDElParam(msg UINT, uiLo *uint32, uiHi *uint32) LPARAM { + ret1 := syscall3(packDDElParam, 3, + uintptr(msg), + uintptr(unsafe.Pointer(uiLo)), + uintptr(unsafe.Pointer(uiHi))) + return LPARAM(ret1) +} + +func PaintDesktop(hdc HDC) bool { + ret1 := syscall3(paintDesktop, 1, + uintptr(hdc), + 0, + 0) + return ret1 != 0 +} + +func PeekMessage(lpMsg *MSG, hWnd HWND, wMsgFilterMin UINT, wMsgFilterMax UINT, wRemoveMsg UINT) bool { + ret1 := syscall6(peekMessage, 5, + uintptr(unsafe.Pointer(lpMsg)), + uintptr(hWnd), + uintptr(wMsgFilterMin), + uintptr(wMsgFilterMax), + uintptr(wRemoveMsg), + 0) + return ret1 != 0 +} + +func PostMessage(hWnd HWND, msg UINT, wParam WPARAM, lParam LPARAM) bool { + ret1 := syscall6(postMessage, 4, + uintptr(hWnd), + uintptr(msg), + uintptr(wParam), + uintptr(lParam), + 0, + 0) + return ret1 != 0 +} + +func PostQuitMessage(nExitCode int32) { + syscall3(postQuitMessage, 1, + uintptr(nExitCode), + 0, + 0) +} + +func PostThreadMessage(idThread DWORD, msg UINT, wParam WPARAM, lParam LPARAM) bool { + ret1 := syscall6(postThreadMessage, 4, + uintptr(idThread), + uintptr(msg), + uintptr(wParam), + uintptr(lParam), + 0, + 0) + return ret1 != 0 +} + +func PrintWindow(hwnd HWND, hdcBlt HDC, nFlags UINT) bool { + ret1 := syscall3(printWindow, 3, + uintptr(hwnd), + uintptr(hdcBlt), + uintptr(nFlags)) + return ret1 != 0 +} + +func PrivateExtractIcons(szFileName string, nIconIndex int32, cxIcon int32, cyIcon int32, phicon *HICON, piconid *UINT, nIcons UINT, flags UINT) UINT { + szFileNameStr := unicode16FromString(szFileName) + ret1 := syscall9(privateExtractIcons, 8, + uintptr(unsafe.Pointer(&szFileNameStr[0])), + uintptr(nIconIndex), + uintptr(cxIcon), + uintptr(cyIcon), + uintptr(unsafe.Pointer(phicon)), + uintptr(unsafe.Pointer(piconid)), + uintptr(nIcons), + uintptr(flags), + 0) + return UINT(ret1) +} + +func PtInRect(lprc /*const*/ *RECT, pt POINT) bool { + ret1 := syscall3(ptInRect, 3, + uintptr(unsafe.Pointer(lprc)), + uintptr(pt.X), + uintptr(pt.Y)) + return ret1 != 0 +} + +func RealChildWindowFromPoint(hwndParent HWND, ptParentClientCoords POINT) HWND { + ret1 := syscall3(realChildWindowFromPoint, 3, + uintptr(hwndParent), + uintptr(ptParentClientCoords.X), + uintptr(ptParentClientCoords.Y)) + return HWND(ret1) +} + +func RealGetWindowClass(hwnd HWND, ptszClassName LPWSTR, cchClassNameMax UINT) UINT { + ret1 := syscall3(realGetWindowClass, 3, + uintptr(hwnd), + uintptr(unsafe.Pointer(ptszClassName)), + uintptr(cchClassNameMax)) + return UINT(ret1) +} + +func RedrawWindow(hWnd HWND, lprcUpdate /*const*/ *RECT, hrgnUpdate HRGN, flags UINT) bool { + ret1 := syscall6(redrawWindow, 4, + uintptr(hWnd), + uintptr(unsafe.Pointer(lprcUpdate)), + uintptr(hrgnUpdate), + uintptr(flags), + 0, + 0) + return ret1 != 0 +} + +func RegisterClassEx(unnamed0 /*const*/ *WNDCLASSEX) ATOM { + ret1 := syscall3(registerClassEx, 1, + uintptr(unsafe.Pointer(unnamed0)), + 0, + 0) + return ATOM(ret1) +} + +func RegisterClass(lpWndClass /*const*/ *WNDCLASS) ATOM { + ret1 := syscall3(registerClass, 1, + uintptr(unsafe.Pointer(lpWndClass)), + 0, + 0) + return ATOM(ret1) +} + +func RegisterClipboardFormat(lpszFormat string) UINT { + lpszFormatStr := unicode16FromString(lpszFormat) + ret1 := syscall3(registerClipboardFormat, 1, + uintptr(unsafe.Pointer(&lpszFormatStr[0])), + 0, + 0) + return UINT(ret1) +} + +func RegisterDeviceNotification(hRecipient HANDLE, notificationFilter LPVOID, flags DWORD) HDEVNOTIFY { + ret1 := syscall3(registerDeviceNotification, 3, + uintptr(hRecipient), + uintptr(unsafe.Pointer(notificationFilter)), + uintptr(flags)) + return HDEVNOTIFY(ret1) +} + +func RegisterHotKey(hWnd HWND, id int32, fsModifiers UINT, vk UINT) bool { + ret1 := syscall6(registerHotKey, 4, + uintptr(hWnd), + uintptr(id), + uintptr(fsModifiers), + uintptr(vk), + 0, + 0) + return ret1 != 0 +} + +func RegisterPowerSettingNotification(hRecipient HANDLE, powerSettingGuid /*const*/ *GUID, flags DWORD) HPOWERNOTIFY { + ret1 := syscall3(registerPowerSettingNotification, 3, + uintptr(hRecipient), + uintptr(unsafe.Pointer(powerSettingGuid)), + uintptr(flags)) + return HPOWERNOTIFY(ret1) +} + +func RegisterRawInputDevices(pRawInputDevices /*const*/ *RAWINPUTDEVICE, uiNumDevices UINT, cbSize UINT) bool { + ret1 := syscall3(registerRawInputDevices, 3, + uintptr(unsafe.Pointer(pRawInputDevices)), + uintptr(uiNumDevices), + uintptr(cbSize)) + return ret1 != 0 +} + +func RegisterShellHookWindow(hwnd HWND) bool { + ret1 := syscall3(registerShellHookWindow, 1, + uintptr(hwnd), + 0, + 0) + return ret1 != 0 +} + +func RegisterTouchWindow(hwnd HWND, ulFlags ULONG) bool { + ret1 := syscall3(registerTouchWindow, 2, + uintptr(hwnd), + uintptr(ulFlags), + 0) + return ret1 != 0 +} + +func RegisterWindowMessage(lpString string) UINT { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(registerWindowMessage, 1, + uintptr(unsafe.Pointer(&lpStringStr[0])), + 0, + 0) + return UINT(ret1) +} + +func ReleaseCapture() bool { + ret1 := syscall3(releaseCapture, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func ReleaseDC(hWnd HWND, hDC HDC) int32 { + ret1 := syscall3(releaseDC, 2, + uintptr(hWnd), + uintptr(hDC), + 0) + return int32(ret1) +} + +func RemoveMenu(hMenu HMENU, uPosition UINT, uFlags UINT) bool { + ret1 := syscall3(removeMenu, 3, + uintptr(hMenu), + uintptr(uPosition), + uintptr(uFlags)) + return ret1 != 0 +} + +func RemoveProp(hWnd HWND, lpString string) HANDLE { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(removeProp, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(&lpStringStr[0])), + 0) + return HANDLE(ret1) +} + +func ReplyMessage(lResult LRESULT) bool { + ret1 := syscall3(replyMessage, 1, + uintptr(lResult), + 0, + 0) + return ret1 != 0 +} + +func ReuseDDElParam(lParam LPARAM, msgIn UINT, msgOut UINT, uiLo *uint32, uiHi *uint32) LPARAM { + ret1 := syscall6(reuseDDElParam, 5, + uintptr(lParam), + uintptr(msgIn), + uintptr(msgOut), + uintptr(unsafe.Pointer(uiLo)), + uintptr(unsafe.Pointer(uiHi)), + 0) + return LPARAM(ret1) +} + +func ScreenToClient(hWnd HWND, lpPoint *POINT) bool { + ret1 := syscall3(screenToClient, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpPoint)), + 0) + return ret1 != 0 +} + +func ScrollDC(hDC HDC, dx int32, dy int32, lprcScroll /*const*/ *RECT, lprcClip /*const*/ *RECT, hrgnUpdate HRGN, lprcUpdate *RECT) bool { + ret1 := syscall9(scrollDC, 7, + uintptr(hDC), + uintptr(dx), + uintptr(dy), + uintptr(unsafe.Pointer(lprcScroll)), + uintptr(unsafe.Pointer(lprcClip)), + uintptr(hrgnUpdate), + uintptr(unsafe.Pointer(lprcUpdate)), + 0, + 0) + return ret1 != 0 +} + +func ScrollWindow(hWnd HWND, xAmount int32, yAmount int32, lpRect /*const*/ *RECT, lpClipRect /*const*/ *RECT) bool { + ret1 := syscall6(scrollWindow, 5, + uintptr(hWnd), + uintptr(xAmount), + uintptr(yAmount), + uintptr(unsafe.Pointer(lpRect)), + uintptr(unsafe.Pointer(lpClipRect)), + 0) + return ret1 != 0 +} + +func ScrollWindowEx(hWnd HWND, dx int32, dy int32, prcScroll /*const*/ *RECT, prcClip /*const*/ *RECT, hrgnUpdate HRGN, prcUpdate *RECT, flags UINT) int32 { + ret1 := syscall9(scrollWindowEx, 8, + uintptr(hWnd), + uintptr(dx), + uintptr(dy), + uintptr(unsafe.Pointer(prcScroll)), + uintptr(unsafe.Pointer(prcClip)), + uintptr(hrgnUpdate), + uintptr(unsafe.Pointer(prcUpdate)), + uintptr(flags), + 0) + return int32(ret1) +} + +func SendDlgItemMessage(hDlg HWND, nIDDlgItem int32, msg UINT, wParam WPARAM, lParam LPARAM) LRESULT { + ret1 := syscall6(sendDlgItemMessage, 5, + uintptr(hDlg), + uintptr(nIDDlgItem), + uintptr(msg), + uintptr(wParam), + uintptr(lParam), + 0) + return LRESULT(ret1) +} + +func SendIMEMessageEx(unnamed0 HWND, unnamed1 LPARAM) LRESULT { + ret1 := syscall3(sendIMEMessageEx, 2, + uintptr(unnamed0), + uintptr(unnamed1), + 0) + return LRESULT(ret1) +} + +func SendInput(cInputs UINT, pInputs *INPUT, cbSize int32) UINT { + ret1 := syscall3(sendInput, 3, + uintptr(cInputs), + uintptr(unsafe.Pointer(pInputs)), + uintptr(cbSize)) + return UINT(ret1) +} + +func SendMessageCallback(hWnd HWND, msg UINT, wParam WPARAM, lParam LPARAM, lpResultCallBack SENDASYNCPROC, dwData *uint32) bool { + lpResultCallBackCallback := syscall.NewCallback(lpResultCallBack) + ret1 := syscall6(sendMessageCallback, 6, + uintptr(hWnd), + uintptr(msg), + uintptr(wParam), + uintptr(lParam), + lpResultCallBackCallback, + uintptr(unsafe.Pointer(dwData))) + return ret1 != 0 +} + +func SendMessageTimeout(hWnd HWND, msg UINT, wParam WPARAM, lParam LPARAM, fuFlags UINT, uTimeout UINT, lpdwResult *uintptr) LRESULT { + ret1 := syscall9(sendMessageTimeout, 7, + uintptr(hWnd), + uintptr(msg), + uintptr(wParam), + uintptr(lParam), + uintptr(fuFlags), + uintptr(uTimeout), + uintptr(unsafe.Pointer(lpdwResult)), + 0, + 0) + return LRESULT(ret1) +} + +func SendMessage(hWnd HWND, msg UINT, wParam WPARAM, lParam LPARAM) LRESULT { + ret1 := syscall6(sendMessage, 4, + uintptr(hWnd), + uintptr(msg), + uintptr(wParam), + uintptr(lParam), + 0, + 0) + return LRESULT(ret1) +} + +func SendNotifyMessage(hWnd HWND, msg UINT, wParam WPARAM, lParam LPARAM) bool { + ret1 := syscall6(sendNotifyMessage, 4, + uintptr(hWnd), + uintptr(msg), + uintptr(wParam), + uintptr(lParam), + 0, + 0) + return ret1 != 0 +} + +func SetActiveWindow(hWnd HWND) HWND { + ret1 := syscall3(setActiveWindow, 1, + uintptr(hWnd), + 0, + 0) + return HWND(ret1) +} + +func SetCapture(hWnd HWND) HWND { + ret1 := syscall3(setCapture, 1, + uintptr(hWnd), + 0, + 0) + return HWND(ret1) +} + +func SetCaretBlinkTime(uMSeconds UINT) bool { + ret1 := syscall3(setCaretBlinkTime, 1, + uintptr(uMSeconds), + 0, + 0) + return ret1 != 0 +} + +func SetCaretPos(x int32, y int32) bool { + ret1 := syscall3(setCaretPos, 2, + uintptr(x), + uintptr(y), + 0) + return ret1 != 0 +} + +func SetClassLongPtr(hWnd HWND, nIndex int32, dwNewLong uintptr) *uint32 { + ret1 := syscall3(setClassLongPtr, 3, + uintptr(hWnd), + uintptr(nIndex), + dwNewLong) + return (*uint32)(unsafe.Pointer(ret1)) +} + +func SetClassLong(hWnd HWND, nIndex int32, dwNewLong LONG) DWORD { + ret1 := syscall3(setClassLong, 3, + uintptr(hWnd), + uintptr(nIndex), + uintptr(dwNewLong)) + return DWORD(ret1) +} + +func SetClassWord(hWnd HWND, nIndex int32, wNewWord WORD) WORD { + ret1 := syscall3(setClassWord, 3, + uintptr(hWnd), + uintptr(nIndex), + uintptr(wNewWord)) + return WORD(ret1) +} + +func SetClipboardData(uFormat UINT, hMem HANDLE) HANDLE { + ret1 := syscall3(setClipboardData, 2, + uintptr(uFormat), + uintptr(hMem), + 0) + return HANDLE(ret1) +} + +func SetClipboardViewer(hWndNewViewer HWND) HWND { + ret1 := syscall3(setClipboardViewer, 1, + uintptr(hWndNewViewer), + 0, + 0) + return HWND(ret1) +} + +func SetCursor(hCursor HCURSOR) HCURSOR { + ret1 := syscall3(setCursor, 1, + uintptr(hCursor), + 0, + 0) + return HCURSOR(ret1) +} + +func SetCursorPos(x int32, y int32) bool { + ret1 := syscall3(setCursorPos, 2, + uintptr(x), + uintptr(y), + 0) + return ret1 != 0 +} + +func SetDebugErrorLevel(dwLevel DWORD) { + syscall3(setDebugErrorLevel, 1, + uintptr(dwLevel), + 0, + 0) +} + +func SetDlgItemInt(hDlg HWND, nIDDlgItem int32, uValue UINT, bSigned bool) bool { + ret1 := syscall6(setDlgItemInt, 4, + uintptr(hDlg), + uintptr(nIDDlgItem), + uintptr(uValue), + getUintptrFromBool(bSigned), + 0, + 0) + return ret1 != 0 +} + +func SetDlgItemText(hDlg HWND, nIDDlgItem int32, lpString string) bool { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(setDlgItemText, 3, + uintptr(hDlg), + uintptr(nIDDlgItem), + uintptr(unsafe.Pointer(&lpStringStr[0]))) + return ret1 != 0 +} + +func SetDoubleClickTime(unnamed0 UINT) bool { + ret1 := syscall3(setDoubleClickTime, 1, + uintptr(unnamed0), + 0, + 0) + return ret1 != 0 +} + +func SetFocus(hWnd HWND) HWND { + ret1 := syscall3(setFocus, 1, + uintptr(hWnd), + 0, + 0) + return HWND(ret1) +} + +func SetForegroundWindow(hWnd HWND) bool { + ret1 := syscall3(setForegroundWindow, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func SetGestureConfig(hwnd HWND, dwReserved DWORD, cIDs UINT, pGestureConfig *GESTURECONFIG, cbSize UINT) bool { + ret1 := syscall6(setGestureConfig, 5, + uintptr(hwnd), + uintptr(dwReserved), + uintptr(cIDs), + uintptr(unsafe.Pointer(pGestureConfig)), + uintptr(cbSize), + 0) + return ret1 != 0 +} + +func SetKeyboardState(lpKeyState *byte) bool { + ret1 := syscall3(setKeyboardState, 1, + uintptr(unsafe.Pointer(lpKeyState)), + 0, + 0) + return ret1 != 0 +} + +func SetLastErrorEx(dwErrCode DWORD, dwType DWORD) { + syscall3(setLastErrorEx, 2, + uintptr(dwErrCode), + uintptr(dwType), + 0) +} + +func SetLayeredWindowAttributes(hwnd HWND, crKey COLORREF, bAlpha BYTE, dwFlags DWORD) bool { + ret1 := syscall6(setLayeredWindowAttributes, 4, + uintptr(hwnd), + uintptr(crKey), + uintptr(bAlpha), + uintptr(dwFlags), + 0, + 0) + return ret1 != 0 +} + +func SetMenu(hWnd HWND, hMenu HMENU) bool { + ret1 := syscall3(setMenu, 2, + uintptr(hWnd), + uintptr(hMenu), + 0) + return ret1 != 0 +} + +func SetMenuContextHelpId(unnamed0 HMENU, unnamed1 DWORD) bool { + ret1 := syscall3(setMenuContextHelpId, 2, + uintptr(unnamed0), + uintptr(unnamed1), + 0) + return ret1 != 0 +} + +func SetMenuDefaultItem(hMenu HMENU, uItem UINT, fByPos UINT) bool { + ret1 := syscall3(setMenuDefaultItem, 3, + uintptr(hMenu), + uintptr(uItem), + uintptr(fByPos)) + return ret1 != 0 +} + +func SetMenuInfo(unnamed0 HMENU, unnamed1 /*const*/ *MENUINFO) bool { + ret1 := syscall3(setMenuInfo, 2, + uintptr(unnamed0), + uintptr(unsafe.Pointer(unnamed1)), + 0) + return ret1 != 0 +} + +func SetMenuItemBitmaps(hMenu HMENU, uPosition UINT, uFlags UINT, hBitmapUnchecked HBITMAP, hBitmapChecked HBITMAP) bool { + ret1 := syscall6(setMenuItemBitmaps, 5, + uintptr(hMenu), + uintptr(uPosition), + uintptr(uFlags), + uintptr(hBitmapUnchecked), + uintptr(hBitmapChecked), + 0) + return ret1 != 0 +} + +func SetMenuItemInfo(hmenu HMENU, item UINT, fByPositon bool, lpmii /*const*/ *MENUITEMINFO) bool { + ret1 := syscall6(setMenuItemInfo, 4, + uintptr(hmenu), + uintptr(item), + getUintptrFromBool(fByPositon), + uintptr(unsafe.Pointer(lpmii)), + 0, + 0) + return ret1 != 0 +} + +func SetMessageExtraInfo(lParam LPARAM) LPARAM { + ret1 := syscall3(setMessageExtraInfo, 1, + uintptr(lParam), + 0, + 0) + return LPARAM(ret1) +} + +func SetMessageQueue(cMessagesMax int32) bool { + ret1 := syscall3(setMessageQueue, 1, + uintptr(cMessagesMax), + 0, + 0) + return ret1 != 0 +} + +func SetParent(hWndChild HWND, hWndNewParent HWND) HWND { + ret1 := syscall3(setParent, 2, + uintptr(hWndChild), + uintptr(hWndNewParent), + 0) + return HWND(ret1) +} + +func SetProcessDefaultLayout(dwDefaultLayout DWORD) bool { + ret1 := syscall3(setProcessDefaultLayout, 1, + uintptr(dwDefaultLayout), + 0, + 0) + return ret1 != 0 +} + +func SetProcessWindowStation(hWinSta HWINSTA) bool { + ret1 := syscall3(setProcessWindowStation, 1, + uintptr(hWinSta), + 0, + 0) + return ret1 != 0 +} + +func SetProp(hWnd HWND, lpString string, hData HANDLE) bool { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(setProp, 3, + uintptr(hWnd), + uintptr(unsafe.Pointer(&lpStringStr[0])), + uintptr(hData)) + return ret1 != 0 +} + +func SetRect(lprc *RECT, xLeft int32, yTop int32, xRight int32, yBottom int32) bool { + ret1 := syscall6(setRect, 5, + uintptr(unsafe.Pointer(lprc)), + uintptr(xLeft), + uintptr(yTop), + uintptr(xRight), + uintptr(yBottom), + 0) + return ret1 != 0 +} + +func SetRectEmpty(lprc *RECT) bool { + ret1 := syscall3(setRectEmpty, 1, + uintptr(unsafe.Pointer(lprc)), + 0, + 0) + return ret1 != 0 +} + +func SetScrollInfo(hwnd HWND, nBar int32, lpsi /*const*/ *SCROLLINFO, redraw bool) int32 { + ret1 := syscall6(setScrollInfo, 4, + uintptr(hwnd), + uintptr(nBar), + uintptr(unsafe.Pointer(lpsi)), + getUintptrFromBool(redraw), + 0, + 0) + return int32(ret1) +} + +func SetScrollPos(hWnd HWND, nBar int32, nPos int32, bRedraw bool) int32 { + ret1 := syscall6(setScrollPos, 4, + uintptr(hWnd), + uintptr(nBar), + uintptr(nPos), + getUintptrFromBool(bRedraw), + 0, + 0) + return int32(ret1) +} + +func SetScrollRange(hWnd HWND, nBar int32, nMinPos int32, nMaxPos int32, bRedraw bool) bool { + ret1 := syscall6(setScrollRange, 5, + uintptr(hWnd), + uintptr(nBar), + uintptr(nMinPos), + uintptr(nMaxPos), + getUintptrFromBool(bRedraw), + 0) + return ret1 != 0 +} + +func SetSysColors(cElements int32, lpaElements /*const*/ *int32, lpaRgbValues /*const*/ *COLORREF) bool { + ret1 := syscall3(setSysColors, 3, + uintptr(cElements), + uintptr(unsafe.Pointer(lpaElements)), + uintptr(unsafe.Pointer(lpaRgbValues))) + return ret1 != 0 +} + +func SetSystemCursor(hcur HCURSOR, id DWORD) bool { + ret1 := syscall3(setSystemCursor, 2, + uintptr(hcur), + uintptr(id), + 0) + return ret1 != 0 +} + +func SetThreadDesktop(hDesktop HDESK) bool { + ret1 := syscall3(setThreadDesktop, 1, + uintptr(hDesktop), + 0, + 0) + return ret1 != 0 +} + +func SetTimer(hWnd HWND, nIDEvent *uint32, uElapse UINT, lpTimerFunc TIMERPROC) *uint32 { + lpTimerFuncCallback := syscall.NewCallback(lpTimerFunc) + ret1 := syscall6(setTimer, 4, + uintptr(hWnd), + uintptr(unsafe.Pointer(nIDEvent)), + uintptr(uElapse), + lpTimerFuncCallback, + 0, + 0) + return (*uint32)(unsafe.Pointer(ret1)) +} + +func SetUserObjectInformation(hObj HANDLE, nIndex int32, pvInfo uintptr, nLength DWORD) bool { + ret1 := syscall6(setUserObjectInformation, 4, + uintptr(hObj), + uintptr(nIndex), + pvInfo, + uintptr(nLength), + 0, + 0) + return ret1 != 0 +} + +func SetUserObjectSecurity(hObj HANDLE, pSIRequested *SECURITY_INFORMATION, pSID PSECURITY_DESCRIPTOR) bool { + ret1 := syscall3(setUserObjectSecurity, 3, + uintptr(hObj), + uintptr(unsafe.Pointer(pSIRequested)), + uintptr(unsafe.Pointer(pSID))) + return ret1 != 0 +} + +func SetWinEventHook(eventMin DWORD, eventMax DWORD, hmodWinEventProc HMODULE, pfnWinEventProc WINEVENTPROC, idProcess DWORD, idThread DWORD, dwFlags DWORD) HWINEVENTHOOK { + pfnWinEventProcCallback := syscall.NewCallback(pfnWinEventProc) + ret1 := syscall9(setWinEventHook, 7, + uintptr(eventMin), + uintptr(eventMax), + uintptr(hmodWinEventProc), + pfnWinEventProcCallback, + uintptr(idProcess), + uintptr(idThread), + uintptr(dwFlags), + 0, + 0) + return HWINEVENTHOOK(ret1) +} + +func SetWindowContextHelpId(unnamed0 HWND, unnamed1 DWORD) bool { + ret1 := syscall3(setWindowContextHelpId, 2, + uintptr(unnamed0), + uintptr(unnamed1), + 0) + return ret1 != 0 +} + +func SetWindowLongPtr(hWnd HWND, nIndex int32, dwNewLong uintptr) uintptr { + ret1 := syscall3(setWindowLongPtr, 3, + uintptr(hWnd), + uintptr(nIndex), + dwNewLong) + return (uintptr)(unsafe.Pointer(ret1)) +} + +func SetWindowLong(hWnd HWND, nIndex int32, dwNewLong LONG) LONG { + ret1 := syscall3(setWindowLong, 3, + uintptr(hWnd), + uintptr(nIndex), + uintptr(dwNewLong)) + return LONG(ret1) +} + +func SetWindowPlacement(hWnd HWND, lpwndpl /*const*/ *WINDOWPLACEMENT) bool { + ret1 := syscall3(setWindowPlacement, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpwndpl)), + 0) + return ret1 != 0 +} + +func SetWindowPos(hWnd HWND, hWndInsertAfter HWND, x int32, y int32, cx int32, cy int32, uFlags UINT) bool { + ret1 := syscall9(setWindowPos, 7, + uintptr(hWnd), + uintptr(hWndInsertAfter), + uintptr(x), + uintptr(y), + uintptr(cx), + uintptr(cy), + uintptr(uFlags), + 0, + 0) + return ret1 != 0 +} + +func SetWindowRgn(hWnd HWND, hRgn HRGN, bRedraw bool) int32 { + ret1 := syscall3(setWindowRgn, 3, + uintptr(hWnd), + uintptr(hRgn), + getUintptrFromBool(bRedraw)) + return int32(ret1) +} + +func SetWindowText(hWnd HWND, lpString string) bool { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall3(setWindowText, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(&lpStringStr[0])), + 0) + return ret1 != 0 +} + +func SetWindowWord(hWnd HWND, nIndex int32, wNewWord WORD) WORD { + ret1 := syscall3(setWindowWord, 3, + uintptr(hWnd), + uintptr(nIndex), + uintptr(wNewWord)) + return WORD(ret1) +} + +func SetWindowsHookEx(idHook int32, lpfn HOOKPROC, hmod HINSTANCE, dwThreadId DWORD) HHOOK { + lpfnCallback := syscall.NewCallback(func(codeRawArg int32, wParamRawArg WPARAM, lParamRawArg LPARAM) uintptr { + ret := lpfn(codeRawArg, wParamRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall6(setWindowsHookEx, 4, + uintptr(idHook), + lpfnCallback, + uintptr(hmod), + uintptr(dwThreadId), + 0, + 0) + return HHOOK(ret1) +} + +func SetWindowsHook(nFilterType int32, pfnFilterProc HOOKPROC) HHOOK { + pfnFilterProcCallback := syscall.NewCallback(func(codeRawArg int32, wParamRawArg WPARAM, lParamRawArg LPARAM) uintptr { + ret := pfnFilterProc(codeRawArg, wParamRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall3(setWindowsHook, 2, + uintptr(nFilterType), + pfnFilterProcCallback, + 0) + return HHOOK(ret1) +} + +func ShowCaret(hWnd HWND) bool { + ret1 := syscall3(showCaret, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func ShowCursor(bShow bool) int32 { + ret1 := syscall3(showCursor, 1, + getUintptrFromBool(bShow), + 0, + 0) + return int32(ret1) +} + +func ShowOwnedPopups(hWnd HWND, fShow bool) bool { + ret1 := syscall3(showOwnedPopups, 2, + uintptr(hWnd), + getUintptrFromBool(fShow), + 0) + return ret1 != 0 +} + +func ShowScrollBar(hWnd HWND, wBar int32, bShow bool) bool { + ret1 := syscall3(showScrollBar, 3, + uintptr(hWnd), + uintptr(wBar), + getUintptrFromBool(bShow)) + return ret1 != 0 +} + +func ShowWindow(hWnd HWND, nCmdShow int32) bool { + ret1 := syscall3(showWindow, 2, + uintptr(hWnd), + uintptr(nCmdShow), + 0) + return ret1 != 0 +} + +func ShowWindowAsync(hWnd HWND, nCmdShow int32) bool { + ret1 := syscall3(showWindowAsync, 2, + uintptr(hWnd), + uintptr(nCmdShow), + 0) + return ret1 != 0 +} + +func SubtractRect(lprcDst *RECT, lprcSrc1 /*const*/ *RECT, lprcSrc2 /*const*/ *RECT) bool { + ret1 := syscall3(subtractRect, 3, + uintptr(unsafe.Pointer(lprcDst)), + uintptr(unsafe.Pointer(lprcSrc1)), + uintptr(unsafe.Pointer(lprcSrc2))) + return ret1 != 0 +} + +func SwapMouseButton(fSwap bool) bool { + ret1 := syscall3(swapMouseButton, 1, + getUintptrFromBool(fSwap), + 0, + 0) + return ret1 != 0 +} + +func SwitchDesktop(hDesktop HDESK) bool { + ret1 := syscall3(switchDesktop, 1, + uintptr(hDesktop), + 0, + 0) + return ret1 != 0 +} + +func SwitchToThisWindow(hwnd HWND, fUnknown bool) { + syscall3(switchToThisWindow, 2, + uintptr(hwnd), + getUintptrFromBool(fUnknown), + 0) +} + +func SystemParametersInfo(uiAction UINT, uiParam UINT, pvParam uintptr, fWinIni UINT) bool { + ret1 := syscall6(systemParametersInfo, 4, + uintptr(uiAction), + uintptr(uiParam), + pvParam, + uintptr(fWinIni), + 0, + 0) + return ret1 != 0 +} + +func TabbedTextOut(hdc HDC, x int32, y int32, lpString string, chCount int32, nTabPositions int32, lpnTabStopPositions /*const*/ *int32, nTabOrigin int32) LONG { + lpStringStr := unicode16FromString(lpString) + ret1 := syscall9(tabbedTextOut, 8, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(&lpStringStr[0])), + uintptr(chCount), + uintptr(nTabPositions), + uintptr(unsafe.Pointer(lpnTabStopPositions)), + uintptr(nTabOrigin), + 0) + return LONG(ret1) +} + +func TileWindows(hwndParent HWND, wHow UINT, lpRect /*const*/ *RECT, cKids UINT, lpKids /*const*/ *HWND) WORD { + ret1 := syscall6(tileWindows, 5, + uintptr(hwndParent), + uintptr(wHow), + uintptr(unsafe.Pointer(lpRect)), + uintptr(cKids), + uintptr(unsafe.Pointer(lpKids)), + 0) + return WORD(ret1) +} + +func ToAscii(uVirtKey UINT, uScanCode UINT, lpKeyState /*const*/ *byte, lpChar *uint16, uFlags UINT) int32 { + ret1 := syscall6(toAscii, 5, + uintptr(uVirtKey), + uintptr(uScanCode), + uintptr(unsafe.Pointer(lpKeyState)), + uintptr(unsafe.Pointer(lpChar)), + uintptr(uFlags), + 0) + return int32(ret1) +} + +func ToAsciiEx(uVirtKey UINT, uScanCode UINT, lpKeyState /*const*/ *byte, lpChar *uint16, uFlags UINT, dwhkl HKL) int32 { + ret1 := syscall6(toAsciiEx, 6, + uintptr(uVirtKey), + uintptr(uScanCode), + uintptr(unsafe.Pointer(lpKeyState)), + uintptr(unsafe.Pointer(lpChar)), + uintptr(uFlags), + uintptr(dwhkl)) + return int32(ret1) +} + +func ToUnicode(wVirtKey UINT, wScanCode UINT, lpKeyState /*const*/ *byte, pwszBuff LPWSTR, cchBuff int32, wFlags UINT) int32 { + ret1 := syscall6(toUnicode, 6, + uintptr(wVirtKey), + uintptr(wScanCode), + uintptr(unsafe.Pointer(lpKeyState)), + uintptr(unsafe.Pointer(pwszBuff)), + uintptr(cchBuff), + uintptr(wFlags)) + return int32(ret1) +} + +func ToUnicodeEx(wVirtKey UINT, wScanCode UINT, lpKeyState /*const*/ *byte, pwszBuff LPWSTR, cchBuff int32, wFlags UINT, dwhkl HKL) int32 { + ret1 := syscall9(toUnicodeEx, 7, + uintptr(wVirtKey), + uintptr(wScanCode), + uintptr(unsafe.Pointer(lpKeyState)), + uintptr(unsafe.Pointer(pwszBuff)), + uintptr(cchBuff), + uintptr(wFlags), + uintptr(dwhkl), + 0, + 0) + return int32(ret1) +} + +func TrackMouseEvent(lpEventTrack *TRACKMOUSEEVENT) bool { + ret1 := syscall3(trackMouseEvent, 1, + uintptr(unsafe.Pointer(lpEventTrack)), + 0, + 0) + return ret1 != 0 +} + +func TrackPopupMenu(hMenu HMENU, uFlags UINT, x int32, y int32, nReserved int32, hWnd HWND, prcRect /*const*/ *RECT) bool { + ret1 := syscall9(trackPopupMenu, 7, + uintptr(hMenu), + uintptr(uFlags), + uintptr(x), + uintptr(y), + uintptr(nReserved), + uintptr(hWnd), + uintptr(unsafe.Pointer(prcRect)), + 0, + 0) + return ret1 != 0 +} + +func TrackPopupMenuEx(unnamed0 HMENU, unnamed1 UINT, unnamed2 int32, unnamed3 int32, unnamed4 HWND, unnamed5 *TPMPARAMS) bool { + ret1 := syscall6(trackPopupMenuEx, 6, + uintptr(unnamed0), + uintptr(unnamed1), + uintptr(unnamed2), + uintptr(unnamed3), + uintptr(unnamed4), + uintptr(unsafe.Pointer(unnamed5))) + return ret1 != 0 +} + +func TranslateAccelerator(hWnd HWND, hAccTable HACCEL, lpMsg *MSG) int32 { + ret1 := syscall3(translateAccelerator, 3, + uintptr(hWnd), + uintptr(hAccTable), + uintptr(unsafe.Pointer(lpMsg))) + return int32(ret1) +} + +func TranslateMDISysAccel(hWndClient HWND, lpMsg *MSG) bool { + ret1 := syscall3(translateMDISysAccel, 2, + uintptr(hWndClient), + uintptr(unsafe.Pointer(lpMsg)), + 0) + return ret1 != 0 +} + +func TranslateMessage(lpMsg /*const*/ *MSG) bool { + ret1 := syscall3(translateMessage, 1, + uintptr(unsafe.Pointer(lpMsg)), + 0, + 0) + return ret1 != 0 +} + +func UnhookWinEvent(hWinEventHook HWINEVENTHOOK) bool { + ret1 := syscall3(unhookWinEvent, 1, + uintptr(hWinEventHook), + 0, + 0) + return ret1 != 0 +} + +func UnhookWindowsHook(nCode int32, pfnFilterProc HOOKPROC) bool { + pfnFilterProcCallback := syscall.NewCallback(func(codeRawArg int32, wParamRawArg WPARAM, lParamRawArg LPARAM) uintptr { + ret := pfnFilterProc(codeRawArg, wParamRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall3(unhookWindowsHook, 2, + uintptr(nCode), + pfnFilterProcCallback, + 0) + return ret1 != 0 +} + +func UnhookWindowsHookEx(hhk HHOOK) bool { + ret1 := syscall3(unhookWindowsHookEx, 1, + uintptr(hhk), + 0, + 0) + return ret1 != 0 +} + +func UnionRect(lprcDst *RECT, lprcSrc1 /*const*/ *RECT, lprcSrc2 /*const*/ *RECT) bool { + ret1 := syscall3(unionRect, 3, + uintptr(unsafe.Pointer(lprcDst)), + uintptr(unsafe.Pointer(lprcSrc1)), + uintptr(unsafe.Pointer(lprcSrc2))) + return ret1 != 0 +} + +func UnloadKeyboardLayout(hkl HKL) bool { + ret1 := syscall3(unloadKeyboardLayout, 1, + uintptr(hkl), + 0, + 0) + return ret1 != 0 +} + +func UnpackDDElParam(msg UINT, lParam LPARAM, puiLo *uintptr, puiHi *uintptr) bool { + ret1 := syscall6(unpackDDElParam, 4, + uintptr(msg), + uintptr(lParam), + uintptr(unsafe.Pointer(puiLo)), + uintptr(unsafe.Pointer(puiHi)), + 0, + 0) + return ret1 != 0 +} + +func UnregisterClass(lpClassName string, hInstance HINSTANCE) bool { + lpClassNameStr := unicode16FromString(lpClassName) + ret1 := syscall3(unregisterClass, 2, + uintptr(unsafe.Pointer(&lpClassNameStr[0])), + uintptr(hInstance), + 0) + return ret1 != 0 +} + +func UnregisterDeviceNotification(handle HDEVNOTIFY) bool { + ret1 := syscall3(unregisterDeviceNotification, 1, + uintptr(handle), + 0, + 0) + return ret1 != 0 +} + +func UnregisterHotKey(hWnd HWND, id int32) bool { + ret1 := syscall3(unregisterHotKey, 2, + uintptr(hWnd), + uintptr(id), + 0) + return ret1 != 0 +} + +func UnregisterPowerSettingNotification(handle HPOWERNOTIFY) bool { + ret1 := syscall3(unregisterPowerSettingNotification, 1, + uintptr(handle), + 0, + 0) + return ret1 != 0 +} + +func UnregisterTouchWindow(hwnd HWND) bool { + ret1 := syscall3(unregisterTouchWindow, 1, + uintptr(hwnd), + 0, + 0) + return ret1 != 0 +} + +func UpdateLayeredWindow(hWnd HWND, hdcDst HDC, pptDst *POINT, psize *SIZE, hdcSrc HDC, pptSrc *POINT, crKey COLORREF, pblend *BLENDFUNCTION, dwFlags DWORD) bool { + ret1 := syscall9(updateLayeredWindow, 9, + uintptr(hWnd), + uintptr(hdcDst), + uintptr(unsafe.Pointer(pptDst)), + uintptr(unsafe.Pointer(psize)), + uintptr(hdcSrc), + uintptr(unsafe.Pointer(pptSrc)), + uintptr(crKey), + uintptr(unsafe.Pointer(pblend)), + uintptr(dwFlags)) + return ret1 != 0 +} + +func UpdateLayeredWindowIndirect(hWnd HWND, pULWInfo /*const*/ *UPDATELAYEREDWINDOWINFO) bool { + ret1 := syscall3(updateLayeredWindowIndirect, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(pULWInfo)), + 0) + return ret1 != 0 +} + +func UpdateWindow(hWnd HWND) bool { + ret1 := syscall3(updateWindow, 1, + uintptr(hWnd), + 0, + 0) + return ret1 != 0 +} + +func UserHandleGrantAccess(hUserHandle HANDLE, hJob HANDLE, bGrant bool) bool { + ret1 := syscall3(userHandleGrantAccess, 3, + uintptr(hUserHandle), + uintptr(hJob), + getUintptrFromBool(bGrant)) + return ret1 != 0 +} + +func ValidateRect(hWnd HWND, lpRect /*const*/ *RECT) bool { + ret1 := syscall3(validateRect, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpRect)), + 0) + return ret1 != 0 +} + +func ValidateRgn(hWnd HWND, hRgn HRGN) bool { + ret1 := syscall3(validateRgn, 2, + uintptr(hWnd), + uintptr(hRgn), + 0) + return ret1 != 0 +} + +func VkKeyScanEx(ch WCHAR, dwhkl HKL) SHORT { + ret1 := syscall3(vkKeyScanEx, 2, + uintptr(ch), + uintptr(dwhkl), + 0) + return SHORT(ret1) +} + +func VkKeyScan(ch WCHAR) SHORT { + ret1 := syscall3(vkKeyScan, 1, + uintptr(ch), + 0, + 0) + return SHORT(ret1) +} + +func WINNLSEnableIME(unnamed0 HWND, unnamed1 bool) bool { + ret1 := syscall3(wINNLSEnableIME, 2, + uintptr(unnamed0), + getUintptrFromBool(unnamed1), + 0) + return ret1 != 0 +} + +func WINNLSGetEnableStatus(unnamed0 HWND) bool { + ret1 := syscall3(wINNLSGetEnableStatus, 1, + uintptr(unnamed0), + 0, + 0) + return ret1 != 0 +} + +func WINNLSGetIMEHotkey(unnamed0 HWND) UINT { + ret1 := syscall3(wINNLSGetIMEHotkey, 1, + uintptr(unnamed0), + 0, + 0) + return UINT(ret1) +} + +func WaitForInputIdle(hProcess HANDLE, dwMilliseconds DWORD) DWORD { + ret1 := syscall3(waitForInputIdle, 2, + uintptr(hProcess), + uintptr(dwMilliseconds), + 0) + return DWORD(ret1) +} + +func WaitMessage() bool { + ret1 := syscall3(waitMessage, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func WinHelp(hWndMain HWND, lpszHelp string, uCommand UINT, dwData *uint32) bool { + lpszHelpStr := unicode16FromString(lpszHelp) + ret1 := syscall6(winHelp, 4, + uintptr(hWndMain), + uintptr(unsafe.Pointer(&lpszHelpStr[0])), + uintptr(uCommand), + uintptr(unsafe.Pointer(dwData)), + 0, + 0) + return ret1 != 0 +} + +func WindowFromDC(hDC HDC) HWND { + ret1 := syscall3(windowFromDC, 1, + uintptr(hDC), + 0, + 0) + return HWND(ret1) +} + +func WindowFromPoint(point POINT) HWND { + ret1 := syscall3(windowFromPoint, 2, + uintptr(point.X), + uintptr(point.Y), + 0) + return HWND(ret1) +} + +func Keybd_event(bVk BYTE, bScan BYTE, dwFlags DWORD, dwExtraInfo *uint32) { + syscall6(keybd_event, 4, + uintptr(bVk), + uintptr(bScan), + uintptr(dwFlags), + uintptr(unsafe.Pointer(dwExtraInfo)), + 0, + 0) +} + +func Mouse_event(dwFlags DWORD, dx DWORD, dy DWORD, dwData DWORD, dwExtraInfo *uint32) { + syscall6(mouse_event, 5, + uintptr(dwFlags), + uintptr(dx), + uintptr(dy), + uintptr(dwData), + uintptr(unsafe.Pointer(dwExtraInfo)), + 0) +} + +func AlignRects(rect *RECT, b DWORD, c DWORD, d DWORD) bool { + ret1 := syscall6(alignRects, 4, + uintptr(unsafe.Pointer(rect)), + uintptr(b), + uintptr(c), + uintptr(d), + 0, + 0) + return ret1 != 0 +} + +func CascadeChildWindows(parent HWND, flags UINT) WORD { + ret1 := syscall3(cascadeChildWindows, 2, + uintptr(parent), + uintptr(flags), + 0) + return WORD(ret1) +} + +func CreateDialogIndirectParamAorW(hInst HINSTANCE, dlgTemplate /*const*/ uintptr, owner HWND, dlgProc DLGPROC, param LPARAM, flags DWORD) HWND { + dlgProcCallback := syscall.NewCallback(func(hwndDlgRawArg HWND, uMsgRawArg uint32, wParamRawArg WPARAM, lParamRawArg LPARAM) uintptr { + ret := dlgProc(hwndDlgRawArg, uMsgRawArg, wParamRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall6(createDialogIndirectParamAorW, 6, + uintptr(hInst), + dlgTemplate, + uintptr(owner), + dlgProcCallback, + uintptr(param), + uintptr(flags)) + return HWND(ret1) +} + +func DialogBoxIndirectParamAorW(hInstance HINSTANCE, template /*const*/ uintptr, owner HWND, dlgProc DLGPROC, param LPARAM, flags DWORD) INT_PTR { + dlgProcCallback := syscall.NewCallback(func(hwndDlgRawArg HWND, uMsgRawArg uint32, wParamRawArg WPARAM, lParamRawArg LPARAM) uintptr { + ret := dlgProc(hwndDlgRawArg, uMsgRawArg, wParamRawArg, lParamRawArg) + return uintptr(ret) + }) + ret1 := syscall6(dialogBoxIndirectParamAorW, 6, + uintptr(hInstance), + template, + uintptr(owner), + dlgProcCallback, + uintptr(param), + uintptr(flags)) + return (INT_PTR)(unsafe.Pointer(ret1)) +} + +func DrawCaptionTemp(hwnd HWND, hdc HDC, rect /*const*/ *RECT, hFont HFONT, hIcon HICON, str string, uFlags UINT) bool { + strStr := unicode16FromString(str) + ret1 := syscall9(drawCaptionTemp, 7, + uintptr(hwnd), + uintptr(hdc), + uintptr(unsafe.Pointer(rect)), + uintptr(hFont), + uintptr(hIcon), + uintptr(unsafe.Pointer(&strStr[0])), + uintptr(uFlags), + 0, + 0) + return ret1 != 0 +} + +func DrawMenuBarTemp(hwnd HWND, hDC HDC, lprect *RECT, hMenu HMENU, hFont HFONT) DWORD { + ret1 := syscall6(drawMenuBarTemp, 5, + uintptr(hwnd), + uintptr(hDC), + uintptr(unsafe.Pointer(lprect)), + uintptr(hMenu), + uintptr(hFont), + 0) + return DWORD(ret1) +} + +func GetAppCompatFlags(hTask HTASK) DWORD { + ret1 := syscall3(getAppCompatFlags, 1, + uintptr(hTask), + 0, + 0) + return DWORD(ret1) +} + +func GetAppCompatFlags2(hTask HTASK) DWORD { + ret1 := syscall3(getAppCompatFlags2, 1, + uintptr(hTask), + 0, + 0) + return DWORD(ret1) +} + +func GetCursorFrameInfo(hCursor HCURSOR, reserved DWORD, istep DWORD, rate_jiffies *uint32, num_steps *uint32) HCURSOR { + ret1 := syscall6(getCursorFrameInfo, 5, + uintptr(hCursor), + uintptr(reserved), + uintptr(istep), + uintptr(unsafe.Pointer(rate_jiffies)), + uintptr(unsafe.Pointer(num_steps)), + 0) + return HCURSOR(ret1) +} + +func GetInternalWindowPos(hwnd HWND, rectWnd *RECT, ptIcon *POINT) UINT { + ret1 := syscall3(getInternalWindowPos, 3, + uintptr(hwnd), + uintptr(unsafe.Pointer(rectWnd)), + uintptr(unsafe.Pointer(ptIcon))) + return UINT(ret1) +} + +func GetProgmanWindow() HWND { + ret1 := syscall3(getProgmanWindow, 0, + 0, + 0, + 0) + return HWND(ret1) +} + +func GetTaskmanWindow() HWND { + ret1 := syscall3(getTaskmanWindow, 0, + 0, + 0, + 0) + return HWND(ret1) +} + +func KillSystemTimer(hwnd HWND, id *uint32) bool { + ret1 := syscall3(killSystemTimer, 2, + uintptr(hwnd), + uintptr(unsafe.Pointer(id)), + 0) + return ret1 != 0 +} + +func LoadLocalFonts() { + syscall3(loadLocalFonts, 0, + 0, + 0, + 0) +} + +func MessageBoxTimeout(hWnd HWND, text string, title string, aType UINT, langid WORD, timeout DWORD) INT { + textStr := unicode16FromString(text) + titleStr := unicode16FromString(title) + ret1 := syscall6(messageBoxTimeout, 6, + uintptr(hWnd), + uintptr(unsafe.Pointer(&textStr[0])), + uintptr(unsafe.Pointer(&titleStr[0])), + uintptr(aType), + uintptr(langid), + uintptr(timeout)) + return INT(ret1) +} + +func PrivateExtractIconEx(lpwstrFile string, nIndex int32, phIconLarge *HICON, phIconSmall *HICON, nIcons UINT) UINT { + lpwstrFileStr := unicode16FromString(lpwstrFile) + ret1 := syscall6(privateExtractIconEx, 5, + uintptr(unsafe.Pointer(&lpwstrFileStr[0])), + uintptr(nIndex), + uintptr(unsafe.Pointer(phIconLarge)), + uintptr(unsafe.Pointer(phIconSmall)), + uintptr(nIcons), + 0) + return UINT(ret1) +} + +func RegisterLogonProcess(hprocess HANDLE, x bool) DWORD { + ret1 := syscall3(registerLogonProcess, 2, + uintptr(hprocess), + getUintptrFromBool(x), + 0) + return DWORD(ret1) +} + +func RegisterServicesProcess(servicesProcessId DWORD) int32 { + ret1 := syscall3(registerServicesProcess, 1, + uintptr(servicesProcessId), + 0, + 0) + return int32(ret1) +} + +func RegisterSystemThread(flags DWORD, reserved DWORD) { + syscall3(registerSystemThread, 2, + uintptr(flags), + uintptr(reserved), + 0) +} + +func RegisterTasklist(x DWORD) DWORD { + ret1 := syscall3(registerTasklist, 1, + uintptr(x), + 0, + 0) + return DWORD(ret1) +} + +func ScrollChildren(hWnd HWND, uMsg UINT, wParam WPARAM, lParam LPARAM) { + syscall6(scrollChildren, 4, + uintptr(hWnd), + uintptr(uMsg), + uintptr(wParam), + uintptr(lParam), + 0, + 0) +} + +func SetInternalWindowPos(hwnd HWND, showCmd UINT, rect *RECT, pt *POINT) { + syscall6(setInternalWindowPos, 4, + uintptr(hwnd), + uintptr(showCmd), + uintptr(unsafe.Pointer(rect)), + uintptr(unsafe.Pointer(pt)), + 0, + 0) +} + +func SetLogonNotifyWindow(hwinsta HWINSTA, hwnd HWND) DWORD { + ret1 := syscall3(setLogonNotifyWindow, 2, + uintptr(hwinsta), + uintptr(hwnd), + 0) + return DWORD(ret1) +} + +func SetProgmanWindow(hwnd HWND) HWND { + ret1 := syscall3(setProgmanWindow, 1, + uintptr(hwnd), + 0, + 0) + return HWND(ret1) +} + +func SetShellWindow(hwndShell HWND) bool { + ret1 := syscall3(setShellWindow, 1, + uintptr(hwndShell), + 0, + 0) + return ret1 != 0 +} + +func SetShellWindowEx(hwndShell HWND, hwndListView HWND) bool { + ret1 := syscall3(setShellWindowEx, 2, + uintptr(hwndShell), + uintptr(hwndListView), + 0) + return ret1 != 0 +} + +func SetSysColorsTemp(pPens /*const*/ *COLORREF, pBrushes /*const*/ *HBRUSH, n *uint32) *uint32 { + ret1 := syscall3(setSysColorsTemp, 3, + uintptr(unsafe.Pointer(pPens)), + uintptr(unsafe.Pointer(pBrushes)), + uintptr(unsafe.Pointer(n))) + return (*uint32)(unsafe.Pointer(ret1)) +} + +func SetSystemMenu(hwnd HWND, hMenu HMENU) bool { + ret1 := syscall3(setSystemMenu, 2, + uintptr(hwnd), + uintptr(hMenu), + 0) + return ret1 != 0 +} + +func SetSystemTimer(hwnd HWND, id *uint32, timeout UINT, proc TIMERPROC) *uint32 { + procCallback := syscall.NewCallback(proc) + ret1 := syscall6(setSystemTimer, 4, + uintptr(hwnd), + uintptr(unsafe.Pointer(id)), + uintptr(timeout), + procCallback, + 0, + 0) + return (*uint32)(unsafe.Pointer(ret1)) +} + +func SetTaskmanWindow(hwnd HWND) HWND { + ret1 := syscall3(setTaskmanWindow, 1, + uintptr(hwnd), + 0, + 0) + return HWND(ret1) +} + +func SetWindowStationUser(x1 DWORD, x2 DWORD) DWORD { + ret1 := syscall3(setWindowStationUser, 2, + uintptr(x1), + uintptr(x2), + 0) + return DWORD(ret1) +} + +func TileChildWindows(parent HWND, flags UINT) WORD { + ret1 := syscall3(tileChildWindows, 2, + uintptr(parent), + uintptr(flags), + 0) + return WORD(ret1) +} + +func User32InitializeImmEntryTable(unnamed0 DWORD) bool { + ret1 := syscall3(user32InitializeImmEntryTable, 1, + uintptr(unnamed0), + 0, + 0) + return ret1 != 0 +} + +func UserRealizePalette(hDC HDC) UINT { + ret1 := syscall3(userRealizePalette, 1, + uintptr(hDC), + 0, + 0) + return UINT(ret1) +} + +func UserRegisterWowHandlers(aNew /*const*/ uintptr, orig uintptr) { + syscall3(userRegisterWowHandlers, 2, + aNew, + orig, + 0) +} + +func AddClipboardFormatListener(hWnd HWND) DWORD { + ret1 := syscall3(addClipboardFormatListener, 1, + uintptr(hWnd), + 0, + 0) + return DWORD(ret1) +} + +func RemoveClipboardFormatListener(hWnd HWND) DWORD { + ret1 := syscall3(removeClipboardFormatListener, 1, + uintptr(hWnd), + 0, + 0) + return DWORD(ret1) +} diff --git a/grdp/win/uxtheme.go b/grdp/win/uxtheme.go new file mode 100644 index 0000000..841ffc3 --- /dev/null +++ b/grdp/win/uxtheme.go @@ -0,0 +1,841 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "unsafe" +) + +var ( + // Library + libuxtheme uintptr + + // Functions + beginPanningFeedback uintptr + endPanningFeedback uintptr + updatePanningFeedback uintptr + beginBufferedAnimation uintptr + beginBufferedPaint uintptr + bufferedPaintClear uintptr + bufferedPaintInit uintptr + bufferedPaintRenderAnimation uintptr + bufferedPaintSetAlpha uintptr + bufferedPaintStopAllAnimations uintptr + bufferedPaintUnInit uintptr + closeThemeData uintptr + drawThemeBackground uintptr + drawThemeBackgroundEx uintptr + drawThemeEdge uintptr + drawThemeIcon uintptr + drawThemeParentBackground uintptr + drawThemeText uintptr + drawThemeTextEx uintptr + enableThemeDialogTexture uintptr + enableTheming uintptr + endBufferedAnimation uintptr + endBufferedPaint uintptr + getBufferedPaintBits uintptr + getBufferedPaintDC uintptr + getBufferedPaintTargetDC uintptr + getBufferedPaintTargetRect uintptr + getCurrentThemeName uintptr + getThemeAppProperties uintptr + getThemeBackgroundContentRect uintptr + getThemeBackgroundExtent uintptr + getThemeBackgroundRegion uintptr + getThemeBool uintptr + getThemeColor uintptr + getThemeDocumentationProperty uintptr + getThemeEnumValue uintptr + getThemeFilename uintptr + getThemeFont uintptr + getThemeInt uintptr + getThemeIntList uintptr + getThemeMargins uintptr + getThemeMetric uintptr + getThemePartSize uintptr + getThemePosition uintptr + getThemePropertyOrigin uintptr + getThemeRect uintptr + getThemeString uintptr + getThemeSysBool uintptr + getThemeSysColor uintptr + getThemeSysColorBrush uintptr + getThemeSysFont uintptr + getThemeSysInt uintptr + getThemeSysSize uintptr + getThemeSysString uintptr + getThemeTextExtent uintptr + getThemeTextMetrics uintptr + getThemeTransitionDuration uintptr + getWindowTheme uintptr + hitTestThemeBackground uintptr + isAppThemed uintptr + isThemeActive uintptr + isThemeBackgroundPartiallyTransparent uintptr + isThemeDialogTextureEnabled uintptr + isThemePartDefined uintptr + openThemeData uintptr + openThemeDataEx uintptr + setThemeAppProperties uintptr + setWindowTheme uintptr +) + +func init() { + // Library + libuxtheme = doLoadLibrary("uxtheme.dll") + + // Functions + beginPanningFeedback = doGetProcAddress(libuxtheme, "BeginPanningFeedback") + endPanningFeedback = doGetProcAddress(libuxtheme, "EndPanningFeedback") + updatePanningFeedback = doGetProcAddress(libuxtheme, "UpdatePanningFeedback") + beginBufferedAnimation = doGetProcAddress(libuxtheme, "BeginBufferedAnimation") + beginBufferedPaint = doGetProcAddress(libuxtheme, "BeginBufferedPaint") + bufferedPaintClear = doGetProcAddress(libuxtheme, "BufferedPaintClear") + bufferedPaintInit = doGetProcAddress(libuxtheme, "BufferedPaintInit") + bufferedPaintRenderAnimation = doGetProcAddress(libuxtheme, "BufferedPaintRenderAnimation") + bufferedPaintSetAlpha = doGetProcAddress(libuxtheme, "BufferedPaintSetAlpha") + bufferedPaintStopAllAnimations = doGetProcAddress(libuxtheme, "BufferedPaintStopAllAnimations") + bufferedPaintUnInit = doGetProcAddress(libuxtheme, "BufferedPaintUnInit") + closeThemeData = doGetProcAddress(libuxtheme, "CloseThemeData") + drawThemeBackground = doGetProcAddress(libuxtheme, "DrawThemeBackground") + drawThemeBackgroundEx = doGetProcAddress(libuxtheme, "DrawThemeBackgroundEx") + drawThemeEdge = doGetProcAddress(libuxtheme, "DrawThemeEdge") + drawThemeIcon = doGetProcAddress(libuxtheme, "DrawThemeIcon") + drawThemeParentBackground = doGetProcAddress(libuxtheme, "DrawThemeParentBackground") + drawThemeText = doGetProcAddress(libuxtheme, "DrawThemeText") + drawThemeTextEx = doGetProcAddress(libuxtheme, "DrawThemeTextEx") + enableThemeDialogTexture = doGetProcAddress(libuxtheme, "EnableThemeDialogTexture") + enableTheming = doGetProcAddress(libuxtheme, "EnableTheming") + endBufferedAnimation = doGetProcAddress(libuxtheme, "EndBufferedAnimation") + endBufferedPaint = doGetProcAddress(libuxtheme, "EndBufferedPaint") + getBufferedPaintBits = doGetProcAddress(libuxtheme, "GetBufferedPaintBits") + getBufferedPaintDC = doGetProcAddress(libuxtheme, "GetBufferedPaintDC") + getBufferedPaintTargetDC = doGetProcAddress(libuxtheme, "GetBufferedPaintTargetDC") + getBufferedPaintTargetRect = doGetProcAddress(libuxtheme, "GetBufferedPaintTargetRect") + getCurrentThemeName = doGetProcAddress(libuxtheme, "GetCurrentThemeName") + getThemeAppProperties = doGetProcAddress(libuxtheme, "GetThemeAppProperties") + getThemeBackgroundContentRect = doGetProcAddress(libuxtheme, "GetThemeBackgroundContentRect") + getThemeBackgroundExtent = doGetProcAddress(libuxtheme, "GetThemeBackgroundExtent") + getThemeBackgroundRegion = doGetProcAddress(libuxtheme, "GetThemeBackgroundRegion") + getThemeBool = doGetProcAddress(libuxtheme, "GetThemeBool") + getThemeColor = doGetProcAddress(libuxtheme, "GetThemeColor") + getThemeDocumentationProperty = doGetProcAddress(libuxtheme, "GetThemeDocumentationProperty") + getThemeEnumValue = doGetProcAddress(libuxtheme, "GetThemeEnumValue") + getThemeFilename = doGetProcAddress(libuxtheme, "GetThemeFilename") + getThemeFont = doGetProcAddress(libuxtheme, "GetThemeFont") + getThemeInt = doGetProcAddress(libuxtheme, "GetThemeInt") + getThemeIntList = doGetProcAddress(libuxtheme, "GetThemeIntList") + getThemeMargins = doGetProcAddress(libuxtheme, "GetThemeMargins") + getThemeMetric = doGetProcAddress(libuxtheme, "GetThemeMetric") + getThemePartSize = doGetProcAddress(libuxtheme, "GetThemePartSize") + getThemePosition = doGetProcAddress(libuxtheme, "GetThemePosition") + getThemePropertyOrigin = doGetProcAddress(libuxtheme, "GetThemePropertyOrigin") + getThemeRect = doGetProcAddress(libuxtheme, "GetThemeRect") + getThemeString = doGetProcAddress(libuxtheme, "GetThemeString") + getThemeSysBool = doGetProcAddress(libuxtheme, "GetThemeSysBool") + getThemeSysColor = doGetProcAddress(libuxtheme, "GetThemeSysColor") + getThemeSysColorBrush = doGetProcAddress(libuxtheme, "GetThemeSysColorBrush") + getThemeSysFont = doGetProcAddress(libuxtheme, "GetThemeSysFont") + getThemeSysInt = doGetProcAddress(libuxtheme, "GetThemeSysInt") + getThemeSysSize = doGetProcAddress(libuxtheme, "GetThemeSysSize") + getThemeSysString = doGetProcAddress(libuxtheme, "GetThemeSysString") + getThemeTextExtent = doGetProcAddress(libuxtheme, "GetThemeTextExtent") + getThemeTextMetrics = doGetProcAddress(libuxtheme, "GetThemeTextMetrics") + getThemeTransitionDuration = doGetProcAddress(libuxtheme, "GetThemeTransitionDuration") + getWindowTheme = doGetProcAddress(libuxtheme, "GetWindowTheme") + hitTestThemeBackground = doGetProcAddress(libuxtheme, "HitTestThemeBackground") + isAppThemed = doGetProcAddress(libuxtheme, "IsAppThemed") + isThemeActive = doGetProcAddress(libuxtheme, "IsThemeActive") + isThemeBackgroundPartiallyTransparent = doGetProcAddress(libuxtheme, "IsThemeBackgroundPartiallyTransparent") + isThemeDialogTextureEnabled = doGetProcAddress(libuxtheme, "IsThemeDialogTextureEnabled") + isThemePartDefined = doGetProcAddress(libuxtheme, "IsThemePartDefined") + openThemeData = doGetProcAddress(libuxtheme, "OpenThemeData") + openThemeDataEx = doGetProcAddress(libuxtheme, "OpenThemeDataEx") + setThemeAppProperties = doGetProcAddress(libuxtheme, "SetThemeAppProperties") + setWindowTheme = doGetProcAddress(libuxtheme, "SetWindowTheme") +} + +func BeginPanningFeedback(hwnd HWND) bool { + ret1 := syscall3(beginPanningFeedback, 1, + uintptr(hwnd), + 0, + 0) + return ret1 != 0 +} + +func EndPanningFeedback(hwnd HWND, fAnimateBack bool) bool { + ret1 := syscall3(endPanningFeedback, 2, + uintptr(hwnd), + getUintptrFromBool(fAnimateBack), + 0) + return ret1 != 0 +} + +func UpdatePanningFeedback(hwnd HWND, lTotalOverpanOffsetX LONG, lTotalOverpanOffsetY LONG, fInInertia bool) bool { + ret1 := syscall6(updatePanningFeedback, 4, + uintptr(hwnd), + uintptr(lTotalOverpanOffsetX), + uintptr(lTotalOverpanOffsetY), + getUintptrFromBool(fInInertia), + 0, + 0) + return ret1 != 0 +} + +func BeginBufferedAnimation(hwnd HWND, hdcTarget HDC, rcTarget /*const*/ *RECT, dwFormat BP_BUFFERFORMAT, pPaintParams *BP_PAINTPARAMS, pAnimationParams *BP_ANIMATIONPARAMS, phdcFrom *HDC, phdcTo *HDC) HANIMATIONBUFFER { + ret1 := syscall9(beginBufferedAnimation, 8, + uintptr(hwnd), + uintptr(hdcTarget), + uintptr(unsafe.Pointer(rcTarget)), + uintptr(dwFormat), + uintptr(unsafe.Pointer(pPaintParams)), + uintptr(unsafe.Pointer(pAnimationParams)), + uintptr(unsafe.Pointer(phdcFrom)), + uintptr(unsafe.Pointer(phdcTo)), + 0) + return HANIMATIONBUFFER(ret1) +} + +func BeginBufferedPaint(hdcTarget HDC, prcTarget /*const*/ *RECT, dwFormat BP_BUFFERFORMAT, pPaintParams *BP_PAINTPARAMS, phdc *HDC) HPAINTBUFFER { + ret1 := syscall6(beginBufferedPaint, 5, + uintptr(hdcTarget), + uintptr(unsafe.Pointer(prcTarget)), + uintptr(dwFormat), + uintptr(unsafe.Pointer(pPaintParams)), + uintptr(unsafe.Pointer(phdc)), + 0) + return HPAINTBUFFER(ret1) +} + +func BufferedPaintClear(hBufferedPaint HPAINTBUFFER, prc /*const*/ *RECT) HRESULT { + ret1 := syscall3(bufferedPaintClear, 2, + uintptr(hBufferedPaint), + uintptr(unsafe.Pointer(prc)), + 0) + return HRESULT(ret1) +} + +func BufferedPaintInit() HRESULT { + ret1 := syscall3(bufferedPaintInit, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func BufferedPaintRenderAnimation(hwnd HWND, hdcTarget HDC) bool { + ret1 := syscall3(bufferedPaintRenderAnimation, 2, + uintptr(hwnd), + uintptr(hdcTarget), + 0) + return ret1 != 0 +} + +func BufferedPaintSetAlpha(hBufferedPaint HPAINTBUFFER, prc /*const*/ *RECT, alpha BYTE) HRESULT { + ret1 := syscall3(bufferedPaintSetAlpha, 3, + uintptr(hBufferedPaint), + uintptr(unsafe.Pointer(prc)), + uintptr(alpha)) + return HRESULT(ret1) +} + +func BufferedPaintStopAllAnimations(hwnd HWND) HRESULT { + ret1 := syscall3(bufferedPaintStopAllAnimations, 1, + uintptr(hwnd), + 0, + 0) + return HRESULT(ret1) +} + +func BufferedPaintUnInit() HRESULT { + ret1 := syscall3(bufferedPaintUnInit, 0, + 0, + 0, + 0) + return HRESULT(ret1) +} + +func CloseThemeData(hTheme HTHEME) HRESULT { + ret1 := syscall3(closeThemeData, 1, + uintptr(hTheme), + 0, + 0) + return HRESULT(ret1) +} + +func DrawThemeBackground(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, pRect /*const*/ *RECT, pClipRect /*const*/ *RECT) HRESULT { + ret1 := syscall6(drawThemeBackground, 6, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(unsafe.Pointer(pRect)), + uintptr(unsafe.Pointer(pClipRect))) + return HRESULT(ret1) +} + +func DrawThemeBackgroundEx(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, pRect /*const*/ *RECT, pOptions /*const*/ *DTBGOPTS) HRESULT { + ret1 := syscall6(drawThemeBackgroundEx, 6, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(unsafe.Pointer(pRect)), + uintptr(unsafe.Pointer(pOptions))) + return HRESULT(ret1) +} + +func DrawThemeEdge(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, pDestRect /*const*/ *RECT, uEdge UINT, uFlags UINT, pContentRect *RECT) HRESULT { + ret1 := syscall9(drawThemeEdge, 8, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(unsafe.Pointer(pDestRect)), + uintptr(uEdge), + uintptr(uFlags), + uintptr(unsafe.Pointer(pContentRect)), + 0) + return HRESULT(ret1) +} + +func DrawThemeIcon(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, pRect /*const*/ *RECT, himl HIMAGELIST, iImageIndex int32) HRESULT { + ret1 := syscall9(drawThemeIcon, 7, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(unsafe.Pointer(pRect)), + uintptr(himl), + uintptr(iImageIndex), + 0, + 0) + return HRESULT(ret1) +} + +func DrawThemeParentBackground(hwnd HWND, hdc HDC, prc *RECT) HRESULT { + ret1 := syscall3(drawThemeParentBackground, 3, + uintptr(hwnd), + uintptr(hdc), + uintptr(unsafe.Pointer(prc))) + return HRESULT(ret1) +} + +func DrawThemeText(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, pszText string, iCharCount int32, flags DWORD, flags2 DWORD, pRect /*const*/ *RECT) HRESULT { + pszTextStr := unicode16FromString(pszText) + ret1 := syscall9(drawThemeText, 9, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(unsafe.Pointer(&pszTextStr[0])), + uintptr(iCharCount), + uintptr(flags), + uintptr(flags2), + uintptr(unsafe.Pointer(pRect))) + return HRESULT(ret1) +} + +func DrawThemeTextEx(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, pszText string, iCharCount int32, flags DWORD, rect *RECT, options /*const*/ *DTTOPTS) HRESULT { + pszTextStr := unicode16FromString(pszText) + ret1 := syscall9(drawThemeTextEx, 9, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(unsafe.Pointer(&pszTextStr[0])), + uintptr(iCharCount), + uintptr(flags), + uintptr(unsafe.Pointer(rect)), + uintptr(unsafe.Pointer(options))) + return HRESULT(ret1) +} + +func EnableThemeDialogTexture(hwnd HWND, dwFlags DWORD) HRESULT { + ret1 := syscall3(enableThemeDialogTexture, 2, + uintptr(hwnd), + uintptr(dwFlags), + 0) + return HRESULT(ret1) +} + +func EnableTheming(fEnable bool) HRESULT { + ret1 := syscall3(enableTheming, 1, + getUintptrFromBool(fEnable), + 0, + 0) + return HRESULT(ret1) +} + +func EndBufferedAnimation(hbpAnimation HANIMATIONBUFFER, fUpdateTarget bool) HRESULT { + ret1 := syscall3(endBufferedAnimation, 2, + uintptr(hbpAnimation), + getUintptrFromBool(fUpdateTarget), + 0) + return HRESULT(ret1) +} + +func EndBufferedPaint(hPaintBuffer HPAINTBUFFER, fUpdateTarget bool) HRESULT { + ret1 := syscall3(endBufferedPaint, 2, + uintptr(hPaintBuffer), + getUintptrFromBool(fUpdateTarget), + 0) + return HRESULT(ret1) +} + +func GetBufferedPaintBits(hBufferedPaint HPAINTBUFFER, ppbBuffer **RGBQUAD, pcxRow *int) HRESULT { + ret1 := syscall3(getBufferedPaintBits, 3, + uintptr(hBufferedPaint), + uintptr(unsafe.Pointer(ppbBuffer)), + uintptr(unsafe.Pointer(pcxRow))) + return HRESULT(ret1) +} + +func GetBufferedPaintDC(hBufferedPaint HPAINTBUFFER) HDC { + ret1 := syscall3(getBufferedPaintDC, 1, + uintptr(hBufferedPaint), + 0, + 0) + return HDC(ret1) +} + +func GetBufferedPaintTargetDC(hBufferedPaint HPAINTBUFFER) HDC { + ret1 := syscall3(getBufferedPaintTargetDC, 1, + uintptr(hBufferedPaint), + 0, + 0) + return HDC(ret1) +} + +func GetBufferedPaintTargetRect(hBufferedPaint HPAINTBUFFER, prc *RECT) HRESULT { + ret1 := syscall3(getBufferedPaintTargetRect, 2, + uintptr(hBufferedPaint), + uintptr(unsafe.Pointer(prc)), + 0) + return HRESULT(ret1) +} + +func GetCurrentThemeName(pszThemeFileName LPWSTR, dwMaxNameChars int32, pszColorBuff LPWSTR, cchMaxColorChars int32, pszSizeBuff LPWSTR, cchMaxSizeChars int32) HRESULT { + ret1 := syscall6(getCurrentThemeName, 6, + uintptr(unsafe.Pointer(pszThemeFileName)), + uintptr(dwMaxNameChars), + uintptr(unsafe.Pointer(pszColorBuff)), + uintptr(cchMaxColorChars), + uintptr(unsafe.Pointer(pszSizeBuff)), + uintptr(cchMaxSizeChars)) + return HRESULT(ret1) +} + +func GetThemeAppProperties() DWORD { + ret1 := syscall3(getThemeAppProperties, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func GetThemeBackgroundContentRect(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, pBoundingRect /*const*/ *RECT, pContentRect *RECT) HRESULT { + ret1 := syscall6(getThemeBackgroundContentRect, 6, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(unsafe.Pointer(pBoundingRect)), + uintptr(unsafe.Pointer(pContentRect))) + return HRESULT(ret1) +} + +func GetThemeBackgroundExtent(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, pContentRect /*const*/ *RECT, pExtentRect *RECT) HRESULT { + ret1 := syscall6(getThemeBackgroundExtent, 6, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(unsafe.Pointer(pContentRect)), + uintptr(unsafe.Pointer(pExtentRect))) + return HRESULT(ret1) +} + +func GetThemeBackgroundRegion(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, pRect /*const*/ *RECT, pRegion *HRGN) HRESULT { + ret1 := syscall6(getThemeBackgroundRegion, 6, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(unsafe.Pointer(pRect)), + uintptr(unsafe.Pointer(pRegion))) + return HRESULT(ret1) +} + +func GetThemeBool(hTheme HTHEME, iPartId int32, iStateId int32, iPropId int32, pfVal *BOOL) HRESULT { + ret1 := syscall6(getThemeBool, 5, + uintptr(hTheme), + uintptr(iPartId), + uintptr(iStateId), + uintptr(iPropId), + uintptr(unsafe.Pointer(pfVal)), + 0) + return HRESULT(ret1) +} + +func GetThemeColor(hTheme HTHEME, iPartId int32, iStateId int32, iPropId int32, pColor *COLORREF) HRESULT { + ret1 := syscall6(getThemeColor, 5, + uintptr(hTheme), + uintptr(iPartId), + uintptr(iStateId), + uintptr(iPropId), + uintptr(unsafe.Pointer(pColor)), + 0) + return HRESULT(ret1) +} + +func GetThemeDocumentationProperty(pszThemeName string, pszPropertyName string, pszValueBuff LPWSTR, cchMaxValChars int32) HRESULT { + pszThemeNameStr := unicode16FromString(pszThemeName) + pszPropertyNameStr := unicode16FromString(pszPropertyName) + ret1 := syscall6(getThemeDocumentationProperty, 4, + uintptr(unsafe.Pointer(&pszThemeNameStr[0])), + uintptr(unsafe.Pointer(&pszPropertyNameStr[0])), + uintptr(unsafe.Pointer(pszValueBuff)), + uintptr(cchMaxValChars), + 0, + 0) + return HRESULT(ret1) +} + +func GetThemeEnumValue(hTheme HTHEME, iPartId int32, iStateId int32, iPropId int32, piVal *int) HRESULT { + ret1 := syscall6(getThemeEnumValue, 5, + uintptr(hTheme), + uintptr(iPartId), + uintptr(iStateId), + uintptr(iPropId), + uintptr(unsafe.Pointer(piVal)), + 0) + return HRESULT(ret1) +} + +func GetThemeFilename(hTheme HTHEME, iPartId int32, iStateId int32, iPropId int32, pszThemeFilename LPWSTR, cchMaxBuffChars int32) HRESULT { + ret1 := syscall6(getThemeFilename, 6, + uintptr(hTheme), + uintptr(iPartId), + uintptr(iStateId), + uintptr(iPropId), + uintptr(unsafe.Pointer(pszThemeFilename)), + uintptr(cchMaxBuffChars)) + return HRESULT(ret1) +} + +func GetThemeFont(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, iPropId int32, pFont *LOGFONT) HRESULT { + ret1 := syscall6(getThemeFont, 6, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(iPropId), + uintptr(unsafe.Pointer(pFont))) + return HRESULT(ret1) +} + +func GetThemeInt(hTheme HTHEME, iPartId int32, iStateId int32, iPropId int32, piVal *int) HRESULT { + ret1 := syscall6(getThemeInt, 5, + uintptr(hTheme), + uintptr(iPartId), + uintptr(iStateId), + uintptr(iPropId), + uintptr(unsafe.Pointer(piVal)), + 0) + return HRESULT(ret1) +} + +func GetThemeIntList(hTheme HTHEME, iPartId int32, iStateId int32, iPropId int32, pIntList *INTLIST) HRESULT { + ret1 := syscall6(getThemeIntList, 5, + uintptr(hTheme), + uintptr(iPartId), + uintptr(iStateId), + uintptr(iPropId), + uintptr(unsafe.Pointer(pIntList)), + 0) + return HRESULT(ret1) +} + +func GetThemeMargins(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, iPropId int32, prc *RECT, pMargins *MARGINS) HRESULT { + ret1 := syscall9(getThemeMargins, 7, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(iPropId), + uintptr(unsafe.Pointer(prc)), + uintptr(unsafe.Pointer(pMargins)), + 0, + 0) + return HRESULT(ret1) +} + +func GetThemeMetric(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, iPropId int32, piVal *int) HRESULT { + ret1 := syscall6(getThemeMetric, 6, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(iPropId), + uintptr(unsafe.Pointer(piVal))) + return HRESULT(ret1) +} + +func GetThemePartSize(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, prc *RECT, eSize THEMESIZE, psz *SIZE) HRESULT { + ret1 := syscall9(getThemePartSize, 7, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(unsafe.Pointer(prc)), + uintptr(eSize), + uintptr(unsafe.Pointer(psz)), + 0, + 0) + return HRESULT(ret1) +} + +func GetThemePosition(hTheme HTHEME, iPartId int32, iStateId int32, iPropId int32, pPoint *POINT) HRESULT { + ret1 := syscall6(getThemePosition, 5, + uintptr(hTheme), + uintptr(iPartId), + uintptr(iStateId), + uintptr(iPropId), + uintptr(unsafe.Pointer(pPoint)), + 0) + return HRESULT(ret1) +} + +func GetThemePropertyOrigin(hTheme HTHEME, iPartId int32, iStateId int32, iPropId int32, pOrigin *PROPERTYORIGIN) HRESULT { + ret1 := syscall6(getThemePropertyOrigin, 5, + uintptr(hTheme), + uintptr(iPartId), + uintptr(iStateId), + uintptr(iPropId), + uintptr(unsafe.Pointer(pOrigin)), + 0) + return HRESULT(ret1) +} + +func GetThemeRect(hTheme HTHEME, iPartId int32, iStateId int32, iPropId int32, pRect *RECT) HRESULT { + ret1 := syscall6(getThemeRect, 5, + uintptr(hTheme), + uintptr(iPartId), + uintptr(iStateId), + uintptr(iPropId), + uintptr(unsafe.Pointer(pRect)), + 0) + return HRESULT(ret1) +} + +func GetThemeString(hTheme HTHEME, iPartId int32, iStateId int32, iPropId int32, pszBuff LPWSTR, cchMaxBuffChars int32) HRESULT { + ret1 := syscall6(getThemeString, 6, + uintptr(hTheme), + uintptr(iPartId), + uintptr(iStateId), + uintptr(iPropId), + uintptr(unsafe.Pointer(pszBuff)), + uintptr(cchMaxBuffChars)) + return HRESULT(ret1) +} + +func GetThemeSysBool(hTheme HTHEME, iBoolID int32) bool { + ret1 := syscall3(getThemeSysBool, 2, + uintptr(hTheme), + uintptr(iBoolID), + 0) + return ret1 != 0 +} + +func GetThemeSysColor(hTheme HTHEME, iColorID int32) COLORREF { + ret1 := syscall3(getThemeSysColor, 2, + uintptr(hTheme), + uintptr(iColorID), + 0) + return COLORREF(ret1) +} + +func GetThemeSysColorBrush(hTheme HTHEME, iColorID int32) HBRUSH { + ret1 := syscall3(getThemeSysColorBrush, 2, + uintptr(hTheme), + uintptr(iColorID), + 0) + return HBRUSH(ret1) +} + +func GetThemeSysFont(hTheme HTHEME, iFontID int32, plf *LOGFONT) HRESULT { + ret1 := syscall3(getThemeSysFont, 3, + uintptr(hTheme), + uintptr(iFontID), + uintptr(unsafe.Pointer(plf))) + return HRESULT(ret1) +} + +func GetThemeSysInt(hTheme HTHEME, iIntID int32, piValue *int) HRESULT { + ret1 := syscall3(getThemeSysInt, 3, + uintptr(hTheme), + uintptr(iIntID), + uintptr(unsafe.Pointer(piValue))) + return HRESULT(ret1) +} + +func GetThemeSysSize(hTheme HTHEME, iSizeID int32) int32 { + ret1 := syscall3(getThemeSysSize, 2, + uintptr(hTheme), + uintptr(iSizeID), + 0) + return int32(ret1) +} + +func GetThemeSysString(hTheme HTHEME, iStringID int32, pszStringBuff LPWSTR, cchMaxStringChars int32) HRESULT { + ret1 := syscall6(getThemeSysString, 4, + uintptr(hTheme), + uintptr(iStringID), + uintptr(unsafe.Pointer(pszStringBuff)), + uintptr(cchMaxStringChars), + 0, + 0) + return HRESULT(ret1) +} + +func GetThemeTextExtent(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, pszText string, iCharCount int32, dwTextFlags DWORD, pBoundingRect /*const*/ *RECT, pExtentRect *RECT) HRESULT { + pszTextStr := unicode16FromString(pszText) + ret1 := syscall9(getThemeTextExtent, 9, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(unsafe.Pointer(&pszTextStr[0])), + uintptr(iCharCount), + uintptr(dwTextFlags), + uintptr(unsafe.Pointer(pBoundingRect)), + uintptr(unsafe.Pointer(pExtentRect))) + return HRESULT(ret1) +} + +func GetThemeTextMetrics(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, ptm *TEXTMETRIC) HRESULT { + ret1 := syscall6(getThemeTextMetrics, 5, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(unsafe.Pointer(ptm)), + 0) + return HRESULT(ret1) +} + +func GetThemeTransitionDuration(hTheme HTHEME, iPartId int32, iStateIdFrom int32, iStateIdTo int32, iPropId int32, pdwDuration *uint32) HRESULT { + ret1 := syscall6(getThemeTransitionDuration, 6, + uintptr(hTheme), + uintptr(iPartId), + uintptr(iStateIdFrom), + uintptr(iStateIdTo), + uintptr(iPropId), + uintptr(unsafe.Pointer(pdwDuration))) + return HRESULT(ret1) +} + +func GetWindowTheme(hwnd HWND) HTHEME { + ret1 := syscall3(getWindowTheme, 1, + uintptr(hwnd), + 0, + 0) + return HTHEME(ret1) +} + +func HitTestThemeBackground(hTheme HTHEME, hdc HDC, iPartId int32, iStateId int32, dwOptions DWORD, pRect /*const*/ *RECT, hrgn HRGN, ptTest POINT, pwHitTestCode *WORD) HRESULT { + ret1 := syscall12(hitTestThemeBackground, 10, + uintptr(hTheme), + uintptr(hdc), + uintptr(iPartId), + uintptr(iStateId), + uintptr(dwOptions), + uintptr(unsafe.Pointer(pRect)), + uintptr(hrgn), + uintptr(ptTest.X), + uintptr(ptTest.Y), + uintptr(unsafe.Pointer(pwHitTestCode)), + 0, + 0) + return HRESULT(ret1) +} + +func IsAppThemed() bool { + ret1 := syscall3(isAppThemed, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func IsThemeActive() bool { + ret1 := syscall3(isThemeActive, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func IsThemeBackgroundPartiallyTransparent(hTheme HTHEME, iPartId int32, iStateId int32) bool { + ret1 := syscall3(isThemeBackgroundPartiallyTransparent, 3, + uintptr(hTheme), + uintptr(iPartId), + uintptr(iStateId)) + return ret1 != 0 +} + +func IsThemeDialogTextureEnabled(hwnd HWND) bool { + ret1 := syscall3(isThemeDialogTextureEnabled, 1, + uintptr(hwnd), + 0, + 0) + return ret1 != 0 +} + +func IsThemePartDefined(hTheme HTHEME, iPartId int32, iStateId int32) bool { + ret1 := syscall3(isThemePartDefined, 3, + uintptr(hTheme), + uintptr(iPartId), + uintptr(iStateId)) + return ret1 != 0 +} + +func OpenThemeData(hwnd HWND, classlist string) HTHEME { + classlistStr := unicode16FromString(classlist) + ret1 := syscall3(openThemeData, 2, + uintptr(hwnd), + uintptr(unsafe.Pointer(&classlistStr[0])), + 0) + return HTHEME(ret1) +} + +func OpenThemeDataEx(hwnd HWND, pszClassList string, flags DWORD) HTHEME { + pszClassListStr := unicode16FromString(pszClassList) + ret1 := syscall3(openThemeDataEx, 3, + uintptr(hwnd), + uintptr(unsafe.Pointer(&pszClassListStr[0])), + uintptr(flags)) + return HTHEME(ret1) +} + +func SetThemeAppProperties(dwFlags DWORD) { + syscall3(setThemeAppProperties, 1, + uintptr(dwFlags), + 0, + 0) +} + +func SetWindowTheme(hwnd HWND, pszSubAppName string, pszSubIdList string) HRESULT { + pszSubAppNameStr := unicode16FromString(pszSubAppName) + pszSubIdListStr := unicode16FromString(pszSubIdList) + ret1 := syscall3(setWindowTheme, 3, + uintptr(hwnd), + uintptr(unsafe.Pointer(&pszSubAppNameStr[0])), + uintptr(unsafe.Pointer(&pszSubIdListStr[0]))) + return HRESULT(ret1) +} diff --git a/grdp/win/version.go b/grdp/win/version.go new file mode 100644 index 0000000..987f000 --- /dev/null +++ b/grdp/win/version.go @@ -0,0 +1,95 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "unsafe" +) + +var ( + // Library + libversion uintptr + + // Functions + getFileVersionInfoSize uintptr + getFileVersionInfo uintptr + verFindFile uintptr + verInstallFile uintptr + verQueryValue uintptr +) + +func init() { + // Library + libversion = doLoadLibrary("version.dll") + + // Functions + getFileVersionInfoSize = doGetProcAddress(libversion, "GetFileVersionInfoSizeW") + getFileVersionInfo = doGetProcAddress(libversion, "GetFileVersionInfoW") + verFindFile = doGetProcAddress(libversion, "VerFindFileW") + verInstallFile = doGetProcAddress(libversion, "VerInstallFileW") + verQueryValue = doGetProcAddress(libversion, "VerQueryValueW") +} + +func GetFileVersionInfoSize(lptstrFilename string, lpdwHandle *uint32) DWORD { + lptstrFilenameStr := unicode16FromString(lptstrFilename) + ret1 := syscall3(getFileVersionInfoSize, 2, + uintptr(unsafe.Pointer(&lptstrFilenameStr[0])), + uintptr(unsafe.Pointer(lpdwHandle)), + 0) + return DWORD(ret1) +} + +func GetFileVersionInfo(lptstrFilename string, dwHandle DWORD, dwLen DWORD, lpData LPVOID) bool { + lptstrFilenameStr := unicode16FromString(lptstrFilename) + ret1 := syscall6(getFileVersionInfo, 4, + uintptr(unsafe.Pointer(&lptstrFilenameStr[0])), + uintptr(dwHandle), + uintptr(dwLen), + uintptr(unsafe.Pointer(lpData)), + 0, + 0) + return ret1 != 0 +} + +func VerFindFile(uFlags DWORD, szFileName LPWSTR, szWinDir LPWSTR, szAppDir LPWSTR, szCurDir LPWSTR, lpuCurDirLen *uint32, szDestDir LPWSTR, lpuDestDirLen *uint32) DWORD { + ret1 := syscall9(verFindFile, 8, + uintptr(uFlags), + uintptr(unsafe.Pointer(szFileName)), + uintptr(unsafe.Pointer(szWinDir)), + uintptr(unsafe.Pointer(szAppDir)), + uintptr(unsafe.Pointer(szCurDir)), + uintptr(unsafe.Pointer(lpuCurDirLen)), + uintptr(unsafe.Pointer(szDestDir)), + uintptr(unsafe.Pointer(lpuDestDirLen)), + 0) + return DWORD(ret1) +} + +func VerInstallFile(uFlags DWORD, szSrcFileName LPWSTR, szDestFileName LPWSTR, szSrcDir LPWSTR, szDestDir LPWSTR, szCurDir LPWSTR, szTmpFile LPWSTR, lpuTmpFileLen *uint32) DWORD { + ret1 := syscall9(verInstallFile, 8, + uintptr(uFlags), + uintptr(unsafe.Pointer(szSrcFileName)), + uintptr(unsafe.Pointer(szDestFileName)), + uintptr(unsafe.Pointer(szSrcDir)), + uintptr(unsafe.Pointer(szDestDir)), + uintptr(unsafe.Pointer(szCurDir)), + uintptr(unsafe.Pointer(szTmpFile)), + uintptr(unsafe.Pointer(lpuTmpFileLen)), + 0) + return DWORD(ret1) +} + +func VerQueryValue(pBlock /*const*/ LPVOID, lpSubBlock string, lplpBuffer LPVOID, puLen *uint32) bool { + lpSubBlockStr := unicode16FromString(lpSubBlock) + ret1 := syscall6(verQueryValue, 4, + uintptr(unsafe.Pointer(pBlock)), + uintptr(unsafe.Pointer(&lpSubBlockStr[0])), + uintptr(unsafe.Pointer(lplpBuffer)), + uintptr(unsafe.Pointer(puLen)), + 0, + 0) + return ret1 != 0 +} diff --git a/grdp/win/win.go b/grdp/win/win.go new file mode 100644 index 0000000..71b21da --- /dev/null +++ b/grdp/win/win.go @@ -0,0 +1,32 @@ +package win + +import ( + "unicode/utf16" + "unsafe" +) + +func unicode16FromString(s string) []uint16 { + r := make([]rune, 0) + for _, c := range s { + r = append(r, c) + } + b := utf16.Encode(r) + return append(b, uint16(0)) +} + +func stringFromUnicode16(s *uint16) string { + if s == nil { + return "" + } + buffer := []uint16{} + ptr := uintptr(unsafe.Pointer(s)) + for true { + ch := *(*uint16)(unsafe.Pointer(ptr)) + if ch == 0 { + break + } + buffer = append(buffer, ch) + ptr += unsafe.Sizeof(ch) + } + return string(utf16.Decode(buffer)) +} diff --git a/grdp/win/win_386.go b/grdp/win/win_386.go new file mode 100644 index 0000000..fc8dbdb --- /dev/null +++ b/grdp/win/win_386.go @@ -0,0 +1,13 @@ +package win + +const ptrsize = 4 +const is64 = false + +const pad4for64_0for32 = 0 +const pad0for64_4for32 = 4 +const pad4for64_3for32 = 3 +const pad11for64_7for32 = 7 +const pad3for64_2for32 = 2 +const pad3for64_1for32 = 1 +const pad6for64_3for32 = 3 +const pad6for64_0for32 = 0 diff --git a/grdp/win/win_amd64.go b/grdp/win/win_amd64.go new file mode 100644 index 0000000..baba280 --- /dev/null +++ b/grdp/win/win_amd64.go @@ -0,0 +1,13 @@ +package win + +const ptrsize = 8 +const is64 = true + +const pad4for64_0for32 = 4 +const pad0for64_4for32 = 0 +const pad4for64_3for32 = 4 +const pad11for64_7for32 = 11 +const pad3for64_2for32 = 3 +const pad3for64_1for32 = 3 +const pad6for64_3for32 = 6 +const pad6for64_0for32 = 6 diff --git a/grdp/win/win_nonwindows.go b/grdp/win/win_nonwindows.go new file mode 100644 index 0000000..d84ba1f --- /dev/null +++ b/grdp/win/win_nonwindows.go @@ -0,0 +1,12 @@ +// +build !windows + +package win + +import ( + "syscall" +) + +func syscall3(trap, nargs, a1, a2, a3 uintptr) uintptr { + ret, _, _ := syscall.Syscall(trap, a1, a2, a3) + return ret +} diff --git a/grdp/win/win_windows.go b/grdp/win/win_windows.go new file mode 100644 index 0000000..3308dfd --- /dev/null +++ b/grdp/win/win_windows.go @@ -0,0 +1,91 @@ +package win + +import ( + "fmt" + "math" + "syscall" +) + +func doLoadLibrary(name string) uintptr { + lib, _ := syscall.LoadLibrary(name) + return uintptr(lib) +} + +func doGetProcAddress(lib uintptr, name string) uintptr { + addr, _ := syscall.GetProcAddress(syscall.Handle(lib), name) + return uintptr(addr) +} + +func syscall3(trap, nargs, a1, a2, a3 uintptr) uintptr { + ret, _, _ := syscall.Syscall(trap, nargs, a1, a2, a3) + return ret +} + +func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) uintptr { + ret, _, _ := syscall.Syscall6(trap, nargs, a1, a2, a3, a4, a5, a6) + return ret +} + +func syscall9(trap, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) uintptr { + ret, _, _ := syscall.Syscall9(trap, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9) + return ret +} + +func syscall12(trap, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12 uintptr) uintptr { + ret, _, _ := syscall.Syscall12(trap, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) + return ret +} + +func syscall15(trap, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) uintptr { + ret, _, _ := syscall.Syscall15(trap, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) + return ret +} + +func syscallN(trap uintptr, args []uintptr) uintptr { + n := len(args) + num := int(math.Max(1.0, math.Ceil(float64(n)/3.0))) * 3 + for i := n; i < num; i++ { + args = append(args, 0) + } + if num == 3 { + ret, _, _ := syscall.Syscall(trap, uintptr(n), + args[0], args[1], args[2]) + return ret + } else if num == 6 { + ret, _, _ := syscall.Syscall6(trap, uintptr(n), + args[0], args[1], args[2], + args[3], args[4], args[5]) + return ret + } else if num == 9 { + ret, _, _ := syscall.Syscall9(trap, uintptr(n), + args[0], args[1], args[2], + args[3], args[4], args[5], + args[6], args[7], args[8]) + return ret + } else if num == 12 { + ret, _, _ := syscall.Syscall12(trap, uintptr(n), + args[0], args[1], args[2], + args[3], args[4], args[5], + args[6], args[7], args[8], + args[9], args[10], args[11]) + return ret + } else if num == 15 { + ret, _, _ := syscall.Syscall15(trap, uintptr(n), + args[0], args[1], args[2], + args[3], args[4], args[5], + args[6], args[7], args[8], + args[9], args[10], args[11], + args[12], args[13], args[14]) + return ret + } else { + panic(fmt.Errorf("Too many syscall arguments: %d", n)) + } +} + +func getUintptrFromBool(b bool) uintptr { + if b { + return 1 + } else { + return 0 + } +} diff --git a/grdp/win/winmm.go b/grdp/win/winmm.go new file mode 100644 index 0000000..aa48229 --- /dev/null +++ b/grdp/win/winmm.go @@ -0,0 +1,1644 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "syscall" + "unsafe" +) + +var ( + // Library + libwinmm uintptr + + // Functions + closeDriver uintptr + defDriverProc uintptr + drvGetModuleHandle uintptr + getDriverModuleHandle uintptr + openDriver uintptr + playSound uintptr + sendDriverMessage uintptr + auxGetDevCaps uintptr + auxGetNumDevs uintptr + auxGetVolume uintptr + auxOutMessage uintptr + auxSetVolume uintptr + joyGetDevCaps uintptr + joyGetNumDevs uintptr + joyGetPos uintptr + joyGetPosEx uintptr + joyGetThreshold uintptr + joyReleaseCapture uintptr + joySetCapture uintptr + joySetThreshold uintptr + mciGetCreatorTask uintptr + mciGetDeviceIDFromElementID uintptr + mciGetDeviceID uintptr + mciGetErrorString uintptr + mciGetYieldProc uintptr + mciSendCommand uintptr + mciSendString uintptr + mciSetYieldProc uintptr + midiConnect uintptr + midiDisconnect uintptr + midiInAddBuffer uintptr + midiInClose uintptr + midiInGetDevCaps uintptr + midiInGetErrorText uintptr + midiInGetID uintptr + midiInGetNumDevs uintptr + midiInMessage uintptr + midiInOpen uintptr + midiInPrepareHeader uintptr + midiInReset uintptr + midiInStart uintptr + midiInStop uintptr + midiInUnprepareHeader uintptr + midiOutCacheDrumPatches uintptr + midiOutCachePatches uintptr + midiOutClose uintptr + midiOutGetDevCaps uintptr + midiOutGetErrorText uintptr + midiOutGetID uintptr + midiOutGetNumDevs uintptr + midiOutGetVolume uintptr + midiOutLongMsg uintptr + midiOutMessage uintptr + midiOutOpen uintptr + midiOutPrepareHeader uintptr + midiOutReset uintptr + midiOutSetVolume uintptr + midiOutShortMsg uintptr + midiOutUnprepareHeader uintptr + midiStreamClose uintptr + midiStreamOpen uintptr + midiStreamOut uintptr + midiStreamPause uintptr + midiStreamPosition uintptr + midiStreamProperty uintptr + midiStreamRestart uintptr + midiStreamStop uintptr + mixerClose uintptr + mixerGetControlDetails uintptr + mixerGetDevCaps uintptr + mixerGetID uintptr + mixerGetLineControls uintptr + mixerGetLineInfo uintptr + mixerGetNumDevs uintptr + mixerMessage uintptr + mixerOpen uintptr + mixerSetControlDetails uintptr + mmioAdvance uintptr + mmioAscend uintptr + mmioClose uintptr + mmioCreateChunk uintptr + mmioDescend uintptr + mmioFlush uintptr + mmioGetInfo uintptr + mmioInstallIOProc uintptr + mmioOpen uintptr + mmioRead uintptr + mmioRename uintptr + mmioSeek uintptr + mmioSendMessage uintptr + mmioSetBuffer uintptr + mmioSetInfo uintptr + mmioStringToFOURCC uintptr + mmioWrite uintptr + sndPlaySound uintptr + timeBeginPeriod uintptr + timeEndPeriod uintptr + timeGetDevCaps uintptr + timeGetSystemTime uintptr + timeGetTime uintptr + timeKillEvent uintptr + timeSetEvent uintptr + waveInAddBuffer uintptr + waveInClose uintptr + waveInGetDevCaps uintptr + waveInGetErrorText uintptr + waveInGetID uintptr + waveInGetNumDevs uintptr + waveInGetPosition uintptr + waveInMessage uintptr + waveInOpen uintptr + waveInPrepareHeader uintptr + waveInReset uintptr + waveInStart uintptr + waveInStop uintptr + waveInUnprepareHeader uintptr + waveOutBreakLoop uintptr + waveOutClose uintptr + waveOutGetDevCaps uintptr + waveOutGetErrorText uintptr + waveOutGetID uintptr + waveOutGetNumDevs uintptr + waveOutGetPitch uintptr + waveOutGetPlaybackRate uintptr + waveOutGetPosition uintptr + waveOutGetVolume uintptr + waveOutMessage uintptr + waveOutOpen uintptr + waveOutPause uintptr + waveOutPrepareHeader uintptr + waveOutReset uintptr + waveOutRestart uintptr + waveOutSetPitch uintptr + waveOutSetPlaybackRate uintptr + waveOutSetVolume uintptr + waveOutUnprepareHeader uintptr + waveOutWrite uintptr + driverCallback uintptr + joyConfigChanged uintptr + mciDriverNotify uintptr + mciDriverYield uintptr + mciExecute uintptr + mciFreeCommandResource uintptr + mciGetDriverData uintptr + mciLoadCommandResource uintptr + mciSetDriverData uintptr + mmGetCurrentTask uintptr + mmTaskBlock uintptr + mmTaskCreate uintptr + mmTaskSignal uintptr + mmTaskYield uintptr + mmsystemGetVersion uintptr +) + +func init() { + // Library + libwinmm = doLoadLibrary("winmm.dll") + + // Functions + closeDriver = doGetProcAddress(libwinmm, "CloseDriver") + defDriverProc = doGetProcAddress(libwinmm, "DefDriverProc") + drvGetModuleHandle = doGetProcAddress(libwinmm, "DrvGetModuleHandle") + getDriverModuleHandle = doGetProcAddress(libwinmm, "GetDriverModuleHandle") + openDriver = doGetProcAddress(libwinmm, "OpenDriver") + playSound = doGetProcAddress(libwinmm, "PlaySoundW") + sendDriverMessage = doGetProcAddress(libwinmm, "SendDriverMessage") + auxGetDevCaps = doGetProcAddress(libwinmm, "auxGetDevCapsW") + auxGetNumDevs = doGetProcAddress(libwinmm, "auxGetNumDevs") + auxGetVolume = doGetProcAddress(libwinmm, "auxGetVolume") + auxOutMessage = doGetProcAddress(libwinmm, "auxOutMessage") + auxSetVolume = doGetProcAddress(libwinmm, "auxSetVolume") + joyGetDevCaps = doGetProcAddress(libwinmm, "joyGetDevCapsW") + joyGetNumDevs = doGetProcAddress(libwinmm, "joyGetNumDevs") + joyGetPos = doGetProcAddress(libwinmm, "joyGetPos") + joyGetPosEx = doGetProcAddress(libwinmm, "joyGetPosEx") + joyGetThreshold = doGetProcAddress(libwinmm, "joyGetThreshold") + joyReleaseCapture = doGetProcAddress(libwinmm, "joyReleaseCapture") + joySetCapture = doGetProcAddress(libwinmm, "joySetCapture") + joySetThreshold = doGetProcAddress(libwinmm, "joySetThreshold") + mciGetCreatorTask = doGetProcAddress(libwinmm, "mciGetCreatorTask") + mciGetDeviceIDFromElementID = doGetProcAddress(libwinmm, "mciGetDeviceIDFromElementIDW") + mciGetDeviceID = doGetProcAddress(libwinmm, "mciGetDeviceIDW") + mciGetErrorString = doGetProcAddress(libwinmm, "mciGetErrorStringW") + mciGetYieldProc = doGetProcAddress(libwinmm, "mciGetYieldProc") + mciSendCommand = doGetProcAddress(libwinmm, "mciSendCommandW") + mciSendString = doGetProcAddress(libwinmm, "mciSendStringW") + mciSetYieldProc = doGetProcAddress(libwinmm, "mciSetYieldProc") + midiConnect = doGetProcAddress(libwinmm, "midiConnect") + midiDisconnect = doGetProcAddress(libwinmm, "midiDisconnect") + midiInAddBuffer = doGetProcAddress(libwinmm, "midiInAddBuffer") + midiInClose = doGetProcAddress(libwinmm, "midiInClose") + midiInGetDevCaps = doGetProcAddress(libwinmm, "midiInGetDevCapsW") + midiInGetErrorText = doGetProcAddress(libwinmm, "midiInGetErrorTextW") + midiInGetID = doGetProcAddress(libwinmm, "midiInGetID") + midiInGetNumDevs = doGetProcAddress(libwinmm, "midiInGetNumDevs") + midiInMessage = doGetProcAddress(libwinmm, "midiInMessage") + midiInOpen = doGetProcAddress(libwinmm, "midiInOpen") + midiInPrepareHeader = doGetProcAddress(libwinmm, "midiInPrepareHeader") + midiInReset = doGetProcAddress(libwinmm, "midiInReset") + midiInStart = doGetProcAddress(libwinmm, "midiInStart") + midiInStop = doGetProcAddress(libwinmm, "midiInStop") + midiInUnprepareHeader = doGetProcAddress(libwinmm, "midiInUnprepareHeader") + midiOutCacheDrumPatches = doGetProcAddress(libwinmm, "midiOutCacheDrumPatches") + midiOutCachePatches = doGetProcAddress(libwinmm, "midiOutCachePatches") + midiOutClose = doGetProcAddress(libwinmm, "midiOutClose") + midiOutGetDevCaps = doGetProcAddress(libwinmm, "midiOutGetDevCapsW") + midiOutGetErrorText = doGetProcAddress(libwinmm, "midiOutGetErrorTextW") + midiOutGetID = doGetProcAddress(libwinmm, "midiOutGetID") + midiOutGetNumDevs = doGetProcAddress(libwinmm, "midiOutGetNumDevs") + midiOutGetVolume = doGetProcAddress(libwinmm, "midiOutGetVolume") + midiOutLongMsg = doGetProcAddress(libwinmm, "midiOutLongMsg") + midiOutMessage = doGetProcAddress(libwinmm, "midiOutMessage") + midiOutOpen = doGetProcAddress(libwinmm, "midiOutOpen") + midiOutPrepareHeader = doGetProcAddress(libwinmm, "midiOutPrepareHeader") + midiOutReset = doGetProcAddress(libwinmm, "midiOutReset") + midiOutSetVolume = doGetProcAddress(libwinmm, "midiOutSetVolume") + midiOutShortMsg = doGetProcAddress(libwinmm, "midiOutShortMsg") + midiOutUnprepareHeader = doGetProcAddress(libwinmm, "midiOutUnprepareHeader") + midiStreamClose = doGetProcAddress(libwinmm, "midiStreamClose") + midiStreamOpen = doGetProcAddress(libwinmm, "midiStreamOpen") + midiStreamOut = doGetProcAddress(libwinmm, "midiStreamOut") + midiStreamPause = doGetProcAddress(libwinmm, "midiStreamPause") + midiStreamPosition = doGetProcAddress(libwinmm, "midiStreamPosition") + midiStreamProperty = doGetProcAddress(libwinmm, "midiStreamProperty") + midiStreamRestart = doGetProcAddress(libwinmm, "midiStreamRestart") + midiStreamStop = doGetProcAddress(libwinmm, "midiStreamStop") + mixerClose = doGetProcAddress(libwinmm, "mixerClose") + mixerGetControlDetails = doGetProcAddress(libwinmm, "mixerGetControlDetailsW") + mixerGetDevCaps = doGetProcAddress(libwinmm, "mixerGetDevCapsW") + mixerGetID = doGetProcAddress(libwinmm, "mixerGetID") + mixerGetLineControls = doGetProcAddress(libwinmm, "mixerGetLineControlsW") + mixerGetLineInfo = doGetProcAddress(libwinmm, "mixerGetLineInfoW") + mixerGetNumDevs = doGetProcAddress(libwinmm, "mixerGetNumDevs") + mixerMessage = doGetProcAddress(libwinmm, "mixerMessage") + mixerOpen = doGetProcAddress(libwinmm, "mixerOpen") + mixerSetControlDetails = doGetProcAddress(libwinmm, "mixerSetControlDetails") + mmioAdvance = doGetProcAddress(libwinmm, "mmioAdvance") + mmioAscend = doGetProcAddress(libwinmm, "mmioAscend") + mmioClose = doGetProcAddress(libwinmm, "mmioClose") + mmioCreateChunk = doGetProcAddress(libwinmm, "mmioCreateChunk") + mmioDescend = doGetProcAddress(libwinmm, "mmioDescend") + mmioFlush = doGetProcAddress(libwinmm, "mmioFlush") + mmioGetInfo = doGetProcAddress(libwinmm, "mmioGetInfo") + mmioInstallIOProc = doGetProcAddress(libwinmm, "mmioInstallIOProcW") + mmioOpen = doGetProcAddress(libwinmm, "mmioOpenW") + mmioRead = doGetProcAddress(libwinmm, "mmioRead") + mmioRename = doGetProcAddress(libwinmm, "mmioRenameW") + mmioSeek = doGetProcAddress(libwinmm, "mmioSeek") + mmioSendMessage = doGetProcAddress(libwinmm, "mmioSendMessage") + mmioSetBuffer = doGetProcAddress(libwinmm, "mmioSetBuffer") + mmioSetInfo = doGetProcAddress(libwinmm, "mmioSetInfo") + mmioStringToFOURCC = doGetProcAddress(libwinmm, "mmioStringToFOURCCW") + mmioWrite = doGetProcAddress(libwinmm, "mmioWrite") + sndPlaySound = doGetProcAddress(libwinmm, "sndPlaySoundW") + timeBeginPeriod = doGetProcAddress(libwinmm, "timeBeginPeriod") + timeEndPeriod = doGetProcAddress(libwinmm, "timeEndPeriod") + timeGetDevCaps = doGetProcAddress(libwinmm, "timeGetDevCaps") + timeGetSystemTime = doGetProcAddress(libwinmm, "timeGetSystemTime") + timeGetTime = doGetProcAddress(libwinmm, "timeGetTime") + timeKillEvent = doGetProcAddress(libwinmm, "timeKillEvent") + timeSetEvent = doGetProcAddress(libwinmm, "timeSetEvent") + waveInAddBuffer = doGetProcAddress(libwinmm, "waveInAddBuffer") + waveInClose = doGetProcAddress(libwinmm, "waveInClose") + waveInGetDevCaps = doGetProcAddress(libwinmm, "waveInGetDevCapsW") + waveInGetErrorText = doGetProcAddress(libwinmm, "waveInGetErrorTextW") + waveInGetID = doGetProcAddress(libwinmm, "waveInGetID") + waveInGetNumDevs = doGetProcAddress(libwinmm, "waveInGetNumDevs") + waveInGetPosition = doGetProcAddress(libwinmm, "waveInGetPosition") + waveInMessage = doGetProcAddress(libwinmm, "waveInMessage") + waveInOpen = doGetProcAddress(libwinmm, "waveInOpen") + waveInPrepareHeader = doGetProcAddress(libwinmm, "waveInPrepareHeader") + waveInReset = doGetProcAddress(libwinmm, "waveInReset") + waveInStart = doGetProcAddress(libwinmm, "waveInStart") + waveInStop = doGetProcAddress(libwinmm, "waveInStop") + waveInUnprepareHeader = doGetProcAddress(libwinmm, "waveInUnprepareHeader") + waveOutBreakLoop = doGetProcAddress(libwinmm, "waveOutBreakLoop") + waveOutClose = doGetProcAddress(libwinmm, "waveOutClose") + waveOutGetDevCaps = doGetProcAddress(libwinmm, "waveOutGetDevCapsW") + waveOutGetErrorText = doGetProcAddress(libwinmm, "waveOutGetErrorTextW") + waveOutGetID = doGetProcAddress(libwinmm, "waveOutGetID") + waveOutGetNumDevs = doGetProcAddress(libwinmm, "waveOutGetNumDevs") + waveOutGetPitch = doGetProcAddress(libwinmm, "waveOutGetPitch") + waveOutGetPlaybackRate = doGetProcAddress(libwinmm, "waveOutGetPlaybackRate") + waveOutGetPosition = doGetProcAddress(libwinmm, "waveOutGetPosition") + waveOutGetVolume = doGetProcAddress(libwinmm, "waveOutGetVolume") + waveOutMessage = doGetProcAddress(libwinmm, "waveOutMessage") + waveOutOpen = doGetProcAddress(libwinmm, "waveOutOpen") + waveOutPause = doGetProcAddress(libwinmm, "waveOutPause") + waveOutPrepareHeader = doGetProcAddress(libwinmm, "waveOutPrepareHeader") + waveOutReset = doGetProcAddress(libwinmm, "waveOutReset") + waveOutRestart = doGetProcAddress(libwinmm, "waveOutRestart") + waveOutSetPitch = doGetProcAddress(libwinmm, "waveOutSetPitch") + waveOutSetPlaybackRate = doGetProcAddress(libwinmm, "waveOutSetPlaybackRate") + waveOutSetVolume = doGetProcAddress(libwinmm, "waveOutSetVolume") + waveOutUnprepareHeader = doGetProcAddress(libwinmm, "waveOutUnprepareHeader") + waveOutWrite = doGetProcAddress(libwinmm, "waveOutWrite") + driverCallback = doGetProcAddress(libwinmm, "DriverCallback") + joyConfigChanged = doGetProcAddress(libwinmm, "joyConfigChanged") + mciDriverNotify = doGetProcAddress(libwinmm, "mciDriverNotify") + mciDriverYield = doGetProcAddress(libwinmm, "mciDriverYield") + mciExecute = doGetProcAddress(libwinmm, "mciExecute") + mciFreeCommandResource = doGetProcAddress(libwinmm, "mciFreeCommandResource") + mciGetDriverData = doGetProcAddress(libwinmm, "mciGetDriverData") + mciLoadCommandResource = doGetProcAddress(libwinmm, "mciLoadCommandResource") + mciSetDriverData = doGetProcAddress(libwinmm, "mciSetDriverData") + mmGetCurrentTask = doGetProcAddress(libwinmm, "mmGetCurrentTask") + mmTaskBlock = doGetProcAddress(libwinmm, "mmTaskBlock") + mmTaskCreate = doGetProcAddress(libwinmm, "mmTaskCreate") + mmTaskSignal = doGetProcAddress(libwinmm, "mmTaskSignal") + mmTaskYield = doGetProcAddress(libwinmm, "mmTaskYield") + mmsystemGetVersion = doGetProcAddress(libwinmm, "mmsystemGetVersion") +} + +func CloseDriver(hDriver HDRVR, lParam1 LPARAM, lParam2 LPARAM) LRESULT { + ret1 := syscall3(closeDriver, 3, + uintptr(hDriver), + uintptr(lParam1), + uintptr(lParam2)) + return LRESULT(ret1) +} + +func DefDriverProc(dwDriverIdentifier *uint32, hdrvr HDRVR, uMsg UINT, lParam1 LPARAM, lParam2 LPARAM) LRESULT { + ret1 := syscall6(defDriverProc, 5, + uintptr(unsafe.Pointer(dwDriverIdentifier)), + uintptr(hdrvr), + uintptr(uMsg), + uintptr(lParam1), + uintptr(lParam2), + 0) + return LRESULT(ret1) +} + +func DrvGetModuleHandle(hDriver HDRVR) HMODULE { + ret1 := syscall3(drvGetModuleHandle, 1, + uintptr(hDriver), + 0, + 0) + return HMODULE(ret1) +} + +func GetDriverModuleHandle(hDriver HDRVR) HMODULE { + ret1 := syscall3(getDriverModuleHandle, 1, + uintptr(hDriver), + 0, + 0) + return HMODULE(ret1) +} + +func OpenDriver(szDriverName string, szSectionName string, lParam2 LPARAM) HDRVR { + szDriverNameStr := unicode16FromString(szDriverName) + szSectionNameStr := unicode16FromString(szSectionName) + ret1 := syscall3(openDriver, 3, + uintptr(unsafe.Pointer(&szDriverNameStr[0])), + uintptr(unsafe.Pointer(&szSectionNameStr[0])), + uintptr(lParam2)) + return HDRVR(ret1) +} + +func PlaySound(pszSound string, hmod HMODULE, fdwSound DWORD) bool { + pszSoundStr := unicode16FromString(pszSound) + ret1 := syscall3(playSound, 3, + uintptr(unsafe.Pointer(&pszSoundStr[0])), + uintptr(hmod), + uintptr(fdwSound)) + return ret1 != 0 +} + +func SendDriverMessage(hDriver HDRVR, message UINT, lParam1 LPARAM, lParam2 LPARAM) LRESULT { + ret1 := syscall6(sendDriverMessage, 4, + uintptr(hDriver), + uintptr(message), + uintptr(lParam1), + uintptr(lParam2), + 0, + 0) + return LRESULT(ret1) +} + +func AuxGetDevCaps(uDeviceID *uint32, pac *AUXCAPS, cbac UINT) MMRESULT { + ret1 := syscall3(auxGetDevCaps, 3, + uintptr(unsafe.Pointer(uDeviceID)), + uintptr(unsafe.Pointer(pac)), + uintptr(cbac)) + return MMRESULT(ret1) +} + +func AuxGetNumDevs() UINT { + ret1 := syscall3(auxGetNumDevs, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func AuxGetVolume(uDeviceID UINT, pdwVolume *uint32) MMRESULT { + ret1 := syscall3(auxGetVolume, 2, + uintptr(uDeviceID), + uintptr(unsafe.Pointer(pdwVolume)), + 0) + return MMRESULT(ret1) +} + +func AuxOutMessage(uDeviceID UINT, uMsg UINT, dw1 *uint32, dw2 *uint32) MMRESULT { + ret1 := syscall6(auxOutMessage, 4, + uintptr(uDeviceID), + uintptr(uMsg), + uintptr(unsafe.Pointer(dw1)), + uintptr(unsafe.Pointer(dw2)), + 0, + 0) + return MMRESULT(ret1) +} + +func AuxSetVolume(uDeviceID UINT, dwVolume DWORD) MMRESULT { + ret1 := syscall3(auxSetVolume, 2, + uintptr(uDeviceID), + uintptr(dwVolume), + 0) + return MMRESULT(ret1) +} + +func JoyGetDevCaps(uJoyID *uint32, pjc LPJOYCAPS, cbjc UINT) MMRESULT { + ret1 := syscall3(joyGetDevCaps, 3, + uintptr(unsafe.Pointer(uJoyID)), + uintptr(unsafe.Pointer(pjc)), + uintptr(cbjc)) + return MMRESULT(ret1) +} + +func JoyGetNumDevs() UINT { + ret1 := syscall3(joyGetNumDevs, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func JoyGetPos(uJoyID UINT, pji LPJOYINFO) MMRESULT { + ret1 := syscall3(joyGetPos, 2, + uintptr(uJoyID), + uintptr(unsafe.Pointer(pji)), + 0) + return MMRESULT(ret1) +} + +func JoyGetPosEx(uJoyID UINT, pji *JOYINFOEX) MMRESULT { + ret1 := syscall3(joyGetPosEx, 2, + uintptr(uJoyID), + uintptr(unsafe.Pointer(pji)), + 0) + return MMRESULT(ret1) +} + +func JoyGetThreshold(uJoyID UINT, puThreshold *UINT) MMRESULT { + ret1 := syscall3(joyGetThreshold, 2, + uintptr(uJoyID), + uintptr(unsafe.Pointer(puThreshold)), + 0) + return MMRESULT(ret1) +} + +func JoyReleaseCapture(uJoyID UINT) MMRESULT { + ret1 := syscall3(joyReleaseCapture, 1, + uintptr(uJoyID), + 0, + 0) + return MMRESULT(ret1) +} + +func JoySetCapture(hwnd HWND, uJoyID UINT, uPeriod UINT, fChanged bool) MMRESULT { + ret1 := syscall6(joySetCapture, 4, + uintptr(hwnd), + uintptr(uJoyID), + uintptr(uPeriod), + getUintptrFromBool(fChanged), + 0, + 0) + return MMRESULT(ret1) +} + +func JoySetThreshold(uJoyID UINT, uThreshold UINT) MMRESULT { + ret1 := syscall3(joySetThreshold, 2, + uintptr(uJoyID), + uintptr(uThreshold), + 0) + return MMRESULT(ret1) +} + +func MciGetCreatorTask(mciId MCIDEVICEID) HTASK { + ret1 := syscall3(mciGetCreatorTask, 1, + uintptr(mciId), + 0, + 0) + return HTASK(ret1) +} + +func MciGetDeviceIDFromElementID(dwElementID DWORD, lpstrType string) MCIDEVICEID { + lpstrTypeStr := unicode16FromString(lpstrType) + ret1 := syscall3(mciGetDeviceIDFromElementID, 2, + uintptr(dwElementID), + uintptr(unsafe.Pointer(&lpstrTypeStr[0])), + 0) + return MCIDEVICEID(ret1) +} + +func MciGetDeviceID(pszDevice string) MCIDEVICEID { + pszDeviceStr := unicode16FromString(pszDevice) + ret1 := syscall3(mciGetDeviceID, 1, + uintptr(unsafe.Pointer(&pszDeviceStr[0])), + 0, + 0) + return MCIDEVICEID(ret1) +} + +func MciGetErrorString(mcierr MCIERROR, pszText LPWSTR, cchText UINT) bool { + ret1 := syscall3(mciGetErrorString, 3, + uintptr(mcierr), + uintptr(unsafe.Pointer(pszText)), + uintptr(cchText)) + return ret1 != 0 +} + +func MciGetYieldProc(mciId MCIDEVICEID, pdwYieldData *uint32) YIELDPROC { + ret1 := syscall3(mciGetYieldProc, 2, + uintptr(mciId), + uintptr(unsafe.Pointer(pdwYieldData)), + 0) + return func(mciId MCIDEVICEID, dwYieldData DWORD) UINT { + ret2 := syscall3(ret1, 2, + uintptr(mciId), + uintptr(dwYieldData), + 0) + return UINT(ret2) + } +} + +func MciSendCommand(mciId MCIDEVICEID, uMsg UINT, dwParam1 *uint32, dwParam2 *uint32) MCIERROR { + ret1 := syscall6(mciSendCommand, 4, + uintptr(mciId), + uintptr(uMsg), + uintptr(unsafe.Pointer(dwParam1)), + uintptr(unsafe.Pointer(dwParam2)), + 0, + 0) + return MCIERROR(ret1) +} + +func MciSendString(lpstrCommand string, lpstrReturnString LPWSTR, uReturnLength UINT, hwndCallback HWND) MCIERROR { + lpstrCommandStr := unicode16FromString(lpstrCommand) + ret1 := syscall6(mciSendString, 4, + uintptr(unsafe.Pointer(&lpstrCommandStr[0])), + uintptr(unsafe.Pointer(lpstrReturnString)), + uintptr(uReturnLength), + uintptr(hwndCallback), + 0, + 0) + return MCIERROR(ret1) +} + +func MciSetYieldProc(mciId MCIDEVICEID, fpYieldProc YIELDPROC, dwYieldData DWORD) bool { + fpYieldProcCallback := syscall.NewCallback(func(mciIdRawArg MCIDEVICEID, dwYieldDataRawArg DWORD) uintptr { + ret := fpYieldProc(mciIdRawArg, dwYieldDataRawArg) + return uintptr(ret) + }) + ret1 := syscall3(mciSetYieldProc, 3, + uintptr(mciId), + fpYieldProcCallback, + uintptr(dwYieldData)) + return ret1 != 0 +} + +func MidiConnect(hmi HMIDI, hmo HMIDIOUT, pReserved LPVOID) MMRESULT { + ret1 := syscall3(midiConnect, 3, + uintptr(hmi), + uintptr(hmo), + uintptr(unsafe.Pointer(pReserved))) + return MMRESULT(ret1) +} + +func MidiDisconnect(hmi HMIDI, hmo HMIDIOUT, pReserved LPVOID) MMRESULT { + ret1 := syscall3(midiDisconnect, 3, + uintptr(hmi), + uintptr(hmo), + uintptr(unsafe.Pointer(pReserved))) + return MMRESULT(ret1) +} + +func MidiInAddBuffer(hmi HMIDIIN, pmh *MIDIHDR, cbmh UINT) MMRESULT { + ret1 := syscall3(midiInAddBuffer, 3, + uintptr(hmi), + uintptr(unsafe.Pointer(pmh)), + uintptr(cbmh)) + return MMRESULT(ret1) +} + +func MidiInClose(hmi HMIDIIN) MMRESULT { + ret1 := syscall3(midiInClose, 1, + uintptr(hmi), + 0, + 0) + return MMRESULT(ret1) +} + +func MidiInGetDevCaps(uDeviceID *uint32, pmic *MIDIINCAPS, cbmic UINT) MMRESULT { + ret1 := syscall3(midiInGetDevCaps, 3, + uintptr(unsafe.Pointer(uDeviceID)), + uintptr(unsafe.Pointer(pmic)), + uintptr(cbmic)) + return MMRESULT(ret1) +} + +func MidiInGetErrorText(mmrError MMRESULT, pszText LPWSTR, cchText UINT) MMRESULT { + ret1 := syscall3(midiInGetErrorText, 3, + uintptr(mmrError), + uintptr(unsafe.Pointer(pszText)), + uintptr(cchText)) + return MMRESULT(ret1) +} + +func MidiInGetID(hmi HMIDIIN, puDeviceID *UINT) MMRESULT { + ret1 := syscall3(midiInGetID, 2, + uintptr(hmi), + uintptr(unsafe.Pointer(puDeviceID)), + 0) + return MMRESULT(ret1) +} + +func MidiInGetNumDevs() UINT { + ret1 := syscall3(midiInGetNumDevs, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func MidiInMessage(hmi HMIDIIN, uMsg UINT, dw1 *uint32, dw2 *uint32) MMRESULT { + ret1 := syscall6(midiInMessage, 4, + uintptr(hmi), + uintptr(uMsg), + uintptr(unsafe.Pointer(dw1)), + uintptr(unsafe.Pointer(dw2)), + 0, + 0) + return MMRESULT(ret1) +} + +func MidiInOpen(phmi *HMIDIIN, uDeviceID UINT, dwCallback *uint32, dwInstance *uint32, fdwOpen DWORD) MMRESULT { + ret1 := syscall6(midiInOpen, 5, + uintptr(unsafe.Pointer(phmi)), + uintptr(uDeviceID), + uintptr(unsafe.Pointer(dwCallback)), + uintptr(unsafe.Pointer(dwInstance)), + uintptr(fdwOpen), + 0) + return MMRESULT(ret1) +} + +func MidiInPrepareHeader(hmi HMIDIIN, pmh *MIDIHDR, cbmh UINT) MMRESULT { + ret1 := syscall3(midiInPrepareHeader, 3, + uintptr(hmi), + uintptr(unsafe.Pointer(pmh)), + uintptr(cbmh)) + return MMRESULT(ret1) +} + +func MidiInReset(hmi HMIDIIN) MMRESULT { + ret1 := syscall3(midiInReset, 1, + uintptr(hmi), + 0, + 0) + return MMRESULT(ret1) +} + +func MidiInStart(hmi HMIDIIN) MMRESULT { + ret1 := syscall3(midiInStart, 1, + uintptr(hmi), + 0, + 0) + return MMRESULT(ret1) +} + +func MidiInStop(hmi HMIDIIN) MMRESULT { + ret1 := syscall3(midiInStop, 1, + uintptr(hmi), + 0, + 0) + return MMRESULT(ret1) +} + +func MidiInUnprepareHeader(hmi HMIDIIN, pmh *MIDIHDR, cbmh UINT) MMRESULT { + ret1 := syscall3(midiInUnprepareHeader, 3, + uintptr(hmi), + uintptr(unsafe.Pointer(pmh)), + uintptr(cbmh)) + return MMRESULT(ret1) +} + +func MidiOutCacheDrumPatches(hmo HMIDIOUT, uPatch UINT, pwkya *uint16, fuCache UINT) MMRESULT { + ret1 := syscall6(midiOutCacheDrumPatches, 4, + uintptr(hmo), + uintptr(uPatch), + uintptr(unsafe.Pointer(pwkya)), + uintptr(fuCache), + 0, + 0) + return MMRESULT(ret1) +} + +func MidiOutCachePatches(hmo HMIDIOUT, uBank UINT, pwpa *uint16, fuCache UINT) MMRESULT { + ret1 := syscall6(midiOutCachePatches, 4, + uintptr(hmo), + uintptr(uBank), + uintptr(unsafe.Pointer(pwpa)), + uintptr(fuCache), + 0, + 0) + return MMRESULT(ret1) +} + +func MidiOutClose(hmo HMIDIOUT) MMRESULT { + ret1 := syscall3(midiOutClose, 1, + uintptr(hmo), + 0, + 0) + return MMRESULT(ret1) +} + +func MidiOutGetDevCaps(uDeviceID *uint32, pmoc LPMIDIOUTCAPS, cbmoc UINT) MMRESULT { + ret1 := syscall3(midiOutGetDevCaps, 3, + uintptr(unsafe.Pointer(uDeviceID)), + uintptr(unsafe.Pointer(pmoc)), + uintptr(cbmoc)) + return MMRESULT(ret1) +} + +func MidiOutGetErrorText(mmrError MMRESULT, pszText LPWSTR, cchText UINT) MMRESULT { + ret1 := syscall3(midiOutGetErrorText, 3, + uintptr(mmrError), + uintptr(unsafe.Pointer(pszText)), + uintptr(cchText)) + return MMRESULT(ret1) +} + +func MidiOutGetID(hmo HMIDIOUT, puDeviceID *UINT) MMRESULT { + ret1 := syscall3(midiOutGetID, 2, + uintptr(hmo), + uintptr(unsafe.Pointer(puDeviceID)), + 0) + return MMRESULT(ret1) +} + +func MidiOutGetNumDevs() UINT { + ret1 := syscall3(midiOutGetNumDevs, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func MidiOutGetVolume(hmo HMIDIOUT, pdwVolume *uint32) MMRESULT { + ret1 := syscall3(midiOutGetVolume, 2, + uintptr(hmo), + uintptr(unsafe.Pointer(pdwVolume)), + 0) + return MMRESULT(ret1) +} + +func MidiOutLongMsg(hmo HMIDIOUT, pmh *MIDIHDR, cbmh UINT) MMRESULT { + ret1 := syscall3(midiOutLongMsg, 3, + uintptr(hmo), + uintptr(unsafe.Pointer(pmh)), + uintptr(cbmh)) + return MMRESULT(ret1) +} + +func MidiOutMessage(hmo HMIDIOUT, uMsg UINT, dw1 *uint32, dw2 *uint32) MMRESULT { + ret1 := syscall6(midiOutMessage, 4, + uintptr(hmo), + uintptr(uMsg), + uintptr(unsafe.Pointer(dw1)), + uintptr(unsafe.Pointer(dw2)), + 0, + 0) + return MMRESULT(ret1) +} + +func MidiOutOpen(phmo *HMIDIOUT, uDeviceID UINT, dwCallback *uint32, dwInstance *uint32, fdwOpen DWORD) MMRESULT { + ret1 := syscall6(midiOutOpen, 5, + uintptr(unsafe.Pointer(phmo)), + uintptr(uDeviceID), + uintptr(unsafe.Pointer(dwCallback)), + uintptr(unsafe.Pointer(dwInstance)), + uintptr(fdwOpen), + 0) + return MMRESULT(ret1) +} + +func MidiOutPrepareHeader(hmo HMIDIOUT, pmh *MIDIHDR, cbmh UINT) MMRESULT { + ret1 := syscall3(midiOutPrepareHeader, 3, + uintptr(hmo), + uintptr(unsafe.Pointer(pmh)), + uintptr(cbmh)) + return MMRESULT(ret1) +} + +func MidiOutReset(hmo HMIDIOUT) MMRESULT { + ret1 := syscall3(midiOutReset, 1, + uintptr(hmo), + 0, + 0) + return MMRESULT(ret1) +} + +func MidiOutSetVolume(hmo HMIDIOUT, dwVolume DWORD) MMRESULT { + ret1 := syscall3(midiOutSetVolume, 2, + uintptr(hmo), + uintptr(dwVolume), + 0) + return MMRESULT(ret1) +} + +func MidiOutShortMsg(hmo HMIDIOUT, dwMsg DWORD) MMRESULT { + ret1 := syscall3(midiOutShortMsg, 2, + uintptr(hmo), + uintptr(dwMsg), + 0) + return MMRESULT(ret1) +} + +func MidiOutUnprepareHeader(hmo HMIDIOUT, pmh *MIDIHDR, cbmh UINT) MMRESULT { + ret1 := syscall3(midiOutUnprepareHeader, 3, + uintptr(hmo), + uintptr(unsafe.Pointer(pmh)), + uintptr(cbmh)) + return MMRESULT(ret1) +} + +func MidiStreamClose(hms HMIDISTRM) MMRESULT { + ret1 := syscall3(midiStreamClose, 1, + uintptr(hms), + 0, + 0) + return MMRESULT(ret1) +} + +func MidiStreamOpen(phms *HMIDISTRM, puDeviceID *UINT, cMidi DWORD, dwCallback *uint32, dwInstance *uint32, fdwOpen DWORD) MMRESULT { + ret1 := syscall6(midiStreamOpen, 6, + uintptr(unsafe.Pointer(phms)), + uintptr(unsafe.Pointer(puDeviceID)), + uintptr(cMidi), + uintptr(unsafe.Pointer(dwCallback)), + uintptr(unsafe.Pointer(dwInstance)), + uintptr(fdwOpen)) + return MMRESULT(ret1) +} + +func MidiStreamOut(hms HMIDISTRM, pmh *MIDIHDR, cbmh UINT) MMRESULT { + ret1 := syscall3(midiStreamOut, 3, + uintptr(hms), + uintptr(unsafe.Pointer(pmh)), + uintptr(cbmh)) + return MMRESULT(ret1) +} + +func MidiStreamPause(hms HMIDISTRM) MMRESULT { + ret1 := syscall3(midiStreamPause, 1, + uintptr(hms), + 0, + 0) + return MMRESULT(ret1) +} + +func MidiStreamPosition(hms HMIDISTRM, lpmmt *MMTIME, cbmmt UINT) MMRESULT { + ret1 := syscall3(midiStreamPosition, 3, + uintptr(hms), + uintptr(unsafe.Pointer(lpmmt)), + uintptr(cbmmt)) + return MMRESULT(ret1) +} + +func MidiStreamProperty(hms HMIDISTRM, lppropdata *byte, dwProperty DWORD) MMRESULT { + ret1 := syscall3(midiStreamProperty, 3, + uintptr(hms), + uintptr(unsafe.Pointer(lppropdata)), + uintptr(dwProperty)) + return MMRESULT(ret1) +} + +func MidiStreamRestart(hms HMIDISTRM) MMRESULT { + ret1 := syscall3(midiStreamRestart, 1, + uintptr(hms), + 0, + 0) + return MMRESULT(ret1) +} + +func MidiStreamStop(hms HMIDISTRM) MMRESULT { + ret1 := syscall3(midiStreamStop, 1, + uintptr(hms), + 0, + 0) + return MMRESULT(ret1) +} + +func MixerClose(hmx HMIXER) MMRESULT { + ret1 := syscall3(mixerClose, 1, + uintptr(hmx), + 0, + 0) + return MMRESULT(ret1) +} + +func MixerGetControlDetails(hmxobj HMIXEROBJ, pmxcd *MIXERCONTROLDETAILS, fdwDetails DWORD) MMRESULT { + ret1 := syscall3(mixerGetControlDetails, 3, + uintptr(hmxobj), + uintptr(unsafe.Pointer(pmxcd)), + uintptr(fdwDetails)) + return MMRESULT(ret1) +} + +func MixerGetDevCaps(uMxId *uint32, pmxcaps LPMIXERCAPS, cbmxcaps UINT) MMRESULT { + ret1 := syscall3(mixerGetDevCaps, 3, + uintptr(unsafe.Pointer(uMxId)), + uintptr(unsafe.Pointer(pmxcaps)), + uintptr(cbmxcaps)) + return MMRESULT(ret1) +} + +func MixerGetID(hmxobj HMIXEROBJ, puMxId *UINT, fdwId DWORD) MMRESULT { + ret1 := syscall3(mixerGetID, 3, + uintptr(hmxobj), + uintptr(unsafe.Pointer(puMxId)), + uintptr(fdwId)) + return MMRESULT(ret1) +} + +func MixerGetLineControls(hmxobj HMIXEROBJ, pmxlc LPMIXERLINECONTROLS, fdwControls DWORD) MMRESULT { + ret1 := syscall3(mixerGetLineControls, 3, + uintptr(hmxobj), + uintptr(unsafe.Pointer(pmxlc)), + uintptr(fdwControls)) + return MMRESULT(ret1) +} + +func MixerGetLineInfo(hmxobj HMIXEROBJ, pmxl LPMIXERLINE, fdwInfo DWORD) MMRESULT { + ret1 := syscall3(mixerGetLineInfo, 3, + uintptr(hmxobj), + uintptr(unsafe.Pointer(pmxl)), + uintptr(fdwInfo)) + return MMRESULT(ret1) +} + +func MixerGetNumDevs() UINT { + ret1 := syscall3(mixerGetNumDevs, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func MixerMessage(hmx HMIXER, uMsg UINT, dwParam1 *uint32, dwParam2 *uint32) DWORD { + ret1 := syscall6(mixerMessage, 4, + uintptr(hmx), + uintptr(uMsg), + uintptr(unsafe.Pointer(dwParam1)), + uintptr(unsafe.Pointer(dwParam2)), + 0, + 0) + return DWORD(ret1) +} + +func MixerOpen(phmx *HMIXER, uMxId UINT, dwCallback *uint32, dwInstance *uint32, fdwOpen DWORD) MMRESULT { + ret1 := syscall6(mixerOpen, 5, + uintptr(unsafe.Pointer(phmx)), + uintptr(uMxId), + uintptr(unsafe.Pointer(dwCallback)), + uintptr(unsafe.Pointer(dwInstance)), + uintptr(fdwOpen), + 0) + return MMRESULT(ret1) +} + +func MixerSetControlDetails(hmxobj HMIXEROBJ, pmxcd *MIXERCONTROLDETAILS, fdwDetails DWORD) MMRESULT { + ret1 := syscall3(mixerSetControlDetails, 3, + uintptr(hmxobj), + uintptr(unsafe.Pointer(pmxcd)), + uintptr(fdwDetails)) + return MMRESULT(ret1) +} + +func MmioAdvance(hmmio HMMIO, pmmioinfo LPMMIOINFO, fuAdvance UINT) MMRESULT { + ret1 := syscall3(mmioAdvance, 3, + uintptr(hmmio), + uintptr(unsafe.Pointer(pmmioinfo)), + uintptr(fuAdvance)) + return MMRESULT(ret1) +} + +func MmioAscend(hmmio HMMIO, pmmcki LPMMCKINFO, fuAscend UINT) MMRESULT { + ret1 := syscall3(mmioAscend, 3, + uintptr(hmmio), + uintptr(unsafe.Pointer(pmmcki)), + uintptr(fuAscend)) + return MMRESULT(ret1) +} + +func MmioClose(hmmio HMMIO, fuClose UINT) MMRESULT { + ret1 := syscall3(mmioClose, 2, + uintptr(hmmio), + uintptr(fuClose), + 0) + return MMRESULT(ret1) +} + +func MmioCreateChunk(hmmio HMMIO, pmmcki LPMMCKINFO, fuCreate UINT) MMRESULT { + ret1 := syscall3(mmioCreateChunk, 3, + uintptr(hmmio), + uintptr(unsafe.Pointer(pmmcki)), + uintptr(fuCreate)) + return MMRESULT(ret1) +} + +func MmioDescend(hmmio HMMIO, pmmcki LPMMCKINFO, pmmckiParent /*const*/ *MMCKINFO, fuDescend UINT) MMRESULT { + ret1 := syscall6(mmioDescend, 4, + uintptr(hmmio), + uintptr(unsafe.Pointer(pmmcki)), + uintptr(unsafe.Pointer(pmmckiParent)), + uintptr(fuDescend), + 0, + 0) + return MMRESULT(ret1) +} + +func MmioFlush(hmmio HMMIO, fuFlush UINT) MMRESULT { + ret1 := syscall3(mmioFlush, 2, + uintptr(hmmio), + uintptr(fuFlush), + 0) + return MMRESULT(ret1) +} + +func MmioGetInfo(hmmio HMMIO, pmmioinfo LPMMIOINFO, fuInfo UINT) MMRESULT { + ret1 := syscall3(mmioGetInfo, 3, + uintptr(hmmio), + uintptr(unsafe.Pointer(pmmioinfo)), + uintptr(fuInfo)) + return MMRESULT(ret1) +} + +func MmioInstallIOProc(fccIOProc FOURCC, pIOProc *MMIOPROC, dwFlags DWORD) *MMIOPROC { + ret1 := syscall3(mmioInstallIOProc, 3, + uintptr(fccIOProc), + uintptr(unsafe.Pointer(pIOProc)), + uintptr(dwFlags)) + return (*MMIOPROC)(unsafe.Pointer(ret1)) +} + +func MmioOpen(pszFileName LPWSTR, pmmioinfo LPMMIOINFO, fdwOpen DWORD) HMMIO { + ret1 := syscall3(mmioOpen, 3, + uintptr(unsafe.Pointer(pszFileName)), + uintptr(unsafe.Pointer(pmmioinfo)), + uintptr(fdwOpen)) + return HMMIO(ret1) +} + +func MmioRead(hmmio HMMIO, pch HPSTR, cch LONG) LONG { + ret1 := syscall3(mmioRead, 3, + uintptr(hmmio), + uintptr(unsafe.Pointer(pch)), + uintptr(cch)) + return LONG(ret1) +} + +func MmioRename(pszFileName string, pszNewFileName string, pmmioinfo /*const*/ *MMIOINFO, fdwRename DWORD) MMRESULT { + pszFileNameStr := unicode16FromString(pszFileName) + pszNewFileNameStr := unicode16FromString(pszNewFileName) + ret1 := syscall6(mmioRename, 4, + uintptr(unsafe.Pointer(&pszFileNameStr[0])), + uintptr(unsafe.Pointer(&pszNewFileNameStr[0])), + uintptr(unsafe.Pointer(pmmioinfo)), + uintptr(fdwRename), + 0, + 0) + return MMRESULT(ret1) +} + +func MmioSeek(hmmio HMMIO, lOffset LONG, iOrigin int32) LONG { + ret1 := syscall3(mmioSeek, 3, + uintptr(hmmio), + uintptr(lOffset), + uintptr(iOrigin)) + return LONG(ret1) +} + +func MmioSendMessage(hmmio HMMIO, uMsg UINT, lParam1 LPARAM, lParam2 LPARAM) LRESULT { + ret1 := syscall6(mmioSendMessage, 4, + uintptr(hmmio), + uintptr(uMsg), + uintptr(lParam1), + uintptr(lParam2), + 0, + 0) + return LRESULT(ret1) +} + +func MmioSetBuffer(hmmio HMMIO, pchBuffer LPSTR, cchBuffer LONG, fuBuffer UINT) MMRESULT { + ret1 := syscall6(mmioSetBuffer, 4, + uintptr(hmmio), + uintptr(unsafe.Pointer(pchBuffer)), + uintptr(cchBuffer), + uintptr(fuBuffer), + 0, + 0) + return MMRESULT(ret1) +} + +func MmioSetInfo(hmmio HMMIO, pmmioinfo /*const*/ *MMIOINFO, fuInfo UINT) MMRESULT { + ret1 := syscall3(mmioSetInfo, 3, + uintptr(hmmio), + uintptr(unsafe.Pointer(pmmioinfo)), + uintptr(fuInfo)) + return MMRESULT(ret1) +} + +func MmioStringToFOURCC(sz string, uFlags UINT) FOURCC { + szStr := unicode16FromString(sz) + ret1 := syscall3(mmioStringToFOURCC, 2, + uintptr(unsafe.Pointer(&szStr[0])), + uintptr(uFlags), + 0) + return FOURCC(ret1) +} + +func MmioWrite(hmmio HMMIO, pch /*const*/ HPSTR, cch LONG) LONG { + ret1 := syscall3(mmioWrite, 3, + uintptr(hmmio), + uintptr(unsafe.Pointer(pch)), + uintptr(cch)) + return LONG(ret1) +} + +func SndPlaySound(pszSound string, fuSound UINT) bool { + pszSoundStr := unicode16FromString(pszSound) + ret1 := syscall3(sndPlaySound, 2, + uintptr(unsafe.Pointer(&pszSoundStr[0])), + uintptr(fuSound), + 0) + return ret1 != 0 +} + +func TimeBeginPeriod(uPeriod UINT) MMRESULT { + ret1 := syscall3(timeBeginPeriod, 1, + uintptr(uPeriod), + 0, + 0) + return MMRESULT(ret1) +} + +func TimeEndPeriod(uPeriod UINT) MMRESULT { + ret1 := syscall3(timeEndPeriod, 1, + uintptr(uPeriod), + 0, + 0) + return MMRESULT(ret1) +} + +func TimeGetDevCaps(ptc LPTIMECAPS, cbtc UINT) MMRESULT { + ret1 := syscall3(timeGetDevCaps, 2, + uintptr(unsafe.Pointer(ptc)), + uintptr(cbtc), + 0) + return MMRESULT(ret1) +} + +func TimeGetSystemTime(pmmt *MMTIME, cbmmt UINT) MMRESULT { + ret1 := syscall3(timeGetSystemTime, 2, + uintptr(unsafe.Pointer(pmmt)), + uintptr(cbmmt), + 0) + return MMRESULT(ret1) +} + +func TimeGetTime() DWORD { + ret1 := syscall3(timeGetTime, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func TimeKillEvent(uTimerID UINT) MMRESULT { + ret1 := syscall3(timeKillEvent, 1, + uintptr(uTimerID), + 0, + 0) + return MMRESULT(ret1) +} + +func TimeSetEvent(uDelay UINT, uResolution UINT, fptc TIMECALLBACK, dwUser *uint32, fuEvent UINT) MMRESULT { + fptcCallback := syscall.NewCallback(fptc) + ret1 := syscall6(timeSetEvent, 5, + uintptr(uDelay), + uintptr(uResolution), + fptcCallback, + uintptr(unsafe.Pointer(dwUser)), + uintptr(fuEvent), + 0) + return MMRESULT(ret1) +} + +func WaveInAddBuffer(hwi HWAVEIN, pwh LPWAVEHDR, cbwh UINT) MMRESULT { + ret1 := syscall3(waveInAddBuffer, 3, + uintptr(hwi), + uintptr(unsafe.Pointer(pwh)), + uintptr(cbwh)) + return MMRESULT(ret1) +} + +func WaveInClose(hwi HWAVEIN) MMRESULT { + ret1 := syscall3(waveInClose, 1, + uintptr(hwi), + 0, + 0) + return MMRESULT(ret1) +} + +func WaveInGetDevCaps(uDeviceID *uint32, pwic LPWAVEINCAPS, cbwic UINT) MMRESULT { + ret1 := syscall3(waveInGetDevCaps, 3, + uintptr(unsafe.Pointer(uDeviceID)), + uintptr(unsafe.Pointer(pwic)), + uintptr(cbwic)) + return MMRESULT(ret1) +} + +func WaveInGetErrorText(mmrError MMRESULT, pszText LPWSTR, cchText UINT) MMRESULT { + ret1 := syscall3(waveInGetErrorText, 3, + uintptr(mmrError), + uintptr(unsafe.Pointer(pszText)), + uintptr(cchText)) + return MMRESULT(ret1) +} + +func WaveInGetID(hwi HWAVEIN, puDeviceID *UINT) MMRESULT { + ret1 := syscall3(waveInGetID, 2, + uintptr(hwi), + uintptr(unsafe.Pointer(puDeviceID)), + 0) + return MMRESULT(ret1) +} + +func WaveInGetNumDevs() UINT { + ret1 := syscall3(waveInGetNumDevs, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func WaveInGetPosition(hwi HWAVEIN, pmmt *MMTIME, cbmmt UINT) MMRESULT { + ret1 := syscall3(waveInGetPosition, 3, + uintptr(hwi), + uintptr(unsafe.Pointer(pmmt)), + uintptr(cbmmt)) + return MMRESULT(ret1) +} + +func WaveInMessage(hwi HWAVEIN, uMsg UINT, dw1 *uint32, dw2 *uint32) MMRESULT { + ret1 := syscall6(waveInMessage, 4, + uintptr(hwi), + uintptr(uMsg), + uintptr(unsafe.Pointer(dw1)), + uintptr(unsafe.Pointer(dw2)), + 0, + 0) + return MMRESULT(ret1) +} + +func WaveInOpen(phwi *HWAVEIN, uDeviceID UINT, pwfx /*const*/ *WAVEFORMATEX, dwCallback *uint32, dwInstance *uint32, fdwOpen DWORD) MMRESULT { + ret1 := syscall6(waveInOpen, 6, + uintptr(unsafe.Pointer(phwi)), + uintptr(uDeviceID), + uintptr(unsafe.Pointer(pwfx)), + uintptr(unsafe.Pointer(dwCallback)), + uintptr(unsafe.Pointer(dwInstance)), + uintptr(fdwOpen)) + return MMRESULT(ret1) +} + +func WaveInPrepareHeader(hwi HWAVEIN, pwh LPWAVEHDR, cbwh UINT) MMRESULT { + ret1 := syscall3(waveInPrepareHeader, 3, + uintptr(hwi), + uintptr(unsafe.Pointer(pwh)), + uintptr(cbwh)) + return MMRESULT(ret1) +} + +func WaveInReset(hwi HWAVEIN) MMRESULT { + ret1 := syscall3(waveInReset, 1, + uintptr(hwi), + 0, + 0) + return MMRESULT(ret1) +} + +func WaveInStart(hwi HWAVEIN) MMRESULT { + ret1 := syscall3(waveInStart, 1, + uintptr(hwi), + 0, + 0) + return MMRESULT(ret1) +} + +func WaveInStop(hwi HWAVEIN) MMRESULT { + ret1 := syscall3(waveInStop, 1, + uintptr(hwi), + 0, + 0) + return MMRESULT(ret1) +} + +func WaveInUnprepareHeader(hwi HWAVEIN, pwh LPWAVEHDR, cbwh UINT) MMRESULT { + ret1 := syscall3(waveInUnprepareHeader, 3, + uintptr(hwi), + uintptr(unsafe.Pointer(pwh)), + uintptr(cbwh)) + return MMRESULT(ret1) +} + +func WaveOutBreakLoop(hwo HWAVEOUT) MMRESULT { + ret1 := syscall3(waveOutBreakLoop, 1, + uintptr(hwo), + 0, + 0) + return MMRESULT(ret1) +} + +func WaveOutClose(hwo HWAVEOUT) MMRESULT { + ret1 := syscall3(waveOutClose, 1, + uintptr(hwo), + 0, + 0) + return MMRESULT(ret1) +} + +func WaveOutGetDevCaps(uDeviceID *uint32, pwoc LPWAVEOUTCAPS, cbwoc UINT) MMRESULT { + ret1 := syscall3(waveOutGetDevCaps, 3, + uintptr(unsafe.Pointer(uDeviceID)), + uintptr(unsafe.Pointer(pwoc)), + uintptr(cbwoc)) + return MMRESULT(ret1) +} + +func WaveOutGetErrorText(mmrError MMRESULT, pszText LPWSTR, cchText UINT) MMRESULT { + ret1 := syscall3(waveOutGetErrorText, 3, + uintptr(mmrError), + uintptr(unsafe.Pointer(pszText)), + uintptr(cchText)) + return MMRESULT(ret1) +} + +func WaveOutGetID(hwo HWAVEOUT, puDeviceID *UINT) MMRESULT { + ret1 := syscall3(waveOutGetID, 2, + uintptr(hwo), + uintptr(unsafe.Pointer(puDeviceID)), + 0) + return MMRESULT(ret1) +} + +func WaveOutGetNumDevs() UINT { + ret1 := syscall3(waveOutGetNumDevs, 0, + 0, + 0, + 0) + return UINT(ret1) +} + +func WaveOutGetPitch(hwo HWAVEOUT, pdwPitch *uint32) MMRESULT { + ret1 := syscall3(waveOutGetPitch, 2, + uintptr(hwo), + uintptr(unsafe.Pointer(pdwPitch)), + 0) + return MMRESULT(ret1) +} + +func WaveOutGetPlaybackRate(hwo HWAVEOUT, pdwRate *uint32) MMRESULT { + ret1 := syscall3(waveOutGetPlaybackRate, 2, + uintptr(hwo), + uintptr(unsafe.Pointer(pdwRate)), + 0) + return MMRESULT(ret1) +} + +func WaveOutGetPosition(hwo HWAVEOUT, pmmt *MMTIME, cbmmt UINT) MMRESULT { + ret1 := syscall3(waveOutGetPosition, 3, + uintptr(hwo), + uintptr(unsafe.Pointer(pmmt)), + uintptr(cbmmt)) + return MMRESULT(ret1) +} + +func WaveOutGetVolume(hwo HWAVEOUT, pdwVolume *uint32) MMRESULT { + ret1 := syscall3(waveOutGetVolume, 2, + uintptr(hwo), + uintptr(unsafe.Pointer(pdwVolume)), + 0) + return MMRESULT(ret1) +} + +func WaveOutMessage(hwo HWAVEOUT, uMsg UINT, dw1 *uint32, dw2 *uint32) MMRESULT { + ret1 := syscall6(waveOutMessage, 4, + uintptr(hwo), + uintptr(uMsg), + uintptr(unsafe.Pointer(dw1)), + uintptr(unsafe.Pointer(dw2)), + 0, + 0) + return MMRESULT(ret1) +} + +func WaveOutOpen(phwo *HWAVEOUT, uDeviceID UINT, pwfx /*const*/ *WAVEFORMATEX, dwCallback *uint32, dwInstance *uint32, fdwOpen DWORD) MMRESULT { + ret1 := syscall6(waveOutOpen, 6, + uintptr(unsafe.Pointer(phwo)), + uintptr(uDeviceID), + uintptr(unsafe.Pointer(pwfx)), + uintptr(unsafe.Pointer(dwCallback)), + uintptr(unsafe.Pointer(dwInstance)), + uintptr(fdwOpen)) + return MMRESULT(ret1) +} + +func WaveOutPause(hwo HWAVEOUT) MMRESULT { + ret1 := syscall3(waveOutPause, 1, + uintptr(hwo), + 0, + 0) + return MMRESULT(ret1) +} + +func WaveOutPrepareHeader(hwo HWAVEOUT, pwh LPWAVEHDR, cbwh UINT) MMRESULT { + ret1 := syscall3(waveOutPrepareHeader, 3, + uintptr(hwo), + uintptr(unsafe.Pointer(pwh)), + uintptr(cbwh)) + return MMRESULT(ret1) +} + +func WaveOutReset(hwo HWAVEOUT) MMRESULT { + ret1 := syscall3(waveOutReset, 1, + uintptr(hwo), + 0, + 0) + return MMRESULT(ret1) +} + +func WaveOutRestart(hwo HWAVEOUT) MMRESULT { + ret1 := syscall3(waveOutRestart, 1, + uintptr(hwo), + 0, + 0) + return MMRESULT(ret1) +} + +func WaveOutSetPitch(hwo HWAVEOUT, dwPitch DWORD) MMRESULT { + ret1 := syscall3(waveOutSetPitch, 2, + uintptr(hwo), + uintptr(dwPitch), + 0) + return MMRESULT(ret1) +} + +func WaveOutSetPlaybackRate(hwo HWAVEOUT, dwRate DWORD) MMRESULT { + ret1 := syscall3(waveOutSetPlaybackRate, 2, + uintptr(hwo), + uintptr(dwRate), + 0) + return MMRESULT(ret1) +} + +func WaveOutSetVolume(hwo HWAVEOUT, dwVolume DWORD) MMRESULT { + ret1 := syscall3(waveOutSetVolume, 2, + uintptr(hwo), + uintptr(dwVolume), + 0) + return MMRESULT(ret1) +} + +func WaveOutUnprepareHeader(hwo HWAVEOUT, pwh LPWAVEHDR, cbwh UINT) MMRESULT { + ret1 := syscall3(waveOutUnprepareHeader, 3, + uintptr(hwo), + uintptr(unsafe.Pointer(pwh)), + uintptr(cbwh)) + return MMRESULT(ret1) +} + +func WaveOutWrite(hwo HWAVEOUT, pwh LPWAVEHDR, cbwh UINT) MMRESULT { + ret1 := syscall3(waveOutWrite, 3, + uintptr(hwo), + uintptr(unsafe.Pointer(pwh)), + uintptr(cbwh)) + return MMRESULT(ret1) +} + +func DriverCallback(dwCallBack *uint32, uFlags DWORD, hDev HDRVR, wMsg DWORD, dwUser *uint32, dwParam1 *uint32, dwParam2 *uint32) bool { + ret1 := syscall9(driverCallback, 7, + uintptr(unsafe.Pointer(dwCallBack)), + uintptr(uFlags), + uintptr(hDev), + uintptr(wMsg), + uintptr(unsafe.Pointer(dwUser)), + uintptr(unsafe.Pointer(dwParam1)), + uintptr(unsafe.Pointer(dwParam2)), + 0, + 0) + return ret1 != 0 +} + +func JoyConfigChanged(flags DWORD) MMRESULT { + ret1 := syscall3(joyConfigChanged, 1, + uintptr(flags), + 0, + 0) + return MMRESULT(ret1) +} + +func MciDriverNotify(hWndCallBack HWND, wDevID MCIDEVICEID, wStatus UINT) bool { + ret1 := syscall3(mciDriverNotify, 3, + uintptr(hWndCallBack), + uintptr(wDevID), + uintptr(wStatus)) + return ret1 != 0 +} + +func MciDriverYield(uDeviceID MCIDEVICEID) UINT { + ret1 := syscall3(mciDriverYield, 1, + uintptr(uDeviceID), + 0, + 0) + return UINT(ret1) +} + +func MciExecute(lpstrCommand /*const*/ LPCSTR) bool { + ret1 := syscall3(mciExecute, 1, + uintptr(unsafe.Pointer(lpstrCommand)), + 0, + 0) + return ret1 != 0 +} + +func MciFreeCommandResource(uTable UINT) bool { + ret1 := syscall3(mciFreeCommandResource, 1, + uintptr(uTable), + 0, + 0) + return ret1 != 0 +} + +func MciGetDriverData(uDeviceID MCIDEVICEID) *uint32 { + ret1 := syscall3(mciGetDriverData, 1, + uintptr(uDeviceID), + 0, + 0) + return (*uint32)(unsafe.Pointer(ret1)) +} + +func MciLoadCommandResource(hInst HINSTANCE, resNameW string, aType UINT) UINT { + resNameWStr := unicode16FromString(resNameW) + ret1 := syscall3(mciLoadCommandResource, 3, + uintptr(hInst), + uintptr(unsafe.Pointer(&resNameWStr[0])), + uintptr(aType)) + return UINT(ret1) +} + +func MciSetDriverData(uDeviceID MCIDEVICEID, data *uint32) bool { + ret1 := syscall3(mciSetDriverData, 2, + uintptr(uDeviceID), + uintptr(unsafe.Pointer(data)), + 0) + return ret1 != 0 +} + +func MmGetCurrentTask() DWORD { + ret1 := syscall3(mmGetCurrentTask, 0, + 0, + 0, + 0) + return DWORD(ret1) +} + +func MmTaskBlock(tid DWORD) { + syscall3(mmTaskBlock, 1, + uintptr(tid), + 0, + 0) +} + +func MmTaskCreate(cb TASKCALLBACK, ph *HANDLE, client *uint32) UINT { + cbCallback := syscall.NewCallback(cb) + ret1 := syscall3(mmTaskCreate, 3, + cbCallback, + uintptr(unsafe.Pointer(ph)), + uintptr(unsafe.Pointer(client))) + return UINT(ret1) +} + +func MmTaskSignal(tid DWORD) bool { + ret1 := syscall3(mmTaskSignal, 1, + uintptr(tid), + 0, + 0) + return ret1 != 0 +} + +func MmTaskYield() { + syscall3(mmTaskYield, 0, + 0, + 0, + 0) +} + +func MmsystemGetVersion() UINT { + ret1 := syscall3(mmsystemGetVersion, 0, + 0, + 0, + 0) + return UINT(ret1) +} diff --git a/grdp/win/ws2_32.go b/grdp/win/ws2_32.go new file mode 100644 index 0000000..4efb830 --- /dev/null +++ b/grdp/win/ws2_32.go @@ -0,0 +1,904 @@ +// This file was automatically generated by https://github.com/kbinani/win/blob/generator/internal/cmd/gen/gen.go +// go run internal/cmd/gen/gen.go + +// +build windows + +package win + +import ( + "syscall" + "unsafe" +) + +var ( + // Library + libws2_32 uintptr + + // Functions + freeAddrInfoExW uintptr + freeAddrInfoW uintptr + getAddrInfoEx uintptr + getAddrInfoW uintptr + getNameInfoW uintptr + inetNtopW uintptr + inetPtonW uintptr + wPUCompleteOverlappedRequest uintptr + wSAAccept uintptr + wSAAddressToString uintptr + wSAAsyncGetHostByAddr uintptr + wSAAsyncGetHostByName uintptr + wSAAsyncGetProtoByName uintptr + wSAAsyncGetProtoByNumber uintptr + wSAAsyncGetServByName uintptr + wSAAsyncGetServByPort uintptr + wSAAsyncSelect uintptr + wSACancelAsyncRequest uintptr + wSACancelBlockingCall uintptr + wSACleanup uintptr + wSACloseEvent uintptr + wSAConnect uintptr + wSACreateEvent uintptr + wSADuplicateSocket uintptr + wSAEnumNameSpaceProviders uintptr + wSAEnumNetworkEvents uintptr + wSAEnumProtocols uintptr + wSAEventSelect uintptr + wSAGetLastError uintptr + wSAGetOverlappedResult uintptr + wSAGetQOSByName uintptr + wSAGetServiceClassInfo uintptr + wSAGetServiceClassNameByClassId uintptr + wSAHtonl uintptr + wSAHtons uintptr + wSAInstallServiceClass uintptr + wSAIoctl uintptr + wSAIsBlocking uintptr + wSAJoinLeaf uintptr + wSALookupServiceBegin uintptr + wSALookupServiceEnd uintptr + wSALookupServiceNext uintptr + wSANSPIoctl uintptr + wSANtohl uintptr + wSANtohs uintptr + wSAPoll uintptr + wSAProviderConfigChange uintptr + wSARecv uintptr + wSARecvDisconnect uintptr + wSARecvFrom uintptr + wSARemoveServiceClass uintptr + wSASend uintptr + wSASendDisconnect uintptr + wSASendMsg uintptr + wSASendTo uintptr + wSASetBlockingHook uintptr + wSASetLastError uintptr + wSASetService uintptr + wSASocket uintptr + wSAStartup uintptr + wSAStringToAddress uintptr + wSAUnhookBlockingHook uintptr + wSApSetPostRoutine uintptr + wSCDeinstallProvider uintptr + wSCEnableNSProvider uintptr + wSCEnumProtocols uintptr + wSCGetProviderPath uintptr + wSCInstallNameSpace uintptr + wSCInstallProvider uintptr + wSCUnInstallNameSpace uintptr + wSCWriteProviderOrder uintptr + gethostname uintptr +) + +func init() { + // Library + libws2_32 = doLoadLibrary("ws2_32.dll") + + // Functions + freeAddrInfoExW = doGetProcAddress(libws2_32, "FreeAddrInfoExW") + freeAddrInfoW = doGetProcAddress(libws2_32, "FreeAddrInfoW") + getAddrInfoEx = doGetProcAddress(libws2_32, "GetAddrInfoExW") + getAddrInfoW = doGetProcAddress(libws2_32, "GetAddrInfoW") + getNameInfoW = doGetProcAddress(libws2_32, "GetNameInfoW") + inetNtopW = doGetProcAddress(libws2_32, "InetNtopW") + inetPtonW = doGetProcAddress(libws2_32, "InetPtonW") + wPUCompleteOverlappedRequest = doGetProcAddress(libws2_32, "WPUCompleteOverlappedRequest") + wSAAccept = doGetProcAddress(libws2_32, "WSAAccept") + wSAAddressToString = doGetProcAddress(libws2_32, "WSAAddressToStringW") + wSAAsyncGetHostByAddr = doGetProcAddress(libws2_32, "WSAAsyncGetHostByAddr") + wSAAsyncGetHostByName = doGetProcAddress(libws2_32, "WSAAsyncGetHostByName") + wSAAsyncGetProtoByName = doGetProcAddress(libws2_32, "WSAAsyncGetProtoByName") + wSAAsyncGetProtoByNumber = doGetProcAddress(libws2_32, "WSAAsyncGetProtoByNumber") + wSAAsyncGetServByName = doGetProcAddress(libws2_32, "WSAAsyncGetServByName") + wSAAsyncGetServByPort = doGetProcAddress(libws2_32, "WSAAsyncGetServByPort") + wSAAsyncSelect = doGetProcAddress(libws2_32, "WSAAsyncSelect") + wSACancelAsyncRequest = doGetProcAddress(libws2_32, "WSACancelAsyncRequest") + wSACancelBlockingCall = doGetProcAddress(libws2_32, "WSACancelBlockingCall") + wSACleanup = doGetProcAddress(libws2_32, "WSACleanup") + wSACloseEvent = doGetProcAddress(libws2_32, "WSACloseEvent") + wSAConnect = doGetProcAddress(libws2_32, "WSAConnect") + wSACreateEvent = doGetProcAddress(libws2_32, "WSACreateEvent") + wSADuplicateSocket = doGetProcAddress(libws2_32, "WSADuplicateSocketW") + wSAEnumNameSpaceProviders = doGetProcAddress(libws2_32, "WSAEnumNameSpaceProvidersW") + wSAEnumNetworkEvents = doGetProcAddress(libws2_32, "WSAEnumNetworkEvents") + wSAEnumProtocols = doGetProcAddress(libws2_32, "WSAEnumProtocolsW") + wSAEventSelect = doGetProcAddress(libws2_32, "WSAEventSelect") + wSAGetLastError = doGetProcAddress(libws2_32, "WSAGetLastError") + wSAGetOverlappedResult = doGetProcAddress(libws2_32, "WSAGetOverlappedResult") + wSAGetQOSByName = doGetProcAddress(libws2_32, "WSAGetQOSByName") + wSAGetServiceClassInfo = doGetProcAddress(libws2_32, "WSAGetServiceClassInfoW") + wSAGetServiceClassNameByClassId = doGetProcAddress(libws2_32, "WSAGetServiceClassNameByClassIdW") + wSAHtonl = doGetProcAddress(libws2_32, "WSAHtonl") + wSAHtons = doGetProcAddress(libws2_32, "WSAHtons") + wSAInstallServiceClass = doGetProcAddress(libws2_32, "WSAInstallServiceClassW") + wSAIoctl = doGetProcAddress(libws2_32, "WSAIoctl") + wSAIsBlocking = doGetProcAddress(libws2_32, "WSAIsBlocking") + wSAJoinLeaf = doGetProcAddress(libws2_32, "WSAJoinLeaf") + wSALookupServiceBegin = doGetProcAddress(libws2_32, "WSALookupServiceBeginW") + wSALookupServiceEnd = doGetProcAddress(libws2_32, "WSALookupServiceEnd") + wSALookupServiceNext = doGetProcAddress(libws2_32, "WSALookupServiceNextW") + wSANSPIoctl = doGetProcAddress(libws2_32, "WSANSPIoctl") + wSANtohl = doGetProcAddress(libws2_32, "WSANtohl") + wSANtohs = doGetProcAddress(libws2_32, "WSANtohs") + wSAPoll = doGetProcAddress(libws2_32, "WSAPoll") + wSAProviderConfigChange = doGetProcAddress(libws2_32, "WSAProviderConfigChange") + wSARecv = doGetProcAddress(libws2_32, "WSARecv") + wSARecvDisconnect = doGetProcAddress(libws2_32, "WSARecvDisconnect") + wSARecvFrom = doGetProcAddress(libws2_32, "WSARecvFrom") + wSARemoveServiceClass = doGetProcAddress(libws2_32, "WSARemoveServiceClass") + wSASend = doGetProcAddress(libws2_32, "WSASend") + wSASendDisconnect = doGetProcAddress(libws2_32, "WSASendDisconnect") + wSASendMsg = doGetProcAddress(libws2_32, "WSASendMsg") + wSASendTo = doGetProcAddress(libws2_32, "WSASendTo") + wSASetBlockingHook = doGetProcAddress(libws2_32, "WSASetBlockingHook") + wSASetLastError = doGetProcAddress(libws2_32, "WSASetLastError") + wSASetService = doGetProcAddress(libws2_32, "WSASetServiceW") + wSASocket = doGetProcAddress(libws2_32, "WSASocketW") + wSAStartup = doGetProcAddress(libws2_32, "WSAStartup") + wSAStringToAddress = doGetProcAddress(libws2_32, "WSAStringToAddressW") + wSAUnhookBlockingHook = doGetProcAddress(libws2_32, "WSAUnhookBlockingHook") + wSApSetPostRoutine = doGetProcAddress(libws2_32, "WSApSetPostRoutine") + wSCDeinstallProvider = doGetProcAddress(libws2_32, "WSCDeinstallProvider") + wSCEnableNSProvider = doGetProcAddress(libws2_32, "WSCEnableNSProvider") + wSCEnumProtocols = doGetProcAddress(libws2_32, "WSCEnumProtocols") + wSCGetProviderPath = doGetProcAddress(libws2_32, "WSCGetProviderPath") + wSCInstallNameSpace = doGetProcAddress(libws2_32, "WSCInstallNameSpace") + wSCInstallProvider = doGetProcAddress(libws2_32, "WSCInstallProvider") + wSCUnInstallNameSpace = doGetProcAddress(libws2_32, "WSCUnInstallNameSpace") + wSCWriteProviderOrder = doGetProcAddress(libws2_32, "WSCWriteProviderOrder") + gethostname = doGetProcAddress(libws2_32, "gethostname") +} + +func FreeAddrInfoExW(ai *ADDRINFOEX) { + syscall3(freeAddrInfoExW, 1, + uintptr(unsafe.Pointer(ai)), + 0, + 0) +} + +func FreeAddrInfoW(ai PADDRINFO) { + syscall3(freeAddrInfoW, 1, + uintptr(unsafe.Pointer(ai)), + 0, + 0) +} + +func GetAddrInfoEx(name /*const*/ *WCHAR, servname /*const*/ *WCHAR, namespace DWORD, namespace_id *GUID, hints /*const*/ *ADDRINFOEX, result **ADDRINFOEX, timeout *Timeval, overlapped *OVERLAPPED, completion_routine LPLOOKUPSERVICE_COMPLETION_ROUTINE, handle *HANDLE) int32 { + completion_routineCallback := syscall.NewCallback(completion_routine) + ret1 := syscall12(getAddrInfoEx, 10, + uintptr(unsafe.Pointer(name)), + uintptr(unsafe.Pointer(servname)), + uintptr(namespace), + uintptr(unsafe.Pointer(namespace_id)), + uintptr(unsafe.Pointer(hints)), + uintptr(unsafe.Pointer(result)), + uintptr(unsafe.Pointer(timeout)), + uintptr(unsafe.Pointer(overlapped)), + completion_routineCallback, + uintptr(unsafe.Pointer(handle)), + 0, + 0) + return int32(ret1) +} + +func GetAddrInfoW(nodename string, servname string, hints /*const*/ *ADDRINFO, res *PADDRINFO) int32 { + nodenameStr := unicode16FromString(nodename) + servnameStr := unicode16FromString(servname) + ret1 := syscall6(getAddrInfoW, 4, + uintptr(unsafe.Pointer(&nodenameStr[0])), + uintptr(unsafe.Pointer(&servnameStr[0])), + uintptr(unsafe.Pointer(hints)), + uintptr(unsafe.Pointer(res)), + 0, + 0) + return int32(ret1) +} + +func GetNameInfoW(sa /*const*/ *SOCKADDR, salen Socklen_t, host PWCHAR, hostlen DWORD, serv PWCHAR, servlen DWORD, flags INT) int32 { + ret1 := syscall9(getNameInfoW, 7, + uintptr(unsafe.Pointer(sa)), + uintptr(salen), + uintptr(unsafe.Pointer(host)), + uintptr(hostlen), + uintptr(unsafe.Pointer(serv)), + uintptr(servlen), + uintptr(flags), + 0, + 0) + return int32(ret1) +} + +func InetNtopW(family INT, addr uintptr, buffer PWSTR, aLen SIZE_T) string { + ret1 := syscall6(inetNtopW, 4, + uintptr(family), + addr, + uintptr(unsafe.Pointer(buffer)), + uintptr(aLen), + 0, + 0) + return stringFromUnicode16((*uint16)(unsafe.Pointer(ret1))) +} + +func InetPtonW(family INT, addr string, buffer uintptr) INT { + addrStr := unicode16FromString(addr) + ret1 := syscall3(inetPtonW, 3, + uintptr(family), + uintptr(unsafe.Pointer(&addrStr[0])), + buffer) + return INT(ret1) +} + +func WPUCompleteOverlappedRequest(s SOCKET, overlapped LPWSAOVERLAPPED, error DWORD, transferred DWORD, errcode *int32) WSAEVENT { + ret1 := syscall6(wPUCompleteOverlappedRequest, 5, + uintptr(s), + uintptr(unsafe.Pointer(overlapped)), + uintptr(error), + uintptr(transferred), + uintptr(unsafe.Pointer(errcode)), + 0) + return WSAEVENT(ret1) +} + +func WSAAccept(s SOCKET, addr *Sockaddr, addrlen *int32, lpfnCondition LPCONDITIONPROC, dwCallbackData *uint32) SOCKET { + lpfnConditionCallback := syscall.NewCallback(func(lpCallerIdRawArg LPWSABUF, lpCallerDataRawArg LPWSABUF, lpSQOSRawArg LPQOS, lpGQOSRawArg LPQOS, lpCalleeIdRawArg LPWSABUF, lpCalleeDataRawArg LPWSABUF, gRawArg *GROUP, dwCallbackDataRawArg DWORD_PTR) uintptr { + ret := lpfnCondition(lpCallerIdRawArg, lpCallerDataRawArg, lpSQOSRawArg, lpGQOSRawArg, lpCalleeIdRawArg, lpCalleeDataRawArg, gRawArg, dwCallbackDataRawArg) + return uintptr(ret) + }) + ret1 := syscall6(wSAAccept, 5, + uintptr(s), + uintptr(unsafe.Pointer(addr)), + uintptr(unsafe.Pointer(addrlen)), + lpfnConditionCallback, + uintptr(unsafe.Pointer(dwCallbackData)), + 0) + return SOCKET(ret1) +} + +func WSAAddressToString(sockaddr *SOCKADDR, aLen DWORD, info LPWSAPROTOCOL_INFO, string LPWSTR, lenstr *uint32) INT { + ret1 := syscall6(wSAAddressToString, 5, + uintptr(unsafe.Pointer(sockaddr)), + uintptr(aLen), + uintptr(unsafe.Pointer(info)), + uintptr(unsafe.Pointer(string)), + uintptr(unsafe.Pointer(lenstr)), + 0) + return INT(ret1) +} + +func WSAAsyncGetHostByAddr(hWnd HWND, uMsg UINT, addr /*const*/ LPCSTR, aLen INT, aType INT, sbuf LPSTR, buflen INT) HANDLE { + ret1 := syscall9(wSAAsyncGetHostByAddr, 7, + uintptr(hWnd), + uintptr(uMsg), + uintptr(unsafe.Pointer(addr)), + uintptr(aLen), + uintptr(aType), + uintptr(unsafe.Pointer(sbuf)), + uintptr(buflen), + 0, + 0) + return HANDLE(ret1) +} + +func WSAAsyncGetHostByName(hWnd HWND, uMsg UINT, name /*const*/ LPCSTR, sbuf LPSTR, buflen INT) HANDLE { + ret1 := syscall6(wSAAsyncGetHostByName, 5, + uintptr(hWnd), + uintptr(uMsg), + uintptr(unsafe.Pointer(name)), + uintptr(unsafe.Pointer(sbuf)), + uintptr(buflen), + 0) + return HANDLE(ret1) +} + +func WSAAsyncGetProtoByName(hWnd HWND, uMsg UINT, name /*const*/ LPCSTR, sbuf LPSTR, buflen INT) HANDLE { + ret1 := syscall6(wSAAsyncGetProtoByName, 5, + uintptr(hWnd), + uintptr(uMsg), + uintptr(unsafe.Pointer(name)), + uintptr(unsafe.Pointer(sbuf)), + uintptr(buflen), + 0) + return HANDLE(ret1) +} + +func WSAAsyncGetProtoByNumber(hWnd HWND, uMsg UINT, number INT, sbuf LPSTR, buflen INT) HANDLE { + ret1 := syscall6(wSAAsyncGetProtoByNumber, 5, + uintptr(hWnd), + uintptr(uMsg), + uintptr(number), + uintptr(unsafe.Pointer(sbuf)), + uintptr(buflen), + 0) + return HANDLE(ret1) +} + +func WSAAsyncGetServByName(hWnd HWND, uMsg UINT, name /*const*/ LPCSTR, proto /*const*/ LPCSTR, sbuf LPSTR, buflen INT) HANDLE { + ret1 := syscall6(wSAAsyncGetServByName, 6, + uintptr(hWnd), + uintptr(uMsg), + uintptr(unsafe.Pointer(name)), + uintptr(unsafe.Pointer(proto)), + uintptr(unsafe.Pointer(sbuf)), + uintptr(buflen)) + return HANDLE(ret1) +} + +func WSAAsyncGetServByPort(hWnd HWND, uMsg UINT, port INT, proto /*const*/ LPCSTR, sbuf LPSTR, buflen INT) HANDLE { + ret1 := syscall6(wSAAsyncGetServByPort, 6, + uintptr(hWnd), + uintptr(uMsg), + uintptr(port), + uintptr(unsafe.Pointer(proto)), + uintptr(unsafe.Pointer(sbuf)), + uintptr(buflen)) + return HANDLE(ret1) +} + +func WSAAsyncSelect(s SOCKET, hWnd HWND, uMsg UINT, lEvent LONG) INT { + ret1 := syscall6(wSAAsyncSelect, 4, + uintptr(s), + uintptr(hWnd), + uintptr(uMsg), + uintptr(lEvent), + 0, + 0) + return INT(ret1) +} + +func WSACancelAsyncRequest(hAsyncTaskHandle HANDLE) INT { + ret1 := syscall3(wSACancelAsyncRequest, 1, + uintptr(hAsyncTaskHandle), + 0, + 0) + return INT(ret1) +} + +func WSACancelBlockingCall() INT { + ret1 := syscall3(wSACancelBlockingCall, 0, + 0, + 0, + 0) + return INT(ret1) +} + +func WSACleanup() INT { + ret1 := syscall3(wSACleanup, 0, + 0, + 0, + 0) + return INT(ret1) +} + +func WSACloseEvent(event WSAEVENT) bool { + ret1 := syscall3(wSACloseEvent, 1, + uintptr(event), + 0, + 0) + return ret1 != 0 +} + +func WSAConnect(s SOCKET, name /*const*/ *Sockaddr, namelen int32, lpCallerData LPWSABUF, lpCalleeData LPWSABUF, lpSQOS *QOS, lpGQOS *QOS) int32 { + ret1 := syscall9(wSAConnect, 7, + uintptr(s), + uintptr(unsafe.Pointer(name)), + uintptr(namelen), + uintptr(unsafe.Pointer(lpCallerData)), + uintptr(unsafe.Pointer(lpCalleeData)), + uintptr(unsafe.Pointer(lpSQOS)), + uintptr(unsafe.Pointer(lpGQOS)), + 0, + 0) + return int32(ret1) +} + +func WSACreateEvent() WSAEVENT { + ret1 := syscall3(wSACreateEvent, 0, + 0, + 0, + 0) + return WSAEVENT(ret1) +} + +func WSADuplicateSocket(s SOCKET, dwProcessId DWORD, lpProtocolInfo LPWSAPROTOCOL_INFO) int32 { + ret1 := syscall3(wSADuplicateSocket, 3, + uintptr(s), + uintptr(dwProcessId), + uintptr(unsafe.Pointer(lpProtocolInfo))) + return int32(ret1) +} + +func WSAEnumNameSpaceProviders(aLen *uint32, buffer LPWSANAMESPACE_INFO) INT { + ret1 := syscall3(wSAEnumNameSpaceProviders, 2, + uintptr(unsafe.Pointer(aLen)), + uintptr(unsafe.Pointer(buffer)), + 0) + return INT(ret1) +} + +func WSAEnumNetworkEvents(s SOCKET, hEvent WSAEVENT, lpEvent *WSANETWORKEVENTS) int32 { + ret1 := syscall3(wSAEnumNetworkEvents, 3, + uintptr(s), + uintptr(hEvent), + uintptr(unsafe.Pointer(lpEvent))) + return int32(ret1) +} + +func WSAEnumProtocols(protocols *int32, buffer LPWSAPROTOCOL_INFO, aLen *uint32) INT { + ret1 := syscall3(wSAEnumProtocols, 3, + uintptr(unsafe.Pointer(protocols)), + uintptr(unsafe.Pointer(buffer)), + uintptr(unsafe.Pointer(aLen))) + return INT(ret1) +} + +func WSAEventSelect(s SOCKET, hEvent WSAEVENT, lEvent LONG) int32 { + ret1 := syscall3(wSAEventSelect, 3, + uintptr(s), + uintptr(hEvent), + uintptr(lEvent)) + return int32(ret1) +} + +func WSAGetLastError() INT { + ret1 := syscall3(wSAGetLastError, 0, + 0, + 0, + 0) + return INT(ret1) +} + +func WSAGetOverlappedResult(s SOCKET, lpOverlapped LPWSAOVERLAPPED, lpcbTransfer *uint32, fWait bool, lpdwFlags *uint32) bool { + ret1 := syscall6(wSAGetOverlappedResult, 5, + uintptr(s), + uintptr(unsafe.Pointer(lpOverlapped)), + uintptr(unsafe.Pointer(lpcbTransfer)), + getUintptrFromBool(fWait), + uintptr(unsafe.Pointer(lpdwFlags)), + 0) + return ret1 != 0 +} + +func WSAGetQOSByName(s SOCKET, lpQOSName LPWSABUF, lpQOS *QOS) bool { + ret1 := syscall3(wSAGetQOSByName, 3, + uintptr(s), + uintptr(unsafe.Pointer(lpQOSName)), + uintptr(unsafe.Pointer(lpQOS))) + return ret1 != 0 +} + +func WSAGetServiceClassInfo(provider *GUID, service *GUID, aLen *uint32, info LPWSASERVICECLASSINFO) INT { + ret1 := syscall6(wSAGetServiceClassInfo, 4, + uintptr(unsafe.Pointer(provider)), + uintptr(unsafe.Pointer(service)), + uintptr(unsafe.Pointer(aLen)), + uintptr(unsafe.Pointer(info)), + 0, + 0) + return INT(ret1) +} + +func WSAGetServiceClassNameByClassId(class *GUID, service LPWSTR, aLen *uint32) INT { + ret1 := syscall3(wSAGetServiceClassNameByClassId, 3, + uintptr(unsafe.Pointer(class)), + uintptr(unsafe.Pointer(service)), + uintptr(unsafe.Pointer(aLen))) + return INT(ret1) +} + +func WSAHtonl(s SOCKET, hostlong ULONG, lpnetlong *ULONG) int32 { + ret1 := syscall3(wSAHtonl, 3, + uintptr(s), + uintptr(hostlong), + uintptr(unsafe.Pointer(lpnetlong))) + return int32(ret1) +} + +func WSAHtons(s SOCKET, hostshort uint16, lpnetshort *uint16) int32 { + ret1 := syscall3(wSAHtons, 3, + uintptr(s), + uintptr(hostshort), + uintptr(unsafe.Pointer(lpnetshort))) + return int32(ret1) +} + +func WSAInstallServiceClass(info LPWSASERVICECLASSINFO) int32 { + ret1 := syscall3(wSAInstallServiceClass, 1, + uintptr(unsafe.Pointer(info)), + 0, + 0) + return int32(ret1) +} + +func WSAIoctl(s SOCKET, code DWORD, in_buff LPVOID, in_size DWORD, out_buff LPVOID, out_size DWORD, ret_size *uint32, overlapped LPWSAOVERLAPPED, completion LPWSAOVERLAPPED_COMPLETION_ROUTINE) INT { + completionCallback := syscall.NewCallback(completion) + ret1 := syscall9(wSAIoctl, 9, + uintptr(s), + uintptr(code), + uintptr(unsafe.Pointer(in_buff)), + uintptr(in_size), + uintptr(unsafe.Pointer(out_buff)), + uintptr(out_size), + uintptr(unsafe.Pointer(ret_size)), + uintptr(unsafe.Pointer(overlapped)), + completionCallback) + return INT(ret1) +} + +func WSAIsBlocking() bool { + ret1 := syscall3(wSAIsBlocking, 0, + 0, + 0, + 0) + return ret1 != 0 +} + +func WSAJoinLeaf(s SOCKET, addr /*const*/ *Sockaddr, addrlen int32, lpCallerData LPWSABUF, lpCalleeData LPWSABUF, lpSQOS *QOS, lpGQOS *QOS, dwFlags DWORD) SOCKET { + ret1 := syscall9(wSAJoinLeaf, 8, + uintptr(s), + uintptr(unsafe.Pointer(addr)), + uintptr(addrlen), + uintptr(unsafe.Pointer(lpCallerData)), + uintptr(unsafe.Pointer(lpCalleeData)), + uintptr(unsafe.Pointer(lpSQOS)), + uintptr(unsafe.Pointer(lpGQOS)), + uintptr(dwFlags), + 0) + return SOCKET(ret1) +} + +func WSALookupServiceBegin(lpqsRestrictions LPWSAQUERYSET, dwControlFlags DWORD, lphLookup *HANDLE) INT { + ret1 := syscall3(wSALookupServiceBegin, 3, + uintptr(unsafe.Pointer(lpqsRestrictions)), + uintptr(dwControlFlags), + uintptr(unsafe.Pointer(lphLookup))) + return INT(ret1) +} + +func WSALookupServiceEnd(lookup HANDLE) INT { + ret1 := syscall3(wSALookupServiceEnd, 1, + uintptr(lookup), + 0, + 0) + return INT(ret1) +} + +func WSALookupServiceNext(lookup HANDLE, flags DWORD, aLen *uint32, results LPWSAQUERYSET) INT { + ret1 := syscall6(wSALookupServiceNext, 4, + uintptr(lookup), + uintptr(flags), + uintptr(unsafe.Pointer(aLen)), + uintptr(unsafe.Pointer(results)), + 0, + 0) + return INT(ret1) +} + +func WSANSPIoctl(hLookup HANDLE, dwControlCode DWORD, lpvInBuffer LPVOID, cbInBuffer DWORD, lpvOutBuffer LPVOID, cbOutBuffer DWORD, lpcbBytesReturned *uint32, lpCompletion *WSACOMPLETION) INT { + ret1 := syscall9(wSANSPIoctl, 8, + uintptr(hLookup), + uintptr(dwControlCode), + uintptr(unsafe.Pointer(lpvInBuffer)), + uintptr(cbInBuffer), + uintptr(unsafe.Pointer(lpvOutBuffer)), + uintptr(cbOutBuffer), + uintptr(unsafe.Pointer(lpcbBytesReturned)), + uintptr(unsafe.Pointer(lpCompletion)), + 0) + return INT(ret1) +} + +func WSANtohl(s SOCKET, netlong ULONG, lphostlong *ULONG) INT { + ret1 := syscall3(wSANtohl, 3, + uintptr(s), + uintptr(netlong), + uintptr(unsafe.Pointer(lphostlong))) + return INT(ret1) +} + +func WSANtohs(s SOCKET, netshort uint16, lphostshort *uint16) INT { + ret1 := syscall3(wSANtohs, 3, + uintptr(s), + uintptr(netshort), + uintptr(unsafe.Pointer(lphostshort))) + return INT(ret1) +} + +func WSAPoll(wfds *WSAPOLLFD, count ULONG, timeout int32) int32 { + ret1 := syscall3(wSAPoll, 3, + uintptr(unsafe.Pointer(wfds)), + uintptr(count), + uintptr(timeout)) + return int32(ret1) +} + +func WSAProviderConfigChange(handle *HANDLE, overlapped LPWSAOVERLAPPED, completion LPWSAOVERLAPPED_COMPLETION_ROUTINE) INT { + completionCallback := syscall.NewCallback(completion) + ret1 := syscall3(wSAProviderConfigChange, 3, + uintptr(unsafe.Pointer(handle)), + uintptr(unsafe.Pointer(overlapped)), + completionCallback) + return INT(ret1) +} + +func WSARecv(s SOCKET, lpBuffers LPWSABUF, dwBufferCount DWORD, numberOfBytesReceived *uint32, lpFlags *uint32, lpOverlapped LPWSAOVERLAPPED, lpCompletionRoutine LPWSAOVERLAPPED_COMPLETION_ROUTINE) int32 { + lpCompletionRoutineCallback := syscall.NewCallback(lpCompletionRoutine) + ret1 := syscall9(wSARecv, 7, + uintptr(s), + uintptr(unsafe.Pointer(lpBuffers)), + uintptr(dwBufferCount), + uintptr(unsafe.Pointer(numberOfBytesReceived)), + uintptr(unsafe.Pointer(lpFlags)), + uintptr(unsafe.Pointer(lpOverlapped)), + lpCompletionRoutineCallback, + 0, + 0) + return int32(ret1) +} + +func WSARecvDisconnect(s SOCKET, disconnectdata LPWSABUF) INT { + ret1 := syscall3(wSARecvDisconnect, 2, + uintptr(s), + uintptr(unsafe.Pointer(disconnectdata)), + 0) + return INT(ret1) +} + +func WSARecvFrom(s SOCKET, lpBuffers LPWSABUF, dwBufferCount DWORD, lpNumberOfBytesRecvd *uint32, lpFlags *uint32, lpFrom *Sockaddr, lpFromlen *int32, lpOverlapped LPWSAOVERLAPPED, lpCompletionRoutine LPWSAOVERLAPPED_COMPLETION_ROUTINE) INT { + lpCompletionRoutineCallback := syscall.NewCallback(lpCompletionRoutine) + ret1 := syscall9(wSARecvFrom, 9, + uintptr(s), + uintptr(unsafe.Pointer(lpBuffers)), + uintptr(dwBufferCount), + uintptr(unsafe.Pointer(lpNumberOfBytesRecvd)), + uintptr(unsafe.Pointer(lpFlags)), + uintptr(unsafe.Pointer(lpFrom)), + uintptr(unsafe.Pointer(lpFromlen)), + uintptr(unsafe.Pointer(lpOverlapped)), + lpCompletionRoutineCallback) + return INT(ret1) +} + +func WSARemoveServiceClass(info *GUID) int32 { + ret1 := syscall3(wSARemoveServiceClass, 1, + uintptr(unsafe.Pointer(info)), + 0, + 0) + return int32(ret1) +} + +func WSASend(s SOCKET, lpBuffers LPWSABUF, dwBufferCount DWORD, lpNumberOfBytesSent *uint32, dwFlags DWORD, lpOverlapped LPWSAOVERLAPPED, lpCompletionRoutine LPWSAOVERLAPPED_COMPLETION_ROUTINE) INT { + lpCompletionRoutineCallback := syscall.NewCallback(lpCompletionRoutine) + ret1 := syscall9(wSASend, 7, + uintptr(s), + uintptr(unsafe.Pointer(lpBuffers)), + uintptr(dwBufferCount), + uintptr(unsafe.Pointer(lpNumberOfBytesSent)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpOverlapped)), + lpCompletionRoutineCallback, + 0, + 0) + return INT(ret1) +} + +func WSASendDisconnect(s SOCKET, lpBuffers LPWSABUF) INT { + ret1 := syscall3(wSASendDisconnect, 2, + uintptr(s), + uintptr(unsafe.Pointer(lpBuffers)), + 0) + return INT(ret1) +} + +func WSASendMsg(s SOCKET, msg *WSAMSG, dwFlags DWORD, lpNumberOfBytesSent *uint32, lpOverlapped LPWSAOVERLAPPED, lpCompletionRoutine LPWSAOVERLAPPED_COMPLETION_ROUTINE) int32 { + lpCompletionRoutineCallback := syscall.NewCallback(lpCompletionRoutine) + ret1 := syscall6(wSASendMsg, 6, + uintptr(s), + uintptr(unsafe.Pointer(msg)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(lpNumberOfBytesSent)), + uintptr(unsafe.Pointer(lpOverlapped)), + lpCompletionRoutineCallback) + return int32(ret1) +} + +func WSASendTo(s SOCKET, lpBuffers LPWSABUF, dwBufferCount DWORD, lpNumberOfBytesSent *uint32, dwFlags DWORD, to /*const*/ *Sockaddr, tolen int32, lpOverlapped LPWSAOVERLAPPED, lpCompletionRoutine LPWSAOVERLAPPED_COMPLETION_ROUTINE) INT { + lpCompletionRoutineCallback := syscall.NewCallback(lpCompletionRoutine) + ret1 := syscall9(wSASendTo, 9, + uintptr(s), + uintptr(unsafe.Pointer(lpBuffers)), + uintptr(dwBufferCount), + uintptr(unsafe.Pointer(lpNumberOfBytesSent)), + uintptr(dwFlags), + uintptr(unsafe.Pointer(to)), + uintptr(tolen), + uintptr(unsafe.Pointer(lpOverlapped)), + lpCompletionRoutineCallback) + return INT(ret1) +} + +func WSASetBlockingHook(lpBlockFunc FARPROC) FARPROC { + lpBlockFuncCallback := syscall.NewCallback(func() uintptr { + ret := lpBlockFunc() + return uintptr(unsafe.Pointer(ret)) + }) + ret1 := syscall3(wSASetBlockingHook, 1, + lpBlockFuncCallback, + 0, + 0) + return func() INT_PTR { + ret2 := syscall3(ret1, 0, + 0, + 0, + 0) + return (INT_PTR)(unsafe.Pointer(ret2)) + } +} + +func WSASetLastError(iError INT) { + syscall3(wSASetLastError, 1, + uintptr(iError), + 0, + 0) +} + +func WSASetService(query LPWSAQUERYSET, operation WSAESETSERVICEOP, flags DWORD) INT { + ret1 := syscall3(wSASetService, 3, + uintptr(unsafe.Pointer(query)), + uintptr(operation), + uintptr(flags)) + return INT(ret1) +} + +func WSASocket(af int32, aType int32, protocol int32, lpProtocolInfo LPWSAPROTOCOL_INFO, g GROUP, dwFlags DWORD) SOCKET { + ret1 := syscall6(wSASocket, 6, + uintptr(af), + uintptr(aType), + uintptr(protocol), + uintptr(unsafe.Pointer(lpProtocolInfo)), + uintptr(g), + uintptr(dwFlags)) + return SOCKET(ret1) +} + +func WSAStartup(wVersionRequested WORD, lpWSAData *WSADATA) int32 { + ret1 := syscall3(wSAStartup, 2, + uintptr(wVersionRequested), + uintptr(unsafe.Pointer(lpWSAData)), + 0) + return int32(ret1) +} + +func WSAStringToAddress(addressString LPWSTR, addressFamily INT, lpProtocolInfo LPWSAPROTOCOL_INFO, lpAddress *SOCKADDR, lpAddressLength *int32) INT { + ret1 := syscall6(wSAStringToAddress, 5, + uintptr(unsafe.Pointer(addressString)), + uintptr(addressFamily), + uintptr(unsafe.Pointer(lpProtocolInfo)), + uintptr(unsafe.Pointer(lpAddress)), + uintptr(unsafe.Pointer(lpAddressLength)), + 0) + return INT(ret1) +} + +func WSAUnhookBlockingHook() INT { + ret1 := syscall3(wSAUnhookBlockingHook, 0, + 0, + 0, + 0) + return INT(ret1) +} + +func WSApSetPostRoutine(lpPostRoutine LPWPUPOSTMESSAGE) INT { + lpPostRoutineCallback := syscall.NewCallback(func(unnamed0RawArg HWND, unnamed1RawArg UINT, unnamed2RawArg WPARAM, unnamed3RawArg LPARAM) uintptr { + ret := lpPostRoutine(unnamed0RawArg, unnamed1RawArg, unnamed2RawArg, unnamed3RawArg) + return uintptr(ret) + }) + ret1 := syscall3(wSApSetPostRoutine, 1, + lpPostRoutineCallback, + 0, + 0) + return INT(ret1) +} + +func WSCDeinstallProvider(lpProviderId *GUID, lpErrno *int32) INT { + ret1 := syscall3(wSCDeinstallProvider, 2, + uintptr(unsafe.Pointer(lpProviderId)), + uintptr(unsafe.Pointer(lpErrno)), + 0) + return INT(ret1) +} + +func WSCEnableNSProvider(provider *GUID, enable bool) INT { + ret1 := syscall3(wSCEnableNSProvider, 2, + uintptr(unsafe.Pointer(provider)), + getUintptrFromBool(enable), + 0) + return INT(ret1) +} + +func WSCEnumProtocols(protocols *int32, buffer LPWSAPROTOCOL_INFO, aLen *uint32, err *int32) INT { + ret1 := syscall6(wSCEnumProtocols, 4, + uintptr(unsafe.Pointer(protocols)), + uintptr(unsafe.Pointer(buffer)), + uintptr(unsafe.Pointer(aLen)), + uintptr(unsafe.Pointer(err)), + 0, + 0) + return INT(ret1) +} + +func WSCGetProviderPath(provider *GUID, path LPWSTR, aLen *int32, errcode *int32) INT { + ret1 := syscall6(wSCGetProviderPath, 4, + uintptr(unsafe.Pointer(provider)), + uintptr(unsafe.Pointer(path)), + uintptr(unsafe.Pointer(aLen)), + uintptr(unsafe.Pointer(errcode)), + 0, + 0) + return INT(ret1) +} + +func WSCInstallNameSpace(identifier LPWSTR, path LPWSTR, namespace DWORD, version DWORD, provider *GUID) INT { + ret1 := syscall6(wSCInstallNameSpace, 5, + uintptr(unsafe.Pointer(identifier)), + uintptr(unsafe.Pointer(path)), + uintptr(namespace), + uintptr(version), + uintptr(unsafe.Pointer(provider)), + 0) + return INT(ret1) +} + +func WSCInstallProvider(lpProviderId /*const*/ *GUID, lpszProviderDllPath string, lpProtocolInfoList /*const*/ LPWSAPROTOCOL_INFO, dwNumberOfEntries DWORD, lpErrno *int32) INT { + lpszProviderDllPathStr := unicode16FromString(lpszProviderDllPath) + ret1 := syscall6(wSCInstallProvider, 5, + uintptr(unsafe.Pointer(lpProviderId)), + uintptr(unsafe.Pointer(&lpszProviderDllPathStr[0])), + uintptr(unsafe.Pointer(lpProtocolInfoList)), + uintptr(dwNumberOfEntries), + uintptr(unsafe.Pointer(lpErrno)), + 0) + return INT(ret1) +} + +func WSCUnInstallNameSpace(lpProviderId *GUID) INT { + ret1 := syscall3(wSCUnInstallNameSpace, 1, + uintptr(unsafe.Pointer(lpProviderId)), + 0, + 0) + return INT(ret1) +} + +func WSCWriteProviderOrder(entry *uint32, number DWORD) INT { + ret1 := syscall3(wSCWriteProviderOrder, 2, + uintptr(unsafe.Pointer(entry)), + uintptr(number), + 0) + return INT(ret1) +} + +func Gethostname(name *CHAR, namelen INT) int32 { + ret1 := syscall3(gethostname, 2, + uintptr(unsafe.Pointer(name)), + uintptr(namelen), + 0) + return int32(ret1) +} diff --git a/rdp.go b/rdp.go new file mode 100644 index 0000000..cd3df53 --- /dev/null +++ b/rdp.go @@ -0,0 +1,18 @@ +package main + +import ( + "ShotRDP/grdp/glog" +) + +/* +修改部分：grdp/protocol/x224/x224.go#New() +去除requestedProtocol中的PROTOCOL_HYBRID，避免使用NLA +*/ + +func DoRDP(host string) { + client := NewClient(host, glog.INFO) + err := client.Login("", "", "") + if err != nil { + panic(err) + } +} diff --git a/rdp_test.go b/rdp_test.go new file mode 100644 index 0000000..033c372 --- /dev/null +++ b/rdp_test.go @@ -0,0 +1,21 @@ +package main + +import ( + "testing" +) + +func TestDoRDP(t *testing.T) { + /* 测试成功版本： + Windows Server 2008 + Windows Server 2012 + Windows Server 2016 + Windows 7 + Windows 10 + */ + + //DoRDP("192.168.251.129:3389") + //DoRDP("192.168.251.130:3389") + //DoRDP("192.168.251.131:3389") + //DoRDP("192.168.251.132:3389") + DoRDP("192.168.251.133:3389") +}