pax_global_header00006660000000000000000000000064151012224320014502gustar00rootroot0000000000000052 comment=baff334c4cfc3923ed8be72762d63d43e6fc2877 golang-github-go-ole-go-ole-1.3.0/000077500000000000000000000000001510122243200165725ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/.github/000077500000000000000000000000001510122243200201325ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/.github/FUNDING.yml000066400000000000000000000013151510122243200217470ustar00rootroot00000000000000# These are supported funding model platforms github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2] patreon: mattn # Replace with a single Patreon username open_collective: # Replace with a single Open Collective username ko_fi: # Replace with a single Ko-fi username tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry liberapay: # Replace with a single Liberapay username issuehunt: # Replace with a single IssueHunt username otechie: # Replace with a single Otechie username custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] golang-github-go-ole-go-ole-1.3.0/.travis.yml000066400000000000000000000001061510122243200207000ustar00rootroot00000000000000language: go sudo: false go: - 1.9.x - 1.10.x - 1.11.x - tip golang-github-go-ole-go-ole-1.3.0/ChangeLog.md000066400000000000000000000037021510122243200207450ustar00rootroot00000000000000# Version 1.x.x * **Add more test cases and reference new test COM server project.** (Placeholder for future additions) # Version 1.2.0-alphaX **Minimum supported version is now Go 1.4. Go 1.1 support is deprecated, but should still build.** * Added CI configuration for Travis-CI and AppVeyor. * Added test InterfaceID and ClassID for the COM Test Server project. * Added more inline documentation (#83). * Added IEnumVARIANT implementation (#88). * Added IEnumVARIANT test cases (#99, #100, #101). * Added support for retrieving `time.Time` from VARIANT (#92). * Added test case for IUnknown (#64). * Added test case for IDispatch (#64). * Added test cases for scalar variants (#64, #76). # Version 1.1.1 * Fixes for Linux build. * Fixes for Windows build. # Version 1.1.0 The change to provide building on all platforms is a new feature. The increase in minor version reflects that and allows those who wish to stay on 1.0.x to continue to do so. Support for 1.0.x will be limited to bug fixes. * Move GUID out of variables.go into its own file to make new documentation available. * Move OleError out of ole.go into its own file to make new documentation available. * Add documentation to utility functions. * Add documentation to variant receiver functions. * Add documentation to ole structures. * Make variant available to other systems outside of Windows. * Make OLE structures available to other systems outside of Windows. ## New Features * Library should now be built on all platforms supported by Go. Library will NOOP on any platform that is not Windows. * More functions are now documented and available on godoc.org. # Version 1.0.1 1. Fix package references from repository location change. # Version 1.0.0 This version is stable enough for use. The COM API is still incomplete, but provides enough functionality for accessing COM servers using IDispatch interface. There is no changelog for this version. Check commits for history. golang-github-go-ole-go-ole-1.3.0/LICENSE000066400000000000000000000021371510122243200176020ustar00rootroot00000000000000The MIT License (MIT) Copyright © 2013-2017 Yasuhiro Matsumoto, Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. golang-github-go-ole-go-ole-1.3.0/README.md000066400000000000000000000043241510122243200200540ustar00rootroot00000000000000# Go OLE [![Build status](https://ci.appveyor.com/api/projects/status/qr0u2sf7q43us9fj?svg=true)](https://ci.appveyor.com/project/jacobsantos/go-ole-jgs28) [![Build Status](https://travis-ci.org/go-ole/go-ole.svg?branch=master)](https://travis-ci.org/go-ole/go-ole) [![GoDoc](https://godoc.org/github.com/go-ole/go-ole?status.svg)](https://godoc.org/github.com/go-ole/go-ole) Go bindings for Windows COM using shared libraries instead of cgo. By Yasuhiro Matsumoto. ## Install To experiment with go-ole, you can just compile and run the example program: ``` go get github.com/go-ole/go-ole cd /path/to/go-ole/ go test cd /path/to/go-ole/example/excel go run excel.go ``` ## Continuous Integration Continuous integration configuration has been added for both Travis-CI and AppVeyor. You will have to add these to your own account for your fork in order for it to run. **Travis-CI** Travis-CI was added to check builds on Linux to ensure that `go get` works when cross building. Currently, Travis-CI is not used to test cross-building, but this may be changed in the future. It is also not currently possible to test the library on Linux, since COM API is specific to Windows and it is not currently possible to run a COM server on Linux or even connect to a remote COM server. **AppVeyor** AppVeyor is used to build on Windows using the (in-development) test COM server. It is currently only used to test the build and ensure that the code works on Windows. It will be used to register a COM server and then run the test cases based on the test COM server. The tests currently do run and do pass and this should be maintained with commits. ## Versioning Go OLE uses [semantic versioning](http://semver.org) for version numbers, which is similar to the version contract of the Go language. Which means that the major version will always maintain backwards compatibility with minor versions. Minor versions will only add new additions and changes. Fixes will always be in patch. This contract should allow you to upgrade to new minor and patch versions without breakage or modifications to your existing code. Leave a ticket, if there is breakage, so that it could be fixed. ## LICENSE Under the MIT License: http://mattn.mit-license.org/2013 golang-github-go-ole-go-ole-1.3.0/SECURITY.md000066400000000000000000000012561510122243200203670ustar00rootroot00000000000000# Security Policy ## Supported Versions Security updates are applied only to the latest release. ## Reporting a Vulnerability If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released. Please disclose it at [security advisory](https://github.com/go-ole/go-ole/security/advisories/new). This project is maintained by a team of volunteers on a reasonable-effort basis. As such, please give us at least 90 days to work on a fix before public exposure. golang-github-go-ole-go-ole-1.3.0/_example/000077500000000000000000000000001510122243200203645ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/_example/excel/000077500000000000000000000000001510122243200214645ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/_example/excel/excel.go000066400000000000000000000015211510122243200231120ustar00rootroot00000000000000// +build windows package main import ( "time" ole "github.com/go-ole/go-ole" "github.com/go-ole/go-ole/oleutil" ) func main() { ole.CoInitialize(0) unknown, _ := oleutil.CreateObject("Excel.Application") excel, _ := unknown.QueryInterface(ole.IID_IDispatch) oleutil.PutProperty(excel, "Visible", true) workbooks := oleutil.MustGetProperty(excel, "Workbooks").ToIDispatch() workbook := oleutil.MustCallMethod(workbooks, "Add", nil).ToIDispatch() worksheet := oleutil.MustGetProperty(workbook, "Worksheets", 1).ToIDispatch() cell := oleutil.MustGetProperty(worksheet, "Cells", 1, 1).ToIDispatch() oleutil.PutProperty(cell, "Value", 12345) time.Sleep(2000000000) oleutil.PutProperty(workbook, "Saved", true) oleutil.CallMethod(workbook, "Close", false) oleutil.CallMethod(excel, "Quit") excel.Release() ole.CoUninitialize() } golang-github-go-ole-go-ole-1.3.0/_example/excel2/000077500000000000000000000000001510122243200215465ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/_example/excel2/excel.go000066400000000000000000000055601510122243200232030ustar00rootroot00000000000000// +build windows package main import ( "fmt" "log" "os" ole "github.com/go-ole/go-ole" "github.com/go-ole/go-ole/oleutil" ) func writeExample(excel, workbooks *ole.IDispatch, filepath string) { // ref: https://msdn.microsoft.com/zh-tw/library/office/ff198017.aspx // http://stackoverflow.com/questions/12159513/what-is-the-correct-xlfileformat-enumeration-for-excel-97-2003 const xlExcel8 = 56 workbook := oleutil.MustCallMethod(workbooks, "Add", nil).ToIDispatch() defer workbook.Release() worksheet := oleutil.MustGetProperty(workbook, "Worksheets", 1).ToIDispatch() defer worksheet.Release() cell := oleutil.MustGetProperty(worksheet, "Cells", 1, 1).ToIDispatch() oleutil.PutProperty(cell, "Value", 12345) cell.Release() activeWorkBook := oleutil.MustGetProperty(excel, "ActiveWorkBook").ToIDispatch() defer activeWorkBook.Release() os.Remove(filepath) // ref: https://msdn.microsoft.com/zh-tw/library/microsoft.office.tools.excel.workbook.saveas.aspx oleutil.MustCallMethod(activeWorkBook, "SaveAs", filepath, xlExcel8, nil, nil).ToIDispatch() //time.Sleep(2 * time.Second) // let excel could close without asking // oleutil.PutProperty(workbook, "Saved", true) // oleutil.CallMethod(workbook, "Close", false) } func readExample(fileName string, excel, workbooks *ole.IDispatch) { workbook, err := oleutil.CallMethod(workbooks, "Open", fileName) if err != nil { log.Fatalln(err) } defer workbook.ToIDispatch().Release() sheets := oleutil.MustGetProperty(excel, "Sheets").ToIDispatch() sheetCount := (int)(oleutil.MustGetProperty(sheets, "Count").Val) fmt.Println("sheet count=", sheetCount) sheets.Release() worksheet := oleutil.MustGetProperty(workbook.ToIDispatch(), "Worksheets", 1).ToIDispatch() defer worksheet.Release() for row := 1; row <= 2; row++ { for col := 1; col <= 5; col++ { cell := oleutil.MustGetProperty(worksheet, "Cells", row, col).ToIDispatch() val, err := oleutil.GetProperty(cell, "Value") if err != nil { break } fmt.Printf("(%d,%d)=%+v toString=%s\n", col, row, val.Value(), val.ToString()) cell.Release() } } } func showMethodsAndProperties(i *ole.IDispatch) { n, err := i.GetTypeInfoCount() if err != nil { log.Fatalln(err) } tinfo, err := i.GetTypeInfo() if err != nil { log.Fatalln(err) } fmt.Println("n=", n, "tinfo=", tinfo) } func main() { log.SetFlags(log.Flags() | log.Lshortfile) ole.CoInitialize(0) unknown, _ := oleutil.CreateObject("Excel.Application") excel, _ := unknown.QueryInterface(ole.IID_IDispatch) oleutil.PutProperty(excel, "Visible", true) workbooks := oleutil.MustGetProperty(excel, "Workbooks").ToIDispatch() cwd, _ := os.Getwd() writeExample(excel, workbooks, cwd+"\\write.xls") readExample(cwd+"\\excel97-2003.xls", excel, workbooks) showMethodsAndProperties(workbooks) workbooks.Release() // oleutil.CallMethod(excel, "Quit") excel.Release() ole.CoUninitialize() } golang-github-go-ole-go-ole-1.3.0/_example/ie/000077500000000000000000000000001510122243200207615ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/_example/ie/ie.go000066400000000000000000000017121510122243200217060ustar00rootroot00000000000000// +build windows package main import ( "time" ole "github.com/go-ole/go-ole" "github.com/go-ole/go-ole/oleutil" ) func main() { ole.CoInitialize(0) unknown, _ := oleutil.CreateObject("InternetExplorer.Application") ie, _ := unknown.QueryInterface(ole.IID_IDispatch) oleutil.PutProperty(ie, "Visible", true) oleutil.CallMethod(ie, "Navigate", "http://www.google.com") for { if oleutil.MustGetProperty(ie, "Busy").Val == 0 { break } } time.Sleep(1e9) document := oleutil.MustGetProperty(ie, "document").ToIDispatch() // set 'golang' to text box. elems := oleutil.MustCallMethod(document, "getElementsByName", "q").ToIDispatch() q := oleutil.MustCallMethod(elems, "item", 0).ToIDispatch() oleutil.MustPutProperty(q, "value", "golang") // click btnK. elems = oleutil.MustCallMethod(document, "getElementsByName", "btnK").ToIDispatch() btnG := oleutil.MustCallMethod(elems, "item", 0).ToIDispatch() oleutil.MustCallMethod(btnG, "click") } golang-github-go-ole-go-ole-1.3.0/_example/itunes/000077500000000000000000000000001510122243200216735ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/_example/itunes/itunes.go000066400000000000000000000017101510122243200235300ustar00rootroot00000000000000// +build windows package main import ( "log" "os" "strings" ole "github.com/go-ole/go-ole" "github.com/go-ole/go-ole/oleutil" "github.com/gonuts/commander" ) func iTunes() *ole.IDispatch { ole.CoInitialize(0) unknown, err := oleutil.CreateObject("iTunes.Application") if err != nil { log.Fatal(err) } itunes, err := unknown.QueryInterface(ole.IID_IDispatch) if err != nil { log.Fatal(err) } return itunes } func main() { command := &commander.Command{ UsageLine: os.Args[0], Short: "itunes cmd", } command.Subcommands = []*commander.Command{} for _, name := range []string{"Play", "Stop", "Pause", "Quit"} { command.Subcommands = append(command.Subcommands, &commander.Command{ Run: func(cmd *commander.Command, args []string) error { _, err := oleutil.CallMethod(iTunes(), name) return err }, UsageLine: strings.ToLower(name), }) } err := command.Dispatch(os.Args[1:]) if err != nil { log.Fatal(err) } } golang-github-go-ole-go-ole-1.3.0/_example/libreoffice/000077500000000000000000000000001510122243200226355ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/_example/libreoffice/libreoffice.go000066400000000000000000000136761510122243200254520ustar00rootroot00000000000000// +build windows /* Demonstrates basic LibreOffce (OpenOffice) automation with OLE using GO-OLE. Usage: cd [...]\go-ole\example\libreoffice go run libreoffice.go References: http://www.openoffice.org/api/basic/man/tutorial/tutorial.pdf http://api.libreoffice.org/examples/examples.html#OLE_examples https://wiki.openoffice.org/wiki/Documentation/BASIC_Guide Tested environment: go 1.6.2 (windows/amd64) LibreOffice 5.1.0.3 (32 bit) Windows 10 (64 bit) The MIT License (MIT) Copyright (c) 2016 Sebastian Schleemilch . Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ package main import ( "fmt" "log" ole "github.com/go-ole/go-ole" "github.com/go-ole/go-ole/oleutil" ) func checkError(err error, msg string) { if err != nil { log.Fatal(msg) } } // LOGetCell returns an handle to a cell within a worksheet // LibreOffice Basic: GetCell = oSheet.getCellByPosition (nColumn , nRow) func LOGetCell(worksheet *ole.IDispatch, nColumn int, nRow int) (cell *ole.IDispatch) { return oleutil.MustCallMethod(worksheet, "getCellByPosition", nColumn, nRow).ToIDispatch() } // LOGetCellRangeByName returns a named range (e.g. "A1:B4") func LOGetCellRangeByName(worksheet *ole.IDispatch, rangeName string) (cells *ole.IDispatch) { return oleutil.MustCallMethod(worksheet, "getCellRangeByName", rangeName).ToIDispatch() } // LOGetCellString returns the displayed value func LOGetCellString(cell *ole.IDispatch) (value string) { return oleutil.MustGetProperty(cell, "string").ToString() } // LOGetCellValue returns the cell's internal value (not formatted, dummy code, FIXME) func LOGetCellValue(cell *ole.IDispatch) (value string) { val := oleutil.MustGetProperty(cell, "value") fmt.Printf("Cell: %+v\n", val) return val.ToString() } // LOGetCellError returns the error value of a cell (dummy code, FIXME) func LOGetCellError(cell *ole.IDispatch) (result *ole.VARIANT) { return oleutil.MustGetProperty(cell, "error") } // LOSetCellString sets the text value of a cell func LOSetCellString(cell *ole.IDispatch, text string) { oleutil.MustPutProperty(cell, "string", text) } // LOSetCellValue sets the numeric value of a cell func LOSetCellValue(cell *ole.IDispatch, value float64) { oleutil.MustPutProperty(cell, "value", value) } // LOSetCellFormula sets the formula (in englisch language) func LOSetCellFormula(cell *ole.IDispatch, formula string) { oleutil.MustPutProperty(cell, "formula", formula) } // LOSetCellFormulaLocal sets the formula in the user's language (e.g. German =SUMME instead of =SUM) func LOSetCellFormulaLocal(cell *ole.IDispatch, formula string) { oleutil.MustPutProperty(cell, "FormulaLocal", formula) } // LONewSpreadsheet creates a new spreadsheet in a new window and returns a document handle. func LONewSpreadsheet(desktop *ole.IDispatch) (document *ole.IDispatch) { var args = []string{} document = oleutil.MustCallMethod(desktop, "loadComponentFromURL", "private:factory/scalc", // alternative: private:factory/swriter "_blank", 0, args).ToIDispatch() return } // LOOpenFile opens a file (text, spreadsheet, ...) in a new window and returns a document // handle. Example: /home/testuser/spreadsheet.ods func LOOpenFile(desktop *ole.IDispatch, fullpath string) (document *ole.IDispatch) { var args = []string{} document = oleutil.MustCallMethod(desktop, "loadComponentFromURL", "file://"+fullpath, "_blank", 0, args).ToIDispatch() return } // LOSaveFile saves the current document. // Only works if a file already exists, // see https://wiki.openoffice.org/wiki/Saving_a_document func LOSaveFile(document *ole.IDispatch) { // use storeAsURL if neccessary with third URL parameter oleutil.MustCallMethod(document, "store") } // LOGetWorksheet returns a worksheet (index starts at 0) func LOGetWorksheet(document *ole.IDispatch, index int) (worksheet *ole.IDispatch) { sheets := oleutil.MustGetProperty(document, "Sheets").ToIDispatch() worksheet = oleutil.MustCallMethod(sheets, "getByIndex", index).ToIDispatch() return } // This example creates a new spreadsheet, reads and modifies cell values and style. func main() { ole.CoInitialize(0) unknown, errCreate := oleutil.CreateObject("com.sun.star.ServiceManager") checkError(errCreate, "Couldn't create a OLE connection to LibreOffice") ServiceManager, errSM := unknown.QueryInterface(ole.IID_IDispatch) checkError(errSM, "Couldn't start a LibreOffice instance") desktop := oleutil.MustCallMethod(ServiceManager, "createInstance", "com.sun.star.frame.Desktop").ToIDispatch() document := LONewSpreadsheet(desktop) sheet0 := LOGetWorksheet(document, 0) cell1_1 := LOGetCell(sheet0, 1, 1) // cell B2 cell1_2 := LOGetCell(sheet0, 1, 2) // cell B3 cell1_3 := LOGetCell(sheet0, 1, 3) // cell B4 cell1_4 := LOGetCell(sheet0, 1, 4) // cell B5 LOSetCellString(cell1_1, "Hello World") LOSetCellValue(cell1_2, 33.45) LOSetCellFormula(cell1_3, "=B3+5") b4Value := LOGetCellString(cell1_3) LOSetCellString(cell1_4, b4Value) // set background color yellow: oleutil.MustPutProperty(cell1_1, "cellbackcolor", 0xFFFF00) fmt.Printf("Press [ENTER] to exit") fmt.Scanf("%s") ServiceManager.Release() ole.CoUninitialize() } golang-github-go-ole-go-ole-1.3.0/_example/mediaplayer/000077500000000000000000000000001510122243200226605ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/_example/mediaplayer/mediaplayer.go000066400000000000000000000014021510122243200255000ustar00rootroot00000000000000// +build windows package main import ( "fmt" "log" ole "github.com/go-ole/go-ole" "github.com/go-ole/go-ole/oleutil" ) func main() { ole.CoInitialize(0) unknown, err := oleutil.CreateObject("WMPlayer.OCX") if err != nil { log.Fatal(err) } wmp := unknown.MustQueryInterface(ole.IID_IDispatch) collection := oleutil.MustGetProperty(wmp, "MediaCollection").ToIDispatch() list := oleutil.MustCallMethod(collection, "getAll").ToIDispatch() count := int(oleutil.MustGetProperty(list, "count").Val) for i := 0; i < count; i++ { item := oleutil.MustGetProperty(list, "item", i).ToIDispatch() name := oleutil.MustGetProperty(item, "name").ToString() sourceURL := oleutil.MustGetProperty(item, "sourceURL").ToString() fmt.Println(name, sourceURL) } } golang-github-go-ole-go-ole-1.3.0/_example/msagent/000077500000000000000000000000001510122243200220225ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/_example/msagent/msagent.go000066400000000000000000000012721510122243200240110ustar00rootroot00000000000000// +build windows package main import ( "time" ole "github.com/go-ole/go-ole" "github.com/go-ole/go-ole/oleutil" ) func main() { ole.CoInitialize(0) unknown, _ := oleutil.CreateObject("Agent.Control.1") agent, _ := unknown.QueryInterface(ole.IID_IDispatch) oleutil.PutProperty(agent, "Connected", true) characters := oleutil.MustGetProperty(agent, "Characters").ToIDispatch() oleutil.CallMethod(characters, "Load", "Merlin", "c:\\windows\\msagent\\chars\\Merlin.acs") character := oleutil.MustCallMethod(characters, "Character", "Merlin").ToIDispatch() oleutil.CallMethod(character, "Show") oleutil.CallMethod(character, "Speak", "こんにちわ世界") time.Sleep(4000000000) } golang-github-go-ole-go-ole-1.3.0/_example/msxml/000077500000000000000000000000001510122243200215245ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/_example/msxml/rssreader.go000066400000000000000000000025461510122243200240540ustar00rootroot00000000000000// +build windows package main import ( "fmt" "time" ole "github.com/go-ole/go-ole" "github.com/go-ole/go-ole/oleutil" ) func main() { ole.CoInitialize(0) unknown, _ := oleutil.CreateObject("Microsoft.XMLHTTP") xmlhttp, _ := unknown.QueryInterface(ole.IID_IDispatch) _, err := oleutil.CallMethod(xmlhttp, "open", "GET", "http://rss.slashdot.org/Slashdot/slashdot", false) if err != nil { panic(err.Error()) } _, err = oleutil.CallMethod(xmlhttp, "send", nil) if err != nil { panic(err.Error()) } state := -1 for state != 4 { state = int(oleutil.MustGetProperty(xmlhttp, "readyState").Val) time.Sleep(10000000) } responseXml := oleutil.MustGetProperty(xmlhttp, "responseXml").ToIDispatch() items := oleutil.MustCallMethod(responseXml, "selectNodes", "/rdf:RDF/item").ToIDispatch() length := int(oleutil.MustGetProperty(items, "length").Val) println(length) for n := 0; n < length; n++ { item := oleutil.MustGetProperty(items, "item", n).ToIDispatch() title := oleutil.MustCallMethod(item, "selectSingleNode", "title").ToIDispatch() fmt.Println(oleutil.MustGetProperty(title, "text").ToString()) link := oleutil.MustCallMethod(item, "selectSingleNode", "link").ToIDispatch() fmt.Println(" " + oleutil.MustGetProperty(link, "text").ToString()) title.Release() link.Release() item.Release() } items.Release() xmlhttp.Release() } golang-github-go-ole-go-ole-1.3.0/_example/outlook/000077500000000000000000000000001510122243200220605ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/_example/outlook/outlook.go000066400000000000000000000015511510122243200241050ustar00rootroot00000000000000// +build windows package main import ( "fmt" ole "github.com/go-ole/go-ole" "github.com/go-ole/go-ole/oleutil" ) func main() { ole.CoInitialize(0) unknown, _ := oleutil.CreateObject("Outlook.Application") outlook, _ := unknown.QueryInterface(ole.IID_IDispatch) ns := oleutil.MustCallMethod(outlook, "GetNamespace", "MAPI").ToIDispatch() folder := oleutil.MustCallMethod(ns, "GetDefaultFolder", 10).ToIDispatch() contacts := oleutil.MustCallMethod(folder, "Items").ToIDispatch() count := oleutil.MustGetProperty(contacts, "Count").Value().(int32) for i := 1; i <= int(count); i++ { item, err := oleutil.GetProperty(contacts, "Item", i) if err == nil && item.VT == ole.VT_DISPATCH { if value, err := oleutil.GetProperty(item.ToIDispatch(), "FullName"); err == nil { fmt.Println(value.Value()) } } } oleutil.MustCallMethod(outlook, "Quit") } golang-github-go-ole-go-ole-1.3.0/_example/winsock/000077500000000000000000000000001510122243200220415ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/_example/winsock/winsock.go000066400000000000000000000065421510122243200240540ustar00rootroot00000000000000// +build windows package main import ( "log" "syscall" "unsafe" ole "github.com/go-ole/go-ole" "github.com/go-ole/go-ole/oleutil" ) type EventReceiver struct { lpVtbl *EventReceiverVtbl ref int32 host *ole.IDispatch } type EventReceiverVtbl struct { pQueryInterface uintptr pAddRef uintptr pRelease uintptr pGetTypeInfoCount uintptr pGetTypeInfo uintptr pGetIDsOfNames uintptr pInvoke uintptr } func QueryInterface(this *ole.IUnknown, iid *ole.GUID, punk **ole.IUnknown) uint32 { s, _ := ole.StringFromCLSID(iid) *punk = nil if ole.IsEqualGUID(iid, ole.IID_IUnknown) || ole.IsEqualGUID(iid, ole.IID_IDispatch) { AddRef(this) *punk = this return ole.S_OK } if s == "{248DD893-BB45-11CF-9ABC-0080C7E7B78D}" { AddRef(this) *punk = this return ole.S_OK } return ole.E_NOINTERFACE } func AddRef(this *ole.IUnknown) int32 { pthis := (*EventReceiver)(unsafe.Pointer(this)) pthis.ref++ return pthis.ref } func Release(this *ole.IUnknown) int32 { pthis := (*EventReceiver)(unsafe.Pointer(this)) pthis.ref-- return pthis.ref } func GetIDsOfNames(this *ole.IUnknown, iid *ole.GUID, wnames []*uint16, namelen int, lcid int, pdisp []int32) uintptr { for n := 0; n < namelen; n++ { pdisp[n] = int32(n) } return uintptr(ole.S_OK) } func GetTypeInfoCount(pcount *int) uintptr { if pcount != nil { *pcount = 0 } return uintptr(ole.S_OK) } func GetTypeInfo(ptypeif *uintptr) uintptr { return uintptr(ole.E_NOTIMPL) } func Invoke(this *ole.IDispatch, dispid int, riid *ole.GUID, lcid int, flags int16, dispparams *ole.DISPPARAMS, result *ole.VARIANT, pexcepinfo *ole.EXCEPINFO, nerr *uint) uintptr { switch dispid { case 0: log.Println("DataArrival") winsock := (*EventReceiver)(unsafe.Pointer(this)).host var data ole.VARIANT ole.VariantInit(&data) oleutil.CallMethod(winsock, "GetData", &data) s := string(data.ToArray().ToByteArray()) println() println(s) println() case 1: log.Println("Connected") winsock := (*EventReceiver)(unsafe.Pointer(this)).host oleutil.CallMethod(winsock, "SendData", "GET / HTTP/1.0\r\n\r\n") case 3: log.Println("SendProgress") case 4: log.Println("SendComplete") case 5: log.Println("Close") this.Release() case 6: log.Fatal("Error") default: log.Println(dispid) } return ole.E_NOTIMPL } func main() { ole.CoInitialize(0) unknown, err := oleutil.CreateObject("{248DD896-BB45-11CF-9ABC-0080C7E7B78D}") if err != nil { panic(err.Error()) } winsock, _ := unknown.QueryInterface(ole.IID_IDispatch) iid, _ := ole.CLSIDFromString("{248DD893-BB45-11CF-9ABC-0080C7E7B78D}") dest := &EventReceiver{} dest.lpVtbl = &EventReceiverVtbl{} dest.lpVtbl.pQueryInterface = syscall.NewCallback(QueryInterface) dest.lpVtbl.pAddRef = syscall.NewCallback(AddRef) dest.lpVtbl.pRelease = syscall.NewCallback(Release) dest.lpVtbl.pGetTypeInfoCount = syscall.NewCallback(GetTypeInfoCount) dest.lpVtbl.pGetTypeInfo = syscall.NewCallback(GetTypeInfo) dest.lpVtbl.pGetIDsOfNames = syscall.NewCallback(GetIDsOfNames) dest.lpVtbl.pInvoke = syscall.NewCallback(Invoke) dest.host = winsock oleutil.ConnectObject(winsock, iid, (*ole.IUnknown)(unsafe.Pointer(dest))) _, err = oleutil.CallMethod(winsock, "Connect", "127.0.0.1", 80) if err != nil { log.Fatal(err) } var m ole.Msg for dest.ref != 0 { ole.GetMessage(&m, 0, 0, 0) ole.DispatchMessage(&m) } } golang-github-go-ole-go-ole-1.3.0/appveyor.yml000066400000000000000000000031731510122243200211660ustar00rootroot00000000000000# Notes: # - Minimal appveyor.yml file is an empty file. All sections are optional. # - Indent each level of configuration with 2 spaces. Do not use tabs! # - All section names are case-sensitive. # - Section names should be unique on each level. version: "1.3.0.{build}-alpha-{branch}" os: Visual Studio 2019 build: off skip_tags: true clone_folder: c:\gopath\src\github.com\go-ole\go-ole environment: GOPATH: c:\gopath GOROOT: c:\go DOWNLOADPLATFORM: "x64" before_test: # - Download COM Server - ps: Start-FileDownload "https://github.com/go-ole/test-com-server/releases/download/v1.0.2/test-com-server-${env:DOWNLOADPLATFORM}.zip" - 7z e test-com-server-%DOWNLOADPLATFORM%.zip -oc:\gopath\src\github.com\go-ole\go-ole > NUL - c:\gopath\src\github.com\go-ole\go-ole\build\register-assembly.bat test_script: - go test -v -cover ./... # go vet has false positives on unsafe.Pointer with windows/sys. Disabling since it is recommended to use go test instead. # - go vet ./... branches: only: - master - v1.2 - v1.1 - v1.0 matrix: allow_failures: - environment: GOROOT: C:\go-x86 DOWNLOADPLATFORM: "x86" - environment: GOROOT: C:\go118 DOWNLOADPLATFORM: "x64" - environment: GOROOT: C:\go118-x86 DOWNLOADPLATFORM: "x86" install: - go version - go env - go get -u golang.org/x/tools/cmd/cover - go get -u golang.org/x/tools/cmd/godoc - go get -u golang.org/x/tools/cmd/stringer build_script: - cd c:\gopath\src\github.com\go-ole\go-ole - go get -v -t ./... - go build # disable automatic tests test: on # disable deployment deploy: off golang-github-go-ole-go-ole-1.3.0/build/000077500000000000000000000000001510122243200176715ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/build/register-assembly.bat000066400000000000000000000005531510122243200240250ustar00rootroot00000000000000@ECHO OFF IF "x86" == "%DOWNLOADPLATFORM%" ( CALL c:\Windows\Microsoft.NET\Framework\v4.0.30319\RegAsm.exe /codebase /nologo c:\gopath\src\github.com\go-ole\go-ole\TestCOMServer.dll ) IF "x64" == "%DOWNLOADPLATFORM%" ( CALL c:\Windows\Microsoft.NET\Framework64\v4.0.30319\RegAsm.exe /codebase /nologo c:\gopath\src\github.com\go-ole\go-ole\TestCOMServer.dll ) golang-github-go-ole-go-ole-1.3.0/com.go000066400000000000000000000306261510122243200177060ustar00rootroot00000000000000// +build windows package ole import ( "syscall" "unicode/utf16" "unsafe" ) var ( procCoInitialize = modole32.NewProc("CoInitialize") procCoInitializeEx = modole32.NewProc("CoInitializeEx") procCoInitializeSecurity = modole32.NewProc("CoInitializeSecurity") procCoUninitialize = modole32.NewProc("CoUninitialize") procCoCreateInstance = modole32.NewProc("CoCreateInstance") procCoTaskMemFree = modole32.NewProc("CoTaskMemFree") procCLSIDFromProgID = modole32.NewProc("CLSIDFromProgID") procCLSIDFromString = modole32.NewProc("CLSIDFromString") procStringFromCLSID = modole32.NewProc("StringFromCLSID") procStringFromIID = modole32.NewProc("StringFromIID") procIIDFromString = modole32.NewProc("IIDFromString") procCoGetObject = modole32.NewProc("CoGetObject") procGetUserDefaultLCID = modkernel32.NewProc("GetUserDefaultLCID") procCopyMemory = modkernel32.NewProc("RtlMoveMemory") procVariantInit = modoleaut32.NewProc("VariantInit") procVariantClear = modoleaut32.NewProc("VariantClear") procVariantTimeToSystemTime = modoleaut32.NewProc("VariantTimeToSystemTime") procSysAllocString = modoleaut32.NewProc("SysAllocString") procSysAllocStringLen = modoleaut32.NewProc("SysAllocStringLen") procSysFreeString = modoleaut32.NewProc("SysFreeString") procSysStringLen = modoleaut32.NewProc("SysStringLen") procCreateDispTypeInfo = modoleaut32.NewProc("CreateDispTypeInfo") procCreateStdDispatch = modoleaut32.NewProc("CreateStdDispatch") procGetActiveObject = modoleaut32.NewProc("GetActiveObject") procGetMessageW = moduser32.NewProc("GetMessageW") procDispatchMessageW = moduser32.NewProc("DispatchMessageW") ) // This is to enable calling COM Security initialization multiple times var bSecurityInit bool = false // coInitialize initializes COM library on current thread. // // MSDN documentation suggests that this function should not be called. Call // CoInitializeEx() instead. The reason has to do with threading and this // function is only for single-threaded apartments. // // That said, most users of the library have gotten away with just this // function. If you are experiencing threading issues, then use // CoInitializeEx(). func coInitialize() (err error) { // http://msdn.microsoft.com/en-us/library/windows/desktop/ms678543(v=vs.85).aspx // Suggests that no value should be passed to CoInitialized. // Could just be Call() since the parameter is optional. <-- Needs testing to be sure. hr, _, _ := procCoInitialize.Call(uintptr(0)) if hr != 0 { err = NewError(hr) } return } // coInitializeEx initializes COM library with concurrency model. func coInitializeEx(coinit uint32) (err error) { // http://msdn.microsoft.com/en-us/library/windows/desktop/ms695279(v=vs.85).aspx // Suggests that the first parameter is not only optional but should always be NULL. hr, _, _ := procCoInitializeEx.Call(uintptr(0), uintptr(coinit)) if hr != 0 { err = NewError(hr) } return } // coInitializeSecurity: Registers security and sets the default security values // for the process. func coInitializeSecurity(cAuthSvc int32, dwAuthnLevel uint32, dwImpLevel uint32, dwCapabilities uint32) (err error) { // Check COM Security initialization has done previously if !bSecurityInit { // https://learn.microsoft.com/en-us/windows/win32/api/combaseapi/nf-combaseapi-coinitializesecurity hr, _, _ := procCoInitializeSecurity.Call( uintptr(0), // Allow *all* VSS writers to communicate back! uintptr(cAuthSvc), // Default COM authentication service uintptr(0), // Default COM authorization service uintptr(0), // Reserved parameter uintptr(dwAuthnLevel), // Strongest COM authentication level uintptr(dwImpLevel), // Minimal impersonation abilities uintptr(0), // Default COM authentication settings uintptr(dwCapabilities), // Cloaking uintptr(0)) // eserved parameter if hr != 0 { err = NewError(hr) } else { // COM Security initialization done make global flag true. bSecurityInit = true } } return } // CoInitialize initializes COM library on current thread. // // MSDN documentation suggests that this function should not be called. Call // CoInitializeEx() instead. The reason has to do with threading and this // function is only for single-threaded apartments. // // That said, most users of the library have gotten away with just this // function. If you are experiencing threading issues, then use // CoInitializeEx(). func CoInitialize(p uintptr) (err error) { // p is ignored and won't be used. // Avoid any variable not used errors. p = uintptr(0) return coInitialize() } // CoInitializeEx initializes COM library with concurrency model. func CoInitializeEx(p uintptr, coinit uint32) (err error) { // Avoid any variable not used errors. p = uintptr(0) return coInitializeEx(coinit) } // CoUninitialize uninitializes COM Library. func CoUninitialize() { procCoUninitialize.Call() } // CoInitializeSecurity: Registers security and sets the default security values // for the process. func CoInitializeSecurity(cAuthSvc int32, dwAuthnLevel uint32, dwImpLevel uint32, dwCapabilities uint32) (err error) { return coInitializeSecurity(cAuthSvc, dwAuthnLevel, dwImpLevel, dwCapabilities) } // CoTaskMemFree frees memory pointer. func CoTaskMemFree(memptr uintptr) { procCoTaskMemFree.Call(memptr) } // CLSIDFromProgID retrieves Class Identifier with the given Program Identifier. // // The Programmatic Identifier must be registered, because it will be looked up // in the Windows Registry. The registry entry has the following keys: CLSID, // Insertable, Protocol and Shell // (https://msdn.microsoft.com/en-us/library/dd542719(v=vs.85).aspx). // // programID identifies the class id with less precision and is not guaranteed // to be unique. These are usually found in the registry under // HKEY_LOCAL_MACHINE\SOFTWARE\Classes, usually with the format of // "Program.Component.Version" with version being optional. // // CLSIDFromProgID in Windows API. func CLSIDFromProgID(progId string) (clsid *GUID, err error) { var guid GUID lpszProgID := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId))) hr, _, _ := procCLSIDFromProgID.Call(lpszProgID, uintptr(unsafe.Pointer(&guid))) if hr != 0 { err = NewError(hr) } clsid = &guid return } // CLSIDFromString retrieves Class ID from string representation. // // This is technically the string version of the GUID and will convert the // string to object. // // CLSIDFromString in Windows API. func CLSIDFromString(str string) (clsid *GUID, err error) { var guid GUID lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(str))) hr, _, _ := procCLSIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid))) if hr != 0 { err = NewError(hr) } clsid = &guid return } // StringFromCLSID returns GUID formated string from GUID object. func StringFromCLSID(clsid *GUID) (str string, err error) { var p *uint16 hr, _, _ := procStringFromCLSID.Call(uintptr(unsafe.Pointer(clsid)), uintptr(unsafe.Pointer(&p))) if hr != 0 { err = NewError(hr) } str = LpOleStrToString(p) return } // IIDFromString returns GUID from program ID. func IIDFromString(progId string) (clsid *GUID, err error) { var guid GUID lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId))) hr, _, _ := procIIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid))) if hr != 0 { err = NewError(hr) } clsid = &guid return } // StringFromIID returns GUID formatted string from GUID object. func StringFromIID(iid *GUID) (str string, err error) { var p *uint16 hr, _, _ := procStringFromIID.Call(uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&p))) if hr != 0 { err = NewError(hr) } str = LpOleStrToString(p) return } // CreateInstance of single uninitialized object with GUID. func CreateInstance(clsid *GUID, iid *GUID) (unk *IUnknown, err error) { if iid == nil { iid = IID_IUnknown } hr, _, _ := procCoCreateInstance.Call( uintptr(unsafe.Pointer(clsid)), 0, CLSCTX_SERVER, uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&unk))) if hr != 0 { err = NewError(hr) } return } // GetActiveObject retrieves pointer to active object. func GetActiveObject(clsid *GUID, iid *GUID) (unk *IUnknown, err error) { if iid == nil { iid = IID_IUnknown } hr, _, _ := procGetActiveObject.Call( uintptr(unsafe.Pointer(clsid)), uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&unk))) if hr != 0 { err = NewError(hr) } return } type BindOpts struct { CbStruct uint32 GrfFlags uint32 GrfMode uint32 TickCountDeadline uint32 } // GetObject retrieves pointer to active object. func GetObject(programID string, bindOpts *BindOpts, iid *GUID) (unk *IUnknown, err error) { if bindOpts != nil { bindOpts.CbStruct = uint32(unsafe.Sizeof(BindOpts{})) } if iid == nil { iid = IID_IUnknown } hr, _, _ := procCoGetObject.Call( uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(programID))), uintptr(unsafe.Pointer(bindOpts)), uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&unk))) if hr != 0 { err = NewError(hr) } return } // VariantInit initializes variant. func VariantInit(v *VARIANT) (err error) { hr, _, _ := procVariantInit.Call(uintptr(unsafe.Pointer(v))) if hr != 0 { err = NewError(hr) } return } // VariantClear clears value in Variant settings to VT_EMPTY. func VariantClear(v *VARIANT) (err error) { hr, _, _ := procVariantClear.Call(uintptr(unsafe.Pointer(v))) if hr != 0 { err = NewError(hr) } return } // SysAllocString allocates memory for string and copies string into memory. func SysAllocString(v string) (ss *int16) { pss, _, _ := procSysAllocString.Call(uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(v)))) ss = (*int16)(unsafe.Pointer(pss)) return } // SysAllocStringLen copies up to length of given string returning pointer. func SysAllocStringLen(v string) (ss *int16) { utf16 := utf16.Encode([]rune(v + "\x00")) ptr := &utf16[0] pss, _, _ := procSysAllocStringLen.Call(uintptr(unsafe.Pointer(ptr)), uintptr(len(utf16)-1)) ss = (*int16)(unsafe.Pointer(pss)) return } // SysFreeString frees string system memory. This must be called with SysAllocString. func SysFreeString(v *int16) (err error) { hr, _, _ := procSysFreeString.Call(uintptr(unsafe.Pointer(v))) if hr != 0 { err = NewError(hr) } return } // SysStringLen is the length of the system allocated string. func SysStringLen(v *int16) uint32 { l, _, _ := procSysStringLen.Call(uintptr(unsafe.Pointer(v))) return uint32(l) } // CreateStdDispatch provides default IDispatch implementation for IUnknown. // // This handles default IDispatch implementation for objects. It haves a few // limitations with only supporting one language. It will also only return // default exception codes. func CreateStdDispatch(unk *IUnknown, v uintptr, ptinfo *IUnknown) (disp *IDispatch, err error) { hr, _, _ := procCreateStdDispatch.Call( uintptr(unsafe.Pointer(unk)), v, uintptr(unsafe.Pointer(ptinfo)), uintptr(unsafe.Pointer(&disp))) if hr != 0 { err = NewError(hr) } return } // CreateDispTypeInfo provides default ITypeInfo implementation for IDispatch. // // This will not handle the full implementation of the interface. func CreateDispTypeInfo(idata *INTERFACEDATA) (pptinfo *IUnknown, err error) { hr, _, _ := procCreateDispTypeInfo.Call( uintptr(unsafe.Pointer(idata)), uintptr(GetUserDefaultLCID()), uintptr(unsafe.Pointer(&pptinfo))) if hr != 0 { err = NewError(hr) } return } // copyMemory moves location of a block of memory. func copyMemory(dest unsafe.Pointer, src unsafe.Pointer, length uint32) { procCopyMemory.Call(uintptr(dest), uintptr(src), uintptr(length)) } // GetUserDefaultLCID retrieves current user default locale. func GetUserDefaultLCID() (lcid uint32) { ret, _, _ := procGetUserDefaultLCID.Call() lcid = uint32(ret) return } // GetMessage in message queue from runtime. // // This function appears to block. PeekMessage does not block. func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (ret int32, err error) { r0, _, err := procGetMessageW.Call(uintptr(unsafe.Pointer(msg)), uintptr(hwnd), uintptr(MsgFilterMin), uintptr(MsgFilterMax)) ret = int32(r0) return } // DispatchMessage to window procedure. func DispatchMessage(msg *Msg) (ret int32) { r0, _, _ := procDispatchMessageW.Call(uintptr(unsafe.Pointer(msg))) ret = int32(r0) return } golang-github-go-ole-go-ole-1.3.0/com_func.go000066400000000000000000000124221510122243200207130ustar00rootroot00000000000000// +build !windows package ole import ( "time" "unsafe" ) // coInitialize initializes COM library on current thread. // // MSDN documentation suggests that this function should not be called. Call // CoInitializeEx() instead. The reason has to do with threading and this // function is only for single-threaded apartments. // // That said, most users of the library have gotten away with just this // function. If you are experiencing threading issues, then use // CoInitializeEx(). func coInitialize() error { return NewError(E_NOTIMPL) } // coInitializeEx initializes COM library with concurrency model. func coInitializeEx(coinit uint32) error { return NewError(E_NOTIMPL) } // CoInitialize initializes COM library on current thread. // // MSDN documentation suggests that this function should not be called. Call // CoInitializeEx() instead. The reason has to do with threading and this // function is only for single-threaded apartments. // // That said, most users of the library have gotten away with just this // function. If you are experiencing threading issues, then use // CoInitializeEx(). func CoInitialize(p uintptr) error { return NewError(E_NOTIMPL) } // CoInitializeEx initializes COM library with concurrency model. func CoInitializeEx(p uintptr, coinit uint32) error { return NewError(E_NOTIMPL) } // CoUninitialize uninitializes COM Library. func CoUninitialize() {} // CoTaskMemFree frees memory pointer. func CoTaskMemFree(memptr uintptr) {} // CLSIDFromProgID retrieves Class Identifier with the given Program Identifier. // // The Programmatic Identifier must be registered, because it will be looked up // in the Windows Registry. The registry entry has the following keys: CLSID, // Insertable, Protocol and Shell // (https://msdn.microsoft.com/en-us/library/dd542719(v=vs.85).aspx). // // programID identifies the class id with less precision and is not guaranteed // to be unique. These are usually found in the registry under // HKEY_LOCAL_MACHINE\SOFTWARE\Classes, usually with the format of // "Program.Component.Version" with version being optional. // // CLSIDFromProgID in Windows API. func CLSIDFromProgID(progId string) (*GUID, error) { return nil, NewError(E_NOTIMPL) } // CLSIDFromString retrieves Class ID from string representation. // // This is technically the string version of the GUID and will convert the // string to object. // // CLSIDFromString in Windows API. func CLSIDFromString(str string) (*GUID, error) { return nil, NewError(E_NOTIMPL) } // StringFromCLSID returns GUID formated string from GUID object. func StringFromCLSID(clsid *GUID) (string, error) { return "", NewError(E_NOTIMPL) } // IIDFromString returns GUID from program ID. func IIDFromString(progId string) (*GUID, error) { return nil, NewError(E_NOTIMPL) } // StringFromIID returns GUID formatted string from GUID object. func StringFromIID(iid *GUID) (string, error) { return "", NewError(E_NOTIMPL) } // CreateInstance of single uninitialized object with GUID. func CreateInstance(clsid *GUID, iid *GUID) (*IUnknown, error) { return nil, NewError(E_NOTIMPL) } // GetActiveObject retrieves pointer to active object. func GetActiveObject(clsid *GUID, iid *GUID) (*IUnknown, error) { return nil, NewError(E_NOTIMPL) } // VariantInit initializes variant. func VariantInit(v *VARIANT) error { return NewError(E_NOTIMPL) } // VariantClear clears value in Variant settings to VT_EMPTY. func VariantClear(v *VARIANT) error { return NewError(E_NOTIMPL) } // SysAllocString allocates memory for string and copies string into memory. func SysAllocString(v string) *int16 { u := int16(0) return &u } // SysAllocStringLen copies up to length of given string returning pointer. func SysAllocStringLen(v string) *int16 { u := int16(0) return &u } // SysFreeString frees string system memory. This must be called with SysAllocString. func SysFreeString(v *int16) error { return NewError(E_NOTIMPL) } // SysStringLen is the length of the system allocated string. func SysStringLen(v *int16) uint32 { return uint32(0) } // CreateStdDispatch provides default IDispatch implementation for IUnknown. // // This handles default IDispatch implementation for objects. It haves a few // limitations with only supporting one language. It will also only return // default exception codes. func CreateStdDispatch(unk *IUnknown, v uintptr, ptinfo *IUnknown) (*IDispatch, error) { return nil, NewError(E_NOTIMPL) } // CreateDispTypeInfo provides default ITypeInfo implementation for IDispatch. // // This will not handle the full implementation of the interface. func CreateDispTypeInfo(idata *INTERFACEDATA) (*IUnknown, error) { return nil, NewError(E_NOTIMPL) } // copyMemory moves location of a block of memory. func copyMemory(dest unsafe.Pointer, src unsafe.Pointer, length uint32) {} // GetUserDefaultLCID retrieves current user default locale. func GetUserDefaultLCID() uint32 { return uint32(0) } // GetMessage in message queue from runtime. // // This function appears to block. PeekMessage does not block. func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (int32, error) { return int32(0), NewError(E_NOTIMPL) } // DispatchMessage to window procedure. func DispatchMessage(msg *Msg) int32 { return int32(0) } func GetVariantDate(value uint64) (time.Time, error) { return time.Now(), NewError(E_NOTIMPL) } golang-github-go-ole-go-ole-1.3.0/com_func_test.go000066400000000000000000000075121510122243200217560ustar00rootroot00000000000000// +build !windows package ole import "testing" // TestComSetupAndShutDown tests that API fails on Linux. func TestComSetupAndShutDown(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() err := coInitialize() if err == nil { t.Error("should be error, because only Windows is supported.") t.FailNow() } CoUninitialize() } // TestComPublicSetupAndShutDown tests that API fails on Linux. func TestComPublicSetupAndShutDown(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() err := CoInitialize(0) if err == nil { t.Error("should be error, because only Windows is supported.") t.FailNow() } CoUninitialize() } // TestComPublicSetupAndShutDown_WithValue tests that API fails on Linux. func TestComPublicSetupAndShutDown_WithValue(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() err := CoInitialize(5) if err == nil { t.Error("should be error, because only Windows is supported.") t.FailNow() } CoUninitialize() } // TestComExSetupAndShutDown tests that API fails on Linux. func TestComExSetupAndShutDown(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() err := coInitializeEx(COINIT_MULTITHREADED) if err == nil { t.Error("should be error, because only Windows is supported.") t.FailNow() } CoUninitialize() } // TestComPublicExSetupAndShutDown tests that API fails on Linux. func TestComPublicExSetupAndShutDown(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() err := CoInitializeEx(0, COINIT_MULTITHREADED) if err == nil { t.Error("should be error, because only Windows is supported.") t.FailNow() } CoUninitialize() } // TestComPublicExSetupAndShutDown_WithValue tests that API fails on Linux. func TestComPublicExSetupAndShutDown_WithValue(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() err := CoInitializeEx(5, COINIT_MULTITHREADED) if err == nil { t.Error("should be error, because only Windows is supported.") t.FailNow() } CoUninitialize() } // TestClsidFromProgID_WindowsMediaNSSManager tests that API fails on Linux. func TestClsidFromProgID_WindowsMediaNSSManager(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() coInitialize() defer CoUninitialize() _, err := CLSIDFromProgID("WMPNSSCI.NSSManager") if err == nil { t.Error("should be error, because only Windows is supported.") t.FailNow() } } // TestClsidFromString_WindowsMediaNSSManager tests that API fails on Linux. func TestClsidFromString_WindowsMediaNSSManager(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() coInitialize() defer CoUninitialize() _, err := CLSIDFromString("{92498132-4D1A-4297-9B78-9E2E4BA99C07}") if err == nil { t.Error("should be error, because only Windows is supported.") t.FailNow() } } // TestCreateInstance_WindowsMediaNSSManager tests that API fails on Linux. func TestCreateInstance_WindowsMediaNSSManager(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() coInitialize() defer CoUninitialize() _, err := CLSIDFromProgID("WMPNSSCI.NSSManager") if err == nil { t.Error("should be error, because only Windows is supported.") t.FailNow() } } // TestError tests that API fails on Linux. func TestError(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() coInitialize() defer CoUninitialize() _, err := CLSIDFromProgID("INTERFACE-NOT-FOUND") if err == nil { t.Error("should be error, because only Windows is supported.") t.FailNow() } switch vt := err.(type) { case *OleError: default: t.Fatalf("should be *ole.OleError %t", vt) } } golang-github-go-ole-go-ole-1.3.0/com_test.go000066400000000000000000000066101510122243200207410ustar00rootroot00000000000000// +build windows package ole import ( "fmt" "testing" ) func TestComSetupAndShutDown(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() err := coInitialize() if err != nil { t.Error(err) t.FailNow() } CoUninitialize() } func TestComPublicSetupAndShutDown(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() err := CoInitialize(0) if err != nil { t.Error(err) t.FailNow() } CoUninitialize() } func TestComPublicSetupAndShutDown_WithValue(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() err := CoInitialize(5) if err != nil { t.Error(err) t.FailNow() } CoUninitialize() } func TestComExSetupAndShutDown(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() err := coInitializeEx(COINIT_MULTITHREADED) if err != nil { t.Error(err) t.FailNow() } CoUninitialize() } func TestComPublicExSetupAndShutDown(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() err := CoInitializeEx(0, COINIT_MULTITHREADED) if err != nil { t.Error(err) t.FailNow() } CoUninitialize() } func TestComPublicExSetupAndShutDown_WithValue(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() err := CoInitializeEx(5, COINIT_MULTITHREADED) if err != nil { t.Error(err) t.FailNow() } CoUninitialize() } func TestClsidFromProgID_WindowsMediaNSSManager(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() expected := &GUID{0x92498132, 0x4D1A, 0x4297, [8]byte{0x9B, 0x78, 0x9E, 0x2E, 0x4B, 0xA9, 0x9C, 0x07}} coInitialize() defer CoUninitialize() actual, err := CLSIDFromProgID("WMPNSSCI.NSSManager") if err == nil { if !IsEqualGUID(expected, actual) { t.Log(err) t.Log(fmt.Sprintf("Actual GUID: %+v\n", actual)) t.Fail() } } } func TestClsidFromString_WindowsMediaNSSManager(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() expected := &GUID{0x92498132, 0x4D1A, 0x4297, [8]byte{0x9B, 0x78, 0x9E, 0x2E, 0x4B, 0xA9, 0x9C, 0x07}} coInitialize() defer CoUninitialize() actual, err := CLSIDFromString("{92498132-4D1A-4297-9B78-9E2E4BA99C07}") if !IsEqualGUID(expected, actual) { t.Log(err) t.Log(fmt.Sprintf("Actual GUID: %+v\n", actual)) t.Fail() } } func TestCreateInstance_WindowsMediaNSSManager(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() expected := &GUID{0x92498132, 0x4D1A, 0x4297, [8]byte{0x9B, 0x78, 0x9E, 0x2E, 0x4B, 0xA9, 0x9C, 0x07}} coInitialize() defer CoUninitialize() actual, err := CLSIDFromProgID("WMPNSSCI.NSSManager") if err == nil { if !IsEqualGUID(expected, actual) { t.Log(err) t.Log(fmt.Sprintf("Actual GUID: %+v\n", actual)) t.Fail() } unknown, err := CreateInstance(actual, IID_IUnknown) if err != nil { t.Log(err) t.Fail() } unknown.Release() } } func TestError(t *testing.T) { defer func() { if r := recover(); r != nil { t.Log(r) t.Fail() } }() coInitialize() defer CoUninitialize() _, err := CLSIDFromProgID("INTERFACE-NOT-FOUND") if err == nil { t.Fatalf("should be fail: %v", err) } switch vt := err.(type) { case *OleError: default: t.Fatalf("should be *ole.OleError %t", vt) } } golang-github-go-ole-go-ole-1.3.0/connect.go000066400000000000000000000104151510122243200205530ustar00rootroot00000000000000package ole // Connection contains IUnknown for fluent interface interaction. // // Deprecated. Use oleutil package instead. type Connection struct { Object *IUnknown // Access COM } // Initialize COM. func (*Connection) Initialize() (err error) { return coInitialize() } // Uninitialize COM. func (*Connection) Uninitialize() { CoUninitialize() } // Create IUnknown object based first on ProgId and then from String. func (c *Connection) Create(progId string) (err error) { var clsid *GUID clsid, err = CLSIDFromProgID(progId) if err != nil { clsid, err = CLSIDFromString(progId) if err != nil { return } } unknown, err := CreateInstance(clsid, IID_IUnknown) if err != nil { return } c.Object = unknown return } // Release IUnknown object. func (c *Connection) Release() { c.Object.Release() } // Load COM object from list of programIDs or strings. func (c *Connection) Load(names ...string) (errors []error) { var tempErrors []error = make([]error, len(names)) var numErrors int = 0 for _, name := range names { err := c.Create(name) if err != nil { tempErrors = append(tempErrors, err) numErrors += 1 continue } break } copy(errors, tempErrors[0:numErrors]) return } // Dispatch returns Dispatch object. func (c *Connection) Dispatch() (object *Dispatch, err error) { dispatch, err := c.Object.QueryInterface(IID_IDispatch) if err != nil { return } object = &Dispatch{dispatch} return } // Dispatch stores IDispatch object. type Dispatch struct { Object *IDispatch // Dispatch object. } // Call method on IDispatch with parameters. func (d *Dispatch) Call(method string, params ...interface{}) (result *VARIANT, err error) { id, err := d.GetId(method) if err != nil { return } result, err = d.Invoke(id, DISPATCH_METHOD, params) return } // MustCall method on IDispatch with parameters. func (d *Dispatch) MustCall(method string, params ...interface{}) (result *VARIANT) { id, err := d.GetId(method) if err != nil { panic(err) } result, err = d.Invoke(id, DISPATCH_METHOD, params) if err != nil { panic(err) } return } // Get property on IDispatch with parameters. func (d *Dispatch) Get(name string, params ...interface{}) (result *VARIANT, err error) { id, err := d.GetId(name) if err != nil { return } result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params) return } // MustGet property on IDispatch with parameters. func (d *Dispatch) MustGet(name string, params ...interface{}) (result *VARIANT) { id, err := d.GetId(name) if err != nil { panic(err) } result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params) if err != nil { panic(err) } return } // Set property on IDispatch with parameters. func (d *Dispatch) Set(name string, params ...interface{}) (result *VARIANT, err error) { id, err := d.GetId(name) if err != nil { return } result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params) return } // MustSet property on IDispatch with parameters. func (d *Dispatch) MustSet(name string, params ...interface{}) (result *VARIANT) { id, err := d.GetId(name) if err != nil { panic(err) } result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params) if err != nil { panic(err) } return } // GetId retrieves ID of name on IDispatch. func (d *Dispatch) GetId(name string) (id int32, err error) { var dispid []int32 dispid, err = d.Object.GetIDsOfName([]string{name}) if err != nil { return } id = dispid[0] return } // GetIds retrieves all IDs of names on IDispatch. func (d *Dispatch) GetIds(names ...string) (dispid []int32, err error) { dispid, err = d.Object.GetIDsOfName(names) return } // Invoke IDispatch on DisplayID of dispatch type with parameters. // // There have been problems where if send cascading params..., it would error // out because the parameters would be empty. func (d *Dispatch) Invoke(id int32, dispatch int16, params []interface{}) (result *VARIANT, err error) { if len(params) < 1 { result, err = d.Object.Invoke(id, dispatch) } else { result, err = d.Object.Invoke(id, dispatch, params...) } return } // Release IDispatch object. func (d *Dispatch) Release() { d.Object.Release() } // Connect initializes COM and attempts to load IUnknown based on given names. func Connect(names ...string) (connection *Connection) { connection.Initialize() connection.Load(names...) return } golang-github-go-ole-go-ole-1.3.0/connect_test.go000066400000000000000000000052411510122243200216130ustar00rootroot00000000000000// +build !windows package ole import "strings" func Example_quickbooks() { var err error connection := &Connection{nil} err = connection.Initialize() if err != nil { return } defer connection.Uninitialize() err = connection.Create("QBXMLRP2.RequestProcessor.1") if err != nil { if err.(*OleError).Code() == CO_E_CLASSSTRING { return } } defer connection.Release() dispatch, err := connection.Dispatch() if err != nil { return } defer dispatch.Release() } func Example_quickbooksConnectHelperCallDispatch() { var err error connection := &Connection{nil} err = connection.Initialize() if err != nil { return } defer connection.Uninitialize() err = connection.Create("QBXMLRP2.RequestProcessor.1") if err != nil { if err.(*OleError).Code() == CO_E_CLASSSTRING { return } return } defer connection.Release() dispatch, err := connection.Dispatch() if err != nil { return } defer dispatch.Release() var result *VARIANT _, err = dispatch.Call("OpenConnection2", "", "Test Application 1", 1) if err != nil { return } result, err = dispatch.Call("BeginSession", "", 2) if err != nil { return } ticket := result.ToString() _, err = dispatch.Call("EndSession", ticket) if err != nil { return } _, err = dispatch.Call("CloseConnection") if err != nil { return } } func Example_quickbooksConnectHelperDispatchProperty() { var err error connection := &Connection{nil} err = connection.Initialize() if err != nil { return } defer connection.Uninitialize() err = connection.Create("QBXMLRP2.RequestProcessor.1") if err != nil { if err.(*OleError).Code() == CO_E_CLASSSTRING { return } return } defer connection.Release() dispatch, err := connection.Dispatch() if err != nil { return } defer dispatch.Release() var result *VARIANT _, err = dispatch.Call("OpenConnection2", "", "Test Application 1", 1) if err != nil { return } result, err = dispatch.Call("BeginSession", "", 2) if err != nil { return } ticket := result.ToString() result, err = dispatch.Get("QBXMLVersionsForSession", ticket) if err != nil { return } conversion := result.ToArray() totalElements, _ := conversion.TotalElements(0) if totalElements != 13 { return } versions := conversion.ToStringArray() expectedVersionString := "1.0, 1.1, 2.0, 2.1, 3.0, 4.0, 4.1, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0" versionString := strings.Join(versions, ", ") if len(versions) != 13 { return } if expectedVersionString != versionString { return } conversion.Release() _, err = dispatch.Call("EndSession", ticket) if err != nil { return } _, err = dispatch.Call("CloseConnection") if err != nil { return } } golang-github-go-ole-go-ole-1.3.0/connect_windows_test.go000066400000000000000000000062411510122243200233660ustar00rootroot00000000000000// +build windows package ole import ( "fmt" "strings" "testing" ) func Example_quickbooks() { var err error connection := &Connection{nil} err = connection.Initialize() if err != nil { return } defer connection.Uninitialize() err = connection.Create("QBXMLRP2.RequestProcessor.1") if err != nil { if err.(*OleError).Code() == CO_E_CLASSSTRING { return } } defer connection.Release() dispatch, err := connection.Dispatch() if err != nil { return } defer dispatch.Release() } func TestConnectHelperCallDispatch_QuickBooks(t *testing.T) { var err error connection := &Connection{nil} err = connection.Initialize() if err != nil { t.Log(err) t.FailNow() } defer connection.Uninitialize() err = connection.Create("QBXMLRP2.RequestProcessor.1") if err != nil { if err.(*OleError).Code() == CO_E_CLASSSTRING { return } t.Log(err) t.FailNow() } defer connection.Release() dispatch, err := connection.Dispatch() if err != nil { t.Log(err) t.FailNow() } defer dispatch.Release() var result *VARIANT _, err = dispatch.Call("OpenConnection2", "", "Test Application 1", 1) if err != nil { t.Log(err) t.FailNow() } result, err = dispatch.Call("BeginSession", "", 2) if err != nil { t.Log(err) t.FailNow() } ticket := result.ToString() _, err = dispatch.Call("EndSession", ticket) if err != nil { t.Log(err) t.Fail() } _, err = dispatch.Call("CloseConnection") if err != nil { t.Log(err) t.Fail() } } func TestConnectHelperDispatchProperty_QuickBooks(t *testing.T) { var err error connection := &Connection{nil} err = connection.Initialize() if err != nil { t.Log(err) t.FailNow() } defer connection.Uninitialize() err = connection.Create("QBXMLRP2.RequestProcessor.1") if err != nil { if err.(*OleError).Code() == CO_E_CLASSSTRING { return } t.Log(err) t.FailNow() } defer connection.Release() dispatch, err := connection.Dispatch() if err != nil { t.Log(err) t.FailNow() } defer dispatch.Release() var result *VARIANT _, err = dispatch.Call("OpenConnection2", "", "Test Application 1", 1) if err != nil { t.Log(err) t.FailNow() } result, err = dispatch.Call("BeginSession", "", 2) if err != nil { t.Log(err) t.FailNow() } ticket := result.ToString() result, err = dispatch.Get("QBXMLVersionsForSession", ticket) if err != nil { t.Log(err) t.FailNow() } conversion := result.ToArray() totalElements, _ := conversion.TotalElements(0) if totalElements != 13 { t.Log(fmt.Sprintf("%d total elements does not equal 13\n", totalElements)) t.Fail() } versions := conversion.ToStringArray() expectedVersionString := "1.0, 1.1, 2.0, 2.1, 3.0, 4.0, 4.1, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0" versionString := strings.Join(versions, ", ") if len(versions) != 13 { t.Log(fmt.Sprintf("%s\n", versionString)) t.Fail() } if expectedVersionString != versionString { t.Log(fmt.Sprintf("Expected: %s\nActual: %s", expectedVersionString, versionString)) t.Fail() } conversion.Release() _, err = dispatch.Call("EndSession", ticket) if err != nil { t.Log(err) t.Fail() } _, err = dispatch.Call("CloseConnection") if err != nil { t.Log(err) t.Fail() } } golang-github-go-ole-go-ole-1.3.0/constants.go000066400000000000000000000070061510122243200211400ustar00rootroot00000000000000package ole const ( CLSCTX_INPROC_SERVER = 1 CLSCTX_INPROC_HANDLER = 2 CLSCTX_LOCAL_SERVER = 4 CLSCTX_INPROC_SERVER16 = 8 CLSCTX_REMOTE_SERVER = 16 CLSCTX_ALL = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER CLSCTX_INPROC = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER CLSCTX_SERVER = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER ) const ( COINIT_APARTMENTTHREADED = 0x2 COINIT_MULTITHREADED = 0x0 COINIT_DISABLE_OLE1DDE = 0x4 COINIT_SPEED_OVER_MEMORY = 0x8 ) const ( DISPATCH_METHOD = 1 DISPATCH_PROPERTYGET = 2 DISPATCH_PROPERTYPUT = 4 DISPATCH_PROPERTYPUTREF = 8 ) 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 CO_E_CLASSSTRING = 0x800401F3 ) const ( CC_FASTCALL = iota CC_CDECL CC_MSCPASCAL CC_PASCAL = CC_MSCPASCAL CC_MACPASCAL CC_STDCALL CC_FPFASTCALL CC_SYSCALL CC_MPWCDECL CC_MPWPASCAL CC_MAX = CC_MPWPASCAL ) type VT uint16 const ( VT_EMPTY VT = 0x0 VT_NULL VT = 0x1 VT_I2 VT = 0x2 VT_I4 VT = 0x3 VT_R4 VT = 0x4 VT_R8 VT = 0x5 VT_CY VT = 0x6 VT_DATE VT = 0x7 VT_BSTR VT = 0x8 VT_DISPATCH VT = 0x9 VT_ERROR VT = 0xa VT_BOOL VT = 0xb VT_VARIANT VT = 0xc VT_UNKNOWN VT = 0xd VT_DECIMAL VT = 0xe VT_I1 VT = 0x10 VT_UI1 VT = 0x11 VT_UI2 VT = 0x12 VT_UI4 VT = 0x13 VT_I8 VT = 0x14 VT_UI8 VT = 0x15 VT_INT VT = 0x16 VT_UINT VT = 0x17 VT_VOID VT = 0x18 VT_HRESULT VT = 0x19 VT_PTR VT = 0x1a VT_SAFEARRAY VT = 0x1b VT_CARRAY VT = 0x1c VT_USERDEFINED VT = 0x1d VT_LPSTR VT = 0x1e VT_LPWSTR VT = 0x1f VT_RECORD VT = 0x24 VT_INT_PTR VT = 0x25 VT_UINT_PTR VT = 0x26 VT_FILETIME VT = 0x40 VT_BLOB VT = 0x41 VT_STREAM VT = 0x42 VT_STORAGE VT = 0x43 VT_STREAMED_OBJECT VT = 0x44 VT_STORED_OBJECT VT = 0x45 VT_BLOB_OBJECT VT = 0x46 VT_CF VT = 0x47 VT_CLSID VT = 0x48 VT_BSTR_BLOB VT = 0xfff VT_VECTOR VT = 0x1000 VT_ARRAY VT = 0x2000 VT_BYREF VT = 0x4000 VT_RESERVED VT = 0x8000 VT_ILLEGAL VT = 0xffff VT_ILLEGALMASKED VT = 0xfff VT_TYPEMASK VT = 0xfff ) const ( DISPID_UNKNOWN = -1 DISPID_VALUE = 0 DISPID_PROPERTYPUT = -3 DISPID_NEWENUM = -4 DISPID_EVALUATE = -5 DISPID_CONSTRUCTOR = -6 DISPID_DESTRUCTOR = -7 DISPID_COLLECT = -8 ) const ( TKIND_ENUM = 1 TKIND_RECORD = 2 TKIND_MODULE = 3 TKIND_INTERFACE = 4 TKIND_DISPATCH = 5 TKIND_COCLASS = 6 TKIND_ALIAS = 7 TKIND_UNION = 8 TKIND_MAX = 9 ) // Safe Array Feature Flags const ( FADF_AUTO = 0x0001 FADF_STATIC = 0x0002 FADF_EMBEDDED = 0x0004 FADF_FIXEDSIZE = 0x0010 FADF_RECORD = 0x0020 FADF_HAVEIID = 0x0040 FADF_HAVEVARTYPE = 0x0080 FADF_BSTR = 0x0100 FADF_UNKNOWN = 0x0200 FADF_DISPATCH = 0x0400 FADF_VARIANT = 0x0800 FADF_RESERVED = 0xF008 ) golang-github-go-ole-go-ole-1.3.0/data/000077500000000000000000000000001510122243200175035ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/data/screenshot.png000066400000000000000000000340321510122243200223700ustar00rootroot00000000000000PNG  IHDR,brsRGBgAMA a cHRMz&u0`:pQ<7IDATx^}yb-ZVD,X%KXJ6v ˒ !!$Bae):7lj7)Ia?.o*v*l &)vmm`wO9sΙuܹ==>;oӳraY,X0uMim4s 曹7 OL3t uVuX]$E/,7.~ stɋ?W7xI.-_C;]ßp(}ë yi(mztĦiKG#6&3}7 _e/yK.ћ/.i5NG71{_NLj0{u'dkKn~Pq_;ޛny[~r7 Ezn۫t?J*-C.-5iKk>k~;72O<,Wraa'z;sǬU l<%d*?`""2Љg?`:f#m^|5E*KZ 4V\}]a.Gkʽ*'KM ݻs߼pUݫ\e:YV`'?WWV|>rW_}-z|ʬp՗`SXs-9c_SB]Bp+,[x+ g7SCg~v㇭wbʃ_oo-̢wOVg|w |X [/k ,3nxbe{޹y7ݲo͖};弃o\΁%c\ezsa UKOUÒl򓲬Ar9,`u5'4i)c_tk?gY8R8`Vp!o9` } A{\N˛G/ue+R(2uNVyO 8 /)f.#-]󁫠 d(%?Zvk< !,}@j{y֭[|`'BVaX$bX 5H攰te%+%s)aSNZW~uOȑȭLzX"F֪KJ%ꃺwVGsSǤS?AGܫ/L,kJ(.<z4é_(TThWzU`:XnW ipkʽ>`' `=ưX:\]?H8>*%OzX,L dd >D~^vH‘7ᩧ/+~p8f}@o? 밆T{Yt~e~>W^*qZg uߴi=w5[$kֽ\N GX,!&^:Xo,BfߞVD#2ɧč$qpPO%Nâh4+`=*蛏<[7 4O-sFde&oĝX_A6LXʀEX dMdod)g,yW#viŻV=a +)I+x[#_ q NܳggNAw0KS5w aA qWpq+S f,i(РsЋT"A}3f4n$w Aⷸ]&PXFIh%Tfx#9b'~3uB $J'9YII5Ȭ:pHy!~4 :}МuT+ U af@~o#G72 a8׬Q* ,|#y3G !z]$B/ 3N/|ƿ9@@Kz ,MpGf؄5 X &$ rhpp O!EI (< A ^F{OgǓ7> }G6d~?&?R(Cc@Kz, e&L ]䍕8֭[%3)PR< P+C`, fXB+|@(JBZifICԡ'#D ?8łegh@X[miq"$Xt͵$oJ^'}P 3N8]bJLS+B;'c Y״!]NVY(EjKמn!gtNdr/I0ds5G=ܺ?(wY*>\ z.T6Øb;S C7FD\*p 7YhKD lmE2I0Z:kݪ&n=G▦ynop2Ug:8%@b?Ya˫] Lϼ :z,!N,e $ˬ܊чxU~‚B*dESp"NG!G=Gy{:;:lF ciZTGմd+0V` ugO V!`Yod!^;p6l %/9cqCC[O zD ]o98._2DxuB\̒͢B: {AٴÊwѱ?^-- 6;%ke˖+ %ZPOq"NG!]|,aVC0d$4!fq&zk 'e6Тanq#l }7_3#MWkQǬ= ̝wL_0%DVa%we2q:Qx XIGk;j@$}bC出BmAB.L!]VkVAWxKQi89KNj`IKV0Y&p Np|pd~?.N1tB .,r3r3\q2Uۨ)OggGǿ(驇ދ`zdbYz,ɠW|q?@‡yiw!'x)St5 SE0qYrth п{X ZKZ{-HwD, 8LZ 07'˜Jedc zT;3YҪ6o@Ŀ0^7'#f!>e4j;ص\<{ZtX2cZ>|V87b*'N51z>OVKJO jr_fU fj8Ƨ9sn?"!Ąx=հN7kgG Kl@'y W(iugČF xŏ^sDl;#w eg>,M+ {'rfP bV,K*5",}< qr:,"gN^IÌ'^BjupeJf4 d$eҪ%!$MqNE.,fp X8/Il:Y~;{uɦKJ{'q;(`VguLqݣVΦiG Qm0h[ a>L*Z|Ԋ=WjȥWud~X`Aڏ:랽i`pgsϪ*Sbkݽ|PU`bBH[V7hU}޵@QWf rH5L AzS%IIh Y)AX)oB`hIJ] Kp-LT ^!S.X- Ž*kXGT<_ b)2zeS0,2`bLӰFk?ZKK`Ua,qP, I^,^vPJ=1O08BXXʕ(.pt%-' Q #;x^$( Yςh}/f G9x@s+0Y5s8L U0fV9 Xp.&Uܪ]UR+p qOݶ' (\ sA}LKC̷Z}\wUõײV[ 3P>*XsdGpsp \AZ!Fp, ?[!}SV,xXIw %>amadYV-,ɝ »ڮC躵1-Vᇧc7o:D0ASkV3X$Ulp5`[^ gv;RA `iK?OTY`/_Q\th?&nq_5.RJf*+Mn1 .Rh2( Aߜr#˲16Y(!T]u'Cƫ@k`q'2|c6,n+jͻߍe K,{5xOCR:qē\rp\2%,SQ' v,E`V`XNqe*oi۱t*NFB~i0A-*z%ւww{kו'5L2%aq.9 n2s^!m #*nz,lbNB@_x%,Å|ځf}ށ hTKZoXU6 gM7ʃAx4A.8pk;6/ƾzTezXXPWСR-E{p>)[aGf,rvVHbS 䱓P*&,ɌanLTR/Z|FܫSLAWVYRh%}G, xBھC<,9" T(?IBEr#,<.#B*hT(RHX@NjU3`!_UXR+M+c HK\ /?  w s9(aa+%oSBEPT*cKB{X(|)!*1l!#GŪPy՘p_,,+\/[Xh,]ul\'s`2i% `Kt.|zCB%DD=,s+X6X>`R UKyL*pM0LxIbSV8[ 4DT T{X ,Kfx O#SBxX]5dUucW8MUN [ʤ+ XX\-ijzTS<|F '{\_*A@] Je:\#V+u9ALY^A@Oz^Ā AA ezXj,uدtY,\DЫYC*]3+KopRp403>(L!?RyRL ,5YV[ Q@&yӅm:GiQ K J3اa^L p,'kM)r~TYlY*V;ųBPKk5֘zyh OT{& IiĶ\k`|z12Qk6X*,/V;,5۪Wz>X,*sP"d5!}&o2zhT4#6Axy}X%h? UE XW!!? !#~$KfuSb+ ,^+!jn|m U5|RK,Ie?yobwCDFu$r] )crU,JI#mۚZ]f P놳-彰&o%“W@ˬpY 2TPgܼd%WjhZ(VRwJhX2kz\INi N U_붇XO}Mf D*bW7cx^Bm XjwL RrLu kJJ^^Qe1 [X `rqU#U<h jG<.{nµ:7:׺])3;a`6,`kk,~Rt*'Υp"v \z)%~uċ',jb=vj(VO#QSsDMggx;#hte(HQt7& }PE/&w ={XrXp`iB-jZEЀ x'au#cm]z[;jg:C{k^wEŔjVJ, XBJz+Sr(_"-/4mIkxJhkX"k۔c5tzVjjN-L7ּVBzzeوXX U H*RXB>]E/0m18Ls6UT2aY_Z;TBAɪneY5hkPתȅfbqS_Y/y΢$;y0>o Aw Rd-Km뎠2owțxhPW",엍, 1Pi:PDz@ۺDD3"]C` W!K+C`UvM̳@ yvӽ2AUBO|˓Ҽk;&LIjh uԧ[qu|)yzZtOw}+/yXɱGW]e:G^.ʜ^HX!OA_(ѮSQw^BHMwTz0}Iui&4o5Z\"ݮGNue@VkF X# ө敨QkDy:S]B]-*\ JwQ{o +{"$FdiE>+8 4].&rRWUjbN[k_u ֝'T`120o"V\mIc^7yŔE^>83B4^q% =a̔xC> A>CKēYìakAyh ;x?+}k6e C=<#bP%5YگP0 [<tGYyQ/XwԹ~J$)#?\]СW-`r CsȐȸkt}f ^3[Cmn'ք3 B}n Y})u ` 0 && (b[n-1] == '\n' || b[n-1] == '\r'); n-- { } return string(utf16.Decode(b[:n])) } golang-github-go-ole-go-ole-1.3.0/go.mod000066400000000000000000000001121510122243200176720ustar00rootroot00000000000000module github.com/go-ole/go-ole go 1.12 require golang.org/x/sys v0.1.0 golang-github-go-ole-go-ole-1.3.0/go.sum000066400000000000000000000002271510122243200177260ustar00rootroot00000000000000golang.org/x/sys v0.1.0 h1:kunALQeHf1/185U1i0GOB/fy1IPRDDpuoOOqRReG57U= golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang-github-go-ole-go-ole-1.3.0/guid.go000066400000000000000000000176741510122243200200700ustar00rootroot00000000000000package ole var ( // IID_NULL is null Interface ID, used when no other Interface ID is known. IID_NULL = NewGUID("{00000000-0000-0000-0000-000000000000}") // IID_IUnknown is for IUnknown interfaces. IID_IUnknown = NewGUID("{00000000-0000-0000-C000-000000000046}") // IID_IDispatch is for IDispatch interfaces. IID_IDispatch = NewGUID("{00020400-0000-0000-C000-000000000046}") // IID_IEnumVariant is for IEnumVariant interfaces IID_IEnumVariant = NewGUID("{00020404-0000-0000-C000-000000000046}") // IID_IConnectionPointContainer is for IConnectionPointContainer interfaces. IID_IConnectionPointContainer = NewGUID("{B196B284-BAB4-101A-B69C-00AA00341D07}") // IID_IConnectionPoint is for IConnectionPoint interfaces. IID_IConnectionPoint = NewGUID("{B196B286-BAB4-101A-B69C-00AA00341D07}") // IID_IInspectable is for IInspectable interfaces. IID_IInspectable = NewGUID("{AF86E2E0-B12D-4C6A-9C5A-D7AA65101E90}") // IID_IProvideClassInfo is for IProvideClassInfo interfaces. IID_IProvideClassInfo = NewGUID("{B196B283-BAB4-101A-B69C-00AA00341D07}") ) // These are for testing and not part of any library. var ( // IID_ICOMTestString is for ICOMTestString interfaces. // // {E0133EB4-C36F-469A-9D3D-C66B84BE19ED} IID_ICOMTestString = NewGUID("{E0133EB4-C36F-469A-9D3D-C66B84BE19ED}") // IID_ICOMTestInt8 is for ICOMTestInt8 interfaces. // // {BEB06610-EB84-4155-AF58-E2BFF53680B4} IID_ICOMTestInt8 = NewGUID("{BEB06610-EB84-4155-AF58-E2BFF53680B4}") // IID_ICOMTestInt16 is for ICOMTestInt16 interfaces. // // {DAA3F9FA-761E-4976-A860-8364CE55F6FC} IID_ICOMTestInt16 = NewGUID("{DAA3F9FA-761E-4976-A860-8364CE55F6FC}") // IID_ICOMTestInt32 is for ICOMTestInt32 interfaces. // // {E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0} IID_ICOMTestInt32 = NewGUID("{E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0}") // IID_ICOMTestInt64 is for ICOMTestInt64 interfaces. // // {8D437CBC-B3ED-485C-BC32-C336432A1623} IID_ICOMTestInt64 = NewGUID("{8D437CBC-B3ED-485C-BC32-C336432A1623}") // IID_ICOMTestFloat is for ICOMTestFloat interfaces. // // {BF1ED004-EA02-456A-AA55-2AC8AC6B054C} IID_ICOMTestFloat = NewGUID("{BF1ED004-EA02-456A-AA55-2AC8AC6B054C}") // IID_ICOMTestDouble is for ICOMTestDouble interfaces. // // {BF908A81-8687-4E93-999F-D86FAB284BA0} IID_ICOMTestDouble = NewGUID("{BF908A81-8687-4E93-999F-D86FAB284BA0}") // IID_ICOMTestBoolean is for ICOMTestBoolean interfaces. // // {D530E7A6-4EE8-40D1-8931-3D63B8605010} IID_ICOMTestBoolean = NewGUID("{D530E7A6-4EE8-40D1-8931-3D63B8605010}") // IID_ICOMEchoTestObject is for ICOMEchoTestObject interfaces. // // {6485B1EF-D780-4834-A4FE-1EBB51746CA3} IID_ICOMEchoTestObject = NewGUID("{6485B1EF-D780-4834-A4FE-1EBB51746CA3}") // IID_ICOMTestTypes is for ICOMTestTypes interfaces. // // {CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0} IID_ICOMTestTypes = NewGUID("{CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0}") // CLSID_COMEchoTestObject is for COMEchoTestObject class. // // {3C24506A-AE9E-4D50-9157-EF317281F1B0} CLSID_COMEchoTestObject = NewGUID("{3C24506A-AE9E-4D50-9157-EF317281F1B0}") // CLSID_COMTestScalarClass is for COMTestScalarClass class. // // {865B85C5-0334-4AC6-9EF6-AACEC8FC5E86} CLSID_COMTestScalarClass = NewGUID("{865B85C5-0334-4AC6-9EF6-AACEC8FC5E86}") ) const hextable = "0123456789ABCDEF" const emptyGUID = "{00000000-0000-0000-0000-000000000000}" // GUID is Windows API specific GUID type. // // This exists to match Windows GUID type for direct passing for COM. // Format is in xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxxx. type GUID struct { Data1 uint32 Data2 uint16 Data3 uint16 Data4 [8]byte } // NewGUID converts the given string into a globally unique identifier that is // compliant with the Windows API. // // The supplied string may be in any of these formats: // // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX // XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX // {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} // // The conversion of the supplied string is not case-sensitive. func NewGUID(guid string) *GUID { d := []byte(guid) var d1, d2, d3, d4a, d4b []byte switch len(d) { case 38: if d[0] != '{' || d[37] != '}' { return nil } d = d[1:37] fallthrough case 36: if d[8] != '-' || d[13] != '-' || d[18] != '-' || d[23] != '-' { return nil } d1 = d[0:8] d2 = d[9:13] d3 = d[14:18] d4a = d[19:23] d4b = d[24:36] case 32: d1 = d[0:8] d2 = d[8:12] d3 = d[12:16] d4a = d[16:20] d4b = d[20:32] default: return nil } var g GUID var ok1, ok2, ok3, ok4 bool g.Data1, ok1 = decodeHexUint32(d1) g.Data2, ok2 = decodeHexUint16(d2) g.Data3, ok3 = decodeHexUint16(d3) g.Data4, ok4 = decodeHexByte64(d4a, d4b) if ok1 && ok2 && ok3 && ok4 { return &g } return nil } func decodeHexUint32(src []byte) (value uint32, ok bool) { var b1, b2, b3, b4 byte var ok1, ok2, ok3, ok4 bool b1, ok1 = decodeHexByte(src[0], src[1]) b2, ok2 = decodeHexByte(src[2], src[3]) b3, ok3 = decodeHexByte(src[4], src[5]) b4, ok4 = decodeHexByte(src[6], src[7]) value = (uint32(b1) << 24) | (uint32(b2) << 16) | (uint32(b3) << 8) | uint32(b4) ok = ok1 && ok2 && ok3 && ok4 return } func decodeHexUint16(src []byte) (value uint16, ok bool) { var b1, b2 byte var ok1, ok2 bool b1, ok1 = decodeHexByte(src[0], src[1]) b2, ok2 = decodeHexByte(src[2], src[3]) value = (uint16(b1) << 8) | uint16(b2) ok = ok1 && ok2 return } func decodeHexByte64(s1 []byte, s2 []byte) (value [8]byte, ok bool) { var ok1, ok2, ok3, ok4, ok5, ok6, ok7, ok8 bool value[0], ok1 = decodeHexByte(s1[0], s1[1]) value[1], ok2 = decodeHexByte(s1[2], s1[3]) value[2], ok3 = decodeHexByte(s2[0], s2[1]) value[3], ok4 = decodeHexByte(s2[2], s2[3]) value[4], ok5 = decodeHexByte(s2[4], s2[5]) value[5], ok6 = decodeHexByte(s2[6], s2[7]) value[6], ok7 = decodeHexByte(s2[8], s2[9]) value[7], ok8 = decodeHexByte(s2[10], s2[11]) ok = ok1 && ok2 && ok3 && ok4 && ok5 && ok6 && ok7 && ok8 return } func decodeHexByte(c1, c2 byte) (value byte, ok bool) { var n1, n2 byte var ok1, ok2 bool n1, ok1 = decodeHexChar(c1) n2, ok2 = decodeHexChar(c2) value = (n1 << 4) | n2 ok = ok1 && ok2 return } func decodeHexChar(c byte) (byte, bool) { switch { case '0' <= c && c <= '9': return c - '0', true case 'a' <= c && c <= 'f': return c - 'a' + 10, true case 'A' <= c && c <= 'F': return c - 'A' + 10, true } return 0, false } // String converts the GUID to string form. It will adhere to this pattern: // // {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} // // If the GUID is nil, the string representation of an empty GUID is returned: // // {00000000-0000-0000-0000-000000000000} func (guid *GUID) String() string { if guid == nil { return emptyGUID } var c [38]byte c[0] = '{' putUint32Hex(c[1:9], guid.Data1) c[9] = '-' putUint16Hex(c[10:14], guid.Data2) c[14] = '-' putUint16Hex(c[15:19], guid.Data3) c[19] = '-' putByteHex(c[20:24], guid.Data4[0:2]) c[24] = '-' putByteHex(c[25:37], guid.Data4[2:8]) c[37] = '}' return string(c[:]) } func putUint32Hex(b []byte, v uint32) { b[0] = hextable[byte(v>>24)>>4] b[1] = hextable[byte(v>>24)&0x0f] b[2] = hextable[byte(v>>16)>>4] b[3] = hextable[byte(v>>16)&0x0f] b[4] = hextable[byte(v>>8)>>4] b[5] = hextable[byte(v>>8)&0x0f] b[6] = hextable[byte(v)>>4] b[7] = hextable[byte(v)&0x0f] } func putUint16Hex(b []byte, v uint16) { b[0] = hextable[byte(v>>8)>>4] b[1] = hextable[byte(v>>8)&0x0f] b[2] = hextable[byte(v)>>4] b[3] = hextable[byte(v)&0x0f] } func putByteHex(dst, src []byte) { for i := 0; i < len(src); i++ { dst[i*2] = hextable[src[i]>>4] dst[i*2+1] = hextable[src[i]&0x0f] } } // IsEqualGUID compares two GUID. // // Not constant time comparison. func IsEqualGUID(guid1 *GUID, guid2 *GUID) bool { return guid1.Data1 == guid2.Data1 && guid1.Data2 == guid2.Data2 && guid1.Data3 == guid2.Data3 && guid1.Data4[0] == guid2.Data4[0] && guid1.Data4[1] == guid2.Data4[1] && guid1.Data4[2] == guid2.Data4[2] && guid1.Data4[3] == guid2.Data4[3] && guid1.Data4[4] == guid2.Data4[4] && guid1.Data4[5] == guid2.Data4[5] && guid1.Data4[6] == guid2.Data4[6] && guid1.Data4[7] == guid2.Data4[7] } golang-github-go-ole-go-ole-1.3.0/guid_test.go000066400000000000000000000141431510122243200211130ustar00rootroot00000000000000package ole import ( "strings" "testing" ) var guidFixtures = []struct { Name string S string G *GUID ShouldMatch bool }{ {"NULL", "{00000000-0000-0000-0000-000000000000}", &GUID{0x00000000, 0x0000, 0x0000, [8]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, true}, {"IUnknown", "{00000000-0000-0000-C000-000000000046}", &GUID{0x00000000, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}, true}, {"IDispatch", "{00020400-0000-0000-C000-000000000046}", &GUID{0x00020400, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}, true}, {"IEnumVariant", "{00020404-0000-0000-C000-000000000046}", &GUID{0x00020404, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}, true}, {"IConnectionPointContainer", "{B196B284-BAB4-101A-B69C-00AA00341D07}", &GUID{0xB196B284, 0xBAB4, 0x101A, [8]byte{0xB6, 0x9C, 0x00, 0xAA, 0x00, 0x34, 0x1D, 0x07}}, true}, {"IConnectionPoint", "{B196B286-BAB4-101A-B69C-00AA00341D07}", &GUID{0xB196B286, 0xBAB4, 0x101A, [8]byte{0xB6, 0x9C, 0x00, 0xAA, 0x00, 0x34, 0x1D, 0x07}}, true}, {"IInspectable", "{AF86E2E0-B12D-4C6A-9C5A-D7AA65101E90}", &GUID{0xaf86e2e0, 0xb12d, 0x4c6a, [8]byte{0x9c, 0x5a, 0xd7, 0xaa, 0x65, 0x10, 0x1e, 0x90}}, true}, {"IProvideClassInfo", "{B196B283-BAB4-101A-B69C-00AA00341D07}", &GUID{0xb196b283, 0xbab4, 0x101a, [8]byte{0xB6, 0x9C, 0x00, 0xAA, 0x00, 0x34, 0x1D, 0x07}}, true}, {"ICOMTestInt64", "{8D437CBC-B3ED-485C-BC32-C336432A1623}", &GUID{0x8d437cbc, 0xb3ed, 0x485c, [8]byte{0xbc, 0x32, 0xc3, 0x36, 0x43, 0x2a, 0x16, 0x23}}, true}, {"Pattern1", "{10000000-1000-1000-1000-100000000000}", &GUID{0x10000000, 0x1000, 0x1000, [8]byte{0x10, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00}}, true}, {"Pattern2", "{01000000-0100-0100-0100-010000000000}", &GUID{0x01000000, 0x0100, 0x0100, [8]byte{0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}}, true}, {"Pattern3", "{00100000-0010-0010-0010-001000000000}", &GUID{0x00100000, 0x0010, 0x0010, [8]byte{0x00, 0x10, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00}}, true}, {"Pattern4", "{00010000-0001-0001-0001-000100000000}", &GUID{0x00010000, 0x0001, 0x0001, [8]byte{0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}}, true}, {"Pattern5", "{a000a000-a000-a000-a000-a000a000a000}", &GUID{0xa000a000, 0xa000, 0xa000, [8]byte{0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00}}, true}, {"Pattern6", "{0aaa0aaa-0aaa-0aaa-0aaa-0aaa0aaa0aaa}", &GUID{0x0aaa0aaa, 0x0aaa, 0x0aaa, [8]byte{0x0a, 0xaa, 0x0a, 0xaa, 0x0a, 0xaa, 0x0a, 0xaa}}, true}, {"Sequence1", "{12345678-1234-1234-1234-123456789abc}", &GUID{0x12345678, 0x1234, 0x1234, [8]byte{0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc}}, true}, {"Sequence2", "12345678-1234-1234-1234-123456789abc", &GUID{0x12345678, 0x1234, 0x1234, [8]byte{0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc}}, false}, {"Sequence3", "12345678123412341234123456789abc", &GUID{0x12345678, 0x1234, 0x1234, [8]byte{0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc}}, false}, {"CaseUpper1", "{ABCDEFAB-ABCD-ABCD-ABCD-ABCDEFABCDEF}", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, true}, {"CaseUpper2", "ABCDEFAB-ABCD-ABCD-ABCD-ABCDEFABCDEF", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, false}, {"CaseUpper3", "ABCDEFABABCDABCDABCDABCDEFABCDEF", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, false}, {"CaseLower1", "{abcdefab-abcd-abcd-abcd-abcdefabcdef}", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, true}, {"CaseLower2", "abcdefab-abcd-abcd-abcd-abcdefabcdef", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, false}, {"CaseLower3", "abcdefababcdabcdabcdabcdefabcdef", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, false}, {"CaseMixed1", "{AbCdEfAb-AbCd-AbCd-AbCd-AbCdEfAbCdEf}", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, true}, {"CaseMixed2", "{fEdCbAfE-fEdC-fEdC-fEdC-fEdCbAfEdCbA}", &GUID{0xfedcbafe, 0xfedc, 0xfedc, [8]byte{0xfe, 0xdc, 0xfe, 0xdc, 0xba, 0xfe, 0xdc, 0xba}}, true}, {"Empty", "", nil, false}, {"EmptyBrackets", "{}", nil, false}, {"GarbageDash1", "----", nil, false}, {"GarbageDash2", "------------------------------------", nil, false}, {"GarbageDash3", "{------------------------------------}", nil, false}, {"GarbagePadding1", " {abcdefab-abcd-abcd-abcd-abcdefabcdef}", nil, false}, {"GarbagePadding2", "{abcdefab-abcd-abcd-abcd-abcdefabcdef} ", nil, false}, {"GarbagePadding3", " abcdefab-abcd-abcd-abcd-abcdefabcdef", nil, false}, {"GarbagePadding4", "abcdefab-abcd-abcd-abcd-abcdefabcdef ", nil, false}, {"GarbagePadding5", " abcdefababcdabcdabcdabcdefabcdef", nil, false}, {"GarbagePadding6", "abcdefababcdabcdabcdabcdefabcdef ", nil, false}, {"Garbage1", "AFR*@)#$BNHRO*IABNFVaaa", nil, false}, {"Garbage2", "#@*%@#&^%382765*@^#*&^%R*@&#%R7632", nil, false}, {"Garbage3", "#@*%@#&^%382765*@^#*&^%R*@&#%R76377^2", nil, false}, {"Garbage4", "{ABCDEFA*-ABCD-ABCD-ABCD-ABCDEFABCDEF}", nil, false}, {"Garbage5", "{gggggggg-ABCD-ABCD-ABCD-ABCDEFABCDEF}", nil, false}, } // TestGUID tests both NewGUID and GUID.String. func TestGUID(t *testing.T) { for i := 0; i < len(guidFixtures); i++ { guid := NewGUID(guidFixtures[i].S) f := guidFixtures[i] if guid == nil { if f.G != nil { t.Errorf("GUID test \"%v\" (%v of %v) failed. Expected %v from NewGUID. Received instead.", f.Name, i, len(guidFixtures), f.G) } } else if f.G == nil { t.Errorf("GUID test \"%v\" (%v of %v) failed. Expected from NewGUID. Received %v instead.", f.Name, i, len(guidFixtures), guid) } if guid == nil || f.G == nil { continue } if !IsEqualGUID(guid, f.G) { t.Errorf("GUID test \"%v\" (%v of %v) failed. Expected %v from NewGUID. Received %v instead.", f.Name, i, len(guidFixtures), f.G, guid) } if f.ShouldMatch && guid.String() != strings.ToUpper(f.S) { t.Errorf("GUID test \"%v\" (%v of %v) failed. Expected \"%v\" from GUID.String. Received \"%v\" instead.", f.Name, i, len(guidFixtures), strings.ToUpper(f.S), guid) } } } golang-github-go-ole-go-ole-1.3.0/iconnectionpoint.go000066400000000000000000000006621510122243200225070ustar00rootroot00000000000000package ole import "unsafe" type IConnectionPoint struct { IUnknown } type IConnectionPointVtbl struct { IUnknownVtbl GetConnectionInterface uintptr GetConnectionPointContainer uintptr Advise uintptr Unadvise uintptr EnumConnections uintptr } func (v *IConnectionPoint) VTable() *IConnectionPointVtbl { return (*IConnectionPointVtbl)(unsafe.Pointer(v.RawVTable)) } golang-github-go-ole-go-ole-1.3.0/iconnectionpoint_func.go000066400000000000000000000007021510122243200235150ustar00rootroot00000000000000// +build !windows package ole import "unsafe" func (v *IConnectionPoint) GetConnectionInterface(piid **GUID) int32 { return int32(0) } func (v *IConnectionPoint) Advise(unknown *IUnknown) (uint32, error) { return uint32(0), NewError(E_NOTIMPL) } func (v *IConnectionPoint) Unadvise(cookie uint32) error { return NewError(E_NOTIMPL) } func (v *IConnectionPoint) EnumConnections(p *unsafe.Pointer) (err error) { return NewError(E_NOTIMPL) } golang-github-go-ole-go-ole-1.3.0/iconnectionpoint_windows.go000066400000000000000000000015401510122243200242550ustar00rootroot00000000000000// +build windows package ole import ( "syscall" "unsafe" ) func (v *IConnectionPoint) GetConnectionInterface(piid **GUID) int32 { // XXX: This doesn't look like it does what it's supposed to return release((*IUnknown)(unsafe.Pointer(v))) } func (v *IConnectionPoint) Advise(unknown *IUnknown) (cookie uint32, err error) { hr, _, _ := syscall.Syscall( v.VTable().Advise, 3, uintptr(unsafe.Pointer(v)), uintptr(unsafe.Pointer(unknown)), uintptr(unsafe.Pointer(&cookie))) if hr != 0 { err = NewError(hr) } return } func (v *IConnectionPoint) Unadvise(cookie uint32) (err error) { hr, _, _ := syscall.Syscall( v.VTable().Unadvise, 2, uintptr(unsafe.Pointer(v)), uintptr(cookie), 0) if hr != 0 { err = NewError(hr) } return } func (v *IConnectionPoint) EnumConnections(p *unsafe.Pointer) error { return NewError(E_NOTIMPL) } golang-github-go-ole-go-ole-1.3.0/iconnectionpointcontainer.go000066400000000000000000000005421510122243200244070ustar00rootroot00000000000000package ole import "unsafe" type IConnectionPointContainer struct { IUnknown } type IConnectionPointContainerVtbl struct { IUnknownVtbl EnumConnectionPoints uintptr FindConnectionPoint uintptr } func (v *IConnectionPointContainer) VTable() *IConnectionPointContainerVtbl { return (*IConnectionPointContainerVtbl)(unsafe.Pointer(v.RawVTable)) } golang-github-go-ole-go-ole-1.3.0/iconnectionpointcontainer_func.go000066400000000000000000000004301510122243200254160ustar00rootroot00000000000000// +build !windows package ole func (v *IConnectionPointContainer) EnumConnectionPoints(points interface{}) error { return NewError(E_NOTIMPL) } func (v *IConnectionPointContainer) FindConnectionPoint(iid *GUID, point **IConnectionPoint) error { return NewError(E_NOTIMPL) } golang-github-go-ole-go-ole-1.3.0/iconnectionpointcontainer_windows.go000066400000000000000000000007651510122243200261700ustar00rootroot00000000000000// +build windows package ole import ( "syscall" "unsafe" ) func (v *IConnectionPointContainer) EnumConnectionPoints(points interface{}) error { return NewError(E_NOTIMPL) } func (v *IConnectionPointContainer) FindConnectionPoint(iid *GUID, point **IConnectionPoint) (err error) { hr, _, _ := syscall.Syscall( v.VTable().FindConnectionPoint, 3, uintptr(unsafe.Pointer(v)), uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(point))) if hr != 0 { err = NewError(hr) } return } golang-github-go-ole-go-ole-1.3.0/idispatch.go000066400000000000000000000056441510122243200211020ustar00rootroot00000000000000package ole import "unsafe" type IDispatch struct { IUnknown } type IDispatchVtbl struct { IUnknownVtbl GetTypeInfoCount uintptr GetTypeInfo uintptr GetIDsOfNames uintptr Invoke uintptr } func (v *IDispatch) VTable() *IDispatchVtbl { return (*IDispatchVtbl)(unsafe.Pointer(v.RawVTable)) } func (v *IDispatch) GetIDsOfName(names []string) (dispid []int32, err error) { dispid, err = getIDsOfName(v, names) return } func (v *IDispatch) Invoke(dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) { result, err = invoke(v, dispid, dispatch, params...) return } func (v *IDispatch) GetTypeInfoCount() (c uint32, err error) { c, err = getTypeInfoCount(v) return } func (v *IDispatch) GetTypeInfo() (tinfo *ITypeInfo, err error) { tinfo, err = getTypeInfo(v) return } // GetSingleIDOfName is a helper that returns single display ID for IDispatch name. // // This replaces the common pattern of attempting to get a single name from the list of available // IDs. It gives the first ID, if it is available. func (v *IDispatch) GetSingleIDOfName(name string) (displayID int32, err error) { var displayIDs []int32 displayIDs, err = v.GetIDsOfName([]string{name}) if err != nil { return } displayID = displayIDs[0] return } // InvokeWithOptionalArgs accepts arguments as an array, works like Invoke. // // Accepts name and will attempt to retrieve Display ID to pass to Invoke. // // Passing params as an array is a workaround that could be fixed in later versions of Go that // prevent passing empty params. During testing it was discovered that this is an acceptable way of // getting around not being able to pass params normally. func (v *IDispatch) InvokeWithOptionalArgs(name string, dispatch int16, params []interface{}) (result *VARIANT, err error) { displayID, err := v.GetSingleIDOfName(name) if err != nil { return } if len(params) < 1 { result, err = v.Invoke(displayID, dispatch) } else { result, err = v.Invoke(displayID, dispatch, params...) } return } // CallMethod invokes named function with arguments on object. func (v *IDispatch) CallMethod(name string, params ...interface{}) (*VARIANT, error) { return v.InvokeWithOptionalArgs(name, DISPATCH_METHOD, params) } // GetProperty retrieves the property with the name with the ability to pass arguments. // // Most of the time you will not need to pass arguments as most objects do not allow for this // feature. Or at least, should not allow for this feature. Some servers don't follow best practices // and this is provided for those edge cases. func (v *IDispatch) GetProperty(name string, params ...interface{}) (*VARIANT, error) { return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYGET, params) } // PutProperty attempts to mutate a property in the object. func (v *IDispatch) PutProperty(name string, params ...interface{}) (*VARIANT, error) { return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYPUT, params) } golang-github-go-ole-go-ole-1.3.0/idispatch_func.go000066400000000000000000000007311510122243200221050ustar00rootroot00000000000000// +build !windows package ole func getIDsOfName(disp *IDispatch, names []string) ([]int32, error) { return []int32{}, NewError(E_NOTIMPL) } func getTypeInfoCount(disp *IDispatch) (uint32, error) { return uint32(0), NewError(E_NOTIMPL) } func getTypeInfo(disp *IDispatch) (*ITypeInfo, error) { return nil, NewError(E_NOTIMPL) } func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (*VARIANT, error) { return nil, NewError(E_NOTIMPL) } golang-github-go-ole-go-ole-1.3.0/idispatch_windows.go000066400000000000000000000147661510122243200226610ustar00rootroot00000000000000//go:build windows // +build windows package ole import ( "math/big" "syscall" "time" "unsafe" ) func getIDsOfName(disp *IDispatch, names []string) (dispid []int32, err error) { wnames := make([]*uint16, len(names)) for i := 0; i < len(names); i++ { wnames[i] = syscall.StringToUTF16Ptr(names[i]) } dispid = make([]int32, len(names)) namelen := uint32(len(names)) hr, _, _ := syscall.Syscall6( disp.VTable().GetIDsOfNames, 6, uintptr(unsafe.Pointer(disp)), uintptr(unsafe.Pointer(IID_NULL)), uintptr(unsafe.Pointer(&wnames[0])), uintptr(namelen), uintptr(GetUserDefaultLCID()), uintptr(unsafe.Pointer(&dispid[0]))) if hr != 0 { err = NewError(hr) } return } func getTypeInfoCount(disp *IDispatch) (c uint32, err error) { hr, _, _ := syscall.Syscall( disp.VTable().GetTypeInfoCount, 2, uintptr(unsafe.Pointer(disp)), uintptr(unsafe.Pointer(&c)), 0) if hr != 0 { err = NewError(hr) } return } func getTypeInfo(disp *IDispatch) (tinfo *ITypeInfo, err error) { hr, _, _ := syscall.Syscall( disp.VTable().GetTypeInfo, 3, uintptr(unsafe.Pointer(disp)), uintptr(GetUserDefaultLCID()), uintptr(unsafe.Pointer(&tinfo))) if hr != 0 { err = NewError(hr) } return } func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) { var dispparams DISPPARAMS if dispatch&DISPATCH_PROPERTYPUT != 0 { dispnames := [1]int32{DISPID_PROPERTYPUT} dispparams.rgdispidNamedArgs = uintptr(unsafe.Pointer(&dispnames[0])) dispparams.cNamedArgs = 1 } else if dispatch&DISPATCH_PROPERTYPUTREF != 0 { dispnames := [1]int32{DISPID_PROPERTYPUT} dispparams.rgdispidNamedArgs = uintptr(unsafe.Pointer(&dispnames[0])) dispparams.cNamedArgs = 1 } var vargs []VARIANT if len(params) > 0 { vargs = make([]VARIANT, len(params)) for i, v := range params { //n := len(params)-i-1 n := len(params) - i - 1 VariantInit(&vargs[n]) switch vv := v.(type) { case bool: if vv { vargs[n] = NewVariant(VT_BOOL, 0xffff) } else { vargs[n] = NewVariant(VT_BOOL, 0) } case *bool: vargs[n] = NewVariant(VT_BOOL|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*bool))))) case uint8: vargs[n] = NewVariant(VT_I1, int64(v.(uint8))) case *uint8: vargs[n] = NewVariant(VT_I1|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint8))))) case int8: vargs[n] = NewVariant(VT_I1, int64(v.(int8))) case *int8: vargs[n] = NewVariant(VT_I1|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int8))))) case int16: vargs[n] = NewVariant(VT_I2, int64(v.(int16))) case *int16: vargs[n] = NewVariant(VT_I2|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int16))))) case uint16: vargs[n] = NewVariant(VT_UI2, int64(v.(uint16))) case *uint16: vargs[n] = NewVariant(VT_UI2|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint16))))) case int32: vargs[n] = NewVariant(VT_I4, int64(v.(int32))) case *int32: vargs[n] = NewVariant(VT_I4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int32))))) case uint32: vargs[n] = NewVariant(VT_UI4, int64(v.(uint32))) case *uint32: vargs[n] = NewVariant(VT_UI4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint32))))) case int64: vargs[n] = NewVariant(VT_I8, int64(v.(int64))) case *int64: vargs[n] = NewVariant(VT_I8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int64))))) case uint64: vargs[n] = NewVariant(VT_UI8, int64(uintptr(v.(uint64)))) case *uint64: vargs[n] = NewVariant(VT_UI8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint64))))) case int: vargs[n] = NewVariant(VT_I4, int64(v.(int))) case *int: vargs[n] = NewVariant(VT_I4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int))))) case uint: vargs[n] = NewVariant(VT_UI4, int64(v.(uint))) case *uint: vargs[n] = NewVariant(VT_UI4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint))))) case float32: vargs[n] = NewVariant(VT_R4, *(*int64)(unsafe.Pointer(&vv))) case *float32: vargs[n] = NewVariant(VT_R4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*float32))))) case float64: vargs[n] = NewVariant(VT_R8, *(*int64)(unsafe.Pointer(&vv))) case *float64: vargs[n] = NewVariant(VT_R8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*float64))))) case *big.Int: vargs[n] = NewVariant(VT_DECIMAL, v.(*big.Int).Int64()) case string: vargs[n] = NewVariant(VT_BSTR, int64(uintptr(unsafe.Pointer(SysAllocStringLen(v.(string)))))) case *string: vargs[n] = NewVariant(VT_BSTR|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*string))))) case time.Time: s := vv.Format("2006-01-02 15:04:05") vargs[n] = NewVariant(VT_BSTR, int64(uintptr(unsafe.Pointer(SysAllocStringLen(s))))) case *time.Time: s := vv.Format("2006-01-02 15:04:05") vargs[n] = NewVariant(VT_BSTR|VT_BYREF, int64(uintptr(unsafe.Pointer(&s)))) case *IDispatch: vargs[n] = NewVariant(VT_DISPATCH, int64(uintptr(unsafe.Pointer(v.(*IDispatch))))) case **IDispatch: vargs[n] = NewVariant(VT_DISPATCH|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(**IDispatch))))) case nil: vargs[n] = NewVariant(VT_NULL, 0) case *VARIANT: vargs[n] = NewVariant(VT_VARIANT|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*VARIANT))))) case []byte: safeByteArray := safeArrayFromByteSlice(v.([]byte)) vargs[n] = NewVariant(VT_ARRAY|VT_UI1, int64(uintptr(unsafe.Pointer(safeByteArray)))) defer VariantClear(&vargs[n]) case []string: safeByteArray := safeArrayFromStringSlice(v.([]string)) vargs[n] = NewVariant(VT_ARRAY|VT_BSTR, int64(uintptr(unsafe.Pointer(safeByteArray)))) defer VariantClear(&vargs[n]) default: panic("unknown type") } } dispparams.rgvarg = uintptr(unsafe.Pointer(&vargs[0])) dispparams.cArgs = uint32(len(params)) } result = new(VARIANT) var excepInfo EXCEPINFO VariantInit(result) hr, _, _ := syscall.Syscall9( disp.VTable().Invoke, 9, uintptr(unsafe.Pointer(disp)), uintptr(dispid), uintptr(unsafe.Pointer(IID_NULL)), uintptr(GetUserDefaultLCID()), uintptr(dispatch), uintptr(unsafe.Pointer(&dispparams)), uintptr(unsafe.Pointer(result)), uintptr(unsafe.Pointer(&excepInfo)), 0) if hr != 0 { excepInfo.renderStrings() excepInfo.Clear() err = NewErrorWithSubError(hr, excepInfo.description, excepInfo) } for i, varg := range vargs { n := len(params) - i - 1 if varg.VT == VT_BSTR && varg.Val != 0 { SysFreeString(((*int16)(unsafe.Pointer(uintptr(varg.Val))))) } if varg.VT == (VT_BSTR|VT_BYREF) && varg.Val != 0 { *(params[n].(*string)) = LpOleStrToString(*(**uint16)(unsafe.Pointer(uintptr(varg.Val)))) } } return } golang-github-go-ole-go-ole-1.3.0/idispatch_windows_test.go000066400000000000000000000435001510122243200237040ustar00rootroot00000000000000// +build windows package ole import "testing" func wrapCOMExecute(t *testing.T, callback func(*testing.T)) { defer func() { if r := recover(); r != nil { t.Error(r) } }() err := CoInitialize(0) if err != nil { t.Fatal(err) } defer CoUninitialize() callback(t) } func wrapDispatch(t *testing.T, ClassID, UnknownInterfaceID, DispatchInterfaceID *GUID, callback func(*testing.T, *IUnknown, *IDispatch)) { var unknown *IUnknown var dispatch *IDispatch var err error unknown, err = CreateInstance(ClassID, UnknownInterfaceID) if err != nil { t.Error(err) return } defer unknown.Release() dispatch, err = unknown.QueryInterface(DispatchInterfaceID) if err != nil { t.Error(err) return } defer dispatch.Release() callback(t, unknown, dispatch) } func wrapGoOLETestCOMServerEcho(t *testing.T, callback func(*testing.T, *IUnknown, *IDispatch)) { wrapCOMExecute(t, func(t *testing.T) { wrapDispatch(t, CLSID_COMEchoTestObject, IID_IUnknown, IID_ICOMEchoTestObject, callback) }) } func wrapGoOLETestCOMServerScalar(t *testing.T, callback func(*testing.T, *IUnknown, *IDispatch)) { wrapCOMExecute(t, func(t *testing.T) { wrapDispatch(t, CLSID_COMTestScalarClass, IID_IUnknown, IID_ICOMTestTypes, callback) }) } func TestIDispatch_goolecomserver_stringfield(t *testing.T) { wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "StringField" expected := "Test String" _, err := idispatch.PutProperty(method, expected) if err != nil { t.Error(err) return } variant, err := idispatch.GetProperty(method) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(string) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "string", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_int8field(t *testing.T) { wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "Int8Field" expected := int8(2) _, err := idispatch.PutProperty(method, expected) if err != nil { t.Error(err) return } variant, err := idispatch.GetProperty(method) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(int8) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int8", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_uint8field(t *testing.T) { wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "UInt8Field" expected := uint8(4) _, err := idispatch.PutProperty(method, expected) if err != nil { t.Error(err) return } variant, err := idispatch.GetProperty(method) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(uint8) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint8", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_int16field(t *testing.T) { wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "Int16Field" expected := int16(4) _, err := idispatch.PutProperty(method, expected) if err != nil { t.Error(err) return } variant, err := idispatch.GetProperty(method) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(int16) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int16", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_uint16field(t *testing.T) { wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "UInt16Field" expected := uint16(4) _, err := idispatch.PutProperty(method, expected) if err != nil { t.Error(err) return } variant, err := idispatch.GetProperty(method) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(uint16) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint16", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_int32field(t *testing.T) { wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "Int32Field" expected := int32(8) _, err := idispatch.PutProperty(method, expected) if err != nil { t.Error(err) return } variant, err := idispatch.GetProperty(method) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(int32) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int32", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_uint32field(t *testing.T) { wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "UInt32Field" expected := uint32(16) _, err := idispatch.PutProperty(method, expected) if err != nil { t.Error(err) return } variant, err := idispatch.GetProperty(method) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(uint32) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint32", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_int64field(t *testing.T) { wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "Int64Field" expected := int64(32) _, err := idispatch.PutProperty(method, expected) if err != nil { t.Error(err) return } variant, err := idispatch.GetProperty(method) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(int64) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int64", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_uint64field(t *testing.T) { wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "UInt64Field" expected := uint64(64) _, err := idispatch.PutProperty(method, expected) if err != nil { t.Error(err) return } variant, err := idispatch.GetProperty(method) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(uint64) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint64", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_booleanfield_true(t *testing.T) { wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "BooleanField" expected := true _, err := idispatch.PutProperty(method, expected) if err != nil { t.Error(err) return } variant, err := idispatch.GetProperty(method) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(bool) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "bool", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_booleanfield_false(t *testing.T) { wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "BooleanField" expected := false _, err := idispatch.PutProperty(method, expected) if err != nil { t.Error(err) return } variant, err := idispatch.GetProperty(method) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(bool) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "bool", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_float32field(t *testing.T) { wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "Float32Field" expected := float32(2.2) _, err := idispatch.PutProperty(method, expected) if err != nil { t.Error(err) } variant, err := idispatch.GetProperty(method) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(float32) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "float32", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_float64field(t *testing.T) { wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "Float64Field" expected := float64(4.4) _, err := idispatch.PutProperty(method, expected) if err != nil { t.Error(err) } variant, err := idispatch.GetProperty(method) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(float64) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "float64", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_echostring(t *testing.T) { wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "EchoString" expected := "Test String" variant, err := idispatch.CallMethod(method, expected) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(string) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "string", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_echoboolean(t *testing.T) { wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "EchoBoolean" expected := true variant, err := idispatch.CallMethod(method, expected) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(bool) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "bool", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_echoint8(t *testing.T) { wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "EchoInt8" expected := int8(1) variant, err := idispatch.CallMethod(method, expected) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(int8) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int8", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_echouint8(t *testing.T) { wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "EchoUInt8" expected := uint8(1) variant, err := idispatch.CallMethod(method, expected) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(uint8) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint8", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_echoint16(t *testing.T) { wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "EchoInt16" expected := int16(1) variant, err := idispatch.CallMethod(method, expected) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(int16) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int16", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_echouint16(t *testing.T) { wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "EchoUInt16" expected := uint16(1) variant, err := idispatch.CallMethod(method, expected) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(uint16) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint16", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_echoint32(t *testing.T) { wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "EchoInt32" expected := int32(2) variant, err := idispatch.CallMethod(method, expected) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(int32) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int32", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_echouint32(t *testing.T) { wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "EchoUInt32" expected := uint32(4) variant, err := idispatch.CallMethod(method, expected) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(uint32) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint32", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_echoint64(t *testing.T) { wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "EchoInt64" expected := int64(1) variant, err := idispatch.CallMethod(method, expected) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(int64) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int64", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_echouint64(t *testing.T) { wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "EchoUInt64" expected := uint64(1) variant, err := idispatch.CallMethod(method, expected) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(uint64) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint64", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_echofloat32(t *testing.T) { wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "EchoFloat32" expected := float32(2.2) variant, err := idispatch.CallMethod(method, expected) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(float32) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "float32", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } func TestIDispatch_goolecomserver_echofloat64(t *testing.T) { wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) { method := "EchoFloat64" expected := float64(2.2) variant, err := idispatch.CallMethod(method, expected) if err != nil { t.Error(err) return } defer variant.Clear() actual, passed := variant.Value().(float64) if !passed { t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "float64", variant.VT, variant.Val) return } if actual != expected { t.Errorf("%s() expected %v did not match %v", method, expected, actual) } }) } golang-github-go-ole-go-ole-1.3.0/ienumvariant.go000066400000000000000000000004411510122243200216220ustar00rootroot00000000000000package ole import "unsafe" type IEnumVARIANT struct { IUnknown } type IEnumVARIANTVtbl struct { IUnknownVtbl Next uintptr Skip uintptr Reset uintptr Clone uintptr } func (v *IEnumVARIANT) VTable() *IEnumVARIANTVtbl { return (*IEnumVARIANTVtbl)(unsafe.Pointer(v.RawVTable)) } golang-github-go-ole-go-ole-1.3.0/ienumvariant_func.go000066400000000000000000000006351510122243200226420ustar00rootroot00000000000000// +build !windows package ole func (enum *IEnumVARIANT) Clone() (*IEnumVARIANT, error) { return nil, NewError(E_NOTIMPL) } func (enum *IEnumVARIANT) Reset() error { return NewError(E_NOTIMPL) } func (enum *IEnumVARIANT) Skip(celt uint) error { return NewError(E_NOTIMPL) } func (enum *IEnumVARIANT) Next(celt uint) (VARIANT, uint, error) { return NewVariant(VT_NULL, int64(0)), 0, NewError(E_NOTIMPL) } golang-github-go-ole-go-ole-1.3.0/ienumvariant_test.go000066400000000000000000000052161510122243200226660ustar00rootroot00000000000000// +build windows package ole import "testing" func TestIEnumVariant_wmi(t *testing.T) { var err error var classID *GUID IID_ISWbemLocator := &GUID{0x76a6415b, 0xcb41, 0x11d1, [8]byte{0x8b, 0x02, 0x00, 0x60, 0x08, 0x06, 0xd9, 0xb6}} err = CoInitialize(0) if err != nil { t.Errorf("Initialize error: %v", err) } defer CoUninitialize() classID, err = ClassIDFrom("WbemScripting.SWbemLocator") if err != nil { t.Errorf("CreateObject WbemScripting.SWbemLocator returned with %v", err) } comserver, err := CreateInstance(classID, IID_IUnknown) if err != nil { t.Errorf("CreateInstance WbemScripting.SWbemLocator returned with %v", err) } if comserver == nil { t.Error("CreateObject WbemScripting.SWbemLocator not an object") } defer comserver.Release() dispatch, err := comserver.QueryInterface(IID_ISWbemLocator) if err != nil { t.Errorf("context.iunknown.QueryInterface returned with %v", err) } defer dispatch.Release() wbemServices, err := dispatch.CallMethod("ConnectServer") if err != nil { t.Errorf("ConnectServer failed with %v", err) } defer wbemServices.Clear() objectset, err := wbemServices.ToIDispatch().CallMethod("ExecQuery", "SELECT * FROM WIN32_Process") if err != nil { t.Errorf("ExecQuery failed with %v", err) } defer objectset.Clear() enum_property, err := objectset.ToIDispatch().GetProperty("_NewEnum") if err != nil { t.Errorf("Get _NewEnum property failed with %v", err) } defer enum_property.Clear() enum, err := enum_property.ToIUnknown().IEnumVARIANT(IID_IEnumVariant) if err != nil { t.Errorf("IEnumVARIANT() returned with %v", err) } if enum == nil { t.Error("Enum is nil") t.FailNow() } defer enum.Release() for tmp, length, err := enum.Next(1); length > 0; tmp, length, err = enum.Next(1) { if err != nil { t.Errorf("Next() returned with %v", err) } tmp_dispatch := tmp.ToIDispatch() defer tmp_dispatch.Release() props, err := tmp_dispatch.GetProperty("Properties_") if err != nil { t.Errorf("Get Properties_ property failed with %v", err) } defer props.Clear() props_enum_property, err := props.ToIDispatch().GetProperty("_NewEnum") if err != nil { t.Errorf("Get _NewEnum property failed with %v", err) } defer props_enum_property.Clear() props_enum, err := props_enum_property.ToIUnknown().IEnumVARIANT(IID_IEnumVariant) if err != nil { t.Errorf("IEnumVARIANT failed with %v", err) } defer props_enum.Release() class_variant, err := tmp_dispatch.GetProperty("Name") if err != nil { t.Errorf("Get Name property failed with %v", err) } defer class_variant.Clear() class_name := class_variant.ToString() t.Logf("Got %v", class_name) } } golang-github-go-ole-go-ole-1.3.0/ienumvariant_windows.go000066400000000000000000000020341510122243200233740ustar00rootroot00000000000000// +build windows package ole import ( "syscall" "unsafe" ) func (enum *IEnumVARIANT) Clone() (cloned *IEnumVARIANT, err error) { hr, _, _ := syscall.Syscall( enum.VTable().Clone, 2, uintptr(unsafe.Pointer(enum)), uintptr(unsafe.Pointer(&cloned)), 0) if hr != 0 { err = NewError(hr) } return } func (enum *IEnumVARIANT) Reset() (err error) { hr, _, _ := syscall.Syscall( enum.VTable().Reset, 1, uintptr(unsafe.Pointer(enum)), 0, 0) if hr != 0 { err = NewError(hr) } return } func (enum *IEnumVARIANT) Skip(celt uint) (err error) { hr, _, _ := syscall.Syscall( enum.VTable().Skip, 2, uintptr(unsafe.Pointer(enum)), uintptr(celt), 0) if hr != 0 { err = NewError(hr) } return } func (enum *IEnumVARIANT) Next(celt uint) (array VARIANT, length uint, err error) { hr, _, _ := syscall.Syscall6( enum.VTable().Next, 4, uintptr(unsafe.Pointer(enum)), uintptr(celt), uintptr(unsafe.Pointer(&array)), uintptr(unsafe.Pointer(&length)), 0, 0) if hr != 0 { err = NewError(hr) } return } golang-github-go-ole-go-ole-1.3.0/iinspectable.go000066400000000000000000000004741510122243200215700ustar00rootroot00000000000000package ole import "unsafe" type IInspectable struct { IUnknown } type IInspectableVtbl struct { IUnknownVtbl GetIIds uintptr GetRuntimeClassName uintptr GetTrustLevel uintptr } func (v *IInspectable) VTable() *IInspectableVtbl { return (*IInspectableVtbl)(unsafe.Pointer(v.RawVTable)) } golang-github-go-ole-go-ole-1.3.0/iinspectable_func.go000066400000000000000000000005031510122243200225740ustar00rootroot00000000000000// +build !windows package ole func (v *IInspectable) GetIids() ([]*GUID, error) { return []*GUID{}, NewError(E_NOTIMPL) } func (v *IInspectable) GetRuntimeClassName() (string, error) { return "", NewError(E_NOTIMPL) } func (v *IInspectable) GetTrustLevel() (uint32, error) { return uint32(0), NewError(E_NOTIMPL) } golang-github-go-ole-go-ole-1.3.0/iinspectable_windows.go000066400000000000000000000026351510122243200233430ustar00rootroot00000000000000// +build windows package ole import ( "bytes" "encoding/binary" "reflect" "syscall" "unsafe" ) func (v *IInspectable) GetIids() (iids []*GUID, err error) { var count uint32 var array uintptr hr, _, _ := syscall.Syscall( v.VTable().GetIIds, 3, uintptr(unsafe.Pointer(v)), uintptr(unsafe.Pointer(&count)), uintptr(unsafe.Pointer(&array))) if hr != 0 { err = NewError(hr) return } defer CoTaskMemFree(array) iids = make([]*GUID, count) byteCount := count * uint32(unsafe.Sizeof(GUID{})) slicehdr := reflect.SliceHeader{Data: array, Len: int(byteCount), Cap: int(byteCount)} byteSlice := *(*[]byte)(unsafe.Pointer(&slicehdr)) reader := bytes.NewReader(byteSlice) for i := range iids { guid := GUID{} err = binary.Read(reader, binary.LittleEndian, &guid) if err != nil { return } iids[i] = &guid } return } func (v *IInspectable) GetRuntimeClassName() (s string, err error) { var hstring HString hr, _, _ := syscall.Syscall( v.VTable().GetRuntimeClassName, 2, uintptr(unsafe.Pointer(v)), uintptr(unsafe.Pointer(&hstring)), 0) if hr != 0 { err = NewError(hr) return } s = hstring.String() DeleteHString(hstring) return } func (v *IInspectable) GetTrustLevel() (level uint32, err error) { hr, _, _ := syscall.Syscall( v.VTable().GetTrustLevel, 2, uintptr(unsafe.Pointer(v)), uintptr(unsafe.Pointer(&level)), 0) if hr != 0 { err = NewError(hr) } return } golang-github-go-ole-go-ole-1.3.0/iprovideclassinfo.go000066400000000000000000000006101510122243200226410ustar00rootroot00000000000000package ole import "unsafe" type IProvideClassInfo struct { IUnknown } type IProvideClassInfoVtbl struct { IUnknownVtbl GetClassInfo uintptr } func (v *IProvideClassInfo) VTable() *IProvideClassInfoVtbl { return (*IProvideClassInfoVtbl)(unsafe.Pointer(v.RawVTable)) } func (v *IProvideClassInfo) GetClassInfo() (cinfo *ITypeInfo, err error) { cinfo, err = getClassInfo(v) return } golang-github-go-ole-go-ole-1.3.0/iprovideclassinfo_func.go000066400000000000000000000002171510122243200236570ustar00rootroot00000000000000// +build !windows package ole func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) { return nil, NewError(E_NOTIMPL) } golang-github-go-ole-go-ole-1.3.0/iprovideclassinfo_windows.go000066400000000000000000000005061510122243200244170ustar00rootroot00000000000000// +build windows package ole import ( "syscall" "unsafe" ) func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) { hr, _, _ := syscall.Syscall( disp.VTable().GetClassInfo, 2, uintptr(unsafe.Pointer(disp)), uintptr(unsafe.Pointer(&tinfo)), 0) if hr != 0 { err = NewError(hr) } return } golang-github-go-ole-go-ole-1.3.0/itypeinfo.go000066400000000000000000000014201510122243200211240ustar00rootroot00000000000000package ole import "unsafe" type ITypeInfo struct { IUnknown } type ITypeInfoVtbl struct { IUnknownVtbl GetTypeAttr uintptr GetTypeComp uintptr GetFuncDesc uintptr GetVarDesc uintptr GetNames uintptr GetRefTypeOfImplType uintptr GetImplTypeFlags uintptr GetIDsOfNames uintptr Invoke uintptr GetDocumentation uintptr GetDllEntry uintptr GetRefTypeInfo uintptr AddressOfMember uintptr CreateInstance uintptr GetMops uintptr GetContainingTypeLib uintptr ReleaseTypeAttr uintptr ReleaseFuncDesc uintptr ReleaseVarDesc uintptr } func (v *ITypeInfo) VTable() *ITypeInfoVtbl { return (*ITypeInfoVtbl)(unsafe.Pointer(v.RawVTable)) } golang-github-go-ole-go-ole-1.3.0/itypeinfo_func.go000066400000000000000000000001731510122243200221430ustar00rootroot00000000000000// +build !windows package ole func (v *ITypeInfo) GetTypeAttr() (*TYPEATTR, error) { return nil, NewError(E_NOTIMPL) } golang-github-go-ole-go-ole-1.3.0/itypeinfo_windows.go000066400000000000000000000004761510122243200227100ustar00rootroot00000000000000// +build windows package ole import ( "syscall" "unsafe" ) func (v *ITypeInfo) GetTypeAttr() (tattr *TYPEATTR, err error) { hr, _, _ := syscall.Syscall( uintptr(v.VTable().GetTypeAttr), 2, uintptr(unsafe.Pointer(v)), uintptr(unsafe.Pointer(&tattr)), 0) if hr != 0 { err = NewError(hr) } return } golang-github-go-ole-go-ole-1.3.0/iunknown.go000066400000000000000000000023061510122243200207720ustar00rootroot00000000000000package ole import "unsafe" type IUnknown struct { RawVTable *interface{} } type IUnknownVtbl struct { QueryInterface uintptr AddRef uintptr Release uintptr } type UnknownLike interface { QueryInterface(iid *GUID) (disp *IDispatch, err error) AddRef() int32 Release() int32 } func (v *IUnknown) VTable() *IUnknownVtbl { return (*IUnknownVtbl)(unsafe.Pointer(v.RawVTable)) } func (v *IUnknown) PutQueryInterface(interfaceID *GUID, obj interface{}) error { return reflectQueryInterface(v, v.VTable().QueryInterface, interfaceID, obj) } func (v *IUnknown) IDispatch(interfaceID *GUID) (dispatch *IDispatch, err error) { err = v.PutQueryInterface(interfaceID, &dispatch) return } func (v *IUnknown) IEnumVARIANT(interfaceID *GUID) (enum *IEnumVARIANT, err error) { err = v.PutQueryInterface(interfaceID, &enum) return } func (v *IUnknown) QueryInterface(iid *GUID) (*IDispatch, error) { return queryInterface(v, iid) } func (v *IUnknown) MustQueryInterface(iid *GUID) (disp *IDispatch) { unk, err := queryInterface(v, iid) if err != nil { panic(err) } return unk } func (v *IUnknown) AddRef() int32 { return addRef(v) } func (v *IUnknown) Release() int32 { return release(v) } golang-github-go-ole-go-ole-1.3.0/iunknown_func.go000066400000000000000000000006001510122243200220000ustar00rootroot00000000000000// +build !windows package ole func reflectQueryInterface(self interface{}, method uintptr, interfaceID *GUID, obj interface{}) (err error) { return NewError(E_NOTIMPL) } func queryInterface(unk *IUnknown, iid *GUID) (disp *IDispatch, err error) { return nil, NewError(E_NOTIMPL) } func addRef(unk *IUnknown) int32 { return 0 } func release(unk *IUnknown) int32 { return 0 } golang-github-go-ole-go-ole-1.3.0/iunknown_windows.go000066400000000000000000000020541510122243200225440ustar00rootroot00000000000000// +build windows package ole import ( "reflect" "syscall" "unsafe" ) func reflectQueryInterface(self interface{}, method uintptr, interfaceID *GUID, obj interface{}) (err error) { selfValue := reflect.ValueOf(self).Elem() objValue := reflect.ValueOf(obj).Elem() hr, _, _ := syscall.Syscall( method, 3, selfValue.UnsafeAddr(), uintptr(unsafe.Pointer(interfaceID)), objValue.Addr().Pointer()) if hr != 0 { err = NewError(hr) } return } func queryInterface(unk *IUnknown, iid *GUID) (disp *IDispatch, err error) { hr, _, _ := syscall.Syscall( unk.VTable().QueryInterface, 3, uintptr(unsafe.Pointer(unk)), uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&disp))) if hr != 0 { err = NewError(hr) } return } func addRef(unk *IUnknown) int32 { ret, _, _ := syscall.Syscall( unk.VTable().AddRef, 1, uintptr(unsafe.Pointer(unk)), 0, 0) return int32(ret) } func release(unk *IUnknown) int32 { ret, _, _ := syscall.Syscall( unk.VTable().Release, 1, uintptr(unsafe.Pointer(unk)), 0, 0) return int32(ret) } golang-github-go-ole-go-ole-1.3.0/iunknown_windows_test.go000066400000000000000000000006721510122243200236070ustar00rootroot00000000000000// +build windows package ole import "testing" func TestIUnknown(t *testing.T) { defer func() { if r := recover(); r != nil { t.Error(r) } }() var err error err = CoInitialize(0) if err != nil { t.Fatal(err) } defer CoUninitialize() var unknown *IUnknown // oleutil.CreateObject() unknown, err = CreateInstance(CLSID_COMEchoTestObject, IID_IUnknown) if err != nil { t.Fatal(err) return } unknown.Release() } golang-github-go-ole-go-ole-1.3.0/ole.go000066400000000000000000000077141510122243200177110ustar00rootroot00000000000000package ole import ( "fmt" "strings" "unsafe" ) // DISPPARAMS are the arguments that passed to methods or property. type DISPPARAMS struct { rgvarg uintptr rgdispidNamedArgs uintptr cArgs uint32 cNamedArgs uint32 } // EXCEPINFO defines exception info. type EXCEPINFO struct { wCode uint16 wReserved uint16 bstrSource *uint16 bstrDescription *uint16 bstrHelpFile *uint16 dwHelpContext uint32 pvReserved uintptr pfnDeferredFillIn uintptr scode uint32 // Go-specific part. Don't move upper cos it'll break structure layout for native code. rendered bool source string description string helpFile string } // renderStrings translates BSTR strings to Go ones so `.Error` and `.String` // could be safely called after `.Clear`. We need this when we can't rely on // a caller to call `.Clear`. func (e *EXCEPINFO) renderStrings() { e.rendered = true if e.bstrSource == nil { e.source = "" } else { e.source = BstrToString(e.bstrSource) } if e.bstrDescription == nil { e.description = "" } else { e.description = BstrToString(e.bstrDescription) } if e.bstrHelpFile == nil { e.helpFile = "" } else { e.helpFile = BstrToString(e.bstrHelpFile) } } // Clear frees BSTR strings inside an EXCEPINFO and set it to NULL. func (e *EXCEPINFO) Clear() { freeBSTR := func(s *uint16) { // SysFreeString don't return errors and is safe for call's on NULL. // https://docs.microsoft.com/en-us/windows/win32/api/oleauto/nf-oleauto-sysfreestring _ = SysFreeString((*int16)(unsafe.Pointer(s))) } if e.bstrSource != nil { freeBSTR(e.bstrSource) e.bstrSource = nil } if e.bstrDescription != nil { freeBSTR(e.bstrDescription) e.bstrDescription = nil } if e.bstrHelpFile != nil { freeBSTR(e.bstrHelpFile) e.bstrHelpFile = nil } } // WCode return wCode in EXCEPINFO. func (e EXCEPINFO) WCode() uint16 { return e.wCode } // SCODE return scode in EXCEPINFO. func (e EXCEPINFO) SCODE() uint32 { return e.scode } // String convert EXCEPINFO to string. func (e EXCEPINFO) String() string { if !e.rendered { e.renderStrings() } return fmt.Sprintf( "wCode: %#x, bstrSource: %v, bstrDescription: %v, bstrHelpFile: %v, dwHelpContext: %#x, scode: %#x", e.wCode, e.source, e.description, e.helpFile, e.dwHelpContext, e.scode, ) } // Error implements error interface and returns error string. func (e EXCEPINFO) Error() string { if !e.rendered { e.renderStrings() } if e.description != "" { return strings.TrimSpace(e.description) } code := e.scode if e.wCode != 0 { code = uint32(e.wCode) } return fmt.Sprintf("%v: %#x", e.source, code) } // PARAMDATA defines parameter data type. type PARAMDATA struct { Name *int16 Vt uint16 } // METHODDATA defines method info. type METHODDATA struct { Name *uint16 Data *PARAMDATA Dispid int32 Meth uint32 CC int32 CArgs uint32 Flags uint16 VtReturn uint32 } // INTERFACEDATA defines interface info. type INTERFACEDATA struct { MethodData *METHODDATA CMembers uint32 } // Point is 2D vector type. type Point struct { X int32 Y int32 } // Msg is message between processes. type Msg struct { Hwnd uint32 Message uint32 Wparam int32 Lparam int32 Time uint32 Pt Point } // TYPEDESC defines data type. type TYPEDESC struct { Hreftype uint32 VT uint16 } // IDLDESC defines IDL info. type IDLDESC struct { DwReserved uint32 WIDLFlags uint16 } // TYPEATTR defines type info. type TYPEATTR struct { Guid GUID Lcid uint32 dwReserved uint32 MemidConstructor int32 MemidDestructor int32 LpstrSchema *uint16 CbSizeInstance uint32 Typekind int32 CFuncs uint16 CVars uint16 CImplTypes uint16 CbSizeVft uint16 CbAlignment uint16 WTypeFlags uint16 WMajorVerNum uint16 WMinorVerNum uint16 TdescAlias TYPEDESC IdldescType IDLDESC } golang-github-go-ole-go-ole-1.3.0/oleutil/000077500000000000000000000000001510122243200202475ustar00rootroot00000000000000golang-github-go-ole-go-ole-1.3.0/oleutil/connection.go000066400000000000000000000043021510122243200227340ustar00rootroot00000000000000// +build windows package oleutil import ( "reflect" "unsafe" ole "github.com/go-ole/go-ole" ) type stdDispatch struct { lpVtbl *stdDispatchVtbl ref int32 iid *ole.GUID iface interface{} funcMap map[string]int32 } type stdDispatchVtbl struct { pQueryInterface uintptr pAddRef uintptr pRelease uintptr pGetTypeInfoCount uintptr pGetTypeInfo uintptr pGetIDsOfNames uintptr pInvoke uintptr } func dispQueryInterface(this *ole.IUnknown, iid *ole.GUID, punk **ole.IUnknown) uint32 { pthis := (*stdDispatch)(unsafe.Pointer(this)) *punk = nil if ole.IsEqualGUID(iid, ole.IID_IUnknown) || ole.IsEqualGUID(iid, ole.IID_IDispatch) { dispAddRef(this) *punk = this return ole.S_OK } if ole.IsEqualGUID(iid, pthis.iid) { dispAddRef(this) *punk = this return ole.S_OK } return ole.E_NOINTERFACE } func dispAddRef(this *ole.IUnknown) int32 { pthis := (*stdDispatch)(unsafe.Pointer(this)) pthis.ref++ return pthis.ref } func dispRelease(this *ole.IUnknown) int32 { pthis := (*stdDispatch)(unsafe.Pointer(this)) pthis.ref-- return pthis.ref } func dispGetIDsOfNames(this *ole.IUnknown, iid *ole.GUID, wnames []*uint16, namelen int, lcid int, pdisp []int32) uintptr { pthis := (*stdDispatch)(unsafe.Pointer(this)) names := make([]string, len(wnames)) for i := 0; i < len(names); i++ { names[i] = ole.LpOleStrToString(wnames[i]) } for n := 0; n < namelen; n++ { if id, ok := pthis.funcMap[names[n]]; ok { pdisp[n] = id } } return ole.S_OK } func dispGetTypeInfoCount(pcount *int) uintptr { if pcount != nil { *pcount = 0 } return ole.S_OK } func dispGetTypeInfo(ptypeif *uintptr) uintptr { return ole.E_NOTIMPL } func dispInvoke(this *ole.IDispatch, dispid int32, riid *ole.GUID, lcid int, flags int16, dispparams *ole.DISPPARAMS, result *ole.VARIANT, pexcepinfo *ole.EXCEPINFO, nerr *uint) uintptr { pthis := (*stdDispatch)(unsafe.Pointer(this)) found := "" for name, id := range pthis.funcMap { if id == dispid { found = name } } if found != "" { rv := reflect.ValueOf(pthis.iface).Elem() rm := rv.MethodByName(found) rr := rm.Call([]reflect.Value{}) println(len(rr)) return ole.S_OK } return ole.E_NOTIMPL } golang-github-go-ole-go-ole-1.3.0/oleutil/connection_func.go000066400000000000000000000004451510122243200237530ustar00rootroot00000000000000// +build !windows package oleutil import ole "github.com/go-ole/go-ole" // ConnectObject creates a connection point between two services for communication. func ConnectObject(disp *ole.IDispatch, iid *ole.GUID, idisp interface{}) (uint32, error) { return 0, ole.NewError(ole.E_NOTIMPL) } golang-github-go-ole-go-ole-1.3.0/oleutil/connection_windows.go000066400000000000000000000030441510122243200245100ustar00rootroot00000000000000// +build windows package oleutil import ( "reflect" "syscall" "unsafe" ole "github.com/go-ole/go-ole" ) // ConnectObject creates a connection point between two services for communication. func ConnectObject(disp *ole.IDispatch, iid *ole.GUID, idisp interface{}) (cookie uint32, err error) { unknown, err := disp.QueryInterface(ole.IID_IConnectionPointContainer) if err != nil { return } container := (*ole.IConnectionPointContainer)(unsafe.Pointer(unknown)) var point *ole.IConnectionPoint err = container.FindConnectionPoint(iid, &point) if err != nil { return } if edisp, ok := idisp.(*ole.IUnknown); ok { cookie, err = point.Advise(edisp) container.Release() if err != nil { return } } rv := reflect.ValueOf(disp).Elem() if rv.Type().Kind() == reflect.Struct { dest := &stdDispatch{} dest.lpVtbl = &stdDispatchVtbl{} dest.lpVtbl.pQueryInterface = syscall.NewCallback(dispQueryInterface) dest.lpVtbl.pAddRef = syscall.NewCallback(dispAddRef) dest.lpVtbl.pRelease = syscall.NewCallback(dispRelease) dest.lpVtbl.pGetTypeInfoCount = syscall.NewCallback(dispGetTypeInfoCount) dest.lpVtbl.pGetTypeInfo = syscall.NewCallback(dispGetTypeInfo) dest.lpVtbl.pGetIDsOfNames = syscall.NewCallback(dispGetIDsOfNames) dest.lpVtbl.pInvoke = syscall.NewCallback(dispInvoke) dest.iface = disp dest.iid = iid cookie, err = point.Advise((*ole.IUnknown)(unsafe.Pointer(dest))) container.Release() if err != nil { point.Release() return } return } container.Release() return 0, ole.NewError(ole.E_INVALIDARG) } golang-github-go-ole-go-ole-1.3.0/oleutil/go-get.go000066400000000000000000000002211510122243200217530ustar00rootroot00000000000000// This file is here so go get succeeds as without it errors with: // no buildable Go source files in ... // // +build !windows package oleutil golang-github-go-ole-go-ole-1.3.0/oleutil/oleutil.go000066400000000000000000000070241510122243200222560ustar00rootroot00000000000000package oleutil import ole "github.com/go-ole/go-ole" // ClassIDFrom retrieves class ID whether given is program ID or application string. func ClassIDFrom(programID string) (classID *ole.GUID, err error) { return ole.ClassIDFrom(programID) } // CreateObject creates object from programID based on interface type. // // Only supports IUnknown. // // Program ID can be either program ID or application string. func CreateObject(programID string) (unknown *ole.IUnknown, err error) { classID, err := ole.ClassIDFrom(programID) if err != nil { return } unknown, err = ole.CreateInstance(classID, ole.IID_IUnknown) if err != nil { return } return } // GetActiveObject retrieves active object for program ID and interface ID based // on interface type. // // Only supports IUnknown. // // Program ID can be either program ID or application string. func GetActiveObject(programID string) (unknown *ole.IUnknown, err error) { classID, err := ole.ClassIDFrom(programID) if err != nil { return } unknown, err = ole.GetActiveObject(classID, ole.IID_IUnknown) if err != nil { return } return } // CallMethod calls method on IDispatch with parameters. func CallMethod(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) { return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_METHOD, params) } // MustCallMethod calls method on IDispatch with parameters or panics. func MustCallMethod(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) { r, err := CallMethod(disp, name, params...) if err != nil { panic(err.Error()) } return r } // GetProperty retrieves property from IDispatch. func GetProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) { return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYGET, params) } // MustGetProperty retrieves property from IDispatch or panics. func MustGetProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) { r, err := GetProperty(disp, name, params...) if err != nil { panic(err.Error()) } return r } // PutProperty mutates property. func PutProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) { return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYPUT, params) } // MustPutProperty mutates property or panics. func MustPutProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) { r, err := PutProperty(disp, name, params...) if err != nil { panic(err.Error()) } return r } // PutPropertyRef mutates property reference. func PutPropertyRef(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) { return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYPUTREF, params) } // MustPutPropertyRef mutates property reference or panics. func MustPutPropertyRef(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) { r, err := PutPropertyRef(disp, name, params...) if err != nil { panic(err.Error()) } return r } func ForEach(disp *ole.IDispatch, f func(v *ole.VARIANT) error) error { newEnum, err := disp.GetProperty("_NewEnum") if err != nil { return err } defer newEnum.Clear() enum, err := newEnum.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant) if err != nil { return err } defer enum.Release() for item, length, err := enum.Next(1); length > 0; item, length, err = enum.Next(1) { if err != nil { return err } if ferr := f(&item); ferr != nil { return ferr } } return nil } golang-github-go-ole-go-ole-1.3.0/safearray.go000066400000000000000000000011761510122243200211030ustar00rootroot00000000000000// Package is meant to retrieve and process safe array data returned from COM. package ole // SafeArrayBound defines the SafeArray boundaries. type SafeArrayBound struct { Elements uint32 LowerBound int32 } // SafeArray is how COM handles arrays. type SafeArray struct { Dimensions uint16 FeaturesFlag uint16 ElementsSize uint32 LocksAmount uint32 Data uint32 Bounds [16]byte } // SAFEARRAY is obsolete, exists for backwards compatibility. // Use SafeArray type SAFEARRAY SafeArray // SAFEARRAYBOUND is obsolete, exists for backwards compatibility. // Use SafeArrayBound type SAFEARRAYBOUND SafeArrayBound golang-github-go-ole-go-ole-1.3.0/safearray_func.go000066400000000000000000000142101510122243200221070ustar00rootroot00000000000000// +build !windows package ole import ( "unsafe" ) // safeArrayAccessData returns raw array pointer. // // AKA: SafeArrayAccessData in Windows API. func safeArrayAccessData(safearray *SafeArray) (uintptr, error) { return uintptr(0), NewError(E_NOTIMPL) } // safeArrayUnaccessData releases raw array. // // AKA: SafeArrayUnaccessData in Windows API. func safeArrayUnaccessData(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayAllocData allocates SafeArray. // // AKA: SafeArrayAllocData in Windows API. func safeArrayAllocData(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayAllocDescriptor allocates SafeArray. // // AKA: SafeArrayAllocDescriptor in Windows API. func safeArrayAllocDescriptor(dimensions uint32) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayAllocDescriptorEx allocates SafeArray. // // AKA: SafeArrayAllocDescriptorEx in Windows API. func safeArrayAllocDescriptorEx(variantType VT, dimensions uint32) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayCopy returns copy of SafeArray. // // AKA: SafeArrayCopy in Windows API. func safeArrayCopy(original *SafeArray) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayCopyData duplicates SafeArray into another SafeArray object. // // AKA: SafeArrayCopyData in Windows API. func safeArrayCopyData(original *SafeArray, duplicate *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayCreate creates SafeArray. // // AKA: SafeArrayCreate in Windows API. func safeArrayCreate(variantType VT, dimensions uint32, bounds *SafeArrayBound) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayCreateEx creates SafeArray. // // AKA: SafeArrayCreateEx in Windows API. func safeArrayCreateEx(variantType VT, dimensions uint32, bounds *SafeArrayBound, extra uintptr) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayCreateVector creates SafeArray. // // AKA: SafeArrayCreateVector in Windows API. func safeArrayCreateVector(variantType VT, lowerBound int32, length uint32) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayCreateVectorEx creates SafeArray. // // AKA: SafeArrayCreateVectorEx in Windows API. func safeArrayCreateVectorEx(variantType VT, lowerBound int32, length uint32, extra uintptr) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayDestroy destroys SafeArray object. // // AKA: SafeArrayDestroy in Windows API. func safeArrayDestroy(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayDestroyData destroys SafeArray object. // // AKA: SafeArrayDestroyData in Windows API. func safeArrayDestroyData(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayDestroyDescriptor destroys SafeArray object. // // AKA: SafeArrayDestroyDescriptor in Windows API. func safeArrayDestroyDescriptor(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayGetDim is the amount of dimensions in the SafeArray. // // SafeArrays may have multiple dimensions. Meaning, it could be // multidimensional array. // // AKA: SafeArrayGetDim in Windows API. func safeArrayGetDim(safearray *SafeArray) (*uint32, error) { u := uint32(0) return &u, NewError(E_NOTIMPL) } // safeArrayGetElementSize is the element size in bytes. // // AKA: SafeArrayGetElemsize in Windows API. func safeArrayGetElementSize(safearray *SafeArray) (*uint32, error) { u := uint32(0) return &u, NewError(E_NOTIMPL) } // safeArrayGetElement retrieves element at given index. func safeArrayGetElement(safearray *SafeArray, index int32, pv unsafe.Pointer) error { return NewError(E_NOTIMPL) } // safeArrayGetElement retrieves element at given index and converts to string. func safeArrayGetElementString(safearray *SafeArray, index int32) (string, error) { return "", NewError(E_NOTIMPL) } // safeArrayGetIID is the InterfaceID of the elements in the SafeArray. // // AKA: SafeArrayGetIID in Windows API. func safeArrayGetIID(safearray *SafeArray) (*GUID, error) { return nil, NewError(E_NOTIMPL) } // safeArrayGetLBound returns lower bounds of SafeArray. // // SafeArrays may have multiple dimensions. Meaning, it could be // multidimensional array. // // AKA: SafeArrayGetLBound in Windows API. func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (int32, error) { return int32(0), NewError(E_NOTIMPL) } // safeArrayGetUBound returns upper bounds of SafeArray. // // SafeArrays may have multiple dimensions. Meaning, it could be // multidimensional array. // // AKA: SafeArrayGetUBound in Windows API. func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (int32, error) { return int32(0), NewError(E_NOTIMPL) } // safeArrayGetVartype returns data type of SafeArray. // // AKA: SafeArrayGetVartype in Windows API. func safeArrayGetVartype(safearray *SafeArray) (uint16, error) { return uint16(0), NewError(E_NOTIMPL) } // safeArrayLock locks SafeArray for reading to modify SafeArray. // // This must be called during some calls to ensure that another process does not // read or write to the SafeArray during editing. // // AKA: SafeArrayLock in Windows API. func safeArrayLock(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayUnlock unlocks SafeArray for reading. // // AKA: SafeArrayUnlock in Windows API. func safeArrayUnlock(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayPutElement stores the data element at the specified location in the // array. // // AKA: SafeArrayPutElement in Windows API. func safeArrayPutElement(safearray *SafeArray, index int64, element uintptr) error { return NewError(E_NOTIMPL) } // safeArrayGetRecordInfo accesses IRecordInfo info for custom types. // // AKA: SafeArrayGetRecordInfo in Windows API. // // XXX: Must implement IRecordInfo interface for this to return. func safeArrayGetRecordInfo(safearray *SafeArray) (interface{}, error) { return nil, NewError(E_NOTIMPL) } // safeArraySetRecordInfo mutates IRecordInfo info for custom types. // // AKA: SafeArraySetRecordInfo in Windows API. // // XXX: Must implement IRecordInfo interface for this to return. func safeArraySetRecordInfo(safearray *SafeArray, recordInfo interface{}) error { return NewError(E_NOTIMPL) } golang-github-go-ole-go-ole-1.3.0/safearray_test.go000066400000000000000000000043511510122243200221400ustar00rootroot00000000000000package ole // This tests more than one function. It tests all of the functions needed in // order to retrieve an SafeArray populated with Strings. func Example_safeArrayGetElementString() { CoInitialize(0) defer CoUninitialize() clsid, err := CLSIDFromProgID("QBXMLRP2.RequestProcessor.1") if err != nil { if err.(*OleError).Code() == CO_E_CLASSSTRING { return } } unknown, err := CreateInstance(clsid, IID_IUnknown) if err != nil { return } defer unknown.Release() dispatch, err := unknown.QueryInterface(IID_IDispatch) if err != nil { return } var dispid []int32 dispid, err = dispatch.GetIDsOfName([]string{"OpenConnection2"}) if err != nil { return } var result *VARIANT _, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD, "", "Test Application 1", 1) if err != nil { return } dispid, err = dispatch.GetIDsOfName([]string{"BeginSession"}) if err != nil { return } result, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD, "", 2) if err != nil { return } ticket := result.ToString() dispid, err = dispatch.GetIDsOfName([]string{"QBXMLVersionsForSession"}) if err != nil { return } result, err = dispatch.Invoke(dispid[0], DISPATCH_PROPERTYGET, ticket) if err != nil { return } // Where the real tests begin. var qbXMLVersions *SafeArray var qbXmlVersionStrings []string qbXMLVersions = result.ToArray().Array // Get array bounds var LowerBounds int32 var UpperBounds int32 LowerBounds, err = safeArrayGetLBound(qbXMLVersions, 1) if err != nil { return } UpperBounds, err = safeArrayGetUBound(qbXMLVersions, 1) if err != nil { return } totalElements := UpperBounds - LowerBounds + 1 qbXmlVersionStrings = make([]string, totalElements) for i := int32(0); i < totalElements; i++ { qbXmlVersionStrings[i], _ = safeArrayGetElementString(qbXMLVersions, i) } // Release Safe Array memory safeArrayDestroy(qbXMLVersions) dispid, err = dispatch.GetIDsOfName([]string{"EndSession"}) if err != nil { return } _, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD, ticket) if err != nil { return } dispid, err = dispatch.GetIDsOfName([]string{"CloseConnection"}) if err != nil { return } _, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD) if err != nil { return } } golang-github-go-ole-go-ole-1.3.0/safearray_windows.go000066400000000000000000000272051510122243200226560ustar00rootroot00000000000000// +build windows package ole import ( "unsafe" ) var ( procSafeArrayAccessData = modoleaut32.NewProc("SafeArrayAccessData") procSafeArrayAllocData = modoleaut32.NewProc("SafeArrayAllocData") procSafeArrayAllocDescriptor = modoleaut32.NewProc("SafeArrayAllocDescriptor") procSafeArrayAllocDescriptorEx = modoleaut32.NewProc("SafeArrayAllocDescriptorEx") procSafeArrayCopy = modoleaut32.NewProc("SafeArrayCopy") procSafeArrayCopyData = modoleaut32.NewProc("SafeArrayCopyData") procSafeArrayCreate = modoleaut32.NewProc("SafeArrayCreate") procSafeArrayCreateEx = modoleaut32.NewProc("SafeArrayCreateEx") procSafeArrayCreateVector = modoleaut32.NewProc("SafeArrayCreateVector") procSafeArrayCreateVectorEx = modoleaut32.NewProc("SafeArrayCreateVectorEx") procSafeArrayDestroy = modoleaut32.NewProc("SafeArrayDestroy") procSafeArrayDestroyData = modoleaut32.NewProc("SafeArrayDestroyData") procSafeArrayDestroyDescriptor = modoleaut32.NewProc("SafeArrayDestroyDescriptor") procSafeArrayGetDim = modoleaut32.NewProc("SafeArrayGetDim") procSafeArrayGetElement = modoleaut32.NewProc("SafeArrayGetElement") procSafeArrayGetElemsize = modoleaut32.NewProc("SafeArrayGetElemsize") procSafeArrayGetIID = modoleaut32.NewProc("SafeArrayGetIID") procSafeArrayGetLBound = modoleaut32.NewProc("SafeArrayGetLBound") procSafeArrayGetUBound = modoleaut32.NewProc("SafeArrayGetUBound") procSafeArrayGetVartype = modoleaut32.NewProc("SafeArrayGetVartype") procSafeArrayLock = modoleaut32.NewProc("SafeArrayLock") procSafeArrayPtrOfIndex = modoleaut32.NewProc("SafeArrayPtrOfIndex") procSafeArrayUnaccessData = modoleaut32.NewProc("SafeArrayUnaccessData") procSafeArrayUnlock = modoleaut32.NewProc("SafeArrayUnlock") procSafeArrayPutElement = modoleaut32.NewProc("SafeArrayPutElement") //procSafeArrayRedim = modoleaut32.NewProc("SafeArrayRedim") // TODO //procSafeArraySetIID = modoleaut32.NewProc("SafeArraySetIID") // TODO procSafeArrayGetRecordInfo = modoleaut32.NewProc("SafeArrayGetRecordInfo") procSafeArraySetRecordInfo = modoleaut32.NewProc("SafeArraySetRecordInfo") ) // safeArrayAccessData returns raw array pointer. // // AKA: SafeArrayAccessData in Windows API. // Todo: Test func safeArrayAccessData(safearray *SafeArray) (element uintptr, err error) { err = convertHresultToError( procSafeArrayAccessData.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&element)))) return } // safeArrayUnaccessData releases raw array. // // AKA: SafeArrayUnaccessData in Windows API. func safeArrayUnaccessData(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayUnaccessData.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayAllocData allocates SafeArray. // // AKA: SafeArrayAllocData in Windows API. func safeArrayAllocData(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayAllocData.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayAllocDescriptor allocates SafeArray. // // AKA: SafeArrayAllocDescriptor in Windows API. func safeArrayAllocDescriptor(dimensions uint32) (safearray *SafeArray, err error) { err = convertHresultToError( procSafeArrayAllocDescriptor.Call(uintptr(dimensions), uintptr(unsafe.Pointer(&safearray)))) return } // safeArrayAllocDescriptorEx allocates SafeArray. // // AKA: SafeArrayAllocDescriptorEx in Windows API. func safeArrayAllocDescriptorEx(variantType VT, dimensions uint32) (safearray *SafeArray, err error) { err = convertHresultToError( procSafeArrayAllocDescriptorEx.Call( uintptr(variantType), uintptr(dimensions), uintptr(unsafe.Pointer(&safearray)))) return } // safeArrayCopy returns copy of SafeArray. // // AKA: SafeArrayCopy in Windows API. func safeArrayCopy(original *SafeArray) (safearray *SafeArray, err error) { err = convertHresultToError( procSafeArrayCopy.Call( uintptr(unsafe.Pointer(original)), uintptr(unsafe.Pointer(&safearray)))) return } // safeArrayCopyData duplicates SafeArray into another SafeArray object. // // AKA: SafeArrayCopyData in Windows API. func safeArrayCopyData(original *SafeArray, duplicate *SafeArray) (err error) { err = convertHresultToError( procSafeArrayCopyData.Call( uintptr(unsafe.Pointer(original)), uintptr(unsafe.Pointer(duplicate)))) return } // safeArrayCreate creates SafeArray. // // AKA: SafeArrayCreate in Windows API. func safeArrayCreate(variantType VT, dimensions uint32, bounds *SafeArrayBound) (safearray *SafeArray, err error) { sa, _, err := procSafeArrayCreate.Call( uintptr(variantType), uintptr(dimensions), uintptr(unsafe.Pointer(bounds))) safearray = (*SafeArray)(unsafe.Pointer(&sa)) return } // safeArrayCreateEx creates SafeArray. // // AKA: SafeArrayCreateEx in Windows API. func safeArrayCreateEx(variantType VT, dimensions uint32, bounds *SafeArrayBound, extra uintptr) (safearray *SafeArray, err error) { sa, _, err := procSafeArrayCreateEx.Call( uintptr(variantType), uintptr(dimensions), uintptr(unsafe.Pointer(bounds)), extra) safearray = (*SafeArray)(unsafe.Pointer(sa)) return } // safeArrayCreateVector creates SafeArray. // // AKA: SafeArrayCreateVector in Windows API. func safeArrayCreateVector(variantType VT, lowerBound int32, length uint32) (safearray *SafeArray, err error) { sa, _, err := procSafeArrayCreateVector.Call( uintptr(variantType), uintptr(lowerBound), uintptr(length)) safearray = (*SafeArray)(unsafe.Pointer(sa)) return } // safeArrayCreateVectorEx creates SafeArray. // // AKA: SafeArrayCreateVectorEx in Windows API. func safeArrayCreateVectorEx(variantType VT, lowerBound int32, length uint32, extra uintptr) (safearray *SafeArray, err error) { sa, _, err := procSafeArrayCreateVectorEx.Call( uintptr(variantType), uintptr(lowerBound), uintptr(length), extra) safearray = (*SafeArray)(unsafe.Pointer(sa)) return } // safeArrayDestroy destroys SafeArray object. // // AKA: SafeArrayDestroy in Windows API. func safeArrayDestroy(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayDestroy.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayDestroyData destroys SafeArray object. // // AKA: SafeArrayDestroyData in Windows API. func safeArrayDestroyData(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayDestroyData.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayDestroyDescriptor destroys SafeArray object. // // AKA: SafeArrayDestroyDescriptor in Windows API. func safeArrayDestroyDescriptor(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayDestroyDescriptor.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayGetDim is the amount of dimensions in the SafeArray. // // SafeArrays may have multiple dimensions. Meaning, it could be // multidimensional array. // // AKA: SafeArrayGetDim in Windows API. func safeArrayGetDim(safearray *SafeArray) (dimensions *uint32, err error) { l, _, err := procSafeArrayGetDim.Call(uintptr(unsafe.Pointer(safearray))) dimensions = (*uint32)(unsafe.Pointer(l)) return } // safeArrayGetElementSize is the element size in bytes. // // AKA: SafeArrayGetElemsize in Windows API. func safeArrayGetElementSize(safearray *SafeArray) (length *uint32, err error) { l, _, err := procSafeArrayGetElemsize.Call(uintptr(unsafe.Pointer(safearray))) length = (*uint32)(unsafe.Pointer(l)) return } // safeArrayGetElement retrieves element at given index. func safeArrayGetElement(safearray *SafeArray, index int32, pv unsafe.Pointer) error { return convertHresultToError( procSafeArrayGetElement.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&index)), uintptr(pv))) } // safeArrayGetElementString retrieves element at given index and converts to string. func safeArrayGetElementString(safearray *SafeArray, index int32) (str string, err error) { var element *int16 err = convertHresultToError( procSafeArrayGetElement.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&index)), uintptr(unsafe.Pointer(&element)))) str = BstrToString(*(**uint16)(unsafe.Pointer(&element))) SysFreeString(element) return } // safeArrayGetIID is the InterfaceID of the elements in the SafeArray. // // AKA: SafeArrayGetIID in Windows API. func safeArrayGetIID(safearray *SafeArray) (guid *GUID, err error) { err = convertHresultToError( procSafeArrayGetIID.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&guid)))) return } // safeArrayGetLBound returns lower bounds of SafeArray. // // SafeArrays may have multiple dimensions. Meaning, it could be // multidimensional array. // // AKA: SafeArrayGetLBound in Windows API. func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (lowerBound int32, err error) { err = convertHresultToError( procSafeArrayGetLBound.Call( uintptr(unsafe.Pointer(safearray)), uintptr(dimension), uintptr(unsafe.Pointer(&lowerBound)))) return } // safeArrayGetUBound returns upper bounds of SafeArray. // // SafeArrays may have multiple dimensions. Meaning, it could be // multidimensional array. // // AKA: SafeArrayGetUBound in Windows API. func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (upperBound int32, err error) { err = convertHresultToError( procSafeArrayGetUBound.Call( uintptr(unsafe.Pointer(safearray)), uintptr(dimension), uintptr(unsafe.Pointer(&upperBound)))) return } // safeArrayGetVartype returns data type of SafeArray. // // AKA: SafeArrayGetVartype in Windows API. func safeArrayGetVartype(safearray *SafeArray) (varType uint16, err error) { err = convertHresultToError( procSafeArrayGetVartype.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&varType)))) return } // safeArrayLock locks SafeArray for reading to modify SafeArray. // // This must be called during some calls to ensure that another process does not // read or write to the SafeArray during editing. // // AKA: SafeArrayLock in Windows API. func safeArrayLock(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayLock.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayUnlock unlocks SafeArray for reading. // // AKA: SafeArrayUnlock in Windows API. func safeArrayUnlock(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayUnlock.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayPutElement stores the data element at the specified location in the // array. // // AKA: SafeArrayPutElement in Windows API. func safeArrayPutElement(safearray *SafeArray, index int64, element uintptr) (err error) { err = convertHresultToError( procSafeArrayPutElement.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&index)), uintptr(unsafe.Pointer(element)))) return } // safeArrayGetRecordInfo accesses IRecordInfo info for custom types. // // AKA: SafeArrayGetRecordInfo in Windows API. // // XXX: Must implement IRecordInfo interface for this to return. func safeArrayGetRecordInfo(safearray *SafeArray) (recordInfo interface{}, err error) { err = convertHresultToError( procSafeArrayGetRecordInfo.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&recordInfo)))) return } // safeArraySetRecordInfo mutates IRecordInfo info for custom types. // // AKA: SafeArraySetRecordInfo in Windows API. // // XXX: Must implement IRecordInfo interface for this to return. func safeArraySetRecordInfo(safearray *SafeArray, recordInfo interface{}) (err error) { err = convertHresultToError( procSafeArraySetRecordInfo.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&recordInfo)))) return } golang-github-go-ole-go-ole-1.3.0/safearrayconversion.go000066400000000000000000000062561510122243200232150ustar00rootroot00000000000000// Helper for converting SafeArray to array of objects. package ole import ( "unsafe" ) type SafeArrayConversion struct { Array *SafeArray } func (sac *SafeArrayConversion) ToStringArray() (strings []string) { totalElements, _ := sac.TotalElements(0) strings = make([]string, totalElements) for i := int32(0); i < totalElements; i++ { strings[int32(i)], _ = safeArrayGetElementString(sac.Array, i) } return } func (sac *SafeArrayConversion) ToByteArray() (bytes []byte) { totalElements, _ := sac.TotalElements(0) bytes = make([]byte, totalElements) for i := int32(0); i < totalElements; i++ { safeArrayGetElement(sac.Array, i, unsafe.Pointer(&bytes[int32(i)])) } return } func (sac *SafeArrayConversion) ToValueArray() (values []interface{}) { totalElements, _ := sac.TotalElements(0) values = make([]interface{}, totalElements) vt, _ := safeArrayGetVartype(sac.Array) for i := int32(0); i < totalElements; i++ { switch VT(vt) { case VT_BOOL: var v bool safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) values[i] = v case VT_I1: var v int8 safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) values[i] = v case VT_I2: var v int16 safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) values[i] = v case VT_I4: var v int32 safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) values[i] = v case VT_I8: var v int64 safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) values[i] = v case VT_UI1: var v uint8 safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) values[i] = v case VT_UI2: var v uint16 safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) values[i] = v case VT_UI4: var v uint32 safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) values[i] = v case VT_UI8: var v uint64 safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) values[i] = v case VT_R4: var v float32 safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) values[i] = v case VT_R8: var v float64 safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) values[i] = v case VT_BSTR: v , _ := safeArrayGetElementString(sac.Array, i) values[i] = v case VT_VARIANT: var v VARIANT safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) values[i] = v.Value() v.Clear() default: // TODO } } return } func (sac *SafeArrayConversion) GetType() (varType uint16, err error) { return safeArrayGetVartype(sac.Array) } func (sac *SafeArrayConversion) GetDimensions() (dimensions *uint32, err error) { return safeArrayGetDim(sac.Array) } func (sac *SafeArrayConversion) GetSize() (length *uint32, err error) { return safeArrayGetElementSize(sac.Array) } func (sac *SafeArrayConversion) TotalElements(index uint32) (totalElements int32, err error) { if index < 1 { index = 1 } // Get array bounds var LowerBounds int32 var UpperBounds int32 LowerBounds, err = safeArrayGetLBound(sac.Array, index) if err != nil { return } UpperBounds, err = safeArrayGetUBound(sac.Array, index) if err != nil { return } totalElements = UpperBounds - LowerBounds + 1 return } // Release Safe Array memory func (sac *SafeArrayConversion) Release() { safeArrayDestroy(sac.Array) } golang-github-go-ole-go-ole-1.3.0/safearrayconversion_test.go000066400000000000000000000044201510122243200242430ustar00rootroot00000000000000// +build windows package ole import ( "fmt" "strings" "testing" ) // This tests more than one function. It tests all of the functions needed in order to retrieve an // SafeArray populated with Strings. func TestSafeArrayConversionString(t *testing.T) { CoInitialize(0) defer CoUninitialize() clsid, err := CLSIDFromProgID("QBXMLRP2.RequestProcessor.1") if err != nil { if err.(*OleError).Code() == CO_E_CLASSSTRING { return } t.Log(err) t.FailNow() } unknown, err := CreateInstance(clsid, IID_IUnknown) if err != nil { t.Log(err) t.FailNow() } defer unknown.Release() dispatch, err := unknown.QueryInterface(IID_IDispatch) if err != nil { t.Log(err) t.FailNow() } var dispid []int32 dispid, err = dispatch.GetIDsOfName([]string{"OpenConnection2"}) if err != nil { t.Log(err) t.FailNow() } var result *VARIANT _, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD, "", "Test Application 1", 1) if err != nil { t.Log(err) t.FailNow() } dispid, err = dispatch.GetIDsOfName([]string{"BeginSession"}) if err != nil { t.Log(err) t.FailNow() } result, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD, "", 2) if err != nil { t.Log(err) t.FailNow() } ticket := result.ToString() dispid, err = dispatch.GetIDsOfName([]string{"QBXMLVersionsForSession"}) if err != nil { t.Log(err) t.FailNow() } result, err = dispatch.Invoke(dispid[0], DISPATCH_PROPERTYGET, ticket) if err != nil { t.Log(err) t.FailNow() } // Where the real tests begin. conversion := result.ToArray() totalElements, _ := conversion.TotalElements(0) if totalElements != 13 { t.Log(fmt.Sprintf("%d total elements does not equal 13\n", totalElements)) t.Fail() } versions := conversion.ToStringArray() if len(versions) != 13 { t.Log(fmt.Sprintf("%s\n", strings.Join(versions, ", "))) t.Fail() } conversion.Release() dispid, err = dispatch.GetIDsOfName([]string{"EndSession"}) if err != nil { t.Log(err) t.FailNow() } _, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD, ticket) if err != nil { t.Log(err) t.FailNow() } dispid, err = dispatch.GetIDsOfName([]string{"CloseConnection"}) if err != nil { t.Log(err) t.FailNow() } _, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD) if err != nil { t.Log(err) t.FailNow() } } golang-github-go-ole-go-ole-1.3.0/safearrayslices.go000066400000000000000000000013201510122243200222750ustar00rootroot00000000000000// +build windows package ole import ( "unsafe" ) func safeArrayFromByteSlice(slice []byte) *SafeArray { array, _ := safeArrayCreateVector(VT_UI1, 0, uint32(len(slice))) if array == nil { panic("Could not convert []byte to SAFEARRAY") } for i, v := range slice { safeArrayPutElement(array, int64(i), uintptr(unsafe.Pointer(&v))) } return array } func safeArrayFromStringSlice(slice []string) *SafeArray { array, _ := safeArrayCreateVector(VT_BSTR, 0, uint32(len(slice))) if array == nil { panic("Could not convert []string to SAFEARRAY") } // SysAllocStringLen(s) for i, v := range slice { safeArrayPutElement(array, int64(i), uintptr(unsafe.Pointer(SysAllocStringLen(v)))) } return array } golang-github-go-ole-go-ole-1.3.0/utility.go000066400000000000000000000041751510122243200206330ustar00rootroot00000000000000package ole import ( "unicode/utf16" "unsafe" ) // ClassIDFrom retrieves class ID whether given is program ID or application string. // // Helper that provides check against both Class ID from Program ID and Class ID from string. It is // faster, if you know which you are using, to use the individual functions, but this will check // against available functions for you. func ClassIDFrom(programID string) (classID *GUID, err error) { classID, err = CLSIDFromProgID(programID) if err != nil { classID, err = CLSIDFromString(programID) if err != nil { return } } return } // BytePtrToString converts byte pointer to a Go string. func BytePtrToString(p *byte) string { a := (*[10000]uint8)(unsafe.Pointer(p)) i := 0 for a[i] != 0 { i++ } return string(a[:i]) } // UTF16PtrToString is alias for LpOleStrToString. // // Kept for compatibility reasons. func UTF16PtrToString(p *uint16) string { return LpOleStrToString(p) } // LpOleStrToString converts COM Unicode to Go string. func LpOleStrToString(p *uint16) string { if p == nil { return "" } length := lpOleStrLen(p) a := make([]uint16, length) ptr := unsafe.Pointer(p) for i := 0; i < int(length); i++ { a[i] = *(*uint16)(ptr) ptr = unsafe.Pointer(uintptr(ptr) + 2) } return string(utf16.Decode(a)) } // BstrToString converts COM binary string to Go string. func BstrToString(p *uint16) string { if p == nil { return "" } length := SysStringLen((*int16)(unsafe.Pointer(p))) a := make([]uint16, length) ptr := unsafe.Pointer(p) for i := 0; i < int(length); i++ { a[i] = *(*uint16)(ptr) ptr = unsafe.Pointer(uintptr(ptr) + 2) } return string(utf16.Decode(a)) } // lpOleStrLen returns the length of Unicode string. func lpOleStrLen(p *uint16) (length int64) { if p == nil { return 0 } ptr := unsafe.Pointer(p) for i := 0; ; i++ { if 0 == *(*uint16)(ptr) { length = int64(i) break } ptr = unsafe.Pointer(uintptr(ptr) + 2) } return } // convertHresultToError converts syscall to error, if call is unsuccessful. func convertHresultToError(hr uintptr, r2 uintptr, ignore error) (err error) { if hr != 0 { err = NewError(hr) } return } golang-github-go-ole-go-ole-1.3.0/variables.go000066400000000000000000000005421510122243200210720ustar00rootroot00000000000000// +build windows package ole import ( "golang.org/x/sys/windows" ) var ( modcombase = windows.NewLazySystemDLL("combase.dll") modkernel32 = windows.NewLazySystemDLL("kernel32.dll") modole32 = windows.NewLazySystemDLL("ole32.dll") modoleaut32 = windows.NewLazySystemDLL("oleaut32.dll") moduser32 = windows.NewLazySystemDLL("user32.dll") ) golang-github-go-ole-go-ole-1.3.0/variant.go000066400000000000000000000045761510122243200206010ustar00rootroot00000000000000package ole import "unsafe" // NewVariant returns new variant based on type and value. func NewVariant(vt VT, val int64) VARIANT { return VARIANT{VT: vt, Val: val} } // ToIUnknown converts Variant to Unknown object. func (v *VARIANT) ToIUnknown() *IUnknown { if v.VT != VT_UNKNOWN { return nil } return (*IUnknown)(unsafe.Pointer(uintptr(v.Val))) } // ToIDispatch converts variant to dispatch object. func (v *VARIANT) ToIDispatch() *IDispatch { if v.VT != VT_DISPATCH { return nil } return (*IDispatch)(unsafe.Pointer(uintptr(v.Val))) } // ToArray converts variant to SafeArray helper. func (v *VARIANT) ToArray() *SafeArrayConversion { if v.VT != VT_SAFEARRAY { if v.VT&VT_ARRAY == 0 { return nil } } var safeArray *SafeArray = (*SafeArray)(unsafe.Pointer(uintptr(v.Val))) return &SafeArrayConversion{safeArray} } // ToString converts variant to Go string. func (v *VARIANT) ToString() string { if v.VT != VT_BSTR { return "" } return BstrToString(*(**uint16)(unsafe.Pointer(&v.Val))) } // Clear the memory of variant object. func (v *VARIANT) Clear() error { return VariantClear(v) } // Value returns variant value based on its type. // // Currently supported types: 2- and 4-byte integers, strings, bools. // Note that 64-bit integers, datetimes, and other types are stored as strings // and will be returned as strings. // // Needs to be further converted, because this returns an interface{}. func (v *VARIANT) Value() interface{} { switch v.VT { case VT_I1: return int8(v.Val) case VT_UI1: return uint8(v.Val) case VT_I2: return int16(v.Val) case VT_UI2: return uint16(v.Val) case VT_I4: return int32(v.Val) case VT_UI4: return uint32(v.Val) case VT_I8: return int64(v.Val) case VT_UI8: return uint64(v.Val) case VT_INT: return int(v.Val) case VT_UINT: return uint(v.Val) case VT_INT_PTR: return uintptr(v.Val) // TODO case VT_UINT_PTR: return uintptr(v.Val) case VT_R4: return *(*float32)(unsafe.Pointer(&v.Val)) case VT_R8: return *(*float64)(unsafe.Pointer(&v.Val)) case VT_BSTR: return v.ToString() case VT_DATE: // VT_DATE type will either return float64 or time.Time. d := uint64(v.Val) date, err := GetVariantDate(d) if err != nil { return float64(v.Val) } return date case VT_UNKNOWN: return v.ToIUnknown() case VT_DISPATCH: return v.ToIDispatch() case VT_BOOL: return (v.Val & 0xffff) != 0 } return nil } golang-github-go-ole-go-ole-1.3.0/variant_386.go000066400000000000000000000002611510122243200211640ustar00rootroot00000000000000// +build 386 package ole type VARIANT struct { VT VT // 2 wReserved1 uint16 // 4 wReserved2 uint16 // 6 wReserved3 uint16 // 8 Val int64 // 16 } golang-github-go-ole-go-ole-1.3.0/variant_amd64.go000066400000000000000000000003221510122243200215550ustar00rootroot00000000000000// +build amd64 package ole type VARIANT struct { VT VT // 2 wReserved1 uint16 // 4 wReserved2 uint16 // 6 wReserved3 uint16 // 8 Val int64 // 16 _ [8]byte // 24 } golang-github-go-ole-go-ole-1.3.0/variant_arm.go000066400000000000000000000002611510122243200214230ustar00rootroot00000000000000// +build arm package ole type VARIANT struct { VT VT // 2 wReserved1 uint16 // 4 wReserved2 uint16 // 6 wReserved3 uint16 // 8 Val int64 // 16 } golang-github-go-ole-go-ole-1.3.0/variant_arm64.go000066400000000000000000000003431510122243200215760ustar00rootroot00000000000000//go:build arm64 // +build arm64 package ole type VARIANT struct { VT VT // 2 wReserved1 uint16 // 4 wReserved2 uint16 // 6 wReserved3 uint16 // 8 Val int64 // 16 _ [8]byte // 24 } golang-github-go-ole-go-ole-1.3.0/variant_date_386.go000066400000000000000000000012021510122243200221550ustar00rootroot00000000000000// +build windows,386 package ole import ( "errors" "syscall" "time" "unsafe" ) // GetVariantDate converts COM Variant Time value to Go time.Time. func GetVariantDate(value uint64) (time.Time, error) { var st syscall.Systemtime v1 := uint32(value) v2 := uint32(value >> 32) r, _, _ := procVariantTimeToSystemTime.Call(uintptr(v1), uintptr(v2), uintptr(unsafe.Pointer(&st))) if r != 0 { return time.Date(int(st.Year), time.Month(st.Month), int(st.Day), int(st.Hour), int(st.Minute), int(st.Second), int(st.Milliseconds/1000), time.UTC), nil } return time.Now(), errors.New("Could not convert to time, passing current time.") } golang-github-go-ole-go-ole-1.3.0/variant_date_amd64.go000066400000000000000000000011121510122243200225500ustar00rootroot00000000000000// +build windows,amd64 package ole import ( "errors" "syscall" "time" "unsafe" ) // GetVariantDate converts COM Variant Time value to Go time.Time. func GetVariantDate(value uint64) (time.Time, error) { var st syscall.Systemtime r, _, _ := procVariantTimeToSystemTime.Call(uintptr(value), uintptr(unsafe.Pointer(&st))) if r != 0 { return time.Date(int(st.Year), time.Month(st.Month), int(st.Day), int(st.Hour), int(st.Minute), int(st.Second), int(st.Milliseconds/1000), time.UTC), nil } return time.Now(), errors.New("Could not convert to time, passing current time.") } golang-github-go-ole-go-ole-1.3.0/variant_date_arm.go000066400000000000000000000012021510122243200224140ustar00rootroot00000000000000// +build windows,arm package ole import ( "errors" "syscall" "time" "unsafe" ) // GetVariantDate converts COM Variant Time value to Go time.Time. func GetVariantDate(value uint64) (time.Time, error) { var st syscall.Systemtime v1 := uint32(value) v2 := uint32(value >> 32) r, _, _ := procVariantTimeToSystemTime.Call(uintptr(v1), uintptr(v2), uintptr(unsafe.Pointer(&st))) if r != 0 { return time.Date(int(st.Year), time.Month(st.Month), int(st.Day), int(st.Hour), int(st.Minute), int(st.Second), int(st.Milliseconds/1000), time.UTC), nil } return time.Now(), errors.New("Could not convert to time, passing current time.") } golang-github-go-ole-go-ole-1.3.0/variant_date_arm64.go000066400000000000000000000012401510122243200225700ustar00rootroot00000000000000//go:build windows && arm64 // +build windows,arm64 package ole import ( "errors" "syscall" "time" "unsafe" ) // GetVariantDate converts COM Variant Time value to Go time.Time. func GetVariantDate(value uint64) (time.Time, error) { var st syscall.Systemtime v1 := uint32(value) v2 := uint32(value >> 32) r, _, _ := procVariantTimeToSystemTime.Call(uintptr(v1), uintptr(v2), uintptr(unsafe.Pointer(&st))) if r != 0 { return time.Date(int(st.Year), time.Month(st.Month), int(st.Day), int(st.Hour), int(st.Minute), int(st.Second), int(st.Milliseconds/1000), time.UTC), nil } return time.Now(), errors.New("Could not convert to time, passing current time.") } golang-github-go-ole-go-ole-1.3.0/variant_ppc64le.go000066400000000000000000000003241510122243200221210ustar00rootroot00000000000000// +build ppc64le package ole type VARIANT struct { VT VT // 2 wReserved1 uint16 // 4 wReserved2 uint16 // 6 wReserved3 uint16 // 8 Val int64 // 16 _ [8]byte // 24 } golang-github-go-ole-go-ole-1.3.0/variant_s390x.go000066400000000000000000000003221510122243200215300ustar00rootroot00000000000000// +build s390x package ole type VARIANT struct { VT VT // 2 wReserved1 uint16 // 4 wReserved2 uint16 // 6 wReserved3 uint16 // 8 Val int64 // 16 _ [8]byte // 24 } golang-github-go-ole-go-ole-1.3.0/vt_string.go000066400000000000000000000034401510122243200211410ustar00rootroot00000000000000// generated by stringer -output vt_string.go -type VT; DO NOT EDIT package ole import "fmt" const ( _VT_name_0 = "VT_EMPTYVT_NULLVT_I2VT_I4VT_R4VT_R8VT_CYVT_DATEVT_BSTRVT_DISPATCHVT_ERRORVT_BOOLVT_VARIANTVT_UNKNOWNVT_DECIMAL" _VT_name_1 = "VT_I1VT_UI1VT_UI2VT_UI4VT_I8VT_UI8VT_INTVT_UINTVT_VOIDVT_HRESULTVT_PTRVT_SAFEARRAYVT_CARRAYVT_USERDEFINEDVT_LPSTRVT_LPWSTR" _VT_name_2 = "VT_RECORDVT_INT_PTRVT_UINT_PTR" _VT_name_3 = "VT_FILETIMEVT_BLOBVT_STREAMVT_STORAGEVT_STREAMED_OBJECTVT_STORED_OBJECTVT_BLOB_OBJECTVT_CFVT_CLSID" _VT_name_4 = "VT_BSTR_BLOBVT_VECTOR" _VT_name_5 = "VT_ARRAY" _VT_name_6 = "VT_BYREF" _VT_name_7 = "VT_RESERVED" _VT_name_8 = "VT_ILLEGAL" ) var ( _VT_index_0 = [...]uint8{0, 8, 15, 20, 25, 30, 35, 40, 47, 54, 65, 73, 80, 90, 100, 110} _VT_index_1 = [...]uint8{0, 5, 11, 17, 23, 28, 34, 40, 47, 54, 64, 70, 82, 91, 105, 113, 122} _VT_index_2 = [...]uint8{0, 9, 19, 30} _VT_index_3 = [...]uint8{0, 11, 18, 27, 37, 55, 71, 85, 90, 98} _VT_index_4 = [...]uint8{0, 12, 21} _VT_index_5 = [...]uint8{0, 8} _VT_index_6 = [...]uint8{0, 8} _VT_index_7 = [...]uint8{0, 11} _VT_index_8 = [...]uint8{0, 10} ) func (i VT) String() string { switch { case 0 <= i && i <= 14: return _VT_name_0[_VT_index_0[i]:_VT_index_0[i+1]] case 16 <= i && i <= 31: i -= 16 return _VT_name_1[_VT_index_1[i]:_VT_index_1[i+1]] case 36 <= i && i <= 38: i -= 36 return _VT_name_2[_VT_index_2[i]:_VT_index_2[i+1]] case 64 <= i && i <= 72: i -= 64 return _VT_name_3[_VT_index_3[i]:_VT_index_3[i+1]] case 4095 <= i && i <= 4096: i -= 4095 return _VT_name_4[_VT_index_4[i]:_VT_index_4[i+1]] case i == 8192: return _VT_name_5 case i == 16384: return _VT_name_6 case i == 32768: return _VT_name_7 case i == 65535: return _VT_name_8 default: return fmt.Sprintf("VT(%d)", i) } } golang-github-go-ole-go-ole-1.3.0/winrt.go000066400000000000000000000046001510122243200202640ustar00rootroot00000000000000// +build windows package ole import ( "reflect" "syscall" "unicode/utf8" "unsafe" ) var ( procRoInitialize = modcombase.NewProc("RoInitialize") procRoActivateInstance = modcombase.NewProc("RoActivateInstance") procRoGetActivationFactory = modcombase.NewProc("RoGetActivationFactory") procWindowsCreateString = modcombase.NewProc("WindowsCreateString") procWindowsDeleteString = modcombase.NewProc("WindowsDeleteString") procWindowsGetStringRawBuffer = modcombase.NewProc("WindowsGetStringRawBuffer") ) func RoInitialize(thread_type uint32) (err error) { hr, _, _ := procRoInitialize.Call(uintptr(thread_type)) if hr != 0 { err = NewError(hr) } return } func RoActivateInstance(clsid string) (ins *IInspectable, err error) { hClsid, err := NewHString(clsid) if err != nil { return nil, err } defer DeleteHString(hClsid) hr, _, _ := procRoActivateInstance.Call( uintptr(unsafe.Pointer(hClsid)), uintptr(unsafe.Pointer(&ins))) if hr != 0 { err = NewError(hr) } return } func RoGetActivationFactory(clsid string, iid *GUID) (ins *IInspectable, err error) { hClsid, err := NewHString(clsid) if err != nil { return nil, err } defer DeleteHString(hClsid) hr, _, _ := procRoGetActivationFactory.Call( uintptr(unsafe.Pointer(hClsid)), uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&ins))) if hr != 0 { err = NewError(hr) } return } // HString is handle string for pointers. type HString uintptr // NewHString returns a new HString for Go string. func NewHString(s string) (hstring HString, err error) { u16 := syscall.StringToUTF16Ptr(s) len := uint32(utf8.RuneCountInString(s)) hr, _, _ := procWindowsCreateString.Call( uintptr(unsafe.Pointer(u16)), uintptr(len), uintptr(unsafe.Pointer(&hstring))) if hr != 0 { err = NewError(hr) } return } // DeleteHString deletes HString. func DeleteHString(hstring HString) (err error) { hr, _, _ := procWindowsDeleteString.Call(uintptr(hstring)) if hr != 0 { err = NewError(hr) } return } // String returns Go string value of HString. func (h HString) String() string { var u16buf uintptr var u16len uint32 u16buf, _, _ = procWindowsGetStringRawBuffer.Call( uintptr(h), uintptr(unsafe.Pointer(&u16len))) u16hdr := reflect.SliceHeader{Data: u16buf, Len: int(u16len), Cap: int(u16len)} u16 := *(*[]uint16)(unsafe.Pointer(&u16hdr)) return syscall.UTF16ToString(u16) } golang-github-go-ole-go-ole-1.3.0/winrt_doc.go000066400000000000000000000015121510122243200211100ustar00rootroot00000000000000// +build !windows package ole // RoInitialize func RoInitialize(thread_type uint32) (err error) { return NewError(E_NOTIMPL) } // RoActivateInstance func RoActivateInstance(clsid string) (ins *IInspectable, err error) { return nil, NewError(E_NOTIMPL) } // RoGetActivationFactory func RoGetActivationFactory(clsid string, iid *GUID) (ins *IInspectable, err error) { return nil, NewError(E_NOTIMPL) } // HString is handle string for pointers. type HString uintptr // NewHString returns a new HString for Go string. func NewHString(s string) (hstring HString, err error) { return HString(uintptr(0)), NewError(E_NOTIMPL) } // DeleteHString deletes HString. func DeleteHString(hstring HString) (err error) { return NewError(E_NOTIMPL) } // String returns Go string value of HString. func (h HString) String() string { return "" }