mirror of https://github.com/ethereum/go-ethereum
Péter Szilágyi
8 years ago
parent
bdef758d5c
commit
6ec8135256
@ -1,38 +0,0 @@ |
||||
// Copyright 2017 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
// This file contains the implementation for interacting with the Ledger hardware
|
||||
// wallets. The wire protocol spec can be found in the Ledger Blue GitHub repo:
|
||||
// https://raw.githubusercontent.com/LedgerHQ/blue-app-eth/master/doc/ethapp.asc
|
||||
|
||||
// +build ios
|
||||
|
||||
package usbwallet |
||||
|
||||
import ( |
||||
"errors" |
||||
|
||||
"github.com/ethereum/go-ethereum/accounts" |
||||
) |
||||
|
||||
// Here be dragons! There is no USB support on iOS.
|
||||
|
||||
// ErrIOSNotSupported is returned for all USB hardware backends on iOS.
|
||||
var ErrIOSNotSupported = errors.New("no USB support on iOS") |
||||
|
||||
func NewLedgerHub() (accounts.Backend, error) { |
||||
return nil, ErrIOSNotSupported |
||||
} |
||||
@ -1 +0,0 @@ |
||||
*.sw[op] |
||||
@ -1,12 +0,0 @@ |
||||
language: go |
||||
|
||||
matrix: |
||||
include: |
||||
- os: linux |
||||
dist: trusty |
||||
go: 1.7.4 |
||||
- os: osx |
||||
go: 1.7.4 |
||||
|
||||
script: |
||||
- go test -v -test.run='BCD|Parse' ./... |
||||
@ -1,202 +0,0 @@ |
||||
|
||||
Apache License |
||||
Version 2.0, January 2004 |
||||
http://www.apache.org/licenses/ |
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION |
||||
|
||||
1. Definitions. |
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction, |
||||
and distribution as defined by Sections 1 through 9 of this document. |
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by |
||||
the copyright owner that is granting the License. |
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all |
||||
other entities that control, are controlled by, or are under common |
||||
control with that entity. For the purposes of this definition, |
||||
"control" means (i) the power, direct or indirect, to cause the |
||||
direction or management of such entity, whether by contract or |
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the |
||||
outstanding shares, or (iii) beneficial ownership of such entity. |
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity |
||||
exercising permissions granted by this License. |
||||
|
||||
"Source" form shall mean the preferred form for making modifications, |
||||
including but not limited to software source code, documentation |
||||
source, and configuration files. |
||||
|
||||
"Object" form shall mean any form resulting from mechanical |
||||
transformation or translation of a Source form, including but |
||||
not limited to compiled object code, generated documentation, |
||||
and conversions to other media types. |
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or |
||||
Object form, made available under the License, as indicated by a |
||||
copyright notice that is included in or attached to the work |
||||
(an example is provided in the Appendix below). |
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object |
||||
form, that is based on (or derived from) the Work and for which the |
||||
editorial revisions, annotations, elaborations, or other modifications |
||||
represent, as a whole, an original work of authorship. For the purposes |
||||
of this License, Derivative Works shall not include works that remain |
||||
separable from, or merely link (or bind by name) to the interfaces of, |
||||
the Work and Derivative Works thereof. |
||||
|
||||
"Contribution" shall mean any work of authorship, including |
||||
the original version of the Work and any modifications or additions |
||||
to that Work or Derivative Works thereof, that is intentionally |
||||
submitted to Licensor for inclusion in the Work by the copyright owner |
||||
or by an individual or Legal Entity authorized to submit on behalf of |
||||
the copyright owner. For the purposes of this definition, "submitted" |
||||
means any form of electronic, verbal, or written communication sent |
||||
to the Licensor or its representatives, including but not limited to |
||||
communication on electronic mailing lists, source code control systems, |
||||
and issue tracking systems that are managed by, or on behalf of, the |
||||
Licensor for the purpose of discussing and improving the Work, but |
||||
excluding communication that is conspicuously marked or otherwise |
||||
designated in writing by the copyright owner as "Not a Contribution." |
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity |
||||
on behalf of whom a Contribution has been received by Licensor and |
||||
subsequently incorporated within the Work. |
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of |
||||
this License, each Contributor hereby grants to You a perpetual, |
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable |
||||
copyright license to reproduce, prepare Derivative Works of, |
||||
publicly display, publicly perform, sublicense, and distribute the |
||||
Work and such Derivative Works in Source or Object form. |
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of |
||||
this License, each Contributor hereby grants to You a perpetual, |
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable |
||||
(except as stated in this section) patent license to make, have made, |
||||
use, offer to sell, sell, import, and otherwise transfer the Work, |
||||
where such license applies only to those patent claims licensable |
||||
by such Contributor that are necessarily infringed by their |
||||
Contribution(s) alone or by combination of their Contribution(s) |
||||
with the Work to which such Contribution(s) was submitted. If You |
||||
institute patent litigation against any entity (including a |
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work |
||||
or a Contribution incorporated within the Work constitutes direct |
||||
or contributory patent infringement, then any patent licenses |
||||
granted to You under this License for that Work shall terminate |
||||
as of the date such litigation is filed. |
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the |
||||
Work or Derivative Works thereof in any medium, with or without |
||||
modifications, and in Source or Object form, provided that You |
||||
meet the following conditions: |
||||
|
||||
(a) You must give any other recipients of the Work or |
||||
Derivative Works a copy of this License; and |
||||
|
||||
(b) You must cause any modified files to carry prominent notices |
||||
stating that You changed the files; and |
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works |
||||
that You distribute, all copyright, patent, trademark, and |
||||
attribution notices from the Source form of the Work, |
||||
excluding those notices that do not pertain to any part of |
||||
the Derivative Works; and |
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its |
||||
distribution, then any Derivative Works that You distribute must |
||||
include a readable copy of the attribution notices contained |
||||
within such NOTICE file, excluding those notices that do not |
||||
pertain to any part of the Derivative Works, in at least one |
||||
of the following places: within a NOTICE text file distributed |
||||
as part of the Derivative Works; within the Source form or |
||||
documentation, if provided along with the Derivative Works; or, |
||||
within a display generated by the Derivative Works, if and |
||||
wherever such third-party notices normally appear. The contents |
||||
of the NOTICE file are for informational purposes only and |
||||
do not modify the License. You may add Your own attribution |
||||
notices within Derivative Works that You distribute, alongside |
||||
or as an addendum to the NOTICE text from the Work, provided |
||||
that such additional attribution notices cannot be construed |
||||
as modifying the License. |
||||
|
||||
You may add Your own copyright statement to Your modifications and |
||||
may provide additional or different license terms and conditions |
||||
for use, reproduction, or distribution of Your modifications, or |
||||
for any such Derivative Works as a whole, provided Your use, |
||||
reproduction, and distribution of the Work otherwise complies with |
||||
the conditions stated in this License. |
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise, |
||||
any Contribution intentionally submitted for inclusion in the Work |
||||
by You to the Licensor shall be under the terms and conditions of |
||||
this License, without any additional terms or conditions. |
||||
Notwithstanding the above, nothing herein shall supersede or modify |
||||
the terms of any separate license agreement you may have executed |
||||
with Licensor regarding such Contributions. |
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade |
||||
names, trademarks, service marks, or product names of the Licensor, |
||||
except as required for reasonable and customary use in describing the |
||||
origin of the Work and reproducing the content of the NOTICE file. |
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or |
||||
agreed to in writing, Licensor provides the Work (and each |
||||
Contributor provides its Contributions) on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
||||
implied, including, without limitation, any warranties or conditions |
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A |
||||
PARTICULAR PURPOSE. You are solely responsible for determining the |
||||
appropriateness of using or redistributing the Work and assume any |
||||
risks associated with Your exercise of permissions under this License. |
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory, |
||||
whether in tort (including negligence), contract, or otherwise, |
||||
unless required by applicable law (such as deliberate and grossly |
||||
negligent acts) or agreed to in writing, shall any Contributor be |
||||
liable to You for damages, including any direct, indirect, special, |
||||
incidental, or consequential damages of any character arising as a |
||||
result of this License or out of the use or inability to use the |
||||
Work (including but not limited to damages for loss of goodwill, |
||||
work stoppage, computer failure or malfunction, or any and all |
||||
other commercial damages or losses), even if such Contributor |
||||
has been advised of the possibility of such damages. |
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing |
||||
the Work or Derivative Works thereof, You may choose to offer, |
||||
and charge a fee for, acceptance of support, warranty, indemnity, |
||||
or other liability obligations and/or rights consistent with this |
||||
License. However, in accepting such obligations, You may act only |
||||
on Your own behalf and on Your sole responsibility, not on behalf |
||||
of any other Contributor, and only if You agree to indemnify, |
||||
defend, and hold each Contributor harmless for any liability |
||||
incurred by, or claims asserted against, such Contributor by reason |
||||
of your accepting any such warranty or additional liability. |
||||
|
||||
END OF TERMS AND CONDITIONS |
||||
|
||||
APPENDIX: How to apply the Apache License to your work. |
||||
|
||||
To apply the Apache License to your work, attach the following |
||||
boilerplate notice, with the fields enclosed by brackets "[]" |
||||
replaced with your own identifying information. (Don't include |
||||
the brackets!) The text should be enclosed in the appropriate |
||||
comment syntax for the file format. We also recommend that a |
||||
file or class name and description of purpose be included on the |
||||
same "printed page" as the copyright notice for easier |
||||
identification within third-party archives. |
||||
|
||||
Copyright [yyyy] [name of copyright owner] |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0 |
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
limitations under the License. |
||||
@ -1,47 +0,0 @@ |
||||
Introduction |
||||
============ |
||||
|
||||
[![Travis Build Status][travisimg]][travis] |
||||
[![AppVeyor Build Status][appveyorimg]][appveyor] |
||||
[![GoDoc][docimg]][doc] |
||||
|
||||
The gousb package is an attempt at wrapping the `libusb` library into a Go-like binding in a fully self-contained, go-gettable package. Supported platforms include Linux, macOS and Windows as well as the mobile platforms Android and iOS. |
||||
|
||||
This package is a fork of [`github.com/kylelemons/gousb`](https://github.com/kylelemons/gousb), which at the moment seems to be unmaintained. The current fork is different from the upstream package as it contains code to embed `libusb` directly into the Go package (thus becoming fully self-cotnained and go-gettable), as well as it features a few contributions and bugfixes that never really got addressed in the upstream package, but which address important issues nonetheless. |
||||
|
||||
*Note, if @kylelemons decides to pick development of the upstream project up again, consider all commits made by me to this repo as ready contributions. I cannot vouch for other commits as the upstream repo needs a signed CLA for Google.* |
||||
|
||||
[travisimg]: https://travis-ci.org/karalabe/gousb.svg?branch=master |
||||
[travis]: https://travis-ci.org/karalabe/gousb |
||||
[appveyorimg]: https://ci.appveyor.com/api/projects/status/84k9xse10rl72gn2/branch/master?svg=true |
||||
[appveyor]: https://ci.appveyor.com/project/karalabe/gousb |
||||
[docimg]: https://godoc.org/github.com/karalabe/gousb?status.svg |
||||
[doc]: https://godoc.org/github.com/karalabe/gousb |
||||
|
||||
Installation |
||||
============ |
||||
|
||||
Example: lsusb |
||||
-------------- |
||||
The gousb project provides a simple but useful example: lsusb. This binary will list the USB devices connected to your system and various interesting tidbits about them, their configurations, endpoints, etc. To install it, run the following command: |
||||
|
||||
go get -v github.com/karalabe/gousb/lsusb |
||||
|
||||
gousb |
||||
----- |
||||
If you installed the lsusb example, both libraries below are already installed. |
||||
|
||||
Installing the primary gousb package is really easy: |
||||
|
||||
go get -v github.com/karalabe/gousb/usb |
||||
|
||||
There is also a `usbid` package that will not be installed by default by this command, but which provides useful information including the human-readable vendor and product codes for detected hardware. It's not installed by default and not linked into the `usb` package by default because it adds ~400kb to the resulting binary. If you want both, they can be installed thus: |
||||
|
||||
go get -v github.com/karalabe/gousb/usb{,id} |
||||
|
||||
Documentation |
||||
============= |
||||
The documentation can be viewed via local godoc or via the excellent [godoc.org](http://godoc.org/): |
||||
|
||||
- [usb](http://godoc.org/github.com/karalabe/gousb/usb) |
||||
- [usbid](http://godoc.org/pkg/github.com/karalabe/gousb/usbid) |
||||
@ -1,34 +0,0 @@ |
||||
os: Visual Studio 2015 |
||||
|
||||
# Clone directly into GOPATH. |
||||
clone_folder: C:\gopath\src\github.com\karalabe\gousb |
||||
clone_depth: 5 |
||||
version: "{branch}.{build}" |
||||
environment: |
||||
global: |
||||
GOPATH: C:\gopath |
||||
CC: gcc.exe |
||||
matrix: |
||||
- GOARCH: amd64 |
||||
MSYS2_ARCH: x86_64 |
||||
MSYS2_BITS: 64 |
||||
MSYSTEM: MINGW64 |
||||
PATH: C:\msys64\mingw64\bin\;%PATH% |
||||
- GOARCH: 386 |
||||
MSYS2_ARCH: i686 |
||||
MSYS2_BITS: 32 |
||||
MSYSTEM: MINGW32 |
||||
PATH: C:\msys64\mingw32\bin\;%PATH% |
||||
|
||||
install: |
||||
- rmdir C:\go /s /q |
||||
- appveyor DownloadFile https://storage.googleapis.com/golang/go1.7.4.windows-%GOARCH%.zip |
||||
- 7z x go1.7.4.windows-%GOARCH%.zip -y -oC:\ > NUL |
||||
- go version |
||||
- gcc --version |
||||
|
||||
build_script: |
||||
- go install ./... |
||||
|
||||
test_script: |
||||
- go test -v -test.run="BCD|Parse" ./... |
||||
@ -1,153 +0,0 @@ |
||||
// Copyright 2013 Google Inc. All rights reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package usb |
||||
|
||||
/* |
||||
#ifndef OS_WINDOWS |
||||
#include "os/threads_posix.h" |
||||
#endif |
||||
#include "libusbi.h" |
||||
#include "libusb.h" |
||||
*/ |
||||
import "C" |
||||
|
||||
import ( |
||||
"fmt" |
||||
"reflect" |
||||
"unsafe" |
||||
) |
||||
|
||||
type EndpointInfo struct { |
||||
Address uint8 |
||||
Attributes uint8 |
||||
MaxPacketSize uint16 |
||||
MaxIsoPacket uint32 |
||||
PollInterval uint8 |
||||
RefreshRate uint8 |
||||
SynchAddress uint8 |
||||
} |
||||
|
||||
func (e EndpointInfo) Number() int { |
||||
return int(e.Address) & ENDPOINT_NUM_MASK |
||||
} |
||||
|
||||
func (e EndpointInfo) Direction() EndpointDirection { |
||||
return EndpointDirection(e.Address) & ENDPOINT_DIR_MASK |
||||
} |
||||
|
||||
func (e EndpointInfo) String() string { |
||||
return fmt.Sprintf("Endpoint %d %-3s %s - %s %s [%d %d]", |
||||
e.Number(), e.Direction(), |
||||
TransferType(e.Attributes)&TRANSFER_TYPE_MASK, |
||||
IsoSyncType(e.Attributes)&ISO_SYNC_TYPE_MASK, |
||||
IsoUsageType(e.Attributes)&ISO_USAGE_TYPE_MASK, |
||||
e.MaxPacketSize, e.MaxIsoPacket, |
||||
) |
||||
} |
||||
|
||||
type InterfaceInfo struct { |
||||
Number uint8 |
||||
Setups []InterfaceSetup |
||||
} |
||||
|
||||
func (i InterfaceInfo) String() string { |
||||
return fmt.Sprintf("Interface %02x (%d setups)", i.Number, len(i.Setups)) |
||||
} |
||||
|
||||
type InterfaceSetup struct { |
||||
Number uint8 |
||||
Alternate uint8 |
||||
IfClass uint8 |
||||
IfSubClass uint8 |
||||
IfProtocol uint8 |
||||
Endpoints []EndpointInfo |
||||
} |
||||
|
||||
func (a InterfaceSetup) String() string { |
||||
return fmt.Sprintf("Interface %02x Setup %02x", a.Number, a.Alternate) |
||||
} |
||||
|
||||
type ConfigInfo struct { |
||||
Config uint8 |
||||
Attributes uint8 |
||||
MaxPower uint8 |
||||
Interfaces []InterfaceInfo |
||||
} |
||||
|
||||
func (c ConfigInfo) String() string { |
||||
return fmt.Sprintf("Config %02x", c.Config) |
||||
} |
||||
|
||||
func newConfig(dev *C.libusb_device, cfg *C.struct_libusb_config_descriptor) ConfigInfo { |
||||
c := ConfigInfo{ |
||||
Config: uint8(cfg.bConfigurationValue), |
||||
Attributes: uint8(cfg.bmAttributes), |
||||
MaxPower: uint8(cfg.MaxPower), |
||||
} |
||||
|
||||
var ifaces []C.struct_libusb_interface |
||||
*(*reflect.SliceHeader)(unsafe.Pointer(&ifaces)) = reflect.SliceHeader{ |
||||
Data: uintptr(unsafe.Pointer(cfg._interface)), |
||||
Len: int(cfg.bNumInterfaces), |
||||
Cap: int(cfg.bNumInterfaces), |
||||
} |
||||
c.Interfaces = make([]InterfaceInfo, 0, len(ifaces)) |
||||
for _, iface := range ifaces { |
||||
if iface.num_altsetting == 0 { |
||||
continue |
||||
} |
||||
|
||||
var alts []C.struct_libusb_interface_descriptor |
||||
*(*reflect.SliceHeader)(unsafe.Pointer(&alts)) = reflect.SliceHeader{ |
||||
Data: uintptr(unsafe.Pointer(iface.altsetting)), |
||||
Len: int(iface.num_altsetting), |
||||
Cap: int(iface.num_altsetting), |
||||
} |
||||
descs := make([]InterfaceSetup, 0, len(alts)) |
||||
for _, alt := range alts { |
||||
i := InterfaceSetup{ |
||||
Number: uint8(alt.bInterfaceNumber), |
||||
Alternate: uint8(alt.bAlternateSetting), |
||||
IfClass: uint8(alt.bInterfaceClass), |
||||
IfSubClass: uint8(alt.bInterfaceSubClass), |
||||
IfProtocol: uint8(alt.bInterfaceProtocol), |
||||
} |
||||
var ends []C.struct_libusb_endpoint_descriptor |
||||
*(*reflect.SliceHeader)(unsafe.Pointer(&ends)) = reflect.SliceHeader{ |
||||
Data: uintptr(unsafe.Pointer(alt.endpoint)), |
||||
Len: int(alt.bNumEndpoints), |
||||
Cap: int(alt.bNumEndpoints), |
||||
} |
||||
i.Endpoints = make([]EndpointInfo, 0, len(ends)) |
||||
for _, end := range ends { |
||||
i.Endpoints = append(i.Endpoints, EndpointInfo{ |
||||
Address: uint8(end.bEndpointAddress), |
||||
Attributes: uint8(end.bmAttributes), |
||||
MaxPacketSize: uint16(end.wMaxPacketSize), |
||||
//MaxIsoPacket: uint32(C.libusb_get_max_iso_packet_size(dev, C.uchar(end.bEndpointAddress))),
|
||||
PollInterval: uint8(end.bInterval), |
||||
RefreshRate: uint8(end.bRefresh), |
||||
SynchAddress: uint8(end.bSynchAddress), |
||||
}) |
||||
} |
||||
descs = append(descs, i) |
||||
} |
||||
c.Interfaces = append(c.Interfaces, InterfaceInfo{ |
||||
Number: descs[0].Number, |
||||
Setups: descs, |
||||
}) |
||||
} |
||||
return c |
||||
} |
||||
@ -1,183 +0,0 @@ |
||||
// Copyright 2013 Google Inc. All rights reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package usb |
||||
|
||||
// #include "libusb.h"
|
||||
import "C" |
||||
|
||||
type Class uint8 |
||||
|
||||
const ( |
||||
CLASS_PER_INTERFACE Class = C.LIBUSB_CLASS_PER_INTERFACE |
||||
CLASS_AUDIO Class = C.LIBUSB_CLASS_AUDIO |
||||
CLASS_COMM Class = C.LIBUSB_CLASS_COMM |
||||
CLASS_HID Class = C.LIBUSB_CLASS_HID |
||||
CLASS_PRINTER Class = C.LIBUSB_CLASS_PRINTER |
||||
CLASS_PTP Class = C.LIBUSB_CLASS_PTP |
||||
CLASS_MASS_STORAGE Class = C.LIBUSB_CLASS_MASS_STORAGE |
||||
CLASS_HUB Class = C.LIBUSB_CLASS_HUB |
||||
CLASS_DATA Class = C.LIBUSB_CLASS_DATA |
||||
CLASS_WIRELESS Class = C.LIBUSB_CLASS_WIRELESS |
||||
CLASS_APPLICATION Class = C.LIBUSB_CLASS_APPLICATION |
||||
CLASS_VENDOR_SPEC Class = C.LIBUSB_CLASS_VENDOR_SPEC |
||||
) |
||||
|
||||
var classDescription = map[Class]string{ |
||||
CLASS_PER_INTERFACE: "per-interface", |
||||
CLASS_AUDIO: "audio", |
||||
CLASS_COMM: "communications", |
||||
CLASS_HID: "human interface device", |
||||
CLASS_PRINTER: "printer dclass", |
||||
CLASS_PTP: "picture transfer protocol", |
||||
CLASS_MASS_STORAGE: "mass storage", |
||||
CLASS_HUB: "hub", |
||||
CLASS_DATA: "data", |
||||
CLASS_WIRELESS: "wireless", |
||||
CLASS_APPLICATION: "application", |
||||
CLASS_VENDOR_SPEC: "vendor-specific", |
||||
} |
||||
|
||||
func (c Class) String() string { |
||||
return classDescription[c] |
||||
} |
||||
|
||||
type DescriptorType uint8 |
||||
|
||||
const ( |
||||
DT_DEVICE DescriptorType = C.LIBUSB_DT_DEVICE |
||||
DT_CONFIG DescriptorType = C.LIBUSB_DT_CONFIG |
||||
DT_STRING DescriptorType = C.LIBUSB_DT_STRING |
||||
DT_INTERFACE DescriptorType = C.LIBUSB_DT_INTERFACE |
||||
DT_ENDPOINT DescriptorType = C.LIBUSB_DT_ENDPOINT |
||||
DT_HID DescriptorType = C.LIBUSB_DT_HID |
||||
DT_REPORT DescriptorType = C.LIBUSB_DT_REPORT |
||||
DT_PHYSICAL DescriptorType = C.LIBUSB_DT_PHYSICAL |
||||
DT_HUB DescriptorType = C.LIBUSB_DT_HUB |
||||
) |
||||
|
||||
var descriptorTypeDescription = map[DescriptorType]string{ |
||||
DT_DEVICE: "device", |
||||
DT_CONFIG: "configuration", |
||||
DT_STRING: "string", |
||||
DT_INTERFACE: "interface", |
||||
DT_ENDPOINT: "endpoint", |
||||
DT_HID: "HID", |
||||
DT_REPORT: "HID report", |
||||
DT_PHYSICAL: "physical", |
||||
DT_HUB: "hub", |
||||
} |
||||
|
||||
func (dt DescriptorType) String() string { |
||||
return descriptorTypeDescription[dt] |
||||
} |
||||
|
||||
type EndpointDirection uint8 |
||||
|
||||
const ( |
||||
ENDPOINT_NUM_MASK = 0x03 |
||||
ENDPOINT_DIR_IN EndpointDirection = C.LIBUSB_ENDPOINT_IN |
||||
ENDPOINT_DIR_OUT EndpointDirection = C.LIBUSB_ENDPOINT_OUT |
||||
ENDPOINT_DIR_MASK EndpointDirection = 0x80 |
||||
) |
||||
|
||||
var endpointDirectionDescription = map[EndpointDirection]string{ |
||||
ENDPOINT_DIR_IN: "IN", |
||||
ENDPOINT_DIR_OUT: "OUT", |
||||
} |
||||
|
||||
func (ed EndpointDirection) String() string { |
||||
return endpointDirectionDescription[ed] |
||||
} |
||||
|
||||
type TransferType uint8 |
||||
|
||||
const ( |
||||
TRANSFER_TYPE_CONTROL TransferType = C.LIBUSB_TRANSFER_TYPE_CONTROL |
||||
TRANSFER_TYPE_ISOCHRONOUS TransferType = C.LIBUSB_TRANSFER_TYPE_ISOCHRONOUS |
||||
TRANSFER_TYPE_BULK TransferType = C.LIBUSB_TRANSFER_TYPE_BULK |
||||
TRANSFER_TYPE_INTERRUPT TransferType = C.LIBUSB_TRANSFER_TYPE_INTERRUPT |
||||
TRANSFER_TYPE_MASK TransferType = 0x03 |
||||
) |
||||
|
||||
var transferTypeDescription = map[TransferType]string{ |
||||
TRANSFER_TYPE_CONTROL: "control", |
||||
TRANSFER_TYPE_ISOCHRONOUS: "isochronous", |
||||
TRANSFER_TYPE_BULK: "bulk", |
||||
TRANSFER_TYPE_INTERRUPT: "interrupt", |
||||
} |
||||
|
||||
func (tt TransferType) String() string { |
||||
return transferTypeDescription[tt] |
||||
} |
||||
|
||||
type IsoSyncType uint8 |
||||
|
||||
const ( |
||||
ISO_SYNC_TYPE_NONE IsoSyncType = C.LIBUSB_ISO_SYNC_TYPE_NONE << 2 |
||||
ISO_SYNC_TYPE_ASYNC IsoSyncType = C.LIBUSB_ISO_SYNC_TYPE_ASYNC << 2 |
||||
ISO_SYNC_TYPE_ADAPTIVE IsoSyncType = C.LIBUSB_ISO_SYNC_TYPE_ADAPTIVE << 2 |
||||
ISO_SYNC_TYPE_SYNC IsoSyncType = C.LIBUSB_ISO_SYNC_TYPE_SYNC << 2 |
||||
ISO_SYNC_TYPE_MASK IsoSyncType = 0x0C |
||||
) |
||||
|
||||
var isoSyncTypeDescription = map[IsoSyncType]string{ |
||||
ISO_SYNC_TYPE_NONE: "unsynchronized", |
||||
ISO_SYNC_TYPE_ASYNC: "asynchronous", |
||||
ISO_SYNC_TYPE_ADAPTIVE: "adaptive", |
||||
ISO_SYNC_TYPE_SYNC: "synchronous", |
||||
} |
||||
|
||||
func (ist IsoSyncType) String() string { |
||||
return isoSyncTypeDescription[ist] |
||||
} |
||||
|
||||
type IsoUsageType uint8 |
||||
|
||||
const ( |
||||
ISO_USAGE_TYPE_DATA IsoUsageType = C.LIBUSB_ISO_USAGE_TYPE_DATA << 4 |
||||
ISO_USAGE_TYPE_FEEDBACK IsoUsageType = C.LIBUSB_ISO_USAGE_TYPE_FEEDBACK << 4 |
||||
ISO_USAGE_TYPE_IMPLICIT IsoUsageType = C.LIBUSB_ISO_USAGE_TYPE_IMPLICIT << 4 |
||||
ISO_USAGE_TYPE_MASK IsoUsageType = 0x30 |
||||
) |
||||
|
||||
var isoUsageTypeDescription = map[IsoUsageType]string{ |
||||
ISO_USAGE_TYPE_DATA: "data", |
||||
ISO_USAGE_TYPE_FEEDBACK: "feedback", |
||||
ISO_USAGE_TYPE_IMPLICIT: "implicit data", |
||||
} |
||||
|
||||
func (iut IsoUsageType) String() string { |
||||
return isoUsageTypeDescription[iut] |
||||
} |
||||
|
||||
type RequestType uint8 |
||||
|
||||
const ( |
||||
REQUEST_TYPE_STANDARD = C.LIBUSB_REQUEST_TYPE_STANDARD |
||||
REQUEST_TYPE_CLASS = C.LIBUSB_REQUEST_TYPE_CLASS |
||||
REQUEST_TYPE_VENDOR = C.LIBUSB_REQUEST_TYPE_VENDOR |
||||
REQUEST_TYPE_RESERVED = C.LIBUSB_REQUEST_TYPE_RESERVED |
||||
) |
||||
|
||||
var requestTypeDescription = map[RequestType]string{ |
||||
REQUEST_TYPE_STANDARD: "standard", |
||||
REQUEST_TYPE_CLASS: "class", |
||||
REQUEST_TYPE_VENDOR: "vendor", |
||||
REQUEST_TYPE_RESERVED: "reserved", |
||||
} |
||||
|
||||
func (rt RequestType) String() string { |
||||
return requestTypeDescription[rt] |
||||
} |
||||
@ -1,36 +0,0 @@ |
||||
// Copyright 2013 Google Inc. All rights reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package usb |
||||
|
||||
// To enable internal debugging:
|
||||
// -ldflags "-X github.com/karalabe/gousb/usb.debugInternal true"
|
||||
|
||||
import ( |
||||
"io" |
||||
"io/ioutil" |
||||
"log" // TODO(kevlar): make a logger
|
||||
"os" |
||||
) |
||||
|
||||
var debug *log.Logger |
||||
var debugInternal string |
||||
|
||||
func init() { |
||||
var out io.Writer = ioutil.Discard |
||||
if debugInternal != "" { |
||||
out = os.Stderr |
||||
} |
||||
debug = log.New(out, "usb", log.LstdFlags|log.Lshortfile) |
||||
} |
||||
@ -1,77 +0,0 @@ |
||||
// Copyright 2013 Google Inc. All rights reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package usb |
||||
|
||||
/* |
||||
#ifndef OS_WINDOWS |
||||
#include "os/threads_posix.h" |
||||
#endif |
||||
#include "libusbi.h" |
||||
#include "libusb.h" |
||||
*/ |
||||
import "C" |
||||
|
||||
type Descriptor struct { |
||||
// Bus information
|
||||
Bus uint8 // The bus on which the device was detected
|
||||
Address uint8 // The address of the device on the bus
|
||||
|
||||
// Version information
|
||||
Spec BCD // USB Specification Release Number
|
||||
Device BCD // The device version
|
||||
|
||||
// Product information
|
||||
Vendor ID // The Vendor identifer
|
||||
Product ID // The Product identifier
|
||||
|
||||
// Protocol information
|
||||
Class uint8 // The class of this device
|
||||
SubClass uint8 // The sub-class (within the class) of this device
|
||||
Protocol uint8 // The protocol (within the sub-class) of this device
|
||||
|
||||
// Configuration information
|
||||
Configs []ConfigInfo |
||||
} |
||||
|
||||
func newDescriptor(dev *C.libusb_device) (*Descriptor, error) { |
||||
var desc C.struct_libusb_device_descriptor |
||||
if errno := C.libusb_get_device_descriptor(dev, &desc); errno < 0 { |
||||
return nil, usbError(errno) |
||||
} |
||||
|
||||
// Enumerate configurations
|
||||
var cfgs []ConfigInfo |
||||
for i := 0; i < int(desc.bNumConfigurations); i++ { |
||||
var cfg *C.struct_libusb_config_descriptor |
||||
if errno := C.libusb_get_config_descriptor(dev, C.uint8_t(i), &cfg); errno < 0 { |
||||
return nil, usbError(errno) |
||||
} |
||||
cfgs = append(cfgs, newConfig(dev, cfg)) |
||||
C.libusb_free_config_descriptor(cfg) |
||||
} |
||||
|
||||
return &Descriptor{ |
||||
Bus: uint8(C.libusb_get_bus_number(dev)), |
||||
Address: uint8(C.libusb_get_device_address(dev)), |
||||
Spec: BCD(desc.bcdUSB), |
||||
Device: BCD(desc.bcdDevice), |
||||
Vendor: ID(desc.idVendor), |
||||
Product: ID(desc.idProduct), |
||||
Class: uint8(desc.bDeviceClass), |
||||
SubClass: uint8(desc.bDeviceSubClass), |
||||
Protocol: uint8(desc.bDeviceProtocol), |
||||
Configs: cfgs, |
||||
}, nil |
||||
} |
||||
@ -1,295 +0,0 @@ |
||||
// Copyright 2013 Google Inc. All rights reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package usb |
||||
|
||||
/* |
||||
#ifndef OS_WINDOWS |
||||
#include "os/threads_posix.h" |
||||
#endif |
||||
#include "libusbi.h" |
||||
#include "libusb.h" |
||||
*/ |
||||
import "C" |
||||
|
||||
import ( |
||||
"fmt" |
||||
"reflect" |
||||
"sync" |
||||
"time" |
||||
"unsafe" |
||||
) |
||||
|
||||
var DefaultReadTimeout = 1 * time.Second |
||||
var DefaultWriteTimeout = 1 * time.Second |
||||
var DefaultControlTimeout = 250 * time.Millisecond //5 * time.Second
|
||||
|
||||
type Device struct { |
||||
handle *C.libusb_device_handle |
||||
|
||||
// Embed the device information for easy access
|
||||
*Descriptor |
||||
|
||||
// Timeouts
|
||||
ReadTimeout time.Duration |
||||
WriteTimeout time.Duration |
||||
ControlTimeout time.Duration |
||||
|
||||
// Claimed interfaces
|
||||
lock *sync.Mutex |
||||
claimed map[uint8]int |
||||
|
||||
// Detached kernel interfaces
|
||||
detached map[uint8]int |
||||
} |
||||
|
||||
func newDevice(handle *C.libusb_device_handle, desc *Descriptor) (*Device, error) { |
||||
ifaces := 0 |
||||
d := &Device{ |
||||
handle: handle, |
||||
Descriptor: desc, |
||||
ReadTimeout: DefaultReadTimeout, |
||||
WriteTimeout: DefaultWriteTimeout, |
||||
ControlTimeout: DefaultControlTimeout, |
||||
lock: new(sync.Mutex), |
||||
claimed: make(map[uint8]int, ifaces), |
||||
detached: make(map[uint8]int), |
||||
} |
||||
|
||||
if err := d.detachKernelDriver(); err != nil { |
||||
d.Close() |
||||
return nil, err |
||||
} |
||||
|
||||
return d, nil |
||||
} |
||||
|
||||
// detachKernelDriver detaches any active kernel drivers, if supported by the platform.
|
||||
// If there are any errors, like Context.ListDevices, only the final one will be returned.
|
||||
func (d *Device) detachKernelDriver() (err error) { |
||||
for _, cfg := range d.Configs { |
||||
for _, iface := range cfg.Interfaces { |
||||
switch activeErr := C.libusb_kernel_driver_active(d.handle, C.int(iface.Number)); activeErr { |
||||
case C.LIBUSB_ERROR_NOT_SUPPORTED: |
||||
// no need to do any futher checking, no platform support
|
||||
return |
||||
case 0: |
||||
continue |
||||
case 1: |
||||
switch detachErr := C.libusb_detach_kernel_driver(d.handle, C.int(iface.Number)); detachErr { |
||||
case C.LIBUSB_ERROR_NOT_SUPPORTED: |
||||
// shouldn't ever get here, should be caught by the outer switch
|
||||
return |
||||
case 0: |
||||
d.detached[iface.Number]++ |
||||
case C.LIBUSB_ERROR_NOT_FOUND: |
||||
// this status is returned if libusb's driver is already attached to the device
|
||||
d.detached[iface.Number]++ |
||||
default: |
||||
err = fmt.Errorf("usb: detach kernel driver: %s", usbError(detachErr)) |
||||
} |
||||
default: |
||||
err = fmt.Errorf("usb: active kernel driver check: %s", usbError(activeErr)) |
||||
} |
||||
} |
||||
} |
||||
|
||||
return |
||||
} |
||||
|
||||
// attachKernelDriver re-attaches kernel drivers to any previously detached interfaces, if supported by the platform.
|
||||
// If there are any errors, like Context.ListDevices, only the final one will be returned.
|
||||
func (d *Device) attachKernelDriver() (err error) { |
||||
for iface := range d.detached { |
||||
switch attachErr := C.libusb_attach_kernel_driver(d.handle, C.int(iface)); attachErr { |
||||
case C.LIBUSB_ERROR_NOT_SUPPORTED: |
||||
// no need to do any futher checking, no platform support
|
||||
return |
||||
case 0: |
||||
continue |
||||
default: |
||||
err = fmt.Errorf("usb: attach kernel driver: %s", usbError(attachErr)) |
||||
} |
||||
} |
||||
|
||||
return |
||||
} |
||||
|
||||
func (d *Device) Reset() error { |
||||
if errno := C.libusb_reset_device(d.handle); errno != 0 { |
||||
return usbError(errno) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (d *Device) Control(rType, request uint8, val, idx uint16, data []byte) (int, error) { |
||||
//log.Printf("control xfer: %d:%d/%d:%d %x", idx, rType, request, val, string(data))
|
||||
dataSlice := (*reflect.SliceHeader)(unsafe.Pointer(&data)) |
||||
n := C.libusb_control_transfer( |
||||
d.handle, |
||||
C.uint8_t(rType), |
||||
C.uint8_t(request), |
||||
C.uint16_t(val), |
||||
C.uint16_t(idx), |
||||
(*C.uchar)(unsafe.Pointer(dataSlice.Data)), |
||||
C.uint16_t(len(data)), |
||||
C.uint(d.ControlTimeout/time.Millisecond)) |
||||
if n < 0 { |
||||
return int(n), usbError(n) |
||||
} |
||||
return int(n), nil |
||||
} |
||||
|
||||
// ActiveConfig returns the config id (not the index) of the active configuration.
|
||||
// This corresponds to the ConfigInfo.Config field.
|
||||
func (d *Device) ActiveConfig() (uint8, error) { |
||||
var cfg C.int |
||||
if errno := C.libusb_get_configuration(d.handle, &cfg); errno < 0 { |
||||
return 0, usbError(errno) |
||||
} |
||||
return uint8(cfg), nil |
||||
} |
||||
|
||||
// SetConfig attempts to change the active configuration.
|
||||
// The cfg provided is the config id (not the index) of the configuration to set,
|
||||
// which corresponds to the ConfigInfo.Config field.
|
||||
func (d *Device) SetConfig(cfg uint8) error { |
||||
if errno := C.libusb_set_configuration(d.handle, C.int(cfg)); errno < 0 { |
||||
return usbError(errno) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// Close the device.
|
||||
func (d *Device) Close() error { |
||||
if d.handle == nil { |
||||
return fmt.Errorf("usb: double close on device") |
||||
} |
||||
d.lock.Lock() |
||||
defer d.lock.Unlock() |
||||
for iface := range d.claimed { |
||||
C.libusb_release_interface(d.handle, C.int(iface)) |
||||
} |
||||
d.attachKernelDriver() |
||||
C.libusb_close(d.handle) |
||||
d.handle = nil |
||||
return nil |
||||
} |
||||
|
||||
func (d *Device) OpenEndpoint(conf, iface, setup, epoint uint8) (Endpoint, error) { |
||||
end := &endpoint{ |
||||
Device: d, |
||||
} |
||||
|
||||
var setAlternate bool |
||||
for _, c := range d.Configs { |
||||
if c.Config != conf { |
||||
continue |
||||
} |
||||
debug.Printf("found conf: %#v\n", c) |
||||
for _, i := range c.Interfaces { |
||||
if i.Number != iface { |
||||
continue |
||||
} |
||||
debug.Printf("found iface: %#v\n", i) |
||||
for i, s := range i.Setups { |
||||
if s.Alternate != setup { |
||||
continue |
||||
} |
||||
setAlternate = i != 0 |
||||
|
||||
debug.Printf("found setup: %#v [default: %v]\n", s, !setAlternate) |
||||
for _, e := range s.Endpoints { |
||||
debug.Printf("ep %02x search: %#v\n", epoint, s) |
||||
if e.Address != epoint { |
||||
continue |
||||
} |
||||
end.InterfaceSetup = s |
||||
end.EndpointInfo = e |
||||
switch tt := TransferType(e.Attributes) & TRANSFER_TYPE_MASK; tt { |
||||
case TRANSFER_TYPE_BULK: |
||||
end.xfer = bulk_xfer |
||||
case TRANSFER_TYPE_INTERRUPT: |
||||
end.xfer = interrupt_xfer |
||||
case TRANSFER_TYPE_ISOCHRONOUS: |
||||
end.xfer = isochronous_xfer |
||||
default: |
||||
return nil, fmt.Errorf("usb: %s transfer is unsupported", tt) |
||||
} |
||||
goto found |
||||
} |
||||
return nil, fmt.Errorf("usb: unknown endpoint %02x", epoint) |
||||
} |
||||
return nil, fmt.Errorf("usb: unknown setup %02x", setup) |
||||
} |
||||
return nil, fmt.Errorf("usb: unknown interface %02x", iface) |
||||
} |
||||
return nil, fmt.Errorf("usb: unknown configuration %02x", conf) |
||||
|
||||
found: |
||||
|
||||
// Set the configuration
|
||||
var activeConf C.int |
||||
if errno := C.libusb_get_configuration(d.handle, &activeConf); errno < 0 { |
||||
return nil, fmt.Errorf("usb: getcfg: %s", usbError(errno)) |
||||
} |
||||
if int(activeConf) != int(conf) { |
||||
if errno := C.libusb_set_configuration(d.handle, C.int(conf)); errno < 0 { |
||||
return nil, fmt.Errorf("usb: setcfg: %s", usbError(errno)) |
||||
} |
||||
} |
||||
|
||||
// Claim the interface
|
||||
if errno := C.libusb_claim_interface(d.handle, C.int(iface)); errno < 0 { |
||||
return nil, fmt.Errorf("usb: claim: %s", usbError(errno)) |
||||
} |
||||
|
||||
// Increment the claim count
|
||||
d.lock.Lock() |
||||
d.claimed[iface]++ |
||||
d.lock.Unlock() // unlock immediately because the next calls may block
|
||||
|
||||
// Choose the alternate
|
||||
if setAlternate { |
||||
if errno := C.libusb_set_interface_alt_setting(d.handle, C.int(iface), C.int(setup)); errno < 0 { |
||||
debug.Printf("altsetting error: %s", usbError(errno)) |
||||
return nil, fmt.Errorf("usb: setalt: %s", usbError(errno)) |
||||
} |
||||
} |
||||
|
||||
return end, nil |
||||
} |
||||
|
||||
func (d *Device) GetStringDescriptor(desc_index int) (string, error) { |
||||
|
||||
// allocate 200-byte array limited the length of string descriptor
|
||||
goBuffer := make([]byte, 200) |
||||
|
||||
// get string descriptor from libusb. if errno < 0 then there are any errors.
|
||||
// if errno >= 0; it is a length of result string descriptor
|
||||
errno := C.libusb_get_string_descriptor_ascii( |
||||
d.handle, |
||||
C.uint8_t(desc_index), |
||||
(*C.uchar)(unsafe.Pointer(&goBuffer[0])), |
||||
200) |
||||
|
||||
// if any errors occur
|
||||
if errno < 0 { |
||||
return "", fmt.Errorf("usb: getstr: %s", usbError(errno)) |
||||
} |
||||
// convert slice of byte to string with limited length from errno
|
||||
stringDescriptor := string(goBuffer[:errno]) |
||||
|
||||
return stringDescriptor, nil |
||||
} |
||||
@ -1,100 +0,0 @@ |
||||
// Copyright 2013 Google Inc. All rights reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package usb |
||||
|
||||
// #include "libusb.h"
|
||||
import "C" |
||||
|
||||
import ( |
||||
"fmt" |
||||
"reflect" |
||||
"time" |
||||
"unsafe" |
||||
) |
||||
|
||||
type Endpoint interface { |
||||
Read(b []byte) (int, error) |
||||
Write(b []byte) (int, error) |
||||
Interface() InterfaceSetup |
||||
Info() EndpointInfo |
||||
} |
||||
|
||||
type endpoint struct { |
||||
*Device |
||||
InterfaceSetup |
||||
EndpointInfo |
||||
xfer func(*endpoint, []byte, time.Duration) (int, error) |
||||
} |
||||
|
||||
func (e *endpoint) Read(buf []byte) (int, error) { |
||||
if EndpointDirection(e.Address)&ENDPOINT_DIR_MASK != ENDPOINT_DIR_IN { |
||||
return 0, fmt.Errorf("usb: read: not an IN endpoint") |
||||
} |
||||
|
||||
return e.xfer(e, buf, e.ReadTimeout) |
||||
} |
||||
|
||||
func (e *endpoint) Write(buf []byte) (int, error) { |
||||
if EndpointDirection(e.Address)&ENDPOINT_DIR_MASK != ENDPOINT_DIR_OUT { |
||||
return 0, fmt.Errorf("usb: write: not an OUT endpoint") |
||||
} |
||||
|
||||
return e.xfer(e, buf, e.WriteTimeout) |
||||
} |
||||
|
||||
func (e *endpoint) Interface() InterfaceSetup { return e.InterfaceSetup } |
||||
func (e *endpoint) Info() EndpointInfo { return e.EndpointInfo } |
||||
|
||||
// TODO(kevlar): (*Endpoint).Close
|
||||
|
||||
func bulk_xfer(e *endpoint, buf []byte, timeout time.Duration) (int, error) { |
||||
if len(buf) == 0 { |
||||
return 0, nil |
||||
} |
||||
|
||||
data := (*reflect.SliceHeader)(unsafe.Pointer(&buf)).Data |
||||
|
||||
var cnt C.int |
||||
if errno := C.libusb_bulk_transfer( |
||||
e.handle, |
||||
C.uchar(e.Address), |
||||
(*C.uchar)(unsafe.Pointer(data)), |
||||
C.int(len(buf)), |
||||
&cnt, |
||||
C.uint(timeout/time.Millisecond)); errno < 0 { |
||||
return 0, usbError(errno) |
||||
} |
||||
return int(cnt), nil |
||||
} |
||||
|
||||
func interrupt_xfer(e *endpoint, buf []byte, timeout time.Duration) (int, error) { |
||||
if len(buf) == 0 { |
||||
return 0, nil |
||||
} |
||||
|
||||
data := (*reflect.SliceHeader)(unsafe.Pointer(&buf)).Data |
||||
|
||||
var cnt C.int |
||||
if errno := C.libusb_interrupt_transfer( |
||||
e.handle, |
||||
C.uchar(e.Address), |
||||
(*C.uchar)(unsafe.Pointer(data)), |
||||
C.int(len(buf)), |
||||
&cnt, |
||||
C.uint(timeout/time.Millisecond)); errno < 0 { |
||||
return 0, usbError(errno) |
||||
} |
||||
return int(cnt), nil |
||||
} |
||||
@ -1,92 +0,0 @@ |
||||
// Copyright 2013 Google Inc. All rights reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package usb |
||||
|
||||
import ( |
||||
"fmt" |
||||
) |
||||
|
||||
// #include "libusb.h"
|
||||
import "C" |
||||
|
||||
type usbError C.int |
||||
|
||||
func (e usbError) Error() string { |
||||
return fmt.Sprintf("libusb: %s [code %d]", usbErrorString[e], int(e)) |
||||
} |
||||
|
||||
const ( |
||||
SUCCESS usbError = C.LIBUSB_SUCCESS |
||||
ERROR_IO usbError = C.LIBUSB_ERROR_IO |
||||
ERROR_INVALID_PARAM usbError = C.LIBUSB_ERROR_INVALID_PARAM |
||||
ERROR_ACCESS usbError = C.LIBUSB_ERROR_ACCESS |
||||
ERROR_NO_DEVICE usbError = C.LIBUSB_ERROR_NO_DEVICE |
||||
ERROR_NOT_FOUND usbError = C.LIBUSB_ERROR_NOT_FOUND |
||||
ERROR_BUSY usbError = C.LIBUSB_ERROR_BUSY |
||||
ERROR_TIMEOUT usbError = C.LIBUSB_ERROR_TIMEOUT |
||||
ERROR_OVERFLOW usbError = C.LIBUSB_ERROR_OVERFLOW |
||||
ERROR_PIPE usbError = C.LIBUSB_ERROR_PIPE |
||||
ERROR_INTERRUPTED usbError = C.LIBUSB_ERROR_INTERRUPTED |
||||
ERROR_NO_MEM usbError = C.LIBUSB_ERROR_NO_MEM |
||||
ERROR_NOT_SUPPORTED usbError = C.LIBUSB_ERROR_NOT_SUPPORTED |
||||
ERROR_OTHER usbError = C.LIBUSB_ERROR_OTHER |
||||
) |
||||
|
||||
var usbErrorString = map[usbError]string{ |
||||
C.LIBUSB_SUCCESS: "success", |
||||
C.LIBUSB_ERROR_IO: "i/o error", |
||||
C.LIBUSB_ERROR_INVALID_PARAM: "invalid param", |
||||
C.LIBUSB_ERROR_ACCESS: "bad access", |
||||
C.LIBUSB_ERROR_NO_DEVICE: "no device", |
||||
C.LIBUSB_ERROR_NOT_FOUND: "not found", |
||||
C.LIBUSB_ERROR_BUSY: "device or resource busy", |
||||
C.LIBUSB_ERROR_TIMEOUT: "timeout", |
||||
C.LIBUSB_ERROR_OVERFLOW: "overflow", |
||||
C.LIBUSB_ERROR_PIPE: "pipe error", |
||||
C.LIBUSB_ERROR_INTERRUPTED: "interrupted", |
||||
C.LIBUSB_ERROR_NO_MEM: "out of memory", |
||||
C.LIBUSB_ERROR_NOT_SUPPORTED: "not supported", |
||||
C.LIBUSB_ERROR_OTHER: "unknown error", |
||||
} |
||||
|
||||
type TransferStatus uint8 |
||||
|
||||
const ( |
||||
LIBUSB_TRANSFER_COMPLETED TransferStatus = C.LIBUSB_TRANSFER_COMPLETED |
||||
LIBUSB_TRANSFER_ERROR TransferStatus = C.LIBUSB_TRANSFER_ERROR |
||||
LIBUSB_TRANSFER_TIMED_OUT TransferStatus = C.LIBUSB_TRANSFER_TIMED_OUT |
||||
LIBUSB_TRANSFER_CANCELLED TransferStatus = C.LIBUSB_TRANSFER_CANCELLED |
||||
LIBUSB_TRANSFER_STALL TransferStatus = C.LIBUSB_TRANSFER_STALL |
||||
LIBUSB_TRANSFER_NO_DEVICE TransferStatus = C.LIBUSB_TRANSFER_NO_DEVICE |
||||
LIBUSB_TRANSFER_OVERFLOW TransferStatus = C.LIBUSB_TRANSFER_OVERFLOW |
||||
) |
||||
|
||||
var transferStatusDescription = map[TransferStatus]string{ |
||||
LIBUSB_TRANSFER_COMPLETED: "transfer completed without error", |
||||
LIBUSB_TRANSFER_ERROR: "transfer failed", |
||||
LIBUSB_TRANSFER_TIMED_OUT: "transfer timed out", |
||||
LIBUSB_TRANSFER_CANCELLED: "transfer was cancelled", |
||||
LIBUSB_TRANSFER_STALL: "halt condition detected (endpoint stalled) or control request not supported", |
||||
LIBUSB_TRANSFER_NO_DEVICE: "device was disconnected", |
||||
LIBUSB_TRANSFER_OVERFLOW: "device sent more data than requested", |
||||
} |
||||
|
||||
func (ts TransferStatus) String() string { |
||||
return transferStatusDescription[ts] |
||||
} |
||||
|
||||
func (ts TransferStatus) Error() string { |
||||
return "libusb: " + ts.String() |
||||
} |
||||
@ -1,79 +0,0 @@ |
||||
#include "libusb.h" |
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
|
||||
void print_xfer(struct libusb_transfer *xfer); |
||||
void iso_callback(void *); |
||||
|
||||
void callback(struct libusb_transfer *xfer) { |
||||
//printf("Callback!\n");
|
||||
//print_xfer(xfer);
|
||||
iso_callback(xfer->user_data); |
||||
} |
||||
|
||||
int submit(struct libusb_transfer *xfer) { |
||||
xfer->callback = &callback; |
||||
xfer->status = -1; |
||||
//print_xfer(xfer);
|
||||
//printf("Transfer submitted\n");
|
||||
|
||||
/* fake
|
||||
strcpy(xfer->buffer, "hello"); |
||||
xfer->actual_length = 5; |
||||
callback(xfer); |
||||
return 0; */ |
||||
return libusb_submit_transfer(xfer); |
||||
} |
||||
|
||||
void print_xfer(struct libusb_transfer *xfer) { |
||||
int i; |
||||
|
||||
printf("Transfer:\n"); |
||||
printf(" dev_handle: %p\n", xfer->dev_handle); |
||||
printf(" flags: %08x\n", xfer->flags); |
||||
printf(" endpoint: %x\n", xfer->endpoint); |
||||
printf(" type: %x\n", xfer->type); |
||||
printf(" timeout: %dms\n", xfer->timeout); |
||||
printf(" status: %x\n", xfer->status); |
||||
printf(" length: %d (act: %d)\n", xfer->length, xfer->actual_length); |
||||
printf(" callback: %p\n", xfer->callback); |
||||
printf(" user_data: %p\n", xfer->user_data); |
||||
printf(" buffer: %p\n", xfer->buffer); |
||||
printf(" num_iso_pkts: %d\n", xfer->num_iso_packets); |
||||
printf(" packets:\n"); |
||||
for (i = 0; i < xfer->num_iso_packets; i++) { |
||||
printf(" [%04d] %d (act: %d) %x\n", i, |
||||
xfer->iso_packet_desc[i].length, |
||||
xfer->iso_packet_desc[i].actual_length, |
||||
xfer->iso_packet_desc[i].status); |
||||
} |
||||
} |
||||
|
||||
int extract_data(struct libusb_transfer *xfer, void *raw, int max, unsigned char *status) { |
||||
int i; |
||||
int copied = 0; |
||||
unsigned char *in = xfer->buffer; |
||||
unsigned char *out = raw; |
||||
for (i = 0; i < xfer->num_iso_packets; i++) { |
||||
struct libusb_iso_packet_descriptor pkt = xfer->iso_packet_desc[i]; |
||||
|
||||
// Copy the data
|
||||
int len = pkt.actual_length; |
||||
if (len > max) { |
||||
len = max; |
||||
} |
||||
memcpy(out, in, len); |
||||
copied += len; |
||||
|
||||
// Increment offsets
|
||||
in += pkt.length; |
||||
out += len; |
||||
|
||||
// Extract first error
|
||||
if (pkt.status == 0 || *status != 0) { |
||||
continue; |
||||
} |
||||
*status = pkt.status; |
||||
} |
||||
return copied; |
||||
} |
||||
@ -1,148 +0,0 @@ |
||||
// Copyright 2013 Google Inc. All rights reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package usb |
||||
|
||||
/* |
||||
#include "libusb.h" |
||||
|
||||
int submit(struct libusb_transfer *xfer); |
||||
void print_xfer(struct libusb_transfer *xfer); |
||||
int extract_data(struct libusb_transfer *xfer, void *data, int max, unsigned char *status); |
||||
*/ |
||||
import "C" |
||||
|
||||
import ( |
||||
"fmt" |
||||
"log" |
||||
"time" |
||||
"unsafe" |
||||
) |
||||
|
||||
//export iso_callback
|
||||
func iso_callback(cptr unsafe.Pointer) { |
||||
ch := *(*chan struct{})(cptr) |
||||
close(ch) |
||||
} |
||||
|
||||
func (end *endpoint) allocTransfer() *Transfer { |
||||
// Use libusb_get_max_iso_packet_size ?
|
||||
const ( |
||||
iso_packets = 8 // 128 // 242
|
||||
packet_size = 2 * 960 // 1760
|
||||
) |
||||
|
||||
xfer := C.libusb_alloc_transfer(C.int(iso_packets)) |
||||
if xfer == nil { |
||||
log.Printf("usb: transfer allocation failed?!") |
||||
return nil |
||||
} |
||||
|
||||
buf := make([]byte, iso_packets*packet_size) |
||||
done := make(chan struct{}, 1) |
||||
|
||||
xfer.dev_handle = end.Device.handle |
||||
xfer.endpoint = C.uchar(end.Address) |
||||
xfer._type = C.LIBUSB_TRANSFER_TYPE_ISOCHRONOUS |
||||
|
||||
xfer.buffer = (*C.uchar)((unsafe.Pointer)(&buf[0])) |
||||
xfer.length = C.int(len(buf)) |
||||
xfer.num_iso_packets = iso_packets |
||||
|
||||
C.libusb_set_iso_packet_lengths(xfer, packet_size) |
||||
/* |
||||
pkts := *(*[]C.struct_libusb_packet_descriptor)(unsafe.Pointer(&reflect.SliceHeader{ |
||||
Data: uintptr(unsafe.Pointer(&xfer.iso_packet_desc)), |
||||
Len: iso_packets, |
||||
Cap: iso_packets, |
||||
})) |
||||
*/ |
||||
|
||||
t := &Transfer{ |
||||
xfer: xfer, |
||||
done: done, |
||||
buf: buf, |
||||
} |
||||
xfer.user_data = (unsafe.Pointer)(&t.done) |
||||
|
||||
return t |
||||
} |
||||
|
||||
type Transfer struct { |
||||
xfer *C.struct_libusb_transfer |
||||
pkts []*C.struct_libusb_packet_descriptor |
||||
done chan struct{} |
||||
buf []byte |
||||
} |
||||
|
||||
func (t *Transfer) Submit(timeout time.Duration) error { |
||||
//log.Printf("iso: submitting %#v", t.xfer)
|
||||
t.xfer.timeout = C.uint(timeout / time.Millisecond) |
||||
if errno := C.submit(t.xfer); errno < 0 { |
||||
return usbError(errno) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (t *Transfer) Wait(b []byte) (n int, err error) { |
||||
select { |
||||
case <-time.After(10 * time.Second): |
||||
return 0, fmt.Errorf("wait timed out after 10s") |
||||
case <-t.done: |
||||
} |
||||
// Non-iso transfers:
|
||||
//n = int(t.xfer.actual_length)
|
||||
//copy(b, ((*[1 << 16]byte)(unsafe.Pointer(t.xfer.buffer)))[:n])
|
||||
|
||||
//C.print_xfer(t.xfer)
|
||||
/* |
||||
buf, offset := ((*[1 << 16]byte)(unsafe.Pointer(t.xfer.buffer))), 0 |
||||
for i, pkt := range *t.pkts { |
||||
log.Printf("Type is %T", t.pkts) |
||||
n += copy(b[n:], buf[offset:][:pkt.actual_length]) |
||||
offset += pkt.Length |
||||
if pkt.status != 0 && err == nil { |
||||
err = error(TransferStatus(pkt.status)) |
||||
} |
||||
} |
||||
*/ |
||||
var status uint8 |
||||
n = int(C.extract_data(t.xfer, unsafe.Pointer(&b[0]), C.int(len(b)), (*C.uchar)(unsafe.Pointer(&status)))) |
||||
if status != 0 { |
||||
err = TransferStatus(status) |
||||
} |
||||
return n, err |
||||
} |
||||
|
||||
func (t *Transfer) Close() error { |
||||
C.libusb_free_transfer(t.xfer) |
||||
return nil |
||||
} |
||||
|
||||
func isochronous_xfer(e *endpoint, buf []byte, timeout time.Duration) (int, error) { |
||||
t := e.allocTransfer() |
||||
defer t.Close() |
||||
|
||||
if err := t.Submit(timeout); err != nil { |
||||
log.Printf("iso: xfer failed to submit: %s", err) |
||||
return 0, err |
||||
} |
||||
|
||||
n, err := t.Wait(buf) |
||||
if err != nil { |
||||
log.Printf("iso: xfer failed: %s", err) |
||||
return 0, err |
||||
} |
||||
return n, err |
||||
} |
||||
@ -1,47 +0,0 @@ |
||||
// Copyright 2013 Google Inc. All rights reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package usb |
||||
|
||||
import ( |
||||
"fmt" |
||||
) |
||||
|
||||
type BCD uint16 |
||||
|
||||
const ( |
||||
USB_2_0 BCD = 0x0200 |
||||
USB_1_1 BCD = 0x0110 |
||||
USB_1_0 BCD = 0x0100 |
||||
) |
||||
|
||||
func (d BCD) Int() (i int) { |
||||
ten := 1 |
||||
for o := uint(0); o < 4; o++ { |
||||
n := ((0xF << (o * 4)) & d) >> (o * 4) |
||||
i += int(n) * ten |
||||
ten *= 10 |
||||
} |
||||
return |
||||
} |
||||
|
||||
func (d BCD) String() string { |
||||
return fmt.Sprintf("%02x.%02x", int(d>>8), int(d&0xFF)) |
||||
} |
||||
|
||||
type ID uint16 |
||||
|
||||
func (id ID) String() string { |
||||
return fmt.Sprintf("%04x", int(id)) |
||||
} |
||||
@ -1,178 +0,0 @@ |
||||
// Copyright 2013 Google Inc. All rights reserved.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// Package usb provides a wrapper around libusb-1.0.
|
||||
package usb |
||||
|
||||
/* |
||||
#cgo CFLAGS: -I../internal/libusb/libusb |
||||
#cgo CFLAGS: -DDEFAULT_VISIBILITY="" |
||||
#cgo linux CFLAGS: -DOS_LINUX -D_GNU_SOURCE -DPOLL_NFDS_TYPE=int |
||||
#cgo darwin CFLAGS: -DOS_DARWIN -DPOLL_NFDS_TYPE=int |
||||
#cgo darwin LDFLAGS: -framework CoreFoundation -framework IOKit -lobjc |
||||
#cgo openbsd CFLAGS: -DOS_OPENBSD -DPOLL_NFDS_TYPE=int |
||||
#cgo windows CFLAGS: -DOS_WINDOWS -DUSE_USBDK -DPOLL_NFDS_TYPE=int |
||||
|
||||
#if defined(OS_LINUX) || defined(OS_DARWIN) || defined(OS_OPENBSD) |
||||
#include <sys/poll.h> |
||||
#include "os/threads_posix.c" |
||||
#include "os/poll_posix.c" |
||||
#elif defined(OS_WINDOWS) |
||||
#include "os/threads_windows.c" |
||||
#include "os/poll_windows.c" |
||||
#endif |
||||
|
||||
#ifdef OS_LINUX |
||||
#include "os/linux_usbfs.c" |
||||
#include "os/linux_netlink.c" |
||||
#elif OS_DARWIN |
||||
#include "os/darwin_usb.c" |
||||
#elif OS_OPENBSD |
||||
#include "os/openbsd_usb.c" |
||||
#elif OS_WINDOWS |
||||
#include "os/windows_nt_common.c" |
||||
#include "os/windows_usbdk.c" |
||||
#endif |
||||
|
||||
#include "core.c" |
||||
#include "descriptor.c" |
||||
#include "hotplug.c" |
||||
#include "io.c" |
||||
#include "strerror.c" |
||||
#include "sync.c" |
||||
*/ |
||||
import "C" |
||||
|
||||
import ( |
||||
"log" |
||||
"reflect" |
||||
"unsafe" |
||||
) |
||||
|
||||
type Context struct { |
||||
ctx *C.libusb_context |
||||
done chan struct{} |
||||
} |
||||
|
||||
func (c *Context) Debug(level int) { |
||||
C.libusb_set_debug(c.ctx, C.int(level)) |
||||
} |
||||
|
||||
func NewContext() (*Context, error) { |
||||
c := &Context{ |
||||
done: make(chan struct{}), |
||||
} |
||||
|
||||
if errno := C.libusb_init(&c.ctx); errno != 0 { |
||||
return nil, usbError(errno) |
||||
} |
||||
|
||||
go func() { |
||||
tv := C.struct_timeval{ |
||||
tv_sec: 0, |
||||
tv_usec: 100000, |
||||
} |
||||
for { |
||||
select { |
||||
case <-c.done: |
||||
return |
||||
default: |
||||
} |
||||
if errno := C.libusb_handle_events_timeout_completed(c.ctx, &tv, nil); errno < 0 { |
||||
log.Printf("handle_events: error: %s", usbError(errno)) |
||||
continue |
||||
} |
||||
//log.Printf("handle_events returned")
|
||||
} |
||||
}() |
||||
|
||||
return c, nil |
||||
} |
||||
|
||||
// ListDevices calls each with each enumerated device.
|
||||
// If the function returns true, the device is opened and a Device is returned if the operation succeeds.
|
||||
// Every Device returned (whether an error is also returned or not) must be closed.
|
||||
// If there are any errors enumerating the devices,
|
||||
// the final one is returned along with any successfully opened devices.
|
||||
func (c *Context) ListDevices(each func(desc *Descriptor) bool) ([]*Device, error) { |
||||
var list **C.libusb_device |
||||
cnt := C.libusb_get_device_list(c.ctx, &list) |
||||
if cnt < 0 { |
||||
return nil, usbError(cnt) |
||||
} |
||||
defer C.libusb_free_device_list(list, 1) |
||||
|
||||
var slice []*C.libusb_device |
||||
*(*reflect.SliceHeader)(unsafe.Pointer(&slice)) = reflect.SliceHeader{ |
||||
Data: uintptr(unsafe.Pointer(list)), |
||||
Len: int(cnt), |
||||
Cap: int(cnt), |
||||
} |
||||
|
||||
var reterr error |
||||
var ret []*Device |
||||
for _, dev := range slice { |
||||
desc, err := newDescriptor(dev) |
||||
if err != nil { |
||||
reterr = err |
||||
continue |
||||
} |
||||
|
||||
if each(desc) { |
||||
var handle *C.libusb_device_handle |
||||
if errno := C.libusb_open(dev, &handle); errno != 0 { |
||||
reterr = usbError(errno) |
||||
continue |
||||
} |
||||
if dev, err := newDevice(handle, desc); err != nil { |
||||
reterr = err |
||||
} else { |
||||
ret = append(ret, dev) |
||||
} |
||||
} |
||||
} |
||||
return ret, reterr |
||||
} |
||||
|
||||
// OpenDeviceWithVidPid opens Device from specific VendorId and ProductId.
|
||||
// If there are any errors, it'll returns at second value.
|
||||
func (c *Context) OpenDeviceWithVidPid(vid, pid int) (*Device, error) { |
||||
|
||||
handle := C.libusb_open_device_with_vid_pid(c.ctx, (C.uint16_t)(vid), (C.uint16_t)(pid)) |
||||
if handle == nil { |
||||
return nil, ERROR_NOT_FOUND |
||||
} |
||||
|
||||
dev := C.libusb_get_device(handle) |
||||
if dev == nil { |
||||
return nil, ERROR_NO_DEVICE |
||||
} |
||||
|
||||
desc, err := newDescriptor(dev) |
||||
|
||||
// return an error from nil-handle and nil-device
|
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return newDevice(handle, desc) |
||||
} |
||||
|
||||
func (c *Context) Close() error { |
||||
close(c.done) |
||||
if c.ctx != nil { |
||||
C.libusb_exit(c.ctx) |
||||
} |
||||
c.ctx = nil |
||||
return nil |
||||
} |
||||
@ -0,0 +1,8 @@ |
||||
The components of `hid` are licensed as such: |
||||
|
||||
* `hidapi` is released under the [3-clause BSD](https://github.com/signal11/hidapi/blob/master/LICENSE-bsd.txt) license. |
||||
* `libusb` is released under the [GNU GPL 2.1](https://github.com/libusb/libusb/blob/master/COPYING)license. |
||||
* `go.hid` is released under the [2-clause BSD](https://github.com/GeertJohan/go.hid/blob/master/LICENSE) license. |
||||
* `gowchar` is released under the [3-clause BSD](https://github.com/orofarne/gowchar/blob/master/LICENSE) license. |
||||
|
||||
Given the above, `hid` is licensed under GNU GPL 2.1 or later on Linux and 3-clause BSD on other platforms. |
||||
@ -0,0 +1,41 @@ |
||||
[![GoDoc][docimg]][docurl] |
||||
|
||||
[docimg]: https://godoc.org/github.com/karalabe/hid?status.svg |
||||
[docurl]: https://godoc.org/github.com/karalabe/hid |
||||
|
||||
# Gopher Interface Devices (USB HID) |
||||
|
||||
The `hid` package is a cross platform library for accessing and communicating with USB Human Interface |
||||
Devices (HID). It is an alternative package to [`gousb`](https://github.com/karalabe/gousb) for use |
||||
cases where devices support this ligher mode of operation (e.g. input devices, hardware crypto wallets). |
||||
|
||||
The package wraps [`hidapi`](https://github.com/signal11/hidapi) for accessing OS specific USB HID APIs |
||||
directly instead of using low level USB constructs, which might have permission issues on some platforms. |
||||
On Linux the package also wraps [`libusb`](https://github.com/libusb/libusb). Both of these dependencies |
||||
are vendored directly into the repository and wrapped using CGO, making the `hid` package self-contained |
||||
and go-gettable. |
||||
|
||||
Supported platforms at the moment are Linux, macOS and Windows (exclude constraints are also specified |
||||
for Android and iOS to allow smoother vendoring into cross platform projects). |
||||
|
||||
## Acknowledgements |
||||
|
||||
Although the `hid` package is an implementation from scratch, it was heavily inspired by the existing |
||||
[`go.hid`](https://github.com/GeertJohan/go.hid) library, which seems abandoned since 2015; is incompatible |
||||
with Go 1.6+; and has various external dependencies. Given its inspirational roots, I thought it important |
||||
to give credit to the author of said package too. |
||||
|
||||
Wide character support in the `hid` package is done via the [`gowchar`](https://github.com/orofarne/gowchar) |
||||
library, unmaintained since 2013; non buildable with a modern Go release and failing `go vet` checks. As |
||||
such, `gowchar` was also vendored in inline (copyright headers and origins preserved). |
||||
|
||||
## License |
||||
|
||||
The components of `hid` are licensed as such: |
||||
|
||||
* `hidapi` is released under the [3-clause BSD](https://github.com/signal11/hidapi/blob/master/LICENSE-bsd.txt) license. |
||||
* `libusb` is released under the [GNU GPL 2.1](https://github.com/libusb/libusb/blob/master/COPYING)license. |
||||
* `go.hid` is released under the [2-clause BSD](https://github.com/GeertJohan/go.hid/blob/master/LICENSE) license. |
||||
* `gowchar` is released under the [3-clause BSD](https://github.com/orofarne/gowchar/blob/master/LICENSE) license. |
||||
|
||||
Given the above, `hid` is licensed under GNU GPL 2.1 or later on Linux and 3-clause BSD on other platforms. |
||||
@ -0,0 +1,37 @@ |
||||
// hid - Gopher Interface Devices (USB HID)
|
||||
// Copyright (c) 2017 Péter Szilágyi. All rights reserved.
|
||||
//
|
||||
// This file is released under the 3-clause BSD license. Note however that Linux
|
||||
// support depends on libusb, released under GNU GPL 2.1 or later.
|
||||
|
||||
// Package hid provides an interface for USB HID devices.
|
||||
package hid |
||||
|
||||
import "errors" |
||||
|
||||
// ErrDeviceClosed is returned for operations where the device closed before or
|
||||
// during the execution.
|
||||
var ErrDeviceClosed = errors.New("hid: device closed") |
||||
|
||||
// ErrUnsupportedPlatform is returned for all operations where the underlying
|
||||
// operating system is not supported by the library.
|
||||
var ErrUnsupportedPlatform = errors.New("hid: unsupported platform") |
||||
|
||||
// DeviceInfo is a hidapi info structure.
|
||||
type DeviceInfo struct { |
||||
Path string // Platform-specific device path
|
||||
VendorID uint16 // Device Vendor ID
|
||||
ProductID uint16 // Device Product ID
|
||||
Release uint16 // Device Release Number in binary-coded decimal, also known as Device Version Number
|
||||
Serial string // Serial Number
|
||||
Manufacturer string // Manufacturer String
|
||||
Product string // Product string
|
||||
UsagePage uint16 // Usage Page for this Device/Interface (Windows/Mac only)
|
||||
Usage uint16 // Usage for this Device/Interface (Windows/Mac only)
|
||||
|
||||
// The USB interface which this logical device
|
||||
// represents. Valid on both Linux implementations
|
||||
// in all cases, and valid on the Windows implementation
|
||||
// only if the device contains more than one interface.
|
||||
Interface int |
||||
} |
||||
@ -0,0 +1,53 @@ |
||||
// hid - Gopher Interface Devices (USB HID)
|
||||
// Copyright (c) 2017 Péter Szilágyi. All rights reserved.
|
||||
//
|
||||
// This file is released under the 3-clause BSD license. Note however that Linux
|
||||
// support depends on libusb, released under GNU GPL 2.1 or later.
|
||||
|
||||
// +build !linux
|
||||
// +build !darwin ios
|
||||
// +build !windows
|
||||
|
||||
package hid |
||||
|
||||
// Supported returns whether this platform is supported by the HID library or not.
|
||||
// The goal of this method is to allow programatically handling platforms that do
|
||||
// not support USB HID and not having to fall back to build constraints.
|
||||
func Supported() bool { |
||||
return false |
||||
} |
||||
|
||||
// Enumerate returns a list of all the HID devices attached to the system which
|
||||
// match the vendor and product id. On platforms that this file implements the
|
||||
// function is a noop and returns an empty list always.
|
||||
func Enumerate(vendorID uint16, productID uint16) []DeviceInfo { |
||||
return nil |
||||
} |
||||
|
||||
// Device is a live HID USB connected device handle. On platforms that this file
|
||||
// implements the type lacks the actual HID device and all methods are noop.
|
||||
type Device struct { |
||||
DeviceInfo // Embed the infos for easier access
|
||||
} |
||||
|
||||
// Open connects to an HID device by its path name. On platforms that this file
|
||||
// implements the method just returns an error.
|
||||
func (info DeviceInfo) Open() (*Device, error) { |
||||
return nil, ErrUnsupportedPlatform |
||||
} |
||||
|
||||
// Close releases the HID USB device handle. On platforms that this file implements
|
||||
// the method is just a noop.
|
||||
func (dev *Device) Close() {} |
||||
|
||||
// Write sends an output report to a HID device. On platforms that this file
|
||||
// implements the method just returns an error.
|
||||
func (dev *Device) Write(b []byte) (int, error) { |
||||
return 0, ErrUnsupportedPlatform |
||||
} |
||||
|
||||
// Read retrieves an input report from a HID device. On platforms that this file
|
||||
// implements the method just returns an error.
|
||||
func (dev *Device) Read(b []byte) (int, error) { |
||||
return 0, ErrUnsupportedPlatform |
||||
} |
||||
@ -0,0 +1,216 @@ |
||||
// hid - Gopher Interface Devices (USB HID)
|
||||
// Copyright (c) 2017 Péter Szilágyi. All rights reserved.
|
||||
//
|
||||
// This file is released under the 3-clause BSD license. Note however that Linux
|
||||
// support depends on libusb, released under GNU GPL 2.1 or later.
|
||||
|
||||
// +build !ios
|
||||
// +build linux darwin windows
|
||||
|
||||
package hid |
||||
|
||||
/* |
||||
#cgo CFLAGS: -I./hidapi/hidapi |
||||
|
||||
#cgo linux CFLAGS: -I./libusb/libusb -DDEFAULT_VISIBILITY="" -DOS_LINUX -D_GNU_SOURCE -DPOLL_NFDS_TYPE=int |
||||
#cgo darwin CFLAGS: -DOS_DARWIN |
||||
#cgo darwin LDFLAGS: -framework CoreFoundation -framework IOKit |
||||
#cgo windows CFLAGS: -DOS_WINDOWS |
||||
#cgo windows LDFLAGS: -lsetupapi |
||||
|
||||
#ifdef OS_LINUX |
||||
#include <sys/poll.h> |
||||
#include "os/threads_posix.c" |
||||
#include "os/poll_posix.c" |
||||
|
||||
#include "os/linux_usbfs.c" |
||||
#include "os/linux_netlink.c" |
||||
|
||||
#include "core.c" |
||||
#include "descriptor.c" |
||||
#include "hotplug.c" |
||||
#include "io.c" |
||||
#include "strerror.c" |
||||
#include "sync.c" |
||||
|
||||
#include "hidapi/libusb/hid.c" |
||||
#elif OS_DARWIN |
||||
#include "hidapi/mac/hid.c" |
||||
#elif OS_WINDOWS |
||||
#include "hidapi/windows/hid.c" |
||||
#endif |
||||
*/ |
||||
import "C" |
||||
import ( |
||||
"errors" |
||||
"runtime" |
||||
"sync" |
||||
"unsafe" |
||||
) |
||||
|
||||
func init() { |
||||
// Initialize the HIDAPI library
|
||||
C.hid_init() |
||||
} |
||||
|
||||
// Supported returns whether this platform is supported by the HID library or not.
|
||||
// The goal of this method is to allow programatically handling platforms that do
|
||||
// not support USB HID and not having to fall back to build constraints.
|
||||
func Supported() bool { |
||||
return true |
||||
} |
||||
|
||||
// Enumerate returns a list of all the HID devices attached to the system which
|
||||
// match the vendor and product id:
|
||||
// - If the vendor id is set to 0 then any vendor matches.
|
||||
// - If the product id is set to 0 then any product matches.
|
||||
// - If the vendor and product id are both 0, all HID devices are returned.
|
||||
func Enumerate(vendorID uint16, productID uint16) []DeviceInfo { |
||||
// Gather all device infos and ensure they are freed before returning
|
||||
head := C.hid_enumerate(C.ushort(vendorID), C.ushort(productID)) |
||||
if head == nil { |
||||
return nil |
||||
} |
||||
defer C.hid_free_enumeration(head) |
||||
|
||||
// Iterate the list and retrieve the device details
|
||||
var infos []DeviceInfo |
||||
for ; head != nil; head = head.next { |
||||
info := DeviceInfo{ |
||||
Path: C.GoString(head.path), |
||||
VendorID: uint16(head.vendor_id), |
||||
ProductID: uint16(head.product_id), |
||||
Release: uint16(head.release_number), |
||||
UsagePage: uint16(head.usage_page), |
||||
Usage: uint16(head.usage), |
||||
Interface: int(head.interface_number), |
||||
} |
||||
if head.serial_number != nil { |
||||
info.Serial, _ = wcharTToString(head.serial_number) |
||||
} |
||||
if head.product_string != nil { |
||||
info.Product, _ = wcharTToString(head.product_string) |
||||
} |
||||
if head.manufacturer_string != nil { |
||||
info.Manufacturer, _ = wcharTToString(head.manufacturer_string) |
||||
} |
||||
infos = append(infos, info) |
||||
} |
||||
return infos |
||||
} |
||||
|
||||
// Open connects to an HID device by its path name.
|
||||
func (info DeviceInfo) Open() (*Device, error) { |
||||
path := C.CString(info.Path) |
||||
defer C.free(unsafe.Pointer(path)) |
||||
|
||||
device := C.hid_open_path(path) |
||||
if device == nil { |
||||
return nil, errors.New("hidapi: failed to open device") |
||||
} |
||||
return &Device{ |
||||
DeviceInfo: info, |
||||
device: device, |
||||
}, nil |
||||
} |
||||
|
||||
// Device is a live HID USB connected device handle.
|
||||
type Device struct { |
||||
DeviceInfo // Embed the infos for easier access
|
||||
|
||||
device *C.hid_device // Low level HID device to communicate through
|
||||
lock sync.Mutex |
||||
} |
||||
|
||||
// Close releases the HID USB device handle.
|
||||
func (dev *Device) Close() { |
||||
dev.lock.Lock() |
||||
defer dev.lock.Unlock() |
||||
|
||||
if dev.device != nil { |
||||
C.hid_close(dev.device) |
||||
dev.device = nil |
||||
} |
||||
} |
||||
|
||||
// Write sends an output report to a HID device.
|
||||
//
|
||||
// Write will send the data on the first OUT endpoint, if one exists. If it does
|
||||
// not, it will send the data through the Control Endpoint (Endpoint 0).
|
||||
func (dev *Device) Write(b []byte) (int, error) { |
||||
// Abort if nothing to write
|
||||
if len(b) == 0 { |
||||
return 0, nil |
||||
} |
||||
// Abort if device closed in between
|
||||
dev.lock.Lock() |
||||
device := dev.device |
||||
dev.lock.Unlock() |
||||
|
||||
if device == nil { |
||||
return 0, ErrDeviceClosed |
||||
} |
||||
// Prepend a HID report ID on Windows, other OSes don't need it
|
||||
var report []byte |
||||
if runtime.GOOS == "windows" { |
||||
report = append([]byte{0x00}, b...) |
||||
} else { |
||||
report = b |
||||
} |
||||
// Execute the write operation
|
||||
written := int(C.hid_write(device, (*C.uchar)(&report[0]), C.size_t(len(report)))) |
||||
if written == -1 { |
||||
// If the write failed, verify if closed or other error
|
||||
dev.lock.Lock() |
||||
device = dev.device |
||||
dev.lock.Unlock() |
||||
|
||||
if device == nil { |
||||
return 0, ErrDeviceClosed |
||||
} |
||||
// Device not closed, some other error occurred
|
||||
message := C.hid_error(device) |
||||
if message == nil { |
||||
return 0, errors.New("hidapi: unknown failure") |
||||
} |
||||
failure, _ := wcharTToString(message) |
||||
return 0, errors.New("hidapi: " + failure) |
||||
} |
||||
return written, nil |
||||
} |
||||
|
||||
// Read retrieves an input report from a HID device.
|
||||
func (dev *Device) Read(b []byte) (int, error) { |
||||
// Aborth if nothing to read
|
||||
if len(b) == 0 { |
||||
return 0, nil |
||||
} |
||||
// Abort if device closed in between
|
||||
dev.lock.Lock() |
||||
device := dev.device |
||||
dev.lock.Unlock() |
||||
|
||||
if device == nil { |
||||
return 0, ErrDeviceClosed |
||||
} |
||||
// Execute the read operation
|
||||
read := int(C.hid_read(device, (*C.uchar)(&b[0]), C.size_t(len(b)))) |
||||
if read == -1 { |
||||
// If the read failed, verify if closed or other error
|
||||
dev.lock.Lock() |
||||
device = dev.device |
||||
dev.lock.Unlock() |
||||
|
||||
if device == nil { |
||||
return 0, ErrDeviceClosed |
||||
} |
||||
// Device not closed, some other error occurred
|
||||
message := C.hid_error(device) |
||||
if message == nil { |
||||
return 0, errors.New("hidapi: unknown failure") |
||||
} |
||||
failure, _ := wcharTToString(message) |
||||
return 0, errors.New("hidapi: " + failure) |
||||
} |
||||
return read, nil |
||||
} |
||||
@ -0,0 +1,16 @@ |
||||
|
||||
HIDAPI Authors: |
||||
|
||||
Alan Ott <alan@signal11.us>: |
||||
Original Author and Maintainer |
||||
Linux, Windows, and Mac implementations |
||||
|
||||
Ludovic Rousseau <rousseau@debian.org>: |
||||
Formatting for Doxygen documentation |
||||
Bug fixes |
||||
Correctness fixes |
||||
|
||||
|
||||
For a comprehensive list of contributions, see the commit list at github: |
||||
http://github.com/signal11/hidapi/commits/master |
||||
|
||||
@ -0,0 +1,26 @@ |
||||
Copyright (c) 2010, Alan Ott, Signal 11 Software |
||||
All rights reserved. |
||||
|
||||
Redistribution and use in source and binary forms, with or without |
||||
modification, are permitted provided that the following conditions are met: |
||||
|
||||
* Redistributions of source code must retain the above copyright notice, |
||||
this list of conditions and the following disclaimer. |
||||
* Redistributions in binary form must reproduce the above copyright |
||||
notice, this list of conditions and the following disclaimer in the |
||||
documentation and/or other materials provided with the distribution. |
||||
* Neither the name of Signal 11 Software nor the names of its |
||||
contributors may be used to endorse or promote products derived from |
||||
this software without specific prior written permission. |
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
||||
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
||||
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
||||
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
||||
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
||||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
||||
POSSIBILITY OF SUCH DAMAGE. |
||||
@ -0,0 +1,674 @@ |
||||
GNU GENERAL PUBLIC LICENSE |
||||
Version 3, 29 June 2007 |
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> |
||||
Everyone is permitted to copy and distribute verbatim copies |
||||
of this license document, but changing it is not allowed. |
||||
|
||||
Preamble |
||||
|
||||
The GNU General Public License is a free, copyleft license for |
||||
software and other kinds of works. |
||||
|
||||
The licenses for most software and other practical works are designed |
||||
to take away your freedom to share and change the works. By contrast, |
||||
the GNU General Public License is intended to guarantee your freedom to |
||||
share and change all versions of a program--to make sure it remains free |
||||
software for all its users. We, the Free Software Foundation, use the |
||||
GNU General Public License for most of our software; it applies also to |
||||
any other work released this way by its authors. You can apply it to |
||||
your programs, too. |
||||
|
||||
When we speak of free software, we are referring to freedom, not |
||||
price. Our General Public Licenses are designed to make sure that you |
||||
have the freedom to distribute copies of free software (and charge for |
||||
them if you wish), that you receive source code or can get it if you |
||||
want it, that you can change the software or use pieces of it in new |
||||
free programs, and that you know you can do these things. |
||||
|
||||
To protect your rights, we need to prevent others from denying you |
||||
these rights or asking you to surrender the rights. Therefore, you have |
||||
certain responsibilities if you distribute copies of the software, or if |
||||
you modify it: responsibilities to respect the freedom of others. |
||||
|
||||
For example, if you distribute copies of such a program, whether |
||||
gratis or for a fee, you must pass on to the recipients the same |
||||
freedoms that you received. You must make sure that they, too, receive |
||||
or can get the source code. And you must show them these terms so they |
||||
know their rights. |
||||
|
||||
Developers that use the GNU GPL protect your rights with two steps: |
||||
(1) assert copyright on the software, and (2) offer you this License |
||||
giving you legal permission to copy, distribute and/or modify it. |
||||
|
||||
For the developers' and authors' protection, the GPL clearly explains |
||||
that there is no warranty for this free software. For both users' and |
||||
authors' sake, the GPL requires that modified versions be marked as |
||||
changed, so that their problems will not be attributed erroneously to |
||||
authors of previous versions. |
||||
|
||||
Some devices are designed to deny users access to install or run |
||||
modified versions of the software inside them, although the manufacturer |
||||
can do so. This is fundamentally incompatible with the aim of |
||||
protecting users' freedom to change the software. The systematic |
||||
pattern of such abuse occurs in the area of products for individuals to |
||||
use, which is precisely where it is most unacceptable. Therefore, we |
||||
have designed this version of the GPL to prohibit the practice for those |
||||
products. If such problems arise substantially in other domains, we |
||||
stand ready to extend this provision to those domains in future versions |
||||
of the GPL, as needed to protect the freedom of users. |
||||
|
||||
Finally, every program is threatened constantly by software patents. |
||||
States should not allow patents to restrict development and use of |
||||
software on general-purpose computers, but in those that do, we wish to |
||||
avoid the special danger that patents applied to a free program could |
||||
make it effectively proprietary. To prevent this, the GPL assures that |
||||
patents cannot be used to render the program non-free. |
||||
|
||||
The precise terms and conditions for copying, distribution and |
||||
modification follow. |
||||
|
||||
TERMS AND CONDITIONS |
||||
|
||||
0. Definitions. |
||||
|
||||
"This License" refers to version 3 of the GNU General Public License. |
||||
|
||||
"Copyright" also means copyright-like laws that apply to other kinds of |
||||
works, such as semiconductor masks. |
||||
|
||||
"The Program" refers to any copyrightable work licensed under this |
||||
License. Each licensee is addressed as "you". "Licensees" and |
||||
"recipients" may be individuals or organizations. |
||||
|
||||
To "modify" a work means to copy from or adapt all or part of the work |
||||
in a fashion requiring copyright permission, other than the making of an |
||||
exact copy. The resulting work is called a "modified version" of the |
||||
earlier work or a work "based on" the earlier work. |
||||
|
||||
A "covered work" means either the unmodified Program or a work based |
||||
on the Program. |
||||
|
||||
To "propagate" a work means to do anything with it that, without |
||||
permission, would make you directly or secondarily liable for |
||||
infringement under applicable copyright law, except executing it on a |
||||
computer or modifying a private copy. Propagation includes copying, |
||||
distribution (with or without modification), making available to the |
||||
public, and in some countries other activities as well. |
||||
|
||||
To "convey" a work means any kind of propagation that enables other |
||||
parties to make or receive copies. Mere interaction with a user through |
||||
a computer network, with no transfer of a copy, is not conveying. |
||||
|
||||
An interactive user interface displays "Appropriate Legal Notices" |
||||
to the extent that it includes a convenient and prominently visible |
||||
feature that (1) displays an appropriate copyright notice, and (2) |
||||
tells the user that there is no warranty for the work (except to the |
||||
extent that warranties are provided), that licensees may convey the |
||||
work under this License, and how to view a copy of this License. If |
||||
the interface presents a list of user commands or options, such as a |
||||
menu, a prominent item in the list meets this criterion. |
||||
|
||||
1. Source Code. |
||||
|
||||
The "source code" for a work means the preferred form of the work |
||||
for making modifications to it. "Object code" means any non-source |
||||
form of a work. |
||||
|
||||
A "Standard Interface" means an interface that either is an official |
||||
standard defined by a recognized standards body, or, in the case of |
||||
interfaces specified for a particular programming language, one that |
||||
is widely used among developers working in that language. |
||||
|
||||
The "System Libraries" of an executable work include anything, other |
||||
than the work as a whole, that (a) is included in the normal form of |
||||
packaging a Major Component, but which is not part of that Major |
||||
Component, and (b) serves only to enable use of the work with that |
||||
Major Component, or to implement a Standard Interface for which an |
||||
implementation is available to the public in source code form. A |
||||
"Major Component", in this context, means a major essential component |
||||
(kernel, window system, and so on) of the specific operating system |
||||
(if any) on which the executable work runs, or a compiler used to |
||||
produce the work, or an object code interpreter used to run it. |
||||
|
||||
The "Corresponding Source" for a work in object code form means all |
||||
the source code needed to generate, install, and (for an executable |
||||
work) run the object code and to modify the work, including scripts to |
||||
control those activities. However, it does not include the work's |
||||
System Libraries, or general-purpose tools or generally available free |
||||
programs which are used unmodified in performing those activities but |
||||
which are not part of the work. For example, Corresponding Source |
||||
includes interface definition files associated with source files for |
||||
the work, and the source code for shared libraries and dynamically |
||||
linked subprograms that the work is specifically designed to require, |
||||
such as by intimate data communication or control flow between those |
||||
subprograms and other parts of the work. |
||||
|
||||
The Corresponding Source need not include anything that users |
||||
can regenerate automatically from other parts of the Corresponding |
||||
Source. |
||||
|
||||
The Corresponding Source for a work in source code form is that |
||||
same work. |
||||
|
||||
2. Basic Permissions. |
||||
|
||||
All rights granted under this License are granted for the term of |
||||
copyright on the Program, and are irrevocable provided the stated |
||||
conditions are met. This License explicitly affirms your unlimited |
||||
permission to run the unmodified Program. The output from running a |
||||
covered work is covered by this License only if the output, given its |
||||
content, constitutes a covered work. This License acknowledges your |
||||
rights of fair use or other equivalent, as provided by copyright law. |
||||
|
||||
You may make, run and propagate covered works that you do not |
||||
convey, without conditions so long as your license otherwise remains |
||||
in force. You may convey covered works to others for the sole purpose |
||||
of having them make modifications exclusively for you, or provide you |
||||
with facilities for running those works, provided that you comply with |
||||
the terms of this License in conveying all material for which you do |
||||
not control copyright. Those thus making or running the covered works |
||||
for you must do so exclusively on your behalf, under your direction |
||||
and control, on terms that prohibit them from making any copies of |
||||
your copyrighted material outside their relationship with you. |
||||
|
||||
Conveying under any other circumstances is permitted solely under |
||||
the conditions stated below. Sublicensing is not allowed; section 10 |
||||
makes it unnecessary. |
||||
|
||||
3. Protecting Users' Legal Rights From Anti-Circumvention Law. |
||||
|
||||
No covered work shall be deemed part of an effective technological |
||||
measure under any applicable law fulfilling obligations under article |
||||
11 of the WIPO copyright treaty adopted on 20 December 1996, or |
||||
similar laws prohibiting or restricting circumvention of such |
||||
measures. |
||||
|
||||
When you convey a covered work, you waive any legal power to forbid |
||||
circumvention of technological measures to the extent such circumvention |
||||
is effected by exercising rights under this License with respect to |
||||
the covered work, and you disclaim any intention to limit operation or |
||||
modification of the work as a means of enforcing, against the work's |
||||
users, your or third parties' legal rights to forbid circumvention of |
||||
technological measures. |
||||
|
||||
4. Conveying Verbatim Copies. |
||||
|
||||
You may convey verbatim copies of the Program's source code as you |
||||
receive it, in any medium, provided that you conspicuously and |
||||
appropriately publish on each copy an appropriate copyright notice; |
||||
keep intact all notices stating that this License and any |
||||
non-permissive terms added in accord with section 7 apply to the code; |
||||
keep intact all notices of the absence of any warranty; and give all |
||||
recipients a copy of this License along with the Program. |
||||
|
||||
You may charge any price or no price for each copy that you convey, |
||||
and you may offer support or warranty protection for a fee. |
||||
|
||||
5. Conveying Modified Source Versions. |
||||
|
||||
You may convey a work based on the Program, or the modifications to |
||||
produce it from the Program, in the form of source code under the |
||||
terms of section 4, provided that you also meet all of these conditions: |
||||
|
||||
a) The work must carry prominent notices stating that you modified |
||||
it, and giving a relevant date. |
||||
|
||||
b) The work must carry prominent notices stating that it is |
||||
released under this License and any conditions added under section |
||||
7. This requirement modifies the requirement in section 4 to |
||||
"keep intact all notices". |
||||
|
||||
c) You must license the entire work, as a whole, under this |
||||
License to anyone who comes into possession of a copy. This |
||||
License will therefore apply, along with any applicable section 7 |
||||
additional terms, to the whole of the work, and all its parts, |
||||
regardless of how they are packaged. This License gives no |
||||
permission to license the work in any other way, but it does not |
||||
invalidate such permission if you have separately received it. |
||||
|
||||
d) If the work has interactive user interfaces, each must display |
||||
Appropriate Legal Notices; however, if the Program has interactive |
||||
interfaces that do not display Appropriate Legal Notices, your |
||||
work need not make them do so. |
||||
|
||||
A compilation of a covered work with other separate and independent |
||||
works, which are not by their nature extensions of the covered work, |
||||
and which are not combined with it such as to form a larger program, |
||||
in or on a volume of a storage or distribution medium, is called an |
||||
"aggregate" if the compilation and its resulting copyright are not |
||||
used to limit the access or legal rights of the compilation's users |
||||
beyond what the individual works permit. Inclusion of a covered work |
||||
in an aggregate does not cause this License to apply to the other |
||||
parts of the aggregate. |
||||
|
||||
6. Conveying Non-Source Forms. |
||||
|
||||
You may convey a covered work in object code form under the terms |
||||
of sections 4 and 5, provided that you also convey the |
||||
machine-readable Corresponding Source under the terms of this License, |
||||
in one of these ways: |
||||
|
||||
a) Convey the object code in, or embodied in, a physical product |
||||
(including a physical distribution medium), accompanied by the |
||||
Corresponding Source fixed on a durable physical medium |
||||
customarily used for software interchange. |
||||
|
||||
b) Convey the object code in, or embodied in, a physical product |
||||
(including a physical distribution medium), accompanied by a |
||||
written offer, valid for at least three years and valid for as |
||||
long as you offer spare parts or customer support for that product |
||||
model, to give anyone who possesses the object code either (1) a |
||||
copy of the Corresponding Source for all the software in the |
||||
product that is covered by this License, on a durable physical |
||||
medium customarily used for software interchange, for a price no |
||||
more than your reasonable cost of physically performing this |
||||
conveying of source, or (2) access to copy the |
||||
Corresponding Source from a network server at no charge. |
||||
|
||||
c) Convey individual copies of the object code with a copy of the |
||||
written offer to provide the Corresponding Source. This |
||||
alternative is allowed only occasionally and noncommercially, and |
||||
only if you received the object code with such an offer, in accord |
||||
with subsection 6b. |
||||
|
||||
d) Convey the object code by offering access from a designated |
||||
place (gratis or for a charge), and offer equivalent access to the |
||||
Corresponding Source in the same way through the same place at no |
||||
further charge. You need not require recipients to copy the |
||||
Corresponding Source along with the object code. If the place to |
||||
copy the object code is a network server, the Corresponding Source |
||||
may be on a different server (operated by you or a third party) |
||||
that supports equivalent copying facilities, provided you maintain |
||||
clear directions next to the object code saying where to find the |
||||
Corresponding Source. Regardless of what server hosts the |
||||
Corresponding Source, you remain obligated to ensure that it is |
||||
available for as long as needed to satisfy these requirements. |
||||
|
||||
e) Convey the object code using peer-to-peer transmission, provided |
||||
you inform other peers where the object code and Corresponding |
||||
Source of the work are being offered to the general public at no |
||||
charge under subsection 6d. |
||||
|
||||
A separable portion of the object code, whose source code is excluded |
||||
from the Corresponding Source as a System Library, need not be |
||||
included in conveying the object code work. |
||||
|
||||
A "User Product" is either (1) a "consumer product", which means any |
||||
tangible personal property which is normally used for personal, family, |
||||
or household purposes, or (2) anything designed or sold for incorporation |
||||
into a dwelling. In determining whether a product is a consumer product, |
||||
doubtful cases shall be resolved in favor of coverage. For a particular |
||||
product received by a particular user, "normally used" refers to a |
||||
typical or common use of that class of product, regardless of the status |
||||
of the particular user or of the way in which the particular user |
||||
actually uses, or expects or is expected to use, the product. A product |
||||
is a consumer product regardless of whether the product has substantial |
||||
commercial, industrial or non-consumer uses, unless such uses represent |
||||
the only significant mode of use of the product. |
||||
|
||||
"Installation Information" for a User Product means any methods, |
||||
procedures, authorization keys, or other information required to install |
||||
and execute modified versions of a covered work in that User Product from |
||||
a modified version of its Corresponding Source. The information must |
||||
suffice to ensure that the continued functioning of the modified object |
||||
code is in no case prevented or interfered with solely because |
||||
modification has been made. |
||||
|
||||
If you convey an object code work under this section in, or with, or |
||||
specifically for use in, a User Product, and the conveying occurs as |
||||
part of a transaction in which the right of possession and use of the |
||||
User Product is transferred to the recipient in perpetuity or for a |
||||
fixed term (regardless of how the transaction is characterized), the |
||||
Corresponding Source conveyed under this section must be accompanied |
||||
by the Installation Information. But this requirement does not apply |
||||
if neither you nor any third party retains the ability to install |
||||
modified object code on the User Product (for example, the work has |
||||
been installed in ROM). |
||||
|
||||
The requirement to provide Installation Information does not include a |
||||
requirement to continue to provide support service, warranty, or updates |
||||
for a work that has been modified or installed by the recipient, or for |
||||
the User Product in which it has been modified or installed. Access to a |
||||
network may be denied when the modification itself materially and |
||||
adversely affects the operation of the network or violates the rules and |
||||
protocols for communication across the network. |
||||
|
||||
Corresponding Source conveyed, and Installation Information provided, |
||||
in accord with this section must be in a format that is publicly |
||||
documented (and with an implementation available to the public in |
||||
source code form), and must require no special password or key for |
||||
unpacking, reading or copying. |
||||
|
||||
7. Additional Terms. |
||||
|
||||
"Additional permissions" are terms that supplement the terms of this |
||||
License by making exceptions from one or more of its conditions. |
||||
Additional permissions that are applicable to the entire Program shall |
||||
be treated as though they were included in this License, to the extent |
||||
that they are valid under applicable law. If additional permissions |
||||
apply only to part of the Program, that part may be used separately |
||||
under those permissions, but the entire Program remains governed by |
||||
this License without regard to the additional permissions. |
||||
|
||||
When you convey a copy of a covered work, you may at your option |
||||
remove any additional permissions from that copy, or from any part of |
||||
it. (Additional permissions may be written to require their own |
||||
removal in certain cases when you modify the work.) You may place |
||||
additional permissions on material, added by you to a covered work, |
||||
for which you have or can give appropriate copyright permission. |
||||
|
||||
Notwithstanding any other provision of this License, for material you |
||||
add to a covered work, you may (if authorized by the copyright holders of |
||||
that material) supplement the terms of this License with terms: |
||||
|
||||
a) Disclaiming warranty or limiting liability differently from the |
||||
terms of sections 15 and 16 of this License; or |
||||
|
||||
b) Requiring preservation of specified reasonable legal notices or |
||||
author attributions in that material or in the Appropriate Legal |
||||
Notices displayed by works containing it; or |
||||
|
||||
c) Prohibiting misrepresentation of the origin of that material, or |
||||
requiring that modified versions of such material be marked in |
||||
reasonable ways as different from the original version; or |
||||
|
||||
d) Limiting the use for publicity purposes of names of licensors or |
||||
authors of the material; or |
||||
|
||||
e) Declining to grant rights under trademark law for use of some |
||||
trade names, trademarks, or service marks; or |
||||
|
||||
f) Requiring indemnification of licensors and authors of that |
||||
material by anyone who conveys the material (or modified versions of |
||||
it) with contractual assumptions of liability to the recipient, for |
||||
any liability that these contractual assumptions directly impose on |
||||
those licensors and authors. |
||||
|
||||
All other non-permissive additional terms are considered "further |
||||
restrictions" within the meaning of section 10. If the Program as you |
||||
received it, or any part of it, contains a notice stating that it is |
||||
governed by this License along with a term that is a further |
||||
restriction, you may remove that term. If a license document contains |
||||
a further restriction but permits relicensing or conveying under this |
||||
License, you may add to a covered work material governed by the terms |
||||
of that license document, provided that the further restriction does |
||||
not survive such relicensing or conveying. |
||||
|
||||
If you add terms to a covered work in accord with this section, you |
||||
must place, in the relevant source files, a statement of the |
||||
additional terms that apply to those files, or a notice indicating |
||||
where to find the applicable terms. |
||||
|
||||
Additional terms, permissive or non-permissive, may be stated in the |
||||
form of a separately written license, or stated as exceptions; |
||||
the above requirements apply either way. |
||||
|
||||
8. Termination. |
||||
|
||||
You may not propagate or modify a covered work except as expressly |
||||
provided under this License. Any attempt otherwise to propagate or |
||||
modify it is void, and will automatically terminate your rights under |
||||
this License (including any patent licenses granted under the third |
||||
paragraph of section 11). |
||||
|
||||
However, if you cease all violation of this License, then your |
||||
license from a particular copyright holder is reinstated (a) |
||||
provisionally, unless and until the copyright holder explicitly and |
||||
finally terminates your license, and (b) permanently, if the copyright |
||||
holder fails to notify you of the violation by some reasonable means |
||||
prior to 60 days after the cessation. |
||||
|
||||
Moreover, your license from a particular copyright holder is |
||||
reinstated permanently if the copyright holder notifies you of the |
||||
violation by some reasonable means, this is the first time you have |
||||
received notice of violation of this License (for any work) from that |
||||
copyright holder, and you cure the violation prior to 30 days after |
||||
your receipt of the notice. |
||||
|
||||
Termination of your rights under this section does not terminate the |
||||
licenses of parties who have received copies or rights from you under |
||||
this License. If your rights have been terminated and not permanently |
||||
reinstated, you do not qualify to receive new licenses for the same |
||||
material under section 10. |
||||
|
||||
9. Acceptance Not Required for Having Copies. |
||||
|
||||
You are not required to accept this License in order to receive or |
||||
run a copy of the Program. Ancillary propagation of a covered work |
||||
occurring solely as a consequence of using peer-to-peer transmission |
||||
to receive a copy likewise does not require acceptance. However, |
||||
nothing other than this License grants you permission to propagate or |
||||
modify any covered work. These actions infringe copyright if you do |
||||
not accept this License. Therefore, by modifying or propagating a |
||||
covered work, you indicate your acceptance of this License to do so. |
||||
|
||||
10. Automatic Licensing of Downstream Recipients. |
||||
|
||||
Each time you convey a covered work, the recipient automatically |
||||
receives a license from the original licensors, to run, modify and |
||||
propagate that work, subject to this License. You are not responsible |
||||
for enforcing compliance by third parties with this License. |
||||
|
||||
An "entity transaction" is a transaction transferring control of an |
||||
organization, or substantially all assets of one, or subdividing an |
||||
organization, or merging organizations. If propagation of a covered |
||||
work results from an entity transaction, each party to that |
||||
transaction who receives a copy of the work also receives whatever |
||||
licenses to the work the party's predecessor in interest had or could |
||||
give under the previous paragraph, plus a right to possession of the |
||||
Corresponding Source of the work from the predecessor in interest, if |
||||
the predecessor has it or can get it with reasonable efforts. |
||||
|
||||
You may not impose any further restrictions on the exercise of the |
||||
rights granted or affirmed under this License. For example, you may |
||||
not impose a license fee, royalty, or other charge for exercise of |
||||
rights granted under this License, and you may not initiate litigation |
||||
(including a cross-claim or counterclaim in a lawsuit) alleging that |
||||
any patent claim is infringed by making, using, selling, offering for |
||||
sale, or importing the Program or any portion of it. |
||||
|
||||
11. Patents. |
||||
|
||||
A "contributor" is a copyright holder who authorizes use under this |
||||
License of the Program or a work on which the Program is based. The |
||||
work thus licensed is called the contributor's "contributor version". |
||||
|
||||
A contributor's "essential patent claims" are all patent claims |
||||
owned or controlled by the contributor, whether already acquired or |
||||
hereafter acquired, that would be infringed by some manner, permitted |
||||
by this License, of making, using, or selling its contributor version, |
||||
but do not include claims that would be infringed only as a |
||||
consequence of further modification of the contributor version. For |
||||
purposes of this definition, "control" includes the right to grant |
||||
patent sublicenses in a manner consistent with the requirements of |
||||
this License. |
||||
|
||||
Each contributor grants you a non-exclusive, worldwide, royalty-free |
||||
patent license under the contributor's essential patent claims, to |
||||
make, use, sell, offer for sale, import and otherwise run, modify and |
||||
propagate the contents of its contributor version. |
||||
|
||||
In the following three paragraphs, a "patent license" is any express |
||||
agreement or commitment, however denominated, not to enforce a patent |
||||
(such as an express permission to practice a patent or covenant not to |
||||
sue for patent infringement). To "grant" such a patent license to a |
||||
party means to make such an agreement or commitment not to enforce a |
||||
patent against the party. |
||||
|
||||
If you convey a covered work, knowingly relying on a patent license, |
||||
and the Corresponding Source of the work is not available for anyone |
||||
to copy, free of charge and under the terms of this License, through a |
||||
publicly available network server or other readily accessible means, |
||||
then you must either (1) cause the Corresponding Source to be so |
||||
available, or (2) arrange to deprive yourself of the benefit of the |
||||
patent license for this particular work, or (3) arrange, in a manner |
||||
consistent with the requirements of this License, to extend the patent |
||||
license to downstream recipients. "Knowingly relying" means you have |
||||
actual knowledge that, but for the patent license, your conveying the |
||||
covered work in a country, or your recipient's use of the covered work |
||||
in a country, would infringe one or more identifiable patents in that |
||||
country that you have reason to believe are valid. |
||||
|
||||
If, pursuant to or in connection with a single transaction or |
||||
arrangement, you convey, or propagate by procuring conveyance of, a |
||||
covered work, and grant a patent license to some of the parties |
||||
receiving the covered work authorizing them to use, propagate, modify |
||||
or convey a specific copy of the covered work, then the patent license |
||||
you grant is automatically extended to all recipients of the covered |
||||
work and works based on it. |
||||
|
||||
A patent license is "discriminatory" if it does not include within |
||||
the scope of its coverage, prohibits the exercise of, or is |
||||
conditioned on the non-exercise of one or more of the rights that are |
||||
specifically granted under this License. You may not convey a covered |
||||
work if you are a party to an arrangement with a third party that is |
||||
in the business of distributing software, under which you make payment |
||||
to the third party based on the extent of your activity of conveying |
||||
the work, and under which the third party grants, to any of the |
||||
parties who would receive the covered work from you, a discriminatory |
||||
patent license (a) in connection with copies of the covered work |
||||
conveyed by you (or copies made from those copies), or (b) primarily |
||||
for and in connection with specific products or compilations that |
||||
contain the covered work, unless you entered into that arrangement, |
||||
or that patent license was granted, prior to 28 March 2007. |
||||
|
||||
Nothing in this License shall be construed as excluding or limiting |
||||
any implied license or other defenses to infringement that may |
||||
otherwise be available to you under applicable patent law. |
||||
|
||||
12. No Surrender of Others' Freedom. |
||||
|
||||
If conditions are imposed on you (whether by court order, agreement or |
||||
otherwise) that contradict the conditions of this License, they do not |
||||
excuse you from the conditions of this License. If you cannot convey a |
||||
covered work so as to satisfy simultaneously your obligations under this |
||||
License and any other pertinent obligations, then as a consequence you may |
||||
not convey it at all. For example, if you agree to terms that obligate you |
||||
to collect a royalty for further conveying from those to whom you convey |
||||
the Program, the only way you could satisfy both those terms and this |
||||
License would be to refrain entirely from conveying the Program. |
||||
|
||||
13. Use with the GNU Affero General Public License. |
||||
|
||||
Notwithstanding any other provision of this License, you have |
||||
permission to link or combine any covered work with a work licensed |
||||
under version 3 of the GNU Affero General Public License into a single |
||||
combined work, and to convey the resulting work. The terms of this |
||||
License will continue to apply to the part which is the covered work, |
||||
but the special requirements of the GNU Affero General Public License, |
||||
section 13, concerning interaction through a network will apply to the |
||||
combination as such. |
||||
|
||||
14. Revised Versions of this License. |
||||
|
||||
The Free Software Foundation may publish revised and/or new versions of |
||||
the GNU General Public License from time to time. Such new versions will |
||||
be similar in spirit to the present version, but may differ in detail to |
||||
address new problems or concerns. |
||||
|
||||
Each version is given a distinguishing version number. If the |
||||
Program specifies that a certain numbered version of the GNU General |
||||
Public License "or any later version" applies to it, you have the |
||||
option of following the terms and conditions either of that numbered |
||||
version or of any later version published by the Free Software |
||||
Foundation. If the Program does not specify a version number of the |
||||
GNU General Public License, you may choose any version ever published |
||||
by the Free Software Foundation. |
||||
|
||||
If the Program specifies that a proxy can decide which future |
||||
versions of the GNU General Public License can be used, that proxy's |
||||
public statement of acceptance of a version permanently authorizes you |
||||
to choose that version for the Program. |
||||
|
||||
Later license versions may give you additional or different |
||||
permissions. However, no additional obligations are imposed on any |
||||
author or copyright holder as a result of your choosing to follow a |
||||
later version. |
||||
|
||||
15. Disclaimer of Warranty. |
||||
|
||||
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY |
||||
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT |
||||
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY |
||||
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, |
||||
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM |
||||
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF |
||||
ALL NECESSARY SERVICING, REPAIR OR CORRECTION. |
||||
|
||||
16. Limitation of Liability. |
||||
|
||||
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING |
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS |
||||
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY |
||||
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE |
||||
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF |
||||
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD |
||||
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), |
||||
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF |
||||
SUCH DAMAGES. |
||||
|
||||
17. Interpretation of Sections 15 and 16. |
||||
|
||||
If the disclaimer of warranty and limitation of liability provided |
||||
above cannot be given local legal effect according to their terms, |
||||
reviewing courts shall apply local law that most closely approximates |
||||
an absolute waiver of all civil liability in connection with the |
||||
Program, unless a warranty or assumption of liability accompanies a |
||||
copy of the Program in return for a fee. |
||||
|
||||
END OF TERMS AND CONDITIONS |
||||
|
||||
How to Apply These Terms to Your New Programs |
||||
|
||||
If you develop a new program, and you want it to be of the greatest |
||||
possible use to the public, the best way to achieve this is to make it |
||||
free software which everyone can redistribute and change under these terms. |
||||
|
||||
To do so, attach the following notices to the program. It is safest |
||||
to attach them to the start of each source file to most effectively |
||||
state the exclusion of warranty; and each file should have at least |
||||
the "copyright" line and a pointer to where the full notice is found. |
||||
|
||||
<one line to give the program's name and a brief idea of what it does.> |
||||
Copyright (C) <year> <name of author> |
||||
|
||||
This program is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License as published by |
||||
the Free Software Foundation, either version 3 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
This program is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with this program. If not, see <http://www.gnu.org/licenses/>. |
||||
|
||||
Also add information on how to contact you by electronic and paper mail. |
||||
|
||||
If the program does terminal interaction, make it output a short |
||||
notice like this when it starts in an interactive mode: |
||||
|
||||
<program> Copyright (C) <year> <name of author> |
||||
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. |
||||
This is free software, and you are welcome to redistribute it |
||||
under certain conditions; type `show c' for details. |
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate |
||||
parts of the General Public License. Of course, your program's commands |
||||
might be different; for a GUI interface, you would use an "about box". |
||||
|
||||
You should also get your employer (if you work as a programmer) or school, |
||||
if any, to sign a "copyright disclaimer" for the program, if necessary. |
||||
For more information on this, and how to apply and follow the GNU GPL, see |
||||
<http://www.gnu.org/licenses/>. |
||||
|
||||
The GNU General Public License does not permit incorporating your program |
||||
into proprietary programs. If your program is a subroutine library, you |
||||
may consider it more useful to permit linking proprietary applications with |
||||
the library. If this is what you want to do, use the GNU Lesser General |
||||
Public License instead of this License. But first, please read |
||||
<http://www.gnu.org/philosophy/why-not-lgpl.html>. |
||||
@ -0,0 +1,9 @@ |
||||
HIDAPI - Multi-Platform library for |
||||
communication with HID devices. |
||||
|
||||
Copyright 2009, Alan Ott, Signal 11 Software. |
||||
All Rights Reserved. |
||||
|
||||
This software may be used by anyone for any reason so |
||||
long as the copyright notice in the source files |
||||
remains intact. |
||||
@ -0,0 +1,13 @@ |
||||
HIDAPI can be used under one of three licenses. |
||||
|
||||
1. The GNU General Public License, version 3.0, in LICENSE-gpl3.txt |
||||
2. A BSD-Style License, in LICENSE-bsd.txt. |
||||
3. The more liberal original HIDAPI license. LICENSE-orig.txt |
||||
|
||||
The license chosen is at the discretion of the user of HIDAPI. For example: |
||||
1. An author of GPL software would likely use HIDAPI under the terms of the |
||||
GPL. |
||||
|
||||
2. An author of commercial closed-source software would likely use HIDAPI |
||||
under the terms of the BSD-style license or the original HIDAPI license. |
||||
|
||||
@ -0,0 +1,339 @@ |
||||
HIDAPI library for Windows, Linux, FreeBSD and Mac OS X |
||||
========================================================= |
||||
|
||||
About |
||||
====== |
||||
|
||||
HIDAPI is a multi-platform library which allows an application to interface |
||||
with USB and Bluetooth HID-Class devices on Windows, Linux, FreeBSD, and Mac |
||||
OS X. HIDAPI can be either built as a shared library (.so or .dll) or |
||||
can be embedded directly into a target application by adding a single source |
||||
file (per platform) and a single header. |
||||
|
||||
HIDAPI has four back-ends: |
||||
* Windows (using hid.dll) |
||||
* Linux/hidraw (using the Kernel's hidraw driver) |
||||
* Linux/libusb (using libusb-1.0) |
||||
* FreeBSD (using libusb-1.0) |
||||
* Mac (using IOHidManager) |
||||
|
||||
On Linux, either the hidraw or the libusb back-end can be used. There are |
||||
tradeoffs, and the functionality supported is slightly different. |
||||
|
||||
Linux/hidraw (linux/hid.c): |
||||
This back-end uses the hidraw interface in the Linux kernel. While this |
||||
back-end will support both USB and Bluetooth, it has some limitations on |
||||
kernels prior to 2.6.39, including the inability to send or receive feature |
||||
reports. In addition, it will only communicate with devices which have |
||||
hidraw nodes associated with them. Keyboards, mice, and some other devices |
||||
which are blacklisted from having hidraw nodes will not work. Fortunately, |
||||
for nearly all the uses of hidraw, this is not a problem. |
||||
|
||||
Linux/FreeBSD/libusb (libusb/hid.c): |
||||
This back-end uses libusb-1.0 to communicate directly to a USB device. This |
||||
back-end will of course not work with Bluetooth devices. |
||||
|
||||
HIDAPI also comes with a Test GUI. The Test GUI is cross-platform and uses |
||||
Fox Toolkit (http://www.fox-toolkit.org). It will build on every platform |
||||
which HIDAPI supports. Since it relies on a 3rd party library, building it |
||||
is optional but recommended because it is so useful when debugging hardware. |
||||
|
||||
What Does the API Look Like? |
||||
============================= |
||||
The API provides the the most commonly used HID functions including sending |
||||
and receiving of input, output, and feature reports. The sample program, |
||||
which communicates with a heavily hacked up version of the Microchip USB |
||||
Generic HID sample looks like this (with error checking removed for |
||||
simplicity): |
||||
|
||||
#ifdef WIN32 |
||||
#include <windows.h> |
||||
#endif |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include "hidapi.h" |
||||
|
||||
#define MAX_STR 255 |
||||
|
||||
int main(int argc, char* argv[]) |
||||
{ |
||||
int res; |
||||
unsigned char buf[65]; |
||||
wchar_t wstr[MAX_STR]; |
||||
hid_device *handle; |
||||
int i; |
||||
|
||||
// Initialize the hidapi library |
||||
res = hid_init(); |
||||
|
||||
// Open the device using the VID, PID, |
||||
// and optionally the Serial number. |
||||
handle = hid_open(0x4d8, 0x3f, NULL); |
||||
|
||||
// Read the Manufacturer String |
||||
res = hid_get_manufacturer_string(handle, wstr, MAX_STR); |
||||
wprintf(L"Manufacturer String: %s\n", wstr); |
||||
|
||||
// Read the Product String |
||||
res = hid_get_product_string(handle, wstr, MAX_STR); |
||||
wprintf(L"Product String: %s\n", wstr); |
||||
|
||||
// Read the Serial Number String |
||||
res = hid_get_serial_number_string(handle, wstr, MAX_STR); |
||||
wprintf(L"Serial Number String: (%d) %s\n", wstr[0], wstr); |
||||
|
||||
// Read Indexed String 1 |
||||
res = hid_get_indexed_string(handle, 1, wstr, MAX_STR); |
||||
wprintf(L"Indexed String 1: %s\n", wstr); |
||||
|
||||
// Toggle LED (cmd 0x80). The first byte is the report number (0x0). |
||||
buf[0] = 0x0; |
||||
buf[1] = 0x80; |
||||
res = hid_write(handle, buf, 65); |
||||
|
||||
// Request state (cmd 0x81). The first byte is the report number (0x0). |
||||
buf[0] = 0x0; |
||||
buf[1] = 0x81; |
||||
res = hid_write(handle, buf, 65); |
||||
|
||||
// Read requested state |
||||
res = hid_read(handle, buf, 65); |
||||
|
||||
// Print out the returned buffer. |
||||
for (i = 0; i < 4; i++) |
||||
printf("buf[%d]: %d\n", i, buf[i]); |
||||
|
||||
// Finalize the hidapi library |
||||
res = hid_exit(); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
If you have your own simple test programs which communicate with standard |
||||
hardware development boards (such as those from Microchip, TI, Atmel, |
||||
FreeScale and others), please consider sending me something like the above |
||||
for inclusion into the HIDAPI source. This will help others who have the |
||||
same hardware as you do. |
||||
|
||||
License |
||||
======== |
||||
HIDAPI may be used by one of three licenses as outlined in LICENSE.txt. |
||||
|
||||
Download |
||||
========= |
||||
HIDAPI can be downloaded from github |
||||
git clone git://github.com/signal11/hidapi.git |
||||
|
||||
Build Instructions |
||||
=================== |
||||
|
||||
This section is long. Don't be put off by this. It's not long because it's |
||||
complicated to build HIDAPI; it's quite the opposite. This section is long |
||||
because of the flexibility of HIDAPI and the large number of ways in which |
||||
it can be built and used. You will likely pick a single build method. |
||||
|
||||
HIDAPI can be built in several different ways. If you elect to build a |
||||
shared library, you will need to build it from the HIDAPI source |
||||
distribution. If you choose instead to embed HIDAPI directly into your |
||||
application, you can skip the building and look at the provided platform |
||||
Makefiles for guidance. These platform Makefiles are located in linux/ |
||||
libusb/ mac/ and windows/ and are called Makefile-manual. In addition, |
||||
Visual Studio projects are provided. Even if you're going to embed HIDAPI |
||||
into your project, it is still beneficial to build the example programs. |
||||
|
||||
|
||||
Prerequisites: |
||||
--------------- |
||||
|
||||
Linux: |
||||
------- |
||||
On Linux, you will need to install development packages for libudev, |
||||
libusb and optionally Fox-toolkit (for the test GUI). On |
||||
Debian/Ubuntu systems these can be installed by running: |
||||
sudo apt-get install libudev-dev libusb-1.0-0-dev libfox-1.6-dev |
||||
|
||||
If you downloaded the source directly from the git repository (using |
||||
git clone), you'll need Autotools: |
||||
sudo apt-get install autotools-dev autoconf automake libtool |
||||
|
||||
FreeBSD: |
||||
--------- |
||||
On FreeBSD you will need to install GNU make, libiconv, and |
||||
optionally Fox-Toolkit (for the test GUI). This is done by running |
||||
the following: |
||||
pkg_add -r gmake libiconv fox16 |
||||
|
||||
If you downloaded the source directly from the git repository (using |
||||
git clone), you'll need Autotools: |
||||
pkg_add -r autotools |
||||
|
||||
Mac: |
||||
----- |
||||
On Mac, you will need to install Fox-Toolkit if you wish to build |
||||
the Test GUI. There are two ways to do this, and each has a slight |
||||
complication. Which method you use depends on your use case. |
||||
|
||||
If you wish to build the Test GUI just for your own testing on your |
||||
own computer, then the easiest method is to install Fox-Toolkit |
||||
using ports: |
||||
sudo port install fox |
||||
|
||||
If you wish to build the TestGUI app bundle to redistribute to |
||||
others, you will need to install Fox-toolkit from source. This is |
||||
because the version of fox that gets installed using ports uses the |
||||
ports X11 libraries which are not compatible with the Apple X11 |
||||
libraries. If you install Fox with ports and then try to distribute |
||||
your built app bundle, it will simply fail to run on other systems. |
||||
To install Fox-Toolkit manually, download the source package from |
||||
http://www.fox-toolkit.org, extract it, and run the following from |
||||
within the extracted source: |
||||
./configure && make && make install |
||||
|
||||
Windows: |
||||
--------- |
||||
On Windows, if you want to build the test GUI, you will need to get |
||||
the hidapi-externals.zip package from the download site. This |
||||
contains pre-built binaries for Fox-toolkit. Extract |
||||
hidapi-externals.zip just outside of hidapi, so that |
||||
hidapi-externals and hidapi are on the same level, as shown: |
||||
|
||||
Parent_Folder |
||||
| |
||||
+hidapi |
||||
+hidapi-externals |
||||
|
||||
Again, this step is not required if you do not wish to build the |
||||
test GUI. |
||||
|
||||
|
||||
Building HIDAPI into a shared library on Unix Platforms: |
||||
--------------------------------------------------------- |
||||
|
||||
On Unix-like systems such as Linux, FreeBSD, Mac, and even Windows, using |
||||
Mingw or Cygwin, the easiest way to build a standard system-installed shared |
||||
library is to use the GNU Autotools build system. If you checked out the |
||||
source from the git repository, run the following: |
||||
|
||||
./bootstrap |
||||
./configure |
||||
make |
||||
make install <----- as root, or using sudo |
||||
|
||||
If you downloaded a source package (ie: if you did not run git clone), you |
||||
can skip the ./bootstrap step. |
||||
|
||||
./configure can take several arguments which control the build. The two most |
||||
likely to be used are: |
||||
--enable-testgui |
||||
Enable build of the Test GUI. This requires Fox toolkit to |
||||
be installed. Instructions for installing Fox-Toolkit on |
||||
each platform are in the Prerequisites section above. |
||||
|
||||
--prefix=/usr |
||||
Specify where you want the output headers and libraries to |
||||
be installed. The example above will put the headers in |
||||
/usr/include and the binaries in /usr/lib. The default is to |
||||
install into /usr/local which is fine on most systems. |
||||
|
||||
Building the manual way on Unix platforms: |
||||
------------------------------------------- |
||||
|
||||
Manual Makefiles are provided mostly to give the user and idea what it takes |
||||
to build a program which embeds HIDAPI directly inside of it. These should |
||||
really be used as examples only. If you want to build a system-wide shared |
||||
library, use the Autotools method described above. |
||||
|
||||
To build HIDAPI using the manual makefiles, change to the directory |
||||
of your platform and run make. For example, on Linux run: |
||||
cd linux/ |
||||
make -f Makefile-manual |
||||
|
||||
To build the Test GUI using the manual makefiles: |
||||
cd testgui/ |
||||
make -f Makefile-manual |
||||
|
||||
Building on Windows: |
||||
--------------------- |
||||
|
||||
To build the HIDAPI DLL on Windows using Visual Studio, build the .sln file |
||||
in the windows/ directory. |
||||
|
||||
To build the Test GUI on windows using Visual Studio, build the .sln file in |
||||
the testgui/ directory. |
||||
|
||||
To build HIDAPI using MinGW or Cygwin using Autotools, use the instructions |
||||
in the section titled "Building HIDAPI into a shared library on Unix |
||||
Platforms" above. Note that building the Test GUI with MinGW or Cygwin will |
||||
require the Windows procedure in the Prerequisites section above (ie: |
||||
hidapi-externals.zip). |
||||
|
||||
To build HIDAPI using MinGW using the Manual Makefiles, see the section |
||||
"Building the manual way on Unix platforms" above. |
||||
|
||||
HIDAPI can also be built using the Windows DDK (now also called the Windows |
||||
Driver Kit or WDK). This method was originally required for the HIDAPI build |
||||
but not anymore. However, some users still prefer this method. It is not as |
||||
well supported anymore but should still work. Patches are welcome if it does |
||||
not. To build using the DDK: |
||||
|
||||
1. Install the Windows Driver Kit (WDK) from Microsoft. |
||||
2. From the Start menu, in the Windows Driver Kits folder, select Build |
||||
Environments, then your operating system, then the x86 Free Build |
||||
Environment (or one that is appropriate for your system). |
||||
3. From the console, change directory to the windows/ddk_build/ directory, |
||||
which is part of the HIDAPI distribution. |
||||
4. Type build. |
||||
5. You can find the output files (DLL and LIB) in a subdirectory created |
||||
by the build system which is appropriate for your environment. On |
||||
Windows XP, this directory is objfre_wxp_x86/i386. |
||||
|
||||
Cross Compiling |
||||
================ |
||||
|
||||
This section talks about cross compiling HIDAPI for Linux using autotools. |
||||
This is useful for using HIDAPI on embedded Linux targets. These |
||||
instructions assume the most raw kind of embedded Linux build, where all |
||||
prerequisites will need to be built first. This process will of course vary |
||||
based on your embedded Linux build system if you are using one, such as |
||||
OpenEmbedded or Buildroot. |
||||
|
||||
For the purpose of this section, it will be assumed that the following |
||||
environment variables are exported. |
||||
|
||||
$ export STAGING=$HOME/out |
||||
$ export HOST=arm-linux |
||||
|
||||
STAGING and HOST can be modified to suit your setup. |
||||
|
||||
Prerequisites |
||||
-------------- |
||||
|
||||
Note that the build of libudev is the very basic configuration. |
||||
|
||||
Build Libusb. From the libusb source directory, run: |
||||
./configure --host=$HOST --prefix=$STAGING |
||||
make |
||||
make install |
||||
|
||||
Build libudev. From the libudev source directory, run: |
||||
./configure --disable-gudev --disable-introspection --disable-hwdb \ |
||||
--host=$HOST --prefix=$STAGING |
||||
make |
||||
make install |
||||
|
||||
Building HIDAPI |
||||
---------------- |
||||
|
||||
Build HIDAPI: |
||||
|
||||
PKG_CONFIG_DIR= \ |
||||
PKG_CONFIG_LIBDIR=$STAGING/lib/pkgconfig:$STAGING/share/pkgconfig \ |
||||
PKG_CONFIG_SYSROOT_DIR=$STAGING \ |
||||
./configure --host=$HOST --prefix=$STAGING |
||||
|
||||
|
||||
Signal 11 Software - 2010-04-11 |
||||
2010-07-28 |
||||
2011-09-10 |
||||
2012-05-01 |
||||
2012-07-03 |
||||
@ -0,0 +1,391 @@ |
||||
/*******************************************************
|
||||
HIDAPI - Multi-Platform library for |
||||
communication with HID devices. |
||||
|
||||
Alan Ott |
||||
Signal 11 Software |
||||
|
||||
8/22/2009 |
||||
|
||||
Copyright 2009, All Rights Reserved. |
||||
|
||||
At the discretion of the user of this library, |
||||
this software may be licensed under the terms of the |
||||
GNU General Public License v3, a BSD-Style license, or the |
||||
original HIDAPI license as outlined in the LICENSE.txt, |
||||
LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt |
||||
files located at the root of the source distribution. |
||||
These files may also be found in the public source |
||||
code repository located at: |
||||
http://github.com/signal11/hidapi .
|
||||
********************************************************/ |
||||
|
||||
/** @file
|
||||
* @defgroup API hidapi API |
||||
*/ |
||||
|
||||
#ifndef HIDAPI_H__ |
||||
#define HIDAPI_H__ |
||||
|
||||
#include <wchar.h> |
||||
|
||||
#ifdef _WIN32 |
||||
#define HID_API_EXPORT __declspec(dllexport) |
||||
#define HID_API_CALL |
||||
#else |
||||
#define HID_API_EXPORT /**< API export macro */ |
||||
#define HID_API_CALL /**< API call macro */ |
||||
#endif |
||||
|
||||
#define HID_API_EXPORT_CALL HID_API_EXPORT HID_API_CALL /**< API export and call macro*/ |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
struct hid_device_; |
||||
typedef struct hid_device_ hid_device; /**< opaque hidapi structure */ |
||||
|
||||
/** hidapi info structure */ |
||||
struct hid_device_info { |
||||
/** Platform-specific device path */ |
||||
char *path; |
||||
/** Device Vendor ID */ |
||||
unsigned short vendor_id; |
||||
/** Device Product ID */ |
||||
unsigned short product_id; |
||||
/** Serial Number */ |
||||
wchar_t *serial_number; |
||||
/** Device Release Number in binary-coded decimal,
|
||||
also known as Device Version Number */ |
||||
unsigned short release_number; |
||||
/** Manufacturer String */ |
||||
wchar_t *manufacturer_string; |
||||
/** Product string */ |
||||
wchar_t *product_string; |
||||
/** Usage Page for this Device/Interface
|
||||
(Windows/Mac only). */ |
||||
unsigned short usage_page; |
||||
/** Usage for this Device/Interface
|
||||
(Windows/Mac only).*/ |
||||
unsigned short usage; |
||||
/** The USB interface which this logical device
|
||||
represents. Valid on both Linux implementations |
||||
in all cases, and valid on the Windows implementation |
||||
only if the device contains more than one interface. */ |
||||
int interface_number; |
||||
|
||||
/** Pointer to the next device */ |
||||
struct hid_device_info *next; |
||||
}; |
||||
|
||||
|
||||
/** @brief Initialize the HIDAPI library.
|
||||
|
||||
This function initializes the HIDAPI library. Calling it is not |
||||
strictly necessary, as it will be called automatically by |
||||
hid_enumerate() and any of the hid_open_*() functions if it is |
||||
needed. This function should be called at the beginning of |
||||
execution however, if there is a chance of HIDAPI handles |
||||
being opened by different threads simultaneously. |
||||
|
||||
@ingroup API |
||||
|
||||
@returns |
||||
This function returns 0 on success and -1 on error. |
||||
*/ |
||||
int HID_API_EXPORT HID_API_CALL hid_init(void); |
||||
|
||||
/** @brief Finalize the HIDAPI library.
|
||||
|
||||
This function frees all of the static data associated with |
||||
HIDAPI. It should be called at the end of execution to avoid |
||||
memory leaks. |
||||
|
||||
@ingroup API |
||||
|
||||
@returns |
||||
This function returns 0 on success and -1 on error. |
||||
*/ |
||||
int HID_API_EXPORT HID_API_CALL hid_exit(void); |
||||
|
||||
/** @brief Enumerate the HID Devices.
|
||||
|
||||
This function returns a linked list of all the HID devices |
||||
attached to the system which match vendor_id and product_id. |
||||
If @p vendor_id is set to 0 then any vendor matches. |
||||
If @p product_id is set to 0 then any product matches. |
||||
If @p vendor_id and @p product_id are both set to 0, then |
||||
all HID devices will be returned. |
||||
|
||||
@ingroup API |
||||
@param vendor_id The Vendor ID (VID) of the types of device |
||||
to open. |
||||
@param product_id The Product ID (PID) of the types of |
||||
device to open. |
||||
|
||||
@returns |
||||
This function returns a pointer to a linked list of type |
||||
struct #hid_device, containing information about the HID devices |
||||
attached to the system, or NULL in the case of failure. Free |
||||
this linked list by calling hid_free_enumeration(). |
||||
*/ |
||||
struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id); |
||||
|
||||
/** @brief Free an enumeration Linked List
|
||||
|
||||
This function frees a linked list created by hid_enumerate(). |
||||
|
||||
@ingroup API |
||||
@param devs Pointer to a list of struct_device returned from |
||||
hid_enumerate(). |
||||
*/ |
||||
void HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs); |
||||
|
||||
/** @brief Open a HID device using a Vendor ID (VID), Product ID
|
||||
(PID) and optionally a serial number. |
||||
|
||||
If @p serial_number is NULL, the first device with the |
||||
specified VID and PID is opened. |
||||
|
||||
@ingroup API |
||||
@param vendor_id The Vendor ID (VID) of the device to open. |
||||
@param product_id The Product ID (PID) of the device to open. |
||||
@param serial_number The Serial Number of the device to open |
||||
(Optionally NULL). |
||||
|
||||
@returns |
||||
This function returns a pointer to a #hid_device object on |
||||
success or NULL on failure. |
||||
*/ |
||||
HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number); |
||||
|
||||
/** @brief Open a HID device by its path name.
|
||||
|
||||
The path name be determined by calling hid_enumerate(), or a |
||||
platform-specific path name can be used (eg: /dev/hidraw0 on |
||||
Linux). |
||||
|
||||
@ingroup API |
||||
@param path The path name of the device to open |
||||
|
||||
@returns |
||||
This function returns a pointer to a #hid_device object on |
||||
success or NULL on failure. |
||||
*/ |
||||
HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path); |
||||
|
||||
/** @brief Write an Output report to a HID device.
|
||||
|
||||
The first byte of @p data[] must contain the Report ID. For |
||||
devices which only support a single report, this must be set |
||||
to 0x0. The remaining bytes contain the report data. Since |
||||
the Report ID is mandatory, calls to hid_write() will always |
||||
contain one more byte than the report contains. For example, |
||||
if a hid report is 16 bytes long, 17 bytes must be passed to |
||||
hid_write(), the Report ID (or 0x0, for devices with a |
||||
single report), followed by the report data (16 bytes). In |
||||
this example, the length passed in would be 17. |
||||
|
||||
hid_write() will send the data on the first OUT endpoint, if |
||||
one exists. If it does not, it will send the data through |
||||
the Control Endpoint (Endpoint 0). |
||||
|
||||
@ingroup API |
||||
@param device A device handle returned from hid_open(). |
||||
@param data The data to send, including the report number as |
||||
the first byte. |
||||
@param length The length in bytes of the data to send. |
||||
|
||||
@returns |
||||
This function returns the actual number of bytes written and |
||||
-1 on error. |
||||
*/ |
||||
int HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned char *data, size_t length); |
||||
|
||||
/** @brief Read an Input report from a HID device with timeout.
|
||||
|
||||
Input reports are returned |
||||
to the host through the INTERRUPT IN endpoint. The first byte will |
||||
contain the Report number if the device uses numbered reports. |
||||
|
||||
@ingroup API |
||||
@param device A device handle returned from hid_open(). |
||||
@param data A buffer to put the read data into. |
||||
@param length The number of bytes to read. For devices with |
||||
multiple reports, make sure to read an extra byte for |
||||
the report number. |
||||
@param milliseconds timeout in milliseconds or -1 for blocking wait. |
||||
|
||||
@returns |
||||
This function returns the actual number of bytes read and |
||||
-1 on error. If no packet was available to be read within |
||||
the timeout period, this function returns 0. |
||||
*/ |
||||
int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds); |
||||
|
||||
/** @brief Read an Input report from a HID device.
|
||||
|
||||
Input reports are returned |
||||
to the host through the INTERRUPT IN endpoint. The first byte will |
||||
contain the Report number if the device uses numbered reports. |
||||
|
||||
@ingroup API |
||||
@param device A device handle returned from hid_open(). |
||||
@param data A buffer to put the read data into. |
||||
@param length The number of bytes to read. For devices with |
||||
multiple reports, make sure to read an extra byte for |
||||
the report number. |
||||
|
||||
@returns |
||||
This function returns the actual number of bytes read and |
||||
-1 on error. If no packet was available to be read and |
||||
the handle is in non-blocking mode, this function returns 0. |
||||
*/ |
||||
int HID_API_EXPORT HID_API_CALL hid_read(hid_device *device, unsigned char *data, size_t length); |
||||
|
||||
/** @brief Set the device handle to be non-blocking.
|
||||
|
||||
In non-blocking mode calls to hid_read() will return |
||||
immediately with a value of 0 if there is no data to be |
||||
read. In blocking mode, hid_read() will wait (block) until |
||||
there is data to read before returning. |
||||
|
||||
Nonblocking can be turned on and off at any time. |
||||
|
||||
@ingroup API |
||||
@param device A device handle returned from hid_open(). |
||||
@param nonblock enable or not the nonblocking reads |
||||
- 1 to enable nonblocking |
||||
- 0 to disable nonblocking. |
||||
|
||||
@returns |
||||
This function returns 0 on success and -1 on error. |
||||
*/ |
||||
int HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *device, int nonblock); |
||||
|
||||
/** @brief Send a Feature report to the device.
|
||||
|
||||
Feature reports are sent over the Control endpoint as a |
||||
Set_Report transfer. The first byte of @p data[] must |
||||
contain the Report ID. For devices which only support a |
||||
single report, this must be set to 0x0. The remaining bytes |
||||
contain the report data. Since the Report ID is mandatory, |
||||
calls to hid_send_feature_report() will always contain one |
||||
more byte than the report contains. For example, if a hid |
||||
report is 16 bytes long, 17 bytes must be passed to |
||||
hid_send_feature_report(): the Report ID (or 0x0, for |
||||
devices which do not use numbered reports), followed by the |
||||
report data (16 bytes). In this example, the length passed |
||||
in would be 17. |
||||
|
||||
@ingroup API |
||||
@param device A device handle returned from hid_open(). |
||||
@param data The data to send, including the report number as |
||||
the first byte. |
||||
@param length The length in bytes of the data to send, including |
||||
the report number. |
||||
|
||||
@returns |
||||
This function returns the actual number of bytes written and |
||||
-1 on error. |
||||
*/ |
||||
int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *device, const unsigned char *data, size_t length); |
||||
|
||||
/** @brief Get a feature report from a HID device.
|
||||
|
||||
Set the first byte of @p data[] to the Report ID of the |
||||
report to be read. Make sure to allow space for this |
||||
extra byte in @p data[]. Upon return, the first byte will |
||||
still contain the Report ID, and the report data will |
||||
start in data[1]. |
||||
|
||||
@ingroup API |
||||
@param device A device handle returned from hid_open(). |
||||
@param data A buffer to put the read data into, including |
||||
the Report ID. Set the first byte of @p data[] to the |
||||
Report ID of the report to be read, or set it to zero |
||||
if your device does not use numbered reports. |
||||
@param length The number of bytes to read, including an |
||||
extra byte for the report ID. The buffer can be longer |
||||
than the actual report. |
||||
|
||||
@returns |
||||
This function returns the number of bytes read plus |
||||
one for the report ID (which is still in the first |
||||
byte), or -1 on error. |
||||
*/ |
||||
int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *device, unsigned char *data, size_t length); |
||||
|
||||
/** @brief Close a HID device.
|
||||
|
||||
@ingroup API |
||||
@param device A device handle returned from hid_open(). |
||||
*/ |
||||
void HID_API_EXPORT HID_API_CALL hid_close(hid_device *device); |
||||
|
||||
/** @brief Get The Manufacturer String from a HID device.
|
||||
|
||||
@ingroup API |
||||
@param device A device handle returned from hid_open(). |
||||
@param string A wide string buffer to put the data into. |
||||
@param maxlen The length of the buffer in multiples of wchar_t. |
||||
|
||||
@returns |
||||
This function returns 0 on success and -1 on error. |
||||
*/ |
||||
int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *device, wchar_t *string, size_t maxlen); |
||||
|
||||
/** @brief Get The Product String from a HID device.
|
||||
|
||||
@ingroup API |
||||
@param device A device handle returned from hid_open(). |
||||
@param string A wide string buffer to put the data into. |
||||
@param maxlen The length of the buffer in multiples of wchar_t. |
||||
|
||||
@returns |
||||
This function returns 0 on success and -1 on error. |
||||
*/ |
||||
int HID_API_EXPORT_CALL hid_get_product_string(hid_device *device, wchar_t *string, size_t maxlen); |
||||
|
||||
/** @brief Get The Serial Number String from a HID device.
|
||||
|
||||
@ingroup API |
||||
@param device A device handle returned from hid_open(). |
||||
@param string A wide string buffer to put the data into. |
||||
@param maxlen The length of the buffer in multiples of wchar_t. |
||||
|
||||
@returns |
||||
This function returns 0 on success and -1 on error. |
||||
*/ |
||||
int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *device, wchar_t *string, size_t maxlen); |
||||
|
||||
/** @brief Get a string from a HID device, based on its string index.
|
||||
|
||||
@ingroup API |
||||
@param device A device handle returned from hid_open(). |
||||
@param string_index The index of the string to get. |
||||
@param string A wide string buffer to put the data into. |
||||
@param maxlen The length of the buffer in multiples of wchar_t. |
||||
|
||||
@returns |
||||
This function returns 0 on success and -1 on error. |
||||
*/ |
||||
int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *device, int string_index, wchar_t *string, size_t maxlen); |
||||
|
||||
/** @brief Get a string describing the last error which occurred.
|
||||
|
||||
@ingroup API |
||||
@param device A device handle returned from hid_open(). |
||||
|
||||
@returns |
||||
This function returns a string containing the last error |
||||
which occurred or NULL if none has occurred. |
||||
*/ |
||||
HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *device); |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif |
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,944 @@ |
||||
/*******************************************************
|
||||
HIDAPI - Multi-Platform library for |
||||
communication with HID devices. |
||||
|
||||
Alan Ott |
||||
Signal 11 Software |
||||
|
||||
8/22/2009 |
||||
|
||||
Copyright 2009, All Rights Reserved. |
||||
|
||||
At the discretion of the user of this library, |
||||
this software may be licensed under the terms of the |
||||
GNU General Public License v3, a BSD-Style license, or the |
||||
original HIDAPI license as outlined in the LICENSE.txt, |
||||
LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt |
||||
files located at the root of the source distribution. |
||||
These files may also be found in the public source |
||||
code repository located at: |
||||
http://github.com/signal11/hidapi .
|
||||
********************************************************/ |
||||
|
||||
#include <windows.h> |
||||
|
||||
#ifndef _NTDEF_ |
||||
typedef LONG NTSTATUS; |
||||
#endif |
||||
|
||||
#ifdef __MINGW32__ |
||||
#include <ntdef.h> |
||||
#include <winbase.h> |
||||
#endif |
||||
|
||||
#ifdef __CYGWIN__ |
||||
#include <ntdef.h> |
||||
#define _wcsdup wcsdup |
||||
#endif |
||||
|
||||
/* The maximum number of characters that can be passed into the
|
||||
HidD_Get*String() functions without it failing.*/ |
||||
#define MAX_STRING_WCHARS 0xFFF |
||||
|
||||
/*#define HIDAPI_USE_DDK*/ |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
#include <setupapi.h> |
||||
#include <winioctl.h> |
||||
#ifdef HIDAPI_USE_DDK |
||||
#include <hidsdi.h> |
||||
#endif |
||||
|
||||
/* Copied from inc/ddk/hidclass.h, part of the Windows DDK. */ |
||||
#define HID_OUT_CTL_CODE(id) \ |
||||
CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_OUT_DIRECT, FILE_ANY_ACCESS) |
||||
#define IOCTL_HID_GET_FEATURE HID_OUT_CTL_CODE(100) |
||||
|
||||
#ifdef __cplusplus |
||||
} /* extern "C" */ |
||||
#endif |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
|
||||
|
||||
#include "hidapi.h" |
||||
|
||||
#undef MIN |
||||
#define MIN(x,y) ((x) < (y)? (x): (y)) |
||||
|
||||
#ifdef _MSC_VER |
||||
/* Thanks Microsoft, but I know how to use strncpy(). */ |
||||
#pragma warning(disable:4996) |
||||
#endif |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
#ifndef HIDAPI_USE_DDK |
||||
/* Since we're not building with the DDK, and the HID header
|
||||
files aren't part of the SDK, we have to define all this |
||||
stuff here. In lookup_functions(), the function pointers |
||||
defined below are set. */ |
||||
typedef struct _HIDD_ATTRIBUTES{ |
||||
ULONG Size; |
||||
USHORT VendorID; |
||||
USHORT ProductID; |
||||
USHORT VersionNumber; |
||||
} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES; |
||||
|
||||
typedef USHORT USAGE; |
||||
typedef struct _HIDP_CAPS { |
||||
USAGE Usage; |
||||
USAGE UsagePage; |
||||
USHORT InputReportByteLength; |
||||
USHORT OutputReportByteLength; |
||||
USHORT FeatureReportByteLength; |
||||
USHORT Reserved[17]; |
||||
USHORT fields_not_used_by_hidapi[10]; |
||||
} HIDP_CAPS, *PHIDP_CAPS; |
||||
typedef void* PHIDP_PREPARSED_DATA; |
||||
#define HIDP_STATUS_SUCCESS 0x110000 |
||||
|
||||
typedef BOOLEAN (__stdcall *HidD_GetAttributes_)(HANDLE device, PHIDD_ATTRIBUTES attrib); |
||||
typedef BOOLEAN (__stdcall *HidD_GetSerialNumberString_)(HANDLE device, PVOID buffer, ULONG buffer_len); |
||||
typedef BOOLEAN (__stdcall *HidD_GetManufacturerString_)(HANDLE handle, PVOID buffer, ULONG buffer_len); |
||||
typedef BOOLEAN (__stdcall *HidD_GetProductString_)(HANDLE handle, PVOID buffer, ULONG buffer_len); |
||||
typedef BOOLEAN (__stdcall *HidD_SetFeature_)(HANDLE handle, PVOID data, ULONG length); |
||||
typedef BOOLEAN (__stdcall *HidD_GetFeature_)(HANDLE handle, PVOID data, ULONG length); |
||||
typedef BOOLEAN (__stdcall *HidD_GetIndexedString_)(HANDLE handle, ULONG string_index, PVOID buffer, ULONG buffer_len); |
||||
typedef BOOLEAN (__stdcall *HidD_GetPreparsedData_)(HANDLE handle, PHIDP_PREPARSED_DATA *preparsed_data); |
||||
typedef BOOLEAN (__stdcall *HidD_FreePreparsedData_)(PHIDP_PREPARSED_DATA preparsed_data); |
||||
typedef NTSTATUS (__stdcall *HidP_GetCaps_)(PHIDP_PREPARSED_DATA preparsed_data, HIDP_CAPS *caps); |
||||
typedef BOOLEAN (__stdcall *HidD_SetNumInputBuffers_)(HANDLE handle, ULONG number_buffers); |
||||
|
||||
static HidD_GetAttributes_ HidD_GetAttributes; |
||||
static HidD_GetSerialNumberString_ HidD_GetSerialNumberString; |
||||
static HidD_GetManufacturerString_ HidD_GetManufacturerString; |
||||
static HidD_GetProductString_ HidD_GetProductString; |
||||
static HidD_SetFeature_ HidD_SetFeature; |
||||
static HidD_GetFeature_ HidD_GetFeature; |
||||
static HidD_GetIndexedString_ HidD_GetIndexedString; |
||||
static HidD_GetPreparsedData_ HidD_GetPreparsedData; |
||||
static HidD_FreePreparsedData_ HidD_FreePreparsedData; |
||||
static HidP_GetCaps_ HidP_GetCaps; |
||||
static HidD_SetNumInputBuffers_ HidD_SetNumInputBuffers; |
||||
|
||||
static HMODULE lib_handle = NULL; |
||||
static BOOLEAN initialized = FALSE; |
||||
#endif /* HIDAPI_USE_DDK */ |
||||
|
||||
struct hid_device_ { |
||||
HANDLE device_handle; |
||||
BOOL blocking; |
||||
USHORT output_report_length; |
||||
size_t input_report_length; |
||||
void *last_error_str; |
||||
DWORD last_error_num; |
||||
BOOL read_pending; |
||||
char *read_buf; |
||||
OVERLAPPED ol; |
||||
}; |
||||
|
||||
static hid_device *new_hid_device() |
||||
{ |
||||
hid_device *dev = (hid_device*) calloc(1, sizeof(hid_device)); |
||||
dev->device_handle = INVALID_HANDLE_VALUE; |
||||
dev->blocking = TRUE; |
||||
dev->output_report_length = 0; |
||||
dev->input_report_length = 0; |
||||
dev->last_error_str = NULL; |
||||
dev->last_error_num = 0; |
||||
dev->read_pending = FALSE; |
||||
dev->read_buf = NULL; |
||||
memset(&dev->ol, 0, sizeof(dev->ol)); |
||||
dev->ol.hEvent = CreateEvent(NULL, FALSE, FALSE /*initial state f=nonsignaled*/, NULL); |
||||
|
||||
return dev; |
||||
} |
||||
|
||||
static void free_hid_device(hid_device *dev) |
||||
{ |
||||
CloseHandle(dev->ol.hEvent); |
||||
CloseHandle(dev->device_handle); |
||||
LocalFree(dev->last_error_str); |
||||
free(dev->read_buf); |
||||
free(dev); |
||||
} |
||||
|
||||
static void register_error(hid_device *device, const char *op) |
||||
{ |
||||
WCHAR *ptr, *msg; |
||||
|
||||
FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | |
||||
FORMAT_MESSAGE_FROM_SYSTEM | |
||||
FORMAT_MESSAGE_IGNORE_INSERTS, |
||||
NULL, |
||||
GetLastError(), |
||||
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), |
||||
(LPVOID)&msg, 0/*sz*/, |
||||
NULL); |
||||
|
||||
/* Get rid of the CR and LF that FormatMessage() sticks at the
|
||||
end of the message. Thanks Microsoft! */ |
||||
ptr = msg; |
||||
while (*ptr) { |
||||
if (*ptr == '\r') { |
||||
*ptr = 0x0000; |
||||
break; |
||||
} |
||||
ptr++; |
||||
} |
||||
|
||||
/* Store the message off in the Device entry so that
|
||||
the hid_error() function can pick it up. */ |
||||
LocalFree(device->last_error_str); |
||||
device->last_error_str = msg; |
||||
} |
||||
|
||||
#ifndef HIDAPI_USE_DDK |
||||
static int lookup_functions() |
||||
{ |
||||
lib_handle = LoadLibraryA("hid.dll"); |
||||
if (lib_handle) { |
||||
#define RESOLVE(x) x = (x##_)GetProcAddress(lib_handle, #x); if (!x) return -1; |
||||
RESOLVE(HidD_GetAttributes); |
||||
RESOLVE(HidD_GetSerialNumberString); |
||||
RESOLVE(HidD_GetManufacturerString); |
||||
RESOLVE(HidD_GetProductString); |
||||
RESOLVE(HidD_SetFeature); |
||||
RESOLVE(HidD_GetFeature); |
||||
RESOLVE(HidD_GetIndexedString); |
||||
RESOLVE(HidD_GetPreparsedData); |
||||
RESOLVE(HidD_FreePreparsedData); |
||||
RESOLVE(HidP_GetCaps); |
||||
RESOLVE(HidD_SetNumInputBuffers); |
||||
#undef RESOLVE |
||||
} |
||||
else |
||||
return -1; |
||||
|
||||
return 0; |
||||
} |
||||
#endif |
||||
|
||||
static HANDLE open_device(const char *path, BOOL enumerate) |
||||
{ |
||||
HANDLE handle; |
||||
DWORD desired_access = (enumerate)? 0: (GENERIC_WRITE | GENERIC_READ); |
||||
DWORD share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE; |
||||
|
||||
handle = CreateFileA(path, |
||||
desired_access, |
||||
share_mode, |
||||
NULL, |
||||
OPEN_EXISTING, |
||||
FILE_FLAG_OVERLAPPED,/*FILE_ATTRIBUTE_NORMAL,*/ |
||||
0); |
||||
|
||||
return handle; |
||||
} |
||||
|
||||
int HID_API_EXPORT hid_init(void) |
||||
{ |
||||
#ifndef HIDAPI_USE_DDK |
||||
if (!initialized) { |
||||
if (lookup_functions() < 0) { |
||||
hid_exit(); |
||||
return -1; |
||||
} |
||||
initialized = TRUE; |
||||
} |
||||
#endif |
||||
return 0; |
||||
} |
||||
|
||||
int HID_API_EXPORT hid_exit(void) |
||||
{ |
||||
#ifndef HIDAPI_USE_DDK |
||||
if (lib_handle) |
||||
FreeLibrary(lib_handle); |
||||
lib_handle = NULL; |
||||
initialized = FALSE; |
||||
#endif |
||||
return 0; |
||||
} |
||||
|
||||
struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id) |
||||
{ |
||||
BOOL res; |
||||
struct hid_device_info *root = NULL; /* return object */ |
||||
struct hid_device_info *cur_dev = NULL; |
||||
|
||||
/* Windows objects for interacting with the driver. */ |
||||
GUID InterfaceClassGuid = {0x4d1e55b2, 0xf16f, 0x11cf, {0x88, 0xcb, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30} }; |
||||
SP_DEVINFO_DATA devinfo_data; |
||||
SP_DEVICE_INTERFACE_DATA device_interface_data; |
||||
SP_DEVICE_INTERFACE_DETAIL_DATA_A *device_interface_detail_data = NULL; |
||||
HDEVINFO device_info_set = INVALID_HANDLE_VALUE; |
||||
int device_index = 0; |
||||
int i; |
||||
|
||||
if (hid_init() < 0) |
||||
return NULL; |
||||
|
||||
/* Initialize the Windows objects. */ |
||||
memset(&devinfo_data, 0x0, sizeof(devinfo_data)); |
||||
devinfo_data.cbSize = sizeof(SP_DEVINFO_DATA); |
||||
device_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA); |
||||
|
||||
/* Get information for all the devices belonging to the HID class. */ |
||||
device_info_set = SetupDiGetClassDevsA(&InterfaceClassGuid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE); |
||||
|
||||
/* Iterate over each device in the HID class, looking for the right one. */ |
||||
|
||||
for (;;) { |
||||
HANDLE write_handle = INVALID_HANDLE_VALUE; |
||||
DWORD required_size = 0; |
||||
HIDD_ATTRIBUTES attrib; |
||||
|
||||
res = SetupDiEnumDeviceInterfaces(device_info_set, |
||||
NULL, |
||||
&InterfaceClassGuid, |
||||
device_index, |
||||
&device_interface_data); |
||||
|
||||
if (!res) { |
||||
/* A return of FALSE from this function means that
|
||||
there are no more devices. */ |
||||
break; |
||||
} |
||||
|
||||
/* Call with 0-sized detail size, and let the function
|
||||
tell us how long the detail struct needs to be. The |
||||
size is put in &required_size. */ |
||||
res = SetupDiGetDeviceInterfaceDetailA(device_info_set, |
||||
&device_interface_data, |
||||
NULL, |
||||
0, |
||||
&required_size, |
||||
NULL); |
||||
|
||||
/* Allocate a long enough structure for device_interface_detail_data. */ |
||||
device_interface_detail_data = (SP_DEVICE_INTERFACE_DETAIL_DATA_A*) malloc(required_size); |
||||
device_interface_detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A); |
||||
|
||||
/* Get the detailed data for this device. The detail data gives us
|
||||
the device path for this device, which is then passed into |
||||
CreateFile() to get a handle to the device. */ |
||||
res = SetupDiGetDeviceInterfaceDetailA(device_info_set, |
||||
&device_interface_data, |
||||
device_interface_detail_data, |
||||
required_size, |
||||
NULL, |
||||
NULL); |
||||
|
||||
if (!res) { |
||||
/* register_error(dev, "Unable to call SetupDiGetDeviceInterfaceDetail");
|
||||
Continue to the next device. */ |
||||
goto cont; |
||||
} |
||||
|
||||
/* Make sure this device is of Setup Class "HIDClass" and has a
|
||||
driver bound to it. */ |
||||
for (i = 0; ; i++) { |
||||
char driver_name[256]; |
||||
|
||||
/* Populate devinfo_data. This function will return failure
|
||||
when there are no more interfaces left. */ |
||||
res = SetupDiEnumDeviceInfo(device_info_set, i, &devinfo_data); |
||||
if (!res) |
||||
goto cont; |
||||
|
||||
res = SetupDiGetDeviceRegistryPropertyA(device_info_set, &devinfo_data, |
||||
SPDRP_CLASS, NULL, (PBYTE)driver_name, sizeof(driver_name), NULL); |
||||
if (!res) |
||||
goto cont; |
||||
|
||||
if (strcmp(driver_name, "HIDClass") == 0) { |
||||
/* See if there's a driver bound. */ |
||||
res = SetupDiGetDeviceRegistryPropertyA(device_info_set, &devinfo_data, |
||||
SPDRP_DRIVER, NULL, (PBYTE)driver_name, sizeof(driver_name), NULL); |
||||
if (res) |
||||
break; |
||||
} |
||||
} |
||||
|
||||
//wprintf(L"HandleName: %s\n", device_interface_detail_data->DevicePath);
|
||||
|
||||
/* Open a handle to the device */ |
||||
write_handle = open_device(device_interface_detail_data->DevicePath, TRUE); |
||||
|
||||
/* Check validity of write_handle. */ |
||||
if (write_handle == INVALID_HANDLE_VALUE) { |
||||
/* Unable to open the device. */ |
||||
//register_error(dev, "CreateFile");
|
||||
goto cont_close; |
||||
}
|
||||
|
||||
|
||||
/* Get the Vendor ID and Product ID for this device. */ |
||||
attrib.Size = sizeof(HIDD_ATTRIBUTES); |
||||
HidD_GetAttributes(write_handle, &attrib); |
||||
//wprintf(L"Product/Vendor: %x %x\n", attrib.ProductID, attrib.VendorID);
|
||||
|
||||
/* Check the VID/PID to see if we should add this
|
||||
device to the enumeration list. */ |
||||
if ((vendor_id == 0x0 || attrib.VendorID == vendor_id) && |
||||
(product_id == 0x0 || attrib.ProductID == product_id)) { |
||||
|
||||
#define WSTR_LEN 512 |
||||
const char *str; |
||||
struct hid_device_info *tmp; |
||||
PHIDP_PREPARSED_DATA pp_data = NULL; |
||||
HIDP_CAPS caps; |
||||
BOOLEAN res; |
||||
NTSTATUS nt_res; |
||||
wchar_t wstr[WSTR_LEN]; /* TODO: Determine Size */ |
||||
size_t len; |
||||
|
||||
/* VID/PID match. Create the record. */ |
||||
tmp = (struct hid_device_info*) calloc(1, sizeof(struct hid_device_info)); |
||||
if (cur_dev) { |
||||
cur_dev->next = tmp; |
||||
} |
||||
else { |
||||
root = tmp; |
||||
} |
||||
cur_dev = tmp; |
||||
|
||||
/* Get the Usage Page and Usage for this device. */ |
||||
res = HidD_GetPreparsedData(write_handle, &pp_data); |
||||
if (res) { |
||||
nt_res = HidP_GetCaps(pp_data, &caps); |
||||
if (nt_res == HIDP_STATUS_SUCCESS) { |
||||
cur_dev->usage_page = caps.UsagePage; |
||||
cur_dev->usage = caps.Usage; |
||||
} |
||||
|
||||
HidD_FreePreparsedData(pp_data); |
||||
} |
||||
|
||||
/* Fill out the record */ |
||||
cur_dev->next = NULL; |
||||
str = device_interface_detail_data->DevicePath; |
||||
if (str) { |
||||
len = strlen(str); |
||||
cur_dev->path = (char*) calloc(len+1, sizeof(char)); |
||||
strncpy(cur_dev->path, str, len+1); |
||||
cur_dev->path[len] = '\0'; |
||||
} |
||||
else |
||||
cur_dev->path = NULL; |
||||
|
||||
/* Serial Number */ |
||||
res = HidD_GetSerialNumberString(write_handle, wstr, sizeof(wstr)); |
||||
wstr[WSTR_LEN-1] = 0x0000; |
||||
if (res) { |
||||
cur_dev->serial_number = _wcsdup(wstr); |
||||
} |
||||
|
||||
/* Manufacturer String */ |
||||
res = HidD_GetManufacturerString(write_handle, wstr, sizeof(wstr)); |
||||
wstr[WSTR_LEN-1] = 0x0000; |
||||
if (res) { |
||||
cur_dev->manufacturer_string = _wcsdup(wstr); |
||||
} |
||||
|
||||
/* Product String */ |
||||
res = HidD_GetProductString(write_handle, wstr, sizeof(wstr)); |
||||
wstr[WSTR_LEN-1] = 0x0000; |
||||
if (res) { |
||||
cur_dev->product_string = _wcsdup(wstr); |
||||
} |
||||
|
||||
/* VID/PID */ |
||||
cur_dev->vendor_id = attrib.VendorID; |
||||
cur_dev->product_id = attrib.ProductID; |
||||
|
||||
/* Release Number */ |
||||
cur_dev->release_number = attrib.VersionNumber; |
||||
|
||||
/* Interface Number. It can sometimes be parsed out of the path
|
||||
on Windows if a device has multiple interfaces. See |
||||
http://msdn.microsoft.com/en-us/windows/hardware/gg487473 or
|
||||
search for "Hardware IDs for HID Devices" at MSDN. If it's not |
||||
in the path, it's set to -1. */ |
||||
cur_dev->interface_number = -1; |
||||
if (cur_dev->path) { |
||||
char *interface_component = strstr(cur_dev->path, "&mi_"); |
||||
if (interface_component) { |
||||
char *hex_str = interface_component + 4; |
||||
char *endptr = NULL; |
||||
cur_dev->interface_number = strtol(hex_str, &endptr, 16); |
||||
if (endptr == hex_str) { |
||||
/* The parsing failed. Set interface_number to -1. */ |
||||
cur_dev->interface_number = -1; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
cont_close: |
||||
CloseHandle(write_handle); |
||||
cont: |
||||
/* We no longer need the detail data. It can be freed */ |
||||
free(device_interface_detail_data); |
||||
|
||||
device_index++; |
||||
|
||||
} |
||||
|
||||
/* Close the device information handle. */ |
||||
SetupDiDestroyDeviceInfoList(device_info_set); |
||||
|
||||
return root; |
||||
|
||||
} |
||||
|
||||
void HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs) |
||||
{ |
||||
/* TODO: Merge this with the Linux version. This function is platform-independent. */ |
||||
struct hid_device_info *d = devs; |
||||
while (d) { |
||||
struct hid_device_info *next = d->next; |
||||
free(d->path); |
||||
free(d->serial_number); |
||||
free(d->manufacturer_string); |
||||
free(d->product_string); |
||||
free(d); |
||||
d = next; |
||||
} |
||||
} |
||||
|
||||
|
||||
HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number) |
||||
{ |
||||
/* TODO: Merge this functions with the Linux version. This function should be platform independent. */ |
||||
struct hid_device_info *devs, *cur_dev; |
||||
const char *path_to_open = NULL; |
||||
hid_device *handle = NULL; |
||||
|
||||
devs = hid_enumerate(vendor_id, product_id); |
||||
cur_dev = devs; |
||||
while (cur_dev) { |
||||
if (cur_dev->vendor_id == vendor_id && |
||||
cur_dev->product_id == product_id) { |
||||
if (serial_number) { |
||||
if (wcscmp(serial_number, cur_dev->serial_number) == 0) { |
||||
path_to_open = cur_dev->path; |
||||
break; |
||||
} |
||||
} |
||||
else { |
||||
path_to_open = cur_dev->path; |
||||
break; |
||||
} |
||||
} |
||||
cur_dev = cur_dev->next; |
||||
} |
||||
|
||||
if (path_to_open) { |
||||
/* Open the device */ |
||||
handle = hid_open_path(path_to_open); |
||||
} |
||||
|
||||
hid_free_enumeration(devs); |
||||
|
||||
return handle; |
||||
} |
||||
|
||||
HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path) |
||||
{ |
||||
hid_device *dev; |
||||
HIDP_CAPS caps; |
||||
PHIDP_PREPARSED_DATA pp_data = NULL; |
||||
BOOLEAN res; |
||||
NTSTATUS nt_res; |
||||
|
||||
if (hid_init() < 0) { |
||||
return NULL; |
||||
} |
||||
|
||||
dev = new_hid_device(); |
||||
|
||||
/* Open a handle to the device */ |
||||
dev->device_handle = open_device(path, FALSE); |
||||
|
||||
/* Check validity of write_handle. */ |
||||
if (dev->device_handle == INVALID_HANDLE_VALUE) { |
||||
/* Unable to open the device. */ |
||||
register_error(dev, "CreateFile"); |
||||
goto err; |
||||
} |
||||
|
||||
/* Set the Input Report buffer size to 64 reports. */ |
||||
res = HidD_SetNumInputBuffers(dev->device_handle, 64); |
||||
if (!res) { |
||||
register_error(dev, "HidD_SetNumInputBuffers"); |
||||
goto err; |
||||
} |
||||
|
||||
/* Get the Input Report length for the device. */ |
||||
res = HidD_GetPreparsedData(dev->device_handle, &pp_data); |
||||
if (!res) { |
||||
register_error(dev, "HidD_GetPreparsedData"); |
||||
goto err; |
||||
} |
||||
nt_res = HidP_GetCaps(pp_data, &caps); |
||||
if (nt_res != HIDP_STATUS_SUCCESS) { |
||||
register_error(dev, "HidP_GetCaps");
|
||||
goto err_pp_data; |
||||
} |
||||
dev->output_report_length = caps.OutputReportByteLength; |
||||
dev->input_report_length = caps.InputReportByteLength; |
||||
HidD_FreePreparsedData(pp_data); |
||||
|
||||
dev->read_buf = (char*) malloc(dev->input_report_length); |
||||
|
||||
return dev; |
||||
|
||||
err_pp_data: |
||||
HidD_FreePreparsedData(pp_data); |
||||
err:
|
||||
free_hid_device(dev); |
||||
return NULL; |
||||
} |
||||
|
||||
int HID_API_EXPORT HID_API_CALL hid_write(hid_device *dev, const unsigned char *data, size_t length) |
||||
{ |
||||
DWORD bytes_written; |
||||
BOOL res; |
||||
|
||||
OVERLAPPED ol; |
||||
unsigned char *buf; |
||||
memset(&ol, 0, sizeof(ol)); |
||||
|
||||
/* Make sure the right number of bytes are passed to WriteFile. Windows
|
||||
expects the number of bytes which are in the _longest_ report (plus |
||||
one for the report number) bytes even if the data is a report |
||||
which is shorter than that. Windows gives us this value in |
||||
caps.OutputReportByteLength. If a user passes in fewer bytes than this, |
||||
create a temporary buffer which is the proper size. */ |
||||
if (length >= dev->output_report_length) { |
||||
/* The user passed the right number of bytes. Use the buffer as-is. */ |
||||
buf = (unsigned char *) data; |
||||
} else { |
||||
/* Create a temporary buffer and copy the user's data
|
||||
into it, padding the rest with zeros. */ |
||||
buf = (unsigned char *) malloc(dev->output_report_length); |
||||
memcpy(buf, data, length); |
||||
memset(buf + length, 0, dev->output_report_length - length); |
||||
length = dev->output_report_length; |
||||
} |
||||
|
||||
res = WriteFile(dev->device_handle, buf, length, NULL, &ol); |
||||
|
||||
if (!res) { |
||||
if (GetLastError() != ERROR_IO_PENDING) { |
||||
/* WriteFile() failed. Return error. */ |
||||
register_error(dev, "WriteFile"); |
||||
bytes_written = -1; |
||||
goto end_of_function; |
||||
} |
||||
} |
||||
|
||||
/* Wait here until the write is done. This makes
|
||||
hid_write() synchronous. */ |
||||
res = GetOverlappedResult(dev->device_handle, &ol, &bytes_written, TRUE/*wait*/); |
||||
if (!res) { |
||||
/* The Write operation failed. */ |
||||
register_error(dev, "WriteFile"); |
||||
bytes_written = -1; |
||||
goto end_of_function; |
||||
} |
||||
|
||||
end_of_function: |
||||
if (buf != data) |
||||
free(buf); |
||||
|
||||
return bytes_written; |
||||
} |
||||
|
||||
|
||||
int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds) |
||||
{ |
||||
DWORD bytes_read = 0; |
||||
size_t copy_len = 0; |
||||
BOOL res; |
||||
|
||||
/* Copy the handle for convenience. */ |
||||
HANDLE ev = dev->ol.hEvent; |
||||
|
||||
if (!dev->read_pending) { |
||||
/* Start an Overlapped I/O read. */ |
||||
dev->read_pending = TRUE; |
||||
memset(dev->read_buf, 0, dev->input_report_length); |
||||
ResetEvent(ev); |
||||
res = ReadFile(dev->device_handle, dev->read_buf, dev->input_report_length, &bytes_read, &dev->ol); |
||||
|
||||
if (!res) { |
||||
if (GetLastError() != ERROR_IO_PENDING) { |
||||
/* ReadFile() has failed.
|
||||
Clean up and return error. */ |
||||
CancelIo(dev->device_handle); |
||||
dev->read_pending = FALSE; |
||||
goto end_of_function; |
||||
} |
||||
} |
||||
} |
||||
|
||||
if (milliseconds >= 0) { |
||||
/* See if there is any data yet. */ |
||||
res = WaitForSingleObject(ev, milliseconds); |
||||
if (res != WAIT_OBJECT_0) { |
||||
/* There was no data this time. Return zero bytes available,
|
||||
but leave the Overlapped I/O running. */ |
||||
return 0; |
||||
} |
||||
} |
||||
|
||||
/* Either WaitForSingleObject() told us that ReadFile has completed, or
|
||||
we are in non-blocking mode. Get the number of bytes read. The actual |
||||
data has been copied to the data[] array which was passed to ReadFile(). */ |
||||
res = GetOverlappedResult(dev->device_handle, &dev->ol, &bytes_read, TRUE/*wait*/); |
||||
|
||||
/* Set pending back to false, even if GetOverlappedResult() returned error. */ |
||||
dev->read_pending = FALSE; |
||||
|
||||
if (res && bytes_read > 0) { |
||||
if (dev->read_buf[0] == 0x0) { |
||||
/* If report numbers aren't being used, but Windows sticks a report
|
||||
number (0x0) on the beginning of the report anyway. To make this |
||||
work like the other platforms, and to make it work more like the |
||||
HID spec, we'll skip over this byte. */ |
||||
bytes_read--; |
||||
copy_len = length > bytes_read ? bytes_read : length; |
||||
memcpy(data, dev->read_buf+1, copy_len); |
||||
} |
||||
else { |
||||
/* Copy the whole buffer, report number and all. */ |
||||
copy_len = length > bytes_read ? bytes_read : length; |
||||
memcpy(data, dev->read_buf, copy_len); |
||||
} |
||||
} |
||||
|
||||
end_of_function: |
||||
if (!res) { |
||||
register_error(dev, "GetOverlappedResult"); |
||||
return -1; |
||||
} |
||||
|
||||
return copy_len; |
||||
} |
||||
|
||||
int HID_API_EXPORT HID_API_CALL hid_read(hid_device *dev, unsigned char *data, size_t length) |
||||
{ |
||||
return hid_read_timeout(dev, data, length, (dev->blocking)? -1: 0); |
||||
} |
||||
|
||||
int HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *dev, int nonblock) |
||||
{ |
||||
dev->blocking = !nonblock; |
||||
return 0; /* Success */ |
||||
} |
||||
|
||||
int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length) |
||||
{ |
||||
BOOL res = HidD_SetFeature(dev->device_handle, (PVOID)data, length); |
||||
if (!res) { |
||||
register_error(dev, "HidD_SetFeature"); |
||||
return -1; |
||||
} |
||||
|
||||
return length; |
||||
} |
||||
|
||||
|
||||
int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length) |
||||
{ |
||||
BOOL res; |
||||
#if 0 |
||||
res = HidD_GetFeature(dev->device_handle, data, length); |
||||
if (!res) { |
||||
register_error(dev, "HidD_GetFeature"); |
||||
return -1; |
||||
} |
||||
return 0; /* HidD_GetFeature() doesn't give us an actual length, unfortunately */ |
||||
#else |
||||
DWORD bytes_returned; |
||||
|
||||
OVERLAPPED ol; |
||||
memset(&ol, 0, sizeof(ol)); |
||||
|
||||
res = DeviceIoControl(dev->device_handle, |
||||
IOCTL_HID_GET_FEATURE, |
||||
data, length, |
||||
data, length, |
||||
&bytes_returned, &ol); |
||||
|
||||
if (!res) { |
||||
if (GetLastError() != ERROR_IO_PENDING) { |
||||
/* DeviceIoControl() failed. Return error. */ |
||||
register_error(dev, "Send Feature Report DeviceIoControl"); |
||||
return -1; |
||||
} |
||||
} |
||||
|
||||
/* Wait here until the write is done. This makes
|
||||
hid_get_feature_report() synchronous. */ |
||||
res = GetOverlappedResult(dev->device_handle, &ol, &bytes_returned, TRUE/*wait*/); |
||||
if (!res) { |
||||
/* The operation failed. */ |
||||
register_error(dev, "Send Feature Report GetOverLappedResult"); |
||||
return -1; |
||||
} |
||||
|
||||
/* bytes_returned does not include the first byte which contains the
|
||||
report ID. The data buffer actually contains one more byte than |
||||
bytes_returned. */ |
||||
bytes_returned++; |
||||
|
||||
return bytes_returned; |
||||
#endif |
||||
} |
||||
|
||||
void HID_API_EXPORT HID_API_CALL hid_close(hid_device *dev) |
||||
{ |
||||
if (!dev) |
||||
return; |
||||
CancelIo(dev->device_handle); |
||||
free_hid_device(dev); |
||||
} |
||||
|
||||
int HID_API_EXPORT_CALL HID_API_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen) |
||||
{ |
||||
BOOL res; |
||||
|
||||
res = HidD_GetManufacturerString(dev->device_handle, string, sizeof(wchar_t) * MIN(maxlen, MAX_STRING_WCHARS)); |
||||
if (!res) { |
||||
register_error(dev, "HidD_GetManufacturerString"); |
||||
return -1; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int HID_API_EXPORT_CALL HID_API_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen) |
||||
{ |
||||
BOOL res; |
||||
|
||||
res = HidD_GetProductString(dev->device_handle, string, sizeof(wchar_t) * MIN(maxlen, MAX_STRING_WCHARS)); |
||||
if (!res) { |
||||
register_error(dev, "HidD_GetProductString"); |
||||
return -1; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int HID_API_EXPORT_CALL HID_API_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen) |
||||
{ |
||||
BOOL res; |
||||
|
||||
res = HidD_GetSerialNumberString(dev->device_handle, string, sizeof(wchar_t) * MIN(maxlen, MAX_STRING_WCHARS)); |
||||
if (!res) { |
||||
register_error(dev, "HidD_GetSerialNumberString"); |
||||
return -1; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int HID_API_EXPORT_CALL HID_API_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen) |
||||
{ |
||||
BOOL res; |
||||
|
||||
res = HidD_GetIndexedString(dev->device_handle, string_index, string, sizeof(wchar_t) * MIN(maxlen, MAX_STRING_WCHARS)); |
||||
if (!res) { |
||||
register_error(dev, "HidD_GetIndexedString"); |
||||
return -1; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
|
||||
HID_API_EXPORT const wchar_t * HID_API_CALL hid_error(hid_device *dev) |
||||
{ |
||||
return (wchar_t*)dev->last_error_str; |
||||
} |
||||
|
||||
|
||||
/*#define PICPGM*/ |
||||
/*#define S11*/ |
||||
#define P32 |
||||
#ifdef S11 |
||||
unsigned short VendorID = 0xa0a0; |
||||
unsigned short ProductID = 0x0001; |
||||
#endif |
||||
|
||||
#ifdef P32 |
||||
unsigned short VendorID = 0x04d8; |
||||
unsigned short ProductID = 0x3f; |
||||
#endif |
||||
|
||||
|
||||
#ifdef PICPGM |
||||
unsigned short VendorID = 0x04d8; |
||||
unsigned short ProductID = 0x0033; |
||||
#endif |
||||
|
||||
|
||||
#if 0 |
||||
int __cdecl main(int argc, char* argv[]) |
||||
{ |
||||
int res; |
||||
unsigned char buf[65]; |
||||
|
||||
UNREFERENCED_PARAMETER(argc); |
||||
UNREFERENCED_PARAMETER(argv); |
||||
|
||||
/* Set up the command buffer. */ |
||||
memset(buf,0x00,sizeof(buf)); |
||||
buf[0] = 0; |
||||
buf[1] = 0x81; |
||||
|
||||
|
||||
/* Open the device. */ |
||||
int handle = open(VendorID, ProductID, L"12345"); |
||||
if (handle < 0) |
||||
printf("unable to open device\n"); |
||||
|
||||
|
||||
/* Toggle LED (cmd 0x80) */ |
||||
buf[1] = 0x80; |
||||
res = write(handle, buf, 65); |
||||
if (res < 0) |
||||
printf("Unable to write()\n"); |
||||
|
||||
/* Request state (cmd 0x81) */ |
||||
buf[1] = 0x81; |
||||
write(handle, buf, 65); |
||||
if (res < 0) |
||||
printf("Unable to write() (2)\n"); |
||||
|
||||
/* Read requested state */ |
||||
read(handle, buf, 65); |
||||
if (res < 0) |
||||
printf("Unable to read()\n"); |
||||
|
||||
/* Print out the returned buffer. */ |
||||
for (int i = 0; i < 4; i++) |
||||
printf("buf[%d]: %d\n", i, buf[i]); |
||||
|
||||
return 0; |
||||
} |
||||
#endif |
||||
|
||||
#ifdef __cplusplus |
||||
} /* extern "C" */ |
||||
#endif |
||||
@ -0,0 +1,227 @@ |
||||
// This file is https://github.com/orofarne/gowchar/blob/master/gowchar.go
|
||||
//
|
||||
// It was vendored inline to work around CGO limitations that don't allow C types
|
||||
// to directly cross package API boundaries.
|
||||
//
|
||||
// The vendored file is licensed under the 3-clause BSD license, according to:
|
||||
// https://github.com/orofarne/gowchar/blob/master/LICENSE
|
||||
|
||||
// +build !ios
|
||||
// +build linux darwin windows
|
||||
|
||||
package hid |
||||
|
||||
/* |
||||
#include <wchar.h> |
||||
|
||||
const size_t SIZEOF_WCHAR_T = sizeof(wchar_t); |
||||
|
||||
void gowchar_set (wchar_t *arr, int pos, wchar_t val) |
||||
{ |
||||
arr[pos] = val; |
||||
} |
||||
|
||||
wchar_t gowchar_get (wchar_t *arr, int pos) |
||||
{ |
||||
return arr[pos]; |
||||
} |
||||
*/ |
||||
import "C" |
||||
|
||||
import ( |
||||
"fmt" |
||||
"unicode/utf16" |
||||
"unicode/utf8" |
||||
) |
||||
|
||||
var sizeofWcharT C.size_t = C.size_t(C.SIZEOF_WCHAR_T) |
||||
|
||||
func stringToWcharT(s string) (*C.wchar_t, C.size_t) { |
||||
switch sizeofWcharT { |
||||
case 2: |
||||
return stringToWchar2(s) // Windows
|
||||
case 4: |
||||
return stringToWchar4(s) // Unix
|
||||
default: |
||||
panic(fmt.Sprintf("Invalid sizeof(wchar_t) = %v", sizeofWcharT)) |
||||
} |
||||
} |
||||
|
||||
func wcharTToString(s *C.wchar_t) (string, error) { |
||||
switch sizeofWcharT { |
||||
case 2: |
||||
return wchar2ToString(s) // Windows
|
||||
case 4: |
||||
return wchar4ToString(s) // Unix
|
||||
default: |
||||
panic(fmt.Sprintf("Invalid sizeof(wchar_t) = %v", sizeofWcharT)) |
||||
} |
||||
} |
||||
|
||||
func wcharTNToString(s *C.wchar_t, size C.size_t) (string, error) { |
||||
switch sizeofWcharT { |
||||
case 2: |
||||
return wchar2NToString(s, size) // Windows
|
||||
case 4: |
||||
return wchar4NToString(s, size) // Unix
|
||||
default: |
||||
panic(fmt.Sprintf("Invalid sizeof(wchar_t) = %v", sizeofWcharT)) |
||||
} |
||||
} |
||||
|
||||
// Windows
|
||||
func stringToWchar2(s string) (*C.wchar_t, C.size_t) { |
||||
var slen int |
||||
s1 := s |
||||
for len(s1) > 0 { |
||||
r, size := utf8.DecodeRuneInString(s1) |
||||
if er, _ := utf16.EncodeRune(r); er == '\uFFFD' { |
||||
slen += 1 |
||||
} else { |
||||
slen += 2 |
||||
} |
||||
s1 = s1[size:] |
||||
} |
||||
slen++ // \0
|
||||
res := C.malloc(C.size_t(slen) * sizeofWcharT) |
||||
var i int |
||||
for len(s) > 0 { |
||||
r, size := utf8.DecodeRuneInString(s) |
||||
if r1, r2 := utf16.EncodeRune(r); r1 != '\uFFFD' { |
||||
C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r1)) |
||||
i++ |
||||
C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r2)) |
||||
i++ |
||||
} else { |
||||
C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r)) |
||||
i++ |
||||
} |
||||
s = s[size:] |
||||
} |
||||
C.gowchar_set((*C.wchar_t)(res), C.int(slen-1), C.wchar_t(0)) // \0
|
||||
return (*C.wchar_t)(res), C.size_t(slen) |
||||
} |
||||
|
||||
// Unix
|
||||
func stringToWchar4(s string) (*C.wchar_t, C.size_t) { |
||||
slen := utf8.RuneCountInString(s) |
||||
slen++ // \0
|
||||
res := C.malloc(C.size_t(slen) * sizeofWcharT) |
||||
var i int |
||||
for len(s) > 0 { |
||||
r, size := utf8.DecodeRuneInString(s) |
||||
C.gowchar_set((*C.wchar_t)(res), C.int(i), C.wchar_t(r)) |
||||
s = s[size:] |
||||
i++ |
||||
} |
||||
C.gowchar_set((*C.wchar_t)(res), C.int(slen-1), C.wchar_t(0)) // \0
|
||||
return (*C.wchar_t)(res), C.size_t(slen) |
||||
} |
||||
|
||||
// Windows
|
||||
func wchar2ToString(s *C.wchar_t) (string, error) { |
||||
var i int |
||||
var res string |
||||
for { |
||||
ch := C.gowchar_get(s, C.int(i)) |
||||
if ch == 0 { |
||||
break |
||||
} |
||||
r := rune(ch) |
||||
i++ |
||||
if !utf16.IsSurrogate(r) { |
||||
if !utf8.ValidRune(r) { |
||||
err := fmt.Errorf("Invalid rune at position %v", i) |
||||
return "", err |
||||
} |
||||
res += string(r) |
||||
} else { |
||||
ch2 := C.gowchar_get(s, C.int(i)) |
||||
r2 := rune(ch2) |
||||
r12 := utf16.DecodeRune(r, r2) |
||||
if r12 == '\uFFFD' { |
||||
err := fmt.Errorf("Invalid surrogate pair at position %v", i-1) |
||||
return "", err |
||||
} |
||||
res += string(r12) |
||||
i++ |
||||
} |
||||
} |
||||
return res, nil |
||||
} |
||||
|
||||
// Unix
|
||||
func wchar4ToString(s *C.wchar_t) (string, error) { |
||||
var i int |
||||
var res string |
||||
for { |
||||
ch := C.gowchar_get(s, C.int(i)) |
||||
if ch == 0 { |
||||
break |
||||
} |
||||
r := rune(ch) |
||||
if !utf8.ValidRune(r) { |
||||
err := fmt.Errorf("Invalid rune at position %v", i) |
||||
return "", err |
||||
} |
||||
res += string(r) |
||||
i++ |
||||
} |
||||
return res, nil |
||||
} |
||||
|
||||
// Windows
|
||||
func wchar2NToString(s *C.wchar_t, size C.size_t) (string, error) { |
||||
var i int |
||||
var res string |
||||
N := int(size) |
||||
for i < N { |
||||
ch := C.gowchar_get(s, C.int(i)) |
||||
if ch == 0 { |
||||
break |
||||
} |
||||
r := rune(ch) |
||||
i++ |
||||
if !utf16.IsSurrogate(r) { |
||||
if !utf8.ValidRune(r) { |
||||
err := fmt.Errorf("Invalid rune at position %v", i) |
||||
return "", err |
||||
} |
||||
|
||||
res += string(r) |
||||
} else { |
||||
if i >= N { |
||||
err := fmt.Errorf("Invalid surrogate pair at position %v", i-1) |
||||
return "", err |
||||
} |
||||
ch2 := C.gowchar_get(s, C.int(i)) |
||||
r2 := rune(ch2) |
||||
r12 := utf16.DecodeRune(r, r2) |
||||
if r12 == '\uFFFD' { |
||||
err := fmt.Errorf("Invalid surrogate pair at position %v", i-1) |
||||
return "", err |
||||
} |
||||
res += string(r12) |
||||
i++ |
||||
} |
||||
} |
||||
return res, nil |
||||
} |
||||
|
||||
// Unix
|
||||
func wchar4NToString(s *C.wchar_t, size C.size_t) (string, error) { |
||||
var i int |
||||
var res string |
||||
N := int(size) |
||||
for i < N { |
||||
ch := C.gowchar_get(s, C.int(i)) |
||||
r := rune(ch) |
||||
if !utf8.ValidRune(r) { |
||||
err := fmt.Errorf("Invalid rune at position %v", i) |
||||
return "", err |
||||
} |
||||
res += string(r) |
||||
i++ |
||||
} |
||||
return res, nil |
||||
} |
||||
Loading…
Reference in new issue