id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
11,500 |
miekg/pkcs11
|
params.go
|
Free
|
func (p *GCMParams) Free() {
if p == nil || p.arena == nil {
return
}
p.arena.Free()
p.params = nil
p.arena = nil
}
|
go
|
func (p *GCMParams) Free() {
if p == nil || p.arena == nil {
return
}
p.arena.Free()
p.params = nil
p.arena = nil
}
|
[
"func",
"(",
"p",
"*",
"GCMParams",
")",
"Free",
"(",
")",
"{",
"if",
"p",
"==",
"nil",
"||",
"p",
".",
"arena",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"p",
".",
"arena",
".",
"Free",
"(",
")",
"\n",
"p",
".",
"params",
"=",
"nil",
"\n",
"p",
".",
"arena",
"=",
"nil",
"\n",
"}"
] |
// Free deallocates the memory reserved for the HSM to write back the actual IV.
//
// This must be called after the entire operation is complete, i.e. after
// Encrypt or EncryptFinal. It is safe to call Free multiple times.
|
[
"Free",
"deallocates",
"the",
"memory",
"reserved",
"for",
"the",
"HSM",
"to",
"write",
"back",
"the",
"actual",
"IV",
".",
"This",
"must",
"be",
"called",
"after",
"the",
"entire",
"operation",
"is",
"complete",
"i",
".",
"e",
".",
"after",
"Encrypt",
"or",
"EncryptFinal",
".",
"It",
"is",
"safe",
"to",
"call",
"Free",
"multiple",
"times",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/params.go#L108-L115
|
11,501 |
miekg/pkcs11
|
params.go
|
NewPSSParams
|
func NewPSSParams(hashAlg, mgf, saltLength uint) []byte {
p := C.CK_RSA_PKCS_PSS_PARAMS{
hashAlg: C.CK_MECHANISM_TYPE(hashAlg),
mgf: C.CK_RSA_PKCS_MGF_TYPE(mgf),
sLen: C.CK_ULONG(saltLength),
}
return C.GoBytes(unsafe.Pointer(&p), C.int(unsafe.Sizeof(p)))
}
|
go
|
func NewPSSParams(hashAlg, mgf, saltLength uint) []byte {
p := C.CK_RSA_PKCS_PSS_PARAMS{
hashAlg: C.CK_MECHANISM_TYPE(hashAlg),
mgf: C.CK_RSA_PKCS_MGF_TYPE(mgf),
sLen: C.CK_ULONG(saltLength),
}
return C.GoBytes(unsafe.Pointer(&p), C.int(unsafe.Sizeof(p)))
}
|
[
"func",
"NewPSSParams",
"(",
"hashAlg",
",",
"mgf",
",",
"saltLength",
"uint",
")",
"[",
"]",
"byte",
"{",
"p",
":=",
"C",
".",
"CK_RSA_PKCS_PSS_PARAMS",
"{",
"hashAlg",
":",
"C",
".",
"CK_MECHANISM_TYPE",
"(",
"hashAlg",
")",
",",
"mgf",
":",
"C",
".",
"CK_RSA_PKCS_MGF_TYPE",
"(",
"mgf",
")",
",",
"sLen",
":",
"C",
".",
"CK_ULONG",
"(",
"saltLength",
")",
",",
"}",
"\n",
"return",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"p",
")",
",",
"C",
".",
"int",
"(",
"unsafe",
".",
"Sizeof",
"(",
"p",
")",
")",
")",
"\n",
"}"
] |
// NewPSSParams creates a CK_RSA_PKCS_PSS_PARAMS structure and returns it as a byte array for use with the CKM_RSA_PKCS_PSS mechanism.
|
[
"NewPSSParams",
"creates",
"a",
"CK_RSA_PKCS_PSS_PARAMS",
"structure",
"and",
"returns",
"it",
"as",
"a",
"byte",
"array",
"for",
"use",
"with",
"the",
"CKM_RSA_PKCS_PSS",
"mechanism",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/params.go#L118-L125
|
11,502 |
miekg/pkcs11
|
params.go
|
NewOAEPParams
|
func NewOAEPParams(hashAlg, mgf, sourceType uint, sourceData []byte) *OAEPParams {
return &OAEPParams{
HashAlg: hashAlg,
MGF: mgf,
SourceType: sourceType,
SourceData: sourceData,
}
}
|
go
|
func NewOAEPParams(hashAlg, mgf, sourceType uint, sourceData []byte) *OAEPParams {
return &OAEPParams{
HashAlg: hashAlg,
MGF: mgf,
SourceType: sourceType,
SourceData: sourceData,
}
}
|
[
"func",
"NewOAEPParams",
"(",
"hashAlg",
",",
"mgf",
",",
"sourceType",
"uint",
",",
"sourceData",
"[",
"]",
"byte",
")",
"*",
"OAEPParams",
"{",
"return",
"&",
"OAEPParams",
"{",
"HashAlg",
":",
"hashAlg",
",",
"MGF",
":",
"mgf",
",",
"SourceType",
":",
"sourceType",
",",
"SourceData",
":",
"sourceData",
",",
"}",
"\n",
"}"
] |
// NewOAEPParams creates a CK_RSA_PKCS_OAEP_PARAMS structure suitable for use with the CKM_RSA_PKCS_OAEP mechanism.
|
[
"NewOAEPParams",
"creates",
"a",
"CK_RSA_PKCS_OAEP_PARAMS",
"structure",
"suitable",
"for",
"use",
"with",
"the",
"CKM_RSA_PKCS_OAEP",
"mechanism",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/params.go#L136-L143
|
11,503 |
miekg/pkcs11
|
params.go
|
NewECDH1DeriveParams
|
func NewECDH1DeriveParams(kdf uint, sharedData []byte, publicKeyData []byte) *ECDH1DeriveParams {
return &ECDH1DeriveParams{
KDF: kdf,
SharedData: sharedData,
PublicKeyData: publicKeyData,
}
}
|
go
|
func NewECDH1DeriveParams(kdf uint, sharedData []byte, publicKeyData []byte) *ECDH1DeriveParams {
return &ECDH1DeriveParams{
KDF: kdf,
SharedData: sharedData,
PublicKeyData: publicKeyData,
}
}
|
[
"func",
"NewECDH1DeriveParams",
"(",
"kdf",
"uint",
",",
"sharedData",
"[",
"]",
"byte",
",",
"publicKeyData",
"[",
"]",
"byte",
")",
"*",
"ECDH1DeriveParams",
"{",
"return",
"&",
"ECDH1DeriveParams",
"{",
"KDF",
":",
"kdf",
",",
"SharedData",
":",
"sharedData",
",",
"PublicKeyData",
":",
"publicKeyData",
",",
"}",
"\n",
"}"
] |
// NewECDH1DeriveParams creates a CK_ECDH1_DERIVE_PARAMS structure suitable for use with the CKM_ECDH1_DERIVE mechanism.
|
[
"NewECDH1DeriveParams",
"creates",
"a",
"CK_ECDH1_DERIVE_PARAMS",
"structure",
"suitable",
"for",
"use",
"with",
"the",
"CKM_ECDH1_DERIVE",
"mechanism",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/params.go#L167-L173
|
11,504 |
miekg/pkcs11
|
pkcs11.go
|
Initialize
|
func (c *Ctx) Initialize() error {
e := C.Initialize(c.ctx)
return toError(e)
}
|
go
|
func (c *Ctx) Initialize() error {
e := C.Initialize(c.ctx)
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"Initialize",
"(",
")",
"error",
"{",
"e",
":=",
"C",
".",
"Initialize",
"(",
"c",
".",
"ctx",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// Initialize initializes the Cryptoki library.
|
[
"Initialize",
"initializes",
"the",
"Cryptoki",
"library",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L804-L807
|
11,505 |
miekg/pkcs11
|
pkcs11.go
|
Finalize
|
func (c *Ctx) Finalize() error {
if c.ctx == nil {
return toError(CKR_CRYPTOKI_NOT_INITIALIZED)
}
e := C.Finalize(c.ctx)
return toError(e)
}
|
go
|
func (c *Ctx) Finalize() error {
if c.ctx == nil {
return toError(CKR_CRYPTOKI_NOT_INITIALIZED)
}
e := C.Finalize(c.ctx)
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"Finalize",
"(",
")",
"error",
"{",
"if",
"c",
".",
"ctx",
"==",
"nil",
"{",
"return",
"toError",
"(",
"CKR_CRYPTOKI_NOT_INITIALIZED",
")",
"\n",
"}",
"\n",
"e",
":=",
"C",
".",
"Finalize",
"(",
"c",
".",
"ctx",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// Finalize indicates that an application is done with the Cryptoki library.
|
[
"Finalize",
"indicates",
"that",
"an",
"application",
"is",
"done",
"with",
"the",
"Cryptoki",
"library",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L810-L816
|
11,506 |
miekg/pkcs11
|
pkcs11.go
|
GetInfo
|
func (c *Ctx) GetInfo() (Info, error) {
var p C.ckInfo
e := C.GetInfo(c.ctx, &p)
i := Info{
CryptokiVersion: toVersion(p.cryptokiVersion),
ManufacturerID: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&p.manufacturerID[0]), 32)), " "),
Flags: uint(p.flags),
LibraryDescription: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&p.libraryDescription[0]), 32)), " "),
LibraryVersion: toVersion(p.libraryVersion),
}
return i, toError(e)
}
|
go
|
func (c *Ctx) GetInfo() (Info, error) {
var p C.ckInfo
e := C.GetInfo(c.ctx, &p)
i := Info{
CryptokiVersion: toVersion(p.cryptokiVersion),
ManufacturerID: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&p.manufacturerID[0]), 32)), " "),
Flags: uint(p.flags),
LibraryDescription: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&p.libraryDescription[0]), 32)), " "),
LibraryVersion: toVersion(p.libraryVersion),
}
return i, toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"GetInfo",
"(",
")",
"(",
"Info",
",",
"error",
")",
"{",
"var",
"p",
"C",
".",
"ckInfo",
"\n",
"e",
":=",
"C",
".",
"GetInfo",
"(",
"c",
".",
"ctx",
",",
"&",
"p",
")",
"\n",
"i",
":=",
"Info",
"{",
"CryptokiVersion",
":",
"toVersion",
"(",
"p",
".",
"cryptokiVersion",
")",
",",
"ManufacturerID",
":",
"strings",
".",
"TrimRight",
"(",
"string",
"(",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"p",
".",
"manufacturerID",
"[",
"0",
"]",
")",
",",
"32",
")",
")",
",",
"\"",
"\"",
")",
",",
"Flags",
":",
"uint",
"(",
"p",
".",
"flags",
")",
",",
"LibraryDescription",
":",
"strings",
".",
"TrimRight",
"(",
"string",
"(",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"p",
".",
"libraryDescription",
"[",
"0",
"]",
")",
",",
"32",
")",
")",
",",
"\"",
"\"",
")",
",",
"LibraryVersion",
":",
"toVersion",
"(",
"p",
".",
"libraryVersion",
")",
",",
"}",
"\n",
"return",
"i",
",",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// GetInfo returns general information about Cryptoki.
|
[
"GetInfo",
"returns",
"general",
"information",
"about",
"Cryptoki",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L819-L830
|
11,507 |
miekg/pkcs11
|
pkcs11.go
|
GetSlotList
|
func (c *Ctx) GetSlotList(tokenPresent bool) ([]uint, error) {
var (
slotList C.CK_ULONG_PTR
ulCount C.CK_ULONG
)
e := C.GetSlotList(c.ctx, cBBool(tokenPresent), &slotList, &ulCount)
if toError(e) != nil {
return nil, toError(e)
}
l := toList(slotList, ulCount)
return l, nil
}
|
go
|
func (c *Ctx) GetSlotList(tokenPresent bool) ([]uint, error) {
var (
slotList C.CK_ULONG_PTR
ulCount C.CK_ULONG
)
e := C.GetSlotList(c.ctx, cBBool(tokenPresent), &slotList, &ulCount)
if toError(e) != nil {
return nil, toError(e)
}
l := toList(slotList, ulCount)
return l, nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"GetSlotList",
"(",
"tokenPresent",
"bool",
")",
"(",
"[",
"]",
"uint",
",",
"error",
")",
"{",
"var",
"(",
"slotList",
"C",
".",
"CK_ULONG_PTR",
"\n",
"ulCount",
"C",
".",
"CK_ULONG",
"\n",
")",
"\n",
"e",
":=",
"C",
".",
"GetSlotList",
"(",
"c",
".",
"ctx",
",",
"cBBool",
"(",
"tokenPresent",
")",
",",
"&",
"slotList",
",",
"&",
"ulCount",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"l",
":=",
"toList",
"(",
"slotList",
",",
"ulCount",
")",
"\n",
"return",
"l",
",",
"nil",
"\n",
"}"
] |
// GetSlotList obtains a list of slots in the system.
|
[
"GetSlotList",
"obtains",
"a",
"list",
"of",
"slots",
"in",
"the",
"system",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L833-L844
|
11,508 |
miekg/pkcs11
|
pkcs11.go
|
GetSlotInfo
|
func (c *Ctx) GetSlotInfo(slotID uint) (SlotInfo, error) {
var csi C.CK_SLOT_INFO
e := C.GetSlotInfo(c.ctx, C.CK_ULONG(slotID), &csi)
s := SlotInfo{
SlotDescription: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&csi.slotDescription[0]), 64)), " "),
ManufacturerID: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&csi.manufacturerID[0]), 32)), " "),
Flags: uint(csi.flags),
HardwareVersion: toVersion(csi.hardwareVersion),
FirmwareVersion: toVersion(csi.firmwareVersion),
}
return s, toError(e)
}
|
go
|
func (c *Ctx) GetSlotInfo(slotID uint) (SlotInfo, error) {
var csi C.CK_SLOT_INFO
e := C.GetSlotInfo(c.ctx, C.CK_ULONG(slotID), &csi)
s := SlotInfo{
SlotDescription: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&csi.slotDescription[0]), 64)), " "),
ManufacturerID: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&csi.manufacturerID[0]), 32)), " "),
Flags: uint(csi.flags),
HardwareVersion: toVersion(csi.hardwareVersion),
FirmwareVersion: toVersion(csi.firmwareVersion),
}
return s, toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"GetSlotInfo",
"(",
"slotID",
"uint",
")",
"(",
"SlotInfo",
",",
"error",
")",
"{",
"var",
"csi",
"C",
".",
"CK_SLOT_INFO",
"\n",
"e",
":=",
"C",
".",
"GetSlotInfo",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_ULONG",
"(",
"slotID",
")",
",",
"&",
"csi",
")",
"\n",
"s",
":=",
"SlotInfo",
"{",
"SlotDescription",
":",
"strings",
".",
"TrimRight",
"(",
"string",
"(",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"csi",
".",
"slotDescription",
"[",
"0",
"]",
")",
",",
"64",
")",
")",
",",
"\"",
"\"",
")",
",",
"ManufacturerID",
":",
"strings",
".",
"TrimRight",
"(",
"string",
"(",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"csi",
".",
"manufacturerID",
"[",
"0",
"]",
")",
",",
"32",
")",
")",
",",
"\"",
"\"",
")",
",",
"Flags",
":",
"uint",
"(",
"csi",
".",
"flags",
")",
",",
"HardwareVersion",
":",
"toVersion",
"(",
"csi",
".",
"hardwareVersion",
")",
",",
"FirmwareVersion",
":",
"toVersion",
"(",
"csi",
".",
"firmwareVersion",
")",
",",
"}",
"\n",
"return",
"s",
",",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// GetSlotInfo obtains information about a particular slot in the system.
|
[
"GetSlotInfo",
"obtains",
"information",
"about",
"a",
"particular",
"slot",
"in",
"the",
"system",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L847-L858
|
11,509 |
miekg/pkcs11
|
pkcs11.go
|
GetTokenInfo
|
func (c *Ctx) GetTokenInfo(slotID uint) (TokenInfo, error) {
var cti C.CK_TOKEN_INFO
e := C.GetTokenInfo(c.ctx, C.CK_ULONG(slotID), &cti)
s := TokenInfo{
Label: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.label[0]), 32)), " "),
ManufacturerID: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.manufacturerID[0]), 32)), " "),
Model: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.model[0]), 16)), " "),
SerialNumber: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.serialNumber[0]), 16)), " "),
Flags: uint(cti.flags),
MaxSessionCount: uint(cti.ulMaxSessionCount),
SessionCount: uint(cti.ulSessionCount),
MaxRwSessionCount: uint(cti.ulMaxRwSessionCount),
RwSessionCount: uint(cti.ulRwSessionCount),
MaxPinLen: uint(cti.ulMaxPinLen),
MinPinLen: uint(cti.ulMinPinLen),
TotalPublicMemory: uint(cti.ulTotalPublicMemory),
FreePublicMemory: uint(cti.ulFreePublicMemory),
TotalPrivateMemory: uint(cti.ulTotalPrivateMemory),
FreePrivateMemory: uint(cti.ulFreePrivateMemory),
HardwareVersion: toVersion(cti.hardwareVersion),
FirmwareVersion: toVersion(cti.firmwareVersion),
UTCTime: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.utcTime[0]), 16)), " "),
}
return s, toError(e)
}
|
go
|
func (c *Ctx) GetTokenInfo(slotID uint) (TokenInfo, error) {
var cti C.CK_TOKEN_INFO
e := C.GetTokenInfo(c.ctx, C.CK_ULONG(slotID), &cti)
s := TokenInfo{
Label: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.label[0]), 32)), " "),
ManufacturerID: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.manufacturerID[0]), 32)), " "),
Model: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.model[0]), 16)), " "),
SerialNumber: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.serialNumber[0]), 16)), " "),
Flags: uint(cti.flags),
MaxSessionCount: uint(cti.ulMaxSessionCount),
SessionCount: uint(cti.ulSessionCount),
MaxRwSessionCount: uint(cti.ulMaxRwSessionCount),
RwSessionCount: uint(cti.ulRwSessionCount),
MaxPinLen: uint(cti.ulMaxPinLen),
MinPinLen: uint(cti.ulMinPinLen),
TotalPublicMemory: uint(cti.ulTotalPublicMemory),
FreePublicMemory: uint(cti.ulFreePublicMemory),
TotalPrivateMemory: uint(cti.ulTotalPrivateMemory),
FreePrivateMemory: uint(cti.ulFreePrivateMemory),
HardwareVersion: toVersion(cti.hardwareVersion),
FirmwareVersion: toVersion(cti.firmwareVersion),
UTCTime: strings.TrimRight(string(C.GoBytes(unsafe.Pointer(&cti.utcTime[0]), 16)), " "),
}
return s, toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"GetTokenInfo",
"(",
"slotID",
"uint",
")",
"(",
"TokenInfo",
",",
"error",
")",
"{",
"var",
"cti",
"C",
".",
"CK_TOKEN_INFO",
"\n",
"e",
":=",
"C",
".",
"GetTokenInfo",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_ULONG",
"(",
"slotID",
")",
",",
"&",
"cti",
")",
"\n",
"s",
":=",
"TokenInfo",
"{",
"Label",
":",
"strings",
".",
"TrimRight",
"(",
"string",
"(",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"cti",
".",
"label",
"[",
"0",
"]",
")",
",",
"32",
")",
")",
",",
"\"",
"\"",
")",
",",
"ManufacturerID",
":",
"strings",
".",
"TrimRight",
"(",
"string",
"(",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"cti",
".",
"manufacturerID",
"[",
"0",
"]",
")",
",",
"32",
")",
")",
",",
"\"",
"\"",
")",
",",
"Model",
":",
"strings",
".",
"TrimRight",
"(",
"string",
"(",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"cti",
".",
"model",
"[",
"0",
"]",
")",
",",
"16",
")",
")",
",",
"\"",
"\"",
")",
",",
"SerialNumber",
":",
"strings",
".",
"TrimRight",
"(",
"string",
"(",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"cti",
".",
"serialNumber",
"[",
"0",
"]",
")",
",",
"16",
")",
")",
",",
"\"",
"\"",
")",
",",
"Flags",
":",
"uint",
"(",
"cti",
".",
"flags",
")",
",",
"MaxSessionCount",
":",
"uint",
"(",
"cti",
".",
"ulMaxSessionCount",
")",
",",
"SessionCount",
":",
"uint",
"(",
"cti",
".",
"ulSessionCount",
")",
",",
"MaxRwSessionCount",
":",
"uint",
"(",
"cti",
".",
"ulMaxRwSessionCount",
")",
",",
"RwSessionCount",
":",
"uint",
"(",
"cti",
".",
"ulRwSessionCount",
")",
",",
"MaxPinLen",
":",
"uint",
"(",
"cti",
".",
"ulMaxPinLen",
")",
",",
"MinPinLen",
":",
"uint",
"(",
"cti",
".",
"ulMinPinLen",
")",
",",
"TotalPublicMemory",
":",
"uint",
"(",
"cti",
".",
"ulTotalPublicMemory",
")",
",",
"FreePublicMemory",
":",
"uint",
"(",
"cti",
".",
"ulFreePublicMemory",
")",
",",
"TotalPrivateMemory",
":",
"uint",
"(",
"cti",
".",
"ulTotalPrivateMemory",
")",
",",
"FreePrivateMemory",
":",
"uint",
"(",
"cti",
".",
"ulFreePrivateMemory",
")",
",",
"HardwareVersion",
":",
"toVersion",
"(",
"cti",
".",
"hardwareVersion",
")",
",",
"FirmwareVersion",
":",
"toVersion",
"(",
"cti",
".",
"firmwareVersion",
")",
",",
"UTCTime",
":",
"strings",
".",
"TrimRight",
"(",
"string",
"(",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"cti",
".",
"utcTime",
"[",
"0",
"]",
")",
",",
"16",
")",
")",
",",
"\"",
"\"",
")",
",",
"}",
"\n",
"return",
"s",
",",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// GetTokenInfo obtains information about a particular token
// in the system.
|
[
"GetTokenInfo",
"obtains",
"information",
"about",
"a",
"particular",
"token",
"in",
"the",
"system",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L862-L886
|
11,510 |
miekg/pkcs11
|
pkcs11.go
|
GetMechanismList
|
func (c *Ctx) GetMechanismList(slotID uint) ([]*Mechanism, error) {
var (
mech C.CK_ULONG_PTR // in pkcs#11 we're all CK_ULONGs \o/
mechlen C.CK_ULONG
)
e := C.GetMechanismList(c.ctx, C.CK_ULONG(slotID), &mech, &mechlen)
if toError(e) != nil {
return nil, toError(e)
}
// Although the function returns only type, cast them back into real
// attributes as this is used in other functions.
m := make([]*Mechanism, int(mechlen))
for i, typ := range toList(mech, mechlen) {
m[i] = NewMechanism(typ, nil)
}
return m, nil
}
|
go
|
func (c *Ctx) GetMechanismList(slotID uint) ([]*Mechanism, error) {
var (
mech C.CK_ULONG_PTR // in pkcs#11 we're all CK_ULONGs \o/
mechlen C.CK_ULONG
)
e := C.GetMechanismList(c.ctx, C.CK_ULONG(slotID), &mech, &mechlen)
if toError(e) != nil {
return nil, toError(e)
}
// Although the function returns only type, cast them back into real
// attributes as this is used in other functions.
m := make([]*Mechanism, int(mechlen))
for i, typ := range toList(mech, mechlen) {
m[i] = NewMechanism(typ, nil)
}
return m, nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"GetMechanismList",
"(",
"slotID",
"uint",
")",
"(",
"[",
"]",
"*",
"Mechanism",
",",
"error",
")",
"{",
"var",
"(",
"mech",
"C",
".",
"CK_ULONG_PTR",
"// in pkcs#11 we're all CK_ULONGs \\o/",
"\n",
"mechlen",
"C",
".",
"CK_ULONG",
"\n",
")",
"\n",
"e",
":=",
"C",
".",
"GetMechanismList",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_ULONG",
"(",
"slotID",
")",
",",
"&",
"mech",
",",
"&",
"mechlen",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"// Although the function returns only type, cast them back into real",
"// attributes as this is used in other functions.",
"m",
":=",
"make",
"(",
"[",
"]",
"*",
"Mechanism",
",",
"int",
"(",
"mechlen",
")",
")",
"\n",
"for",
"i",
",",
"typ",
":=",
"range",
"toList",
"(",
"mech",
",",
"mechlen",
")",
"{",
"m",
"[",
"i",
"]",
"=",
"NewMechanism",
"(",
"typ",
",",
"nil",
")",
"\n",
"}",
"\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] |
// GetMechanismList obtains a list of mechanism types supported by a token.
|
[
"GetMechanismList",
"obtains",
"a",
"list",
"of",
"mechanism",
"types",
"supported",
"by",
"a",
"token",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L889-L905
|
11,511 |
miekg/pkcs11
|
pkcs11.go
|
GetMechanismInfo
|
func (c *Ctx) GetMechanismInfo(slotID uint, m []*Mechanism) (MechanismInfo, error) {
var cm C.CK_MECHANISM_INFO
e := C.GetMechanismInfo(c.ctx, C.CK_ULONG(slotID), C.CK_MECHANISM_TYPE(m[0].Mechanism),
C.CK_MECHANISM_INFO_PTR(&cm))
mi := MechanismInfo{
MinKeySize: uint(cm.ulMinKeySize),
MaxKeySize: uint(cm.ulMaxKeySize),
Flags: uint(cm.flags),
}
return mi, toError(e)
}
|
go
|
func (c *Ctx) GetMechanismInfo(slotID uint, m []*Mechanism) (MechanismInfo, error) {
var cm C.CK_MECHANISM_INFO
e := C.GetMechanismInfo(c.ctx, C.CK_ULONG(slotID), C.CK_MECHANISM_TYPE(m[0].Mechanism),
C.CK_MECHANISM_INFO_PTR(&cm))
mi := MechanismInfo{
MinKeySize: uint(cm.ulMinKeySize),
MaxKeySize: uint(cm.ulMaxKeySize),
Flags: uint(cm.flags),
}
return mi, toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"GetMechanismInfo",
"(",
"slotID",
"uint",
",",
"m",
"[",
"]",
"*",
"Mechanism",
")",
"(",
"MechanismInfo",
",",
"error",
")",
"{",
"var",
"cm",
"C",
".",
"CK_MECHANISM_INFO",
"\n",
"e",
":=",
"C",
".",
"GetMechanismInfo",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_ULONG",
"(",
"slotID",
")",
",",
"C",
".",
"CK_MECHANISM_TYPE",
"(",
"m",
"[",
"0",
"]",
".",
"Mechanism",
")",
",",
"C",
".",
"CK_MECHANISM_INFO_PTR",
"(",
"&",
"cm",
")",
")",
"\n",
"mi",
":=",
"MechanismInfo",
"{",
"MinKeySize",
":",
"uint",
"(",
"cm",
".",
"ulMinKeySize",
")",
",",
"MaxKeySize",
":",
"uint",
"(",
"cm",
".",
"ulMaxKeySize",
")",
",",
"Flags",
":",
"uint",
"(",
"cm",
".",
"flags",
")",
",",
"}",
"\n",
"return",
"mi",
",",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// GetMechanismInfo obtains information about a particular
// mechanism possibly supported by a token.
|
[
"GetMechanismInfo",
"obtains",
"information",
"about",
"a",
"particular",
"mechanism",
"possibly",
"supported",
"by",
"a",
"token",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L909-L919
|
11,512 |
miekg/pkcs11
|
pkcs11.go
|
InitToken
|
func (c *Ctx) InitToken(slotID uint, pin string, label string) error {
p := C.CString(pin)
defer C.free(unsafe.Pointer(p))
ll := len(label)
for ll < 32 {
label += " "
ll++
}
l := C.CString(label[:32])
defer C.free(unsafe.Pointer(l))
e := C.InitToken(c.ctx, C.CK_ULONG(slotID), p, C.CK_ULONG(len(pin)), l)
return toError(e)
}
|
go
|
func (c *Ctx) InitToken(slotID uint, pin string, label string) error {
p := C.CString(pin)
defer C.free(unsafe.Pointer(p))
ll := len(label)
for ll < 32 {
label += " "
ll++
}
l := C.CString(label[:32])
defer C.free(unsafe.Pointer(l))
e := C.InitToken(c.ctx, C.CK_ULONG(slotID), p, C.CK_ULONG(len(pin)), l)
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"InitToken",
"(",
"slotID",
"uint",
",",
"pin",
"string",
",",
"label",
"string",
")",
"error",
"{",
"p",
":=",
"C",
".",
"CString",
"(",
"pin",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"p",
")",
")",
"\n",
"ll",
":=",
"len",
"(",
"label",
")",
"\n",
"for",
"ll",
"<",
"32",
"{",
"label",
"+=",
"\"",
"\"",
"\n",
"ll",
"++",
"\n",
"}",
"\n",
"l",
":=",
"C",
".",
"CString",
"(",
"label",
"[",
":",
"32",
"]",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"l",
")",
")",
"\n",
"e",
":=",
"C",
".",
"InitToken",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_ULONG",
"(",
"slotID",
")",
",",
"p",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"pin",
")",
")",
",",
"l",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// InitToken initializes a token. The label must be 32 characters
// long, it is blank padded if it is not. If it is longer it is capped
// to 32 characters.
|
[
"InitToken",
"initializes",
"a",
"token",
".",
"The",
"label",
"must",
"be",
"32",
"characters",
"long",
"it",
"is",
"blank",
"padded",
"if",
"it",
"is",
"not",
".",
"If",
"it",
"is",
"longer",
"it",
"is",
"capped",
"to",
"32",
"characters",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L924-L936
|
11,513 |
miekg/pkcs11
|
pkcs11.go
|
InitPIN
|
func (c *Ctx) InitPIN(sh SessionHandle, pin string) error {
p := C.CString(pin)
defer C.free(unsafe.Pointer(p))
e := C.InitPIN(c.ctx, C.CK_SESSION_HANDLE(sh), p, C.CK_ULONG(len(pin)))
return toError(e)
}
|
go
|
func (c *Ctx) InitPIN(sh SessionHandle, pin string) error {
p := C.CString(pin)
defer C.free(unsafe.Pointer(p))
e := C.InitPIN(c.ctx, C.CK_SESSION_HANDLE(sh), p, C.CK_ULONG(len(pin)))
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"InitPIN",
"(",
"sh",
"SessionHandle",
",",
"pin",
"string",
")",
"error",
"{",
"p",
":=",
"C",
".",
"CString",
"(",
"pin",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"p",
")",
")",
"\n",
"e",
":=",
"C",
".",
"InitPIN",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"p",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"pin",
")",
")",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// InitPIN initializes the normal user's PIN.
|
[
"InitPIN",
"initializes",
"the",
"normal",
"user",
"s",
"PIN",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L939-L944
|
11,514 |
miekg/pkcs11
|
pkcs11.go
|
SetPIN
|
func (c *Ctx) SetPIN(sh SessionHandle, oldpin string, newpin string) error {
old := C.CString(oldpin)
defer C.free(unsafe.Pointer(old))
new := C.CString(newpin)
defer C.free(unsafe.Pointer(new))
e := C.SetPIN(c.ctx, C.CK_SESSION_HANDLE(sh), old, C.CK_ULONG(len(oldpin)), new, C.CK_ULONG(len(newpin)))
return toError(e)
}
|
go
|
func (c *Ctx) SetPIN(sh SessionHandle, oldpin string, newpin string) error {
old := C.CString(oldpin)
defer C.free(unsafe.Pointer(old))
new := C.CString(newpin)
defer C.free(unsafe.Pointer(new))
e := C.SetPIN(c.ctx, C.CK_SESSION_HANDLE(sh), old, C.CK_ULONG(len(oldpin)), new, C.CK_ULONG(len(newpin)))
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"SetPIN",
"(",
"sh",
"SessionHandle",
",",
"oldpin",
"string",
",",
"newpin",
"string",
")",
"error",
"{",
"old",
":=",
"C",
".",
"CString",
"(",
"oldpin",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"old",
")",
")",
"\n",
"new",
":=",
"C",
".",
"CString",
"(",
"newpin",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"new",
")",
")",
"\n",
"e",
":=",
"C",
".",
"SetPIN",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"old",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"oldpin",
")",
")",
",",
"new",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"newpin",
")",
")",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// SetPIN modifies the PIN of the user who is logged in.
|
[
"SetPIN",
"modifies",
"the",
"PIN",
"of",
"the",
"user",
"who",
"is",
"logged",
"in",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L947-L954
|
11,515 |
miekg/pkcs11
|
pkcs11.go
|
CloseAllSessions
|
func (c *Ctx) CloseAllSessions(slotID uint) error {
if c.ctx == nil {
return toError(CKR_CRYPTOKI_NOT_INITIALIZED)
}
e := C.CloseAllSessions(c.ctx, C.CK_ULONG(slotID))
return toError(e)
}
|
go
|
func (c *Ctx) CloseAllSessions(slotID uint) error {
if c.ctx == nil {
return toError(CKR_CRYPTOKI_NOT_INITIALIZED)
}
e := C.CloseAllSessions(c.ctx, C.CK_ULONG(slotID))
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"CloseAllSessions",
"(",
"slotID",
"uint",
")",
"error",
"{",
"if",
"c",
".",
"ctx",
"==",
"nil",
"{",
"return",
"toError",
"(",
"CKR_CRYPTOKI_NOT_INITIALIZED",
")",
"\n",
"}",
"\n",
"e",
":=",
"C",
".",
"CloseAllSessions",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_ULONG",
"(",
"slotID",
")",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// CloseAllSessions closes all sessions with a token.
|
[
"CloseAllSessions",
"closes",
"all",
"sessions",
"with",
"a",
"token",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L973-L979
|
11,516 |
miekg/pkcs11
|
pkcs11.go
|
GetSessionInfo
|
func (c *Ctx) GetSessionInfo(sh SessionHandle) (SessionInfo, error) {
var csi C.CK_SESSION_INFO
e := C.GetSessionInfo(c.ctx, C.CK_SESSION_HANDLE(sh), &csi)
s := SessionInfo{SlotID: uint(csi.slotID),
State: uint(csi.state),
Flags: uint(csi.flags),
DeviceError: uint(csi.ulDeviceError),
}
return s, toError(e)
}
|
go
|
func (c *Ctx) GetSessionInfo(sh SessionHandle) (SessionInfo, error) {
var csi C.CK_SESSION_INFO
e := C.GetSessionInfo(c.ctx, C.CK_SESSION_HANDLE(sh), &csi)
s := SessionInfo{SlotID: uint(csi.slotID),
State: uint(csi.state),
Flags: uint(csi.flags),
DeviceError: uint(csi.ulDeviceError),
}
return s, toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"GetSessionInfo",
"(",
"sh",
"SessionHandle",
")",
"(",
"SessionInfo",
",",
"error",
")",
"{",
"var",
"csi",
"C",
".",
"CK_SESSION_INFO",
"\n",
"e",
":=",
"C",
".",
"GetSessionInfo",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"&",
"csi",
")",
"\n",
"s",
":=",
"SessionInfo",
"{",
"SlotID",
":",
"uint",
"(",
"csi",
".",
"slotID",
")",
",",
"State",
":",
"uint",
"(",
"csi",
".",
"state",
")",
",",
"Flags",
":",
"uint",
"(",
"csi",
".",
"flags",
")",
",",
"DeviceError",
":",
"uint",
"(",
"csi",
".",
"ulDeviceError",
")",
",",
"}",
"\n",
"return",
"s",
",",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// GetSessionInfo obtains information about the session.
|
[
"GetSessionInfo",
"obtains",
"information",
"about",
"the",
"session",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L982-L991
|
11,517 |
miekg/pkcs11
|
pkcs11.go
|
GetOperationState
|
func (c *Ctx) GetOperationState(sh SessionHandle) ([]byte, error) {
var (
state C.CK_BYTE_PTR
statelen C.CK_ULONG
)
e := C.GetOperationState(c.ctx, C.CK_SESSION_HANDLE(sh), &state, &statelen)
defer C.free(unsafe.Pointer(state))
if toError(e) != nil {
return nil, toError(e)
}
b := C.GoBytes(unsafe.Pointer(state), C.int(statelen))
return b, nil
}
|
go
|
func (c *Ctx) GetOperationState(sh SessionHandle) ([]byte, error) {
var (
state C.CK_BYTE_PTR
statelen C.CK_ULONG
)
e := C.GetOperationState(c.ctx, C.CK_SESSION_HANDLE(sh), &state, &statelen)
defer C.free(unsafe.Pointer(state))
if toError(e) != nil {
return nil, toError(e)
}
b := C.GoBytes(unsafe.Pointer(state), C.int(statelen))
return b, nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"GetOperationState",
"(",
"sh",
"SessionHandle",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"(",
"state",
"C",
".",
"CK_BYTE_PTR",
"\n",
"statelen",
"C",
".",
"CK_ULONG",
"\n",
")",
"\n",
"e",
":=",
"C",
".",
"GetOperationState",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"&",
"state",
",",
"&",
"statelen",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"state",
")",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"b",
":=",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"state",
")",
",",
"C",
".",
"int",
"(",
"statelen",
")",
")",
"\n",
"return",
"b",
",",
"nil",
"\n",
"}"
] |
// GetOperationState obtains the state of the cryptographic operation in a session.
|
[
"GetOperationState",
"obtains",
"the",
"state",
"of",
"the",
"cryptographic",
"operation",
"in",
"a",
"session",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L994-L1006
|
11,518 |
miekg/pkcs11
|
pkcs11.go
|
SetOperationState
|
func (c *Ctx) SetOperationState(sh SessionHandle, state []byte, encryptKey, authKey ObjectHandle) error {
e := C.SetOperationState(c.ctx, C.CK_SESSION_HANDLE(sh), C.CK_BYTE_PTR(unsafe.Pointer(&state[0])),
C.CK_ULONG(len(state)), C.CK_OBJECT_HANDLE(encryptKey), C.CK_OBJECT_HANDLE(authKey))
return toError(e)
}
|
go
|
func (c *Ctx) SetOperationState(sh SessionHandle, state []byte, encryptKey, authKey ObjectHandle) error {
e := C.SetOperationState(c.ctx, C.CK_SESSION_HANDLE(sh), C.CK_BYTE_PTR(unsafe.Pointer(&state[0])),
C.CK_ULONG(len(state)), C.CK_OBJECT_HANDLE(encryptKey), C.CK_OBJECT_HANDLE(authKey))
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"SetOperationState",
"(",
"sh",
"SessionHandle",
",",
"state",
"[",
"]",
"byte",
",",
"encryptKey",
",",
"authKey",
"ObjectHandle",
")",
"error",
"{",
"e",
":=",
"C",
".",
"SetOperationState",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"C",
".",
"CK_BYTE_PTR",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"state",
"[",
"0",
"]",
")",
")",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"state",
")",
")",
",",
"C",
".",
"CK_OBJECT_HANDLE",
"(",
"encryptKey",
")",
",",
"C",
".",
"CK_OBJECT_HANDLE",
"(",
"authKey",
")",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// SetOperationState restores the state of the cryptographic operation in a session.
|
[
"SetOperationState",
"restores",
"the",
"state",
"of",
"the",
"cryptographic",
"operation",
"in",
"a",
"session",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1009-L1013
|
11,519 |
miekg/pkcs11
|
pkcs11.go
|
Login
|
func (c *Ctx) Login(sh SessionHandle, userType uint, pin string) error {
p := C.CString(pin)
defer C.free(unsafe.Pointer(p))
e := C.Login(c.ctx, C.CK_SESSION_HANDLE(sh), C.CK_USER_TYPE(userType), p, C.CK_ULONG(len(pin)))
return toError(e)
}
|
go
|
func (c *Ctx) Login(sh SessionHandle, userType uint, pin string) error {
p := C.CString(pin)
defer C.free(unsafe.Pointer(p))
e := C.Login(c.ctx, C.CK_SESSION_HANDLE(sh), C.CK_USER_TYPE(userType), p, C.CK_ULONG(len(pin)))
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"Login",
"(",
"sh",
"SessionHandle",
",",
"userType",
"uint",
",",
"pin",
"string",
")",
"error",
"{",
"p",
":=",
"C",
".",
"CString",
"(",
"pin",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"p",
")",
")",
"\n",
"e",
":=",
"C",
".",
"Login",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"C",
".",
"CK_USER_TYPE",
"(",
"userType",
")",
",",
"p",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"pin",
")",
")",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// Login logs a user into a token.
|
[
"Login",
"logs",
"a",
"user",
"into",
"a",
"token",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1016-L1021
|
11,520 |
miekg/pkcs11
|
pkcs11.go
|
Logout
|
func (c *Ctx) Logout(sh SessionHandle) error {
if c.ctx == nil {
return toError(CKR_CRYPTOKI_NOT_INITIALIZED)
}
e := C.Logout(c.ctx, C.CK_SESSION_HANDLE(sh))
return toError(e)
}
|
go
|
func (c *Ctx) Logout(sh SessionHandle) error {
if c.ctx == nil {
return toError(CKR_CRYPTOKI_NOT_INITIALIZED)
}
e := C.Logout(c.ctx, C.CK_SESSION_HANDLE(sh))
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"Logout",
"(",
"sh",
"SessionHandle",
")",
"error",
"{",
"if",
"c",
".",
"ctx",
"==",
"nil",
"{",
"return",
"toError",
"(",
"CKR_CRYPTOKI_NOT_INITIALIZED",
")",
"\n",
"}",
"\n",
"e",
":=",
"C",
".",
"Logout",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// Logout logs a user out from a token.
|
[
"Logout",
"logs",
"a",
"user",
"out",
"from",
"a",
"token",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1024-L1030
|
11,521 |
miekg/pkcs11
|
pkcs11.go
|
CreateObject
|
func (c *Ctx) CreateObject(sh SessionHandle, temp []*Attribute) (ObjectHandle, error) {
var obj C.CK_OBJECT_HANDLE
arena, t, tcount := cAttributeList(temp)
defer arena.Free()
e := C.CreateObject(c.ctx, C.CK_SESSION_HANDLE(sh), t, tcount, C.CK_OBJECT_HANDLE_PTR(&obj))
e1 := toError(e)
if e1 == nil {
return ObjectHandle(obj), nil
}
return 0, e1
}
|
go
|
func (c *Ctx) CreateObject(sh SessionHandle, temp []*Attribute) (ObjectHandle, error) {
var obj C.CK_OBJECT_HANDLE
arena, t, tcount := cAttributeList(temp)
defer arena.Free()
e := C.CreateObject(c.ctx, C.CK_SESSION_HANDLE(sh), t, tcount, C.CK_OBJECT_HANDLE_PTR(&obj))
e1 := toError(e)
if e1 == nil {
return ObjectHandle(obj), nil
}
return 0, e1
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"CreateObject",
"(",
"sh",
"SessionHandle",
",",
"temp",
"[",
"]",
"*",
"Attribute",
")",
"(",
"ObjectHandle",
",",
"error",
")",
"{",
"var",
"obj",
"C",
".",
"CK_OBJECT_HANDLE",
"\n",
"arena",
",",
"t",
",",
"tcount",
":=",
"cAttributeList",
"(",
"temp",
")",
"\n",
"defer",
"arena",
".",
"Free",
"(",
")",
"\n",
"e",
":=",
"C",
".",
"CreateObject",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"t",
",",
"tcount",
",",
"C",
".",
"CK_OBJECT_HANDLE_PTR",
"(",
"&",
"obj",
")",
")",
"\n",
"e1",
":=",
"toError",
"(",
"e",
")",
"\n",
"if",
"e1",
"==",
"nil",
"{",
"return",
"ObjectHandle",
"(",
"obj",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"0",
",",
"e1",
"\n",
"}"
] |
// CreateObject creates a new object.
|
[
"CreateObject",
"creates",
"a",
"new",
"object",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1033-L1043
|
11,522 |
miekg/pkcs11
|
pkcs11.go
|
GetObjectSize
|
func (c *Ctx) GetObjectSize(sh SessionHandle, oh ObjectHandle) (uint, error) {
var size C.CK_ULONG
e := C.GetObjectSize(c.ctx, C.CK_SESSION_HANDLE(sh), C.CK_OBJECT_HANDLE(oh), &size)
return uint(size), toError(e)
}
|
go
|
func (c *Ctx) GetObjectSize(sh SessionHandle, oh ObjectHandle) (uint, error) {
var size C.CK_ULONG
e := C.GetObjectSize(c.ctx, C.CK_SESSION_HANDLE(sh), C.CK_OBJECT_HANDLE(oh), &size)
return uint(size), toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"GetObjectSize",
"(",
"sh",
"SessionHandle",
",",
"oh",
"ObjectHandle",
")",
"(",
"uint",
",",
"error",
")",
"{",
"var",
"size",
"C",
".",
"CK_ULONG",
"\n",
"e",
":=",
"C",
".",
"GetObjectSize",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"C",
".",
"CK_OBJECT_HANDLE",
"(",
"oh",
")",
",",
"&",
"size",
")",
"\n",
"return",
"uint",
"(",
"size",
")",
",",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// GetObjectSize gets the size of an object in bytes.
|
[
"GetObjectSize",
"gets",
"the",
"size",
"of",
"an",
"object",
"in",
"bytes",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1066-L1070
|
11,523 |
miekg/pkcs11
|
pkcs11.go
|
SetAttributeValue
|
func (c *Ctx) SetAttributeValue(sh SessionHandle, o ObjectHandle, a []*Attribute) error {
arena, pa, palen := cAttributeList(a)
defer arena.Free()
e := C.SetAttributeValue(c.ctx, C.CK_SESSION_HANDLE(sh), C.CK_OBJECT_HANDLE(o), pa, palen)
return toError(e)
}
|
go
|
func (c *Ctx) SetAttributeValue(sh SessionHandle, o ObjectHandle, a []*Attribute) error {
arena, pa, palen := cAttributeList(a)
defer arena.Free()
e := C.SetAttributeValue(c.ctx, C.CK_SESSION_HANDLE(sh), C.CK_OBJECT_HANDLE(o), pa, palen)
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"SetAttributeValue",
"(",
"sh",
"SessionHandle",
",",
"o",
"ObjectHandle",
",",
"a",
"[",
"]",
"*",
"Attribute",
")",
"error",
"{",
"arena",
",",
"pa",
",",
"palen",
":=",
"cAttributeList",
"(",
"a",
")",
"\n",
"defer",
"arena",
".",
"Free",
"(",
")",
"\n",
"e",
":=",
"C",
".",
"SetAttributeValue",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"C",
".",
"CK_OBJECT_HANDLE",
"(",
"o",
")",
",",
"pa",
",",
"palen",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// SetAttributeValue modifies the value of one or more object attributes
|
[
"SetAttributeValue",
"modifies",
"the",
"value",
"of",
"one",
"or",
"more",
"object",
"attributes"
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1099-L1104
|
11,524 |
miekg/pkcs11
|
pkcs11.go
|
FindObjects
|
func (c *Ctx) FindObjects(sh SessionHandle, max int) ([]ObjectHandle, bool, error) {
var (
objectList C.CK_OBJECT_HANDLE_PTR
ulCount C.CK_ULONG
)
e := C.FindObjects(c.ctx, C.CK_SESSION_HANDLE(sh), &objectList, C.CK_ULONG(max), &ulCount)
if toError(e) != nil {
return nil, false, toError(e)
}
l := toList(C.CK_ULONG_PTR(unsafe.Pointer(objectList)), ulCount)
// Make again a new list of the correct type.
// This is copying data, but this is not an often used function.
o := make([]ObjectHandle, len(l))
for i, v := range l {
o[i] = ObjectHandle(v)
}
return o, ulCount > C.CK_ULONG(max), nil
}
|
go
|
func (c *Ctx) FindObjects(sh SessionHandle, max int) ([]ObjectHandle, bool, error) {
var (
objectList C.CK_OBJECT_HANDLE_PTR
ulCount C.CK_ULONG
)
e := C.FindObjects(c.ctx, C.CK_SESSION_HANDLE(sh), &objectList, C.CK_ULONG(max), &ulCount)
if toError(e) != nil {
return nil, false, toError(e)
}
l := toList(C.CK_ULONG_PTR(unsafe.Pointer(objectList)), ulCount)
// Make again a new list of the correct type.
// This is copying data, but this is not an often used function.
o := make([]ObjectHandle, len(l))
for i, v := range l {
o[i] = ObjectHandle(v)
}
return o, ulCount > C.CK_ULONG(max), nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"FindObjects",
"(",
"sh",
"SessionHandle",
",",
"max",
"int",
")",
"(",
"[",
"]",
"ObjectHandle",
",",
"bool",
",",
"error",
")",
"{",
"var",
"(",
"objectList",
"C",
".",
"CK_OBJECT_HANDLE_PTR",
"\n",
"ulCount",
"C",
".",
"CK_ULONG",
"\n",
")",
"\n",
"e",
":=",
"C",
".",
"FindObjects",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"&",
"objectList",
",",
"C",
".",
"CK_ULONG",
"(",
"max",
")",
",",
"&",
"ulCount",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"false",
",",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"l",
":=",
"toList",
"(",
"C",
".",
"CK_ULONG_PTR",
"(",
"unsafe",
".",
"Pointer",
"(",
"objectList",
")",
")",
",",
"ulCount",
")",
"\n",
"// Make again a new list of the correct type.",
"// This is copying data, but this is not an often used function.",
"o",
":=",
"make",
"(",
"[",
"]",
"ObjectHandle",
",",
"len",
"(",
"l",
")",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"l",
"{",
"o",
"[",
"i",
"]",
"=",
"ObjectHandle",
"(",
"v",
")",
"\n",
"}",
"\n",
"return",
"o",
",",
"ulCount",
">",
"C",
".",
"CK_ULONG",
"(",
"max",
")",
",",
"nil",
"\n",
"}"
] |
// FindObjects continues a search for token and session
// objects that match a template, obtaining additional object
// handles. Calling the function repeatedly may yield additional results until
// an empty slice is returned.
//
// The returned boolean value is deprecated and should be ignored.
|
[
"FindObjects",
"continues",
"a",
"search",
"for",
"token",
"and",
"session",
"objects",
"that",
"match",
"a",
"template",
"obtaining",
"additional",
"object",
"handles",
".",
"Calling",
"the",
"function",
"repeatedly",
"may",
"yield",
"additional",
"results",
"until",
"an",
"empty",
"slice",
"is",
"returned",
".",
"The",
"returned",
"boolean",
"value",
"is",
"deprecated",
"and",
"should",
"be",
"ignored",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1121-L1138
|
11,525 |
miekg/pkcs11
|
pkcs11.go
|
Encrypt
|
func (c *Ctx) Encrypt(sh SessionHandle, message []byte) ([]byte, error) {
var (
enc C.CK_BYTE_PTR
enclen C.CK_ULONG
)
e := C.Encrypt(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(message), C.CK_ULONG(len(message)), &enc, &enclen)
if toError(e) != nil {
return nil, toError(e)
}
s := C.GoBytes(unsafe.Pointer(enc), C.int(enclen))
C.free(unsafe.Pointer(enc))
return s, nil
}
|
go
|
func (c *Ctx) Encrypt(sh SessionHandle, message []byte) ([]byte, error) {
var (
enc C.CK_BYTE_PTR
enclen C.CK_ULONG
)
e := C.Encrypt(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(message), C.CK_ULONG(len(message)), &enc, &enclen)
if toError(e) != nil {
return nil, toError(e)
}
s := C.GoBytes(unsafe.Pointer(enc), C.int(enclen))
C.free(unsafe.Pointer(enc))
return s, nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"Encrypt",
"(",
"sh",
"SessionHandle",
",",
"message",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"(",
"enc",
"C",
".",
"CK_BYTE_PTR",
"\n",
"enclen",
"C",
".",
"CK_ULONG",
"\n",
")",
"\n",
"e",
":=",
"C",
".",
"Encrypt",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"cMessage",
"(",
"message",
")",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"message",
")",
")",
",",
"&",
"enc",
",",
"&",
"enclen",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"s",
":=",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"enc",
")",
",",
"C",
".",
"int",
"(",
"enclen",
")",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"enc",
")",
")",
"\n",
"return",
"s",
",",
"nil",
"\n",
"}"
] |
// Encrypt encrypts single-part data.
|
[
"Encrypt",
"encrypts",
"single",
"-",
"part",
"data",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1155-L1167
|
11,526 |
miekg/pkcs11
|
pkcs11.go
|
DecryptFinal
|
func (c *Ctx) DecryptFinal(sh SessionHandle) ([]byte, error) {
var (
plain C.CK_BYTE_PTR
plainlen C.CK_ULONG
)
e := C.DecryptFinal(c.ctx, C.CK_SESSION_HANDLE(sh), &plain, &plainlen)
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(plain), C.int(plainlen))
C.free(unsafe.Pointer(plain))
return h, nil
}
|
go
|
func (c *Ctx) DecryptFinal(sh SessionHandle) ([]byte, error) {
var (
plain C.CK_BYTE_PTR
plainlen C.CK_ULONG
)
e := C.DecryptFinal(c.ctx, C.CK_SESSION_HANDLE(sh), &plain, &plainlen)
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(plain), C.int(plainlen))
C.free(unsafe.Pointer(plain))
return h, nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"DecryptFinal",
"(",
"sh",
"SessionHandle",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"(",
"plain",
"C",
".",
"CK_BYTE_PTR",
"\n",
"plainlen",
"C",
".",
"CK_ULONG",
"\n",
")",
"\n",
"e",
":=",
"C",
".",
"DecryptFinal",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"&",
"plain",
",",
"&",
"plainlen",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"h",
":=",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"plain",
")",
",",
"C",
".",
"int",
"(",
"plainlen",
")",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"plain",
")",
")",
"\n",
"return",
"h",
",",
"nil",
"\n",
"}"
] |
// DecryptFinal finishes a multiple-part decryption operation.
|
[
"DecryptFinal",
"finishes",
"a",
"multiple",
"-",
"part",
"decryption",
"operation",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1238-L1250
|
11,527 |
miekg/pkcs11
|
pkcs11.go
|
DigestInit
|
func (c *Ctx) DigestInit(sh SessionHandle, m []*Mechanism) error {
arena, mech := cMechanism(m)
defer arena.Free()
e := C.DigestInit(c.ctx, C.CK_SESSION_HANDLE(sh), mech)
return toError(e)
}
|
go
|
func (c *Ctx) DigestInit(sh SessionHandle, m []*Mechanism) error {
arena, mech := cMechanism(m)
defer arena.Free()
e := C.DigestInit(c.ctx, C.CK_SESSION_HANDLE(sh), mech)
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"DigestInit",
"(",
"sh",
"SessionHandle",
",",
"m",
"[",
"]",
"*",
"Mechanism",
")",
"error",
"{",
"arena",
",",
"mech",
":=",
"cMechanism",
"(",
"m",
")",
"\n",
"defer",
"arena",
".",
"Free",
"(",
")",
"\n",
"e",
":=",
"C",
".",
"DigestInit",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"mech",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// DigestInit initializes a message-digesting operation.
|
[
"DigestInit",
"initializes",
"a",
"message",
"-",
"digesting",
"operation",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1253-L1258
|
11,528 |
miekg/pkcs11
|
pkcs11.go
|
DigestUpdate
|
func (c *Ctx) DigestUpdate(sh SessionHandle, message []byte) error {
e := C.DigestUpdate(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(message), C.CK_ULONG(len(message)))
if toError(e) != nil {
return toError(e)
}
return nil
}
|
go
|
func (c *Ctx) DigestUpdate(sh SessionHandle, message []byte) error {
e := C.DigestUpdate(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(message), C.CK_ULONG(len(message)))
if toError(e) != nil {
return toError(e)
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"DigestUpdate",
"(",
"sh",
"SessionHandle",
",",
"message",
"[",
"]",
"byte",
")",
"error",
"{",
"e",
":=",
"C",
".",
"DigestUpdate",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"cMessage",
"(",
"message",
")",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"message",
")",
")",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// DigestUpdate continues a multiple-part message-digesting operation.
|
[
"DigestUpdate",
"continues",
"a",
"multiple",
"-",
"part",
"message",
"-",
"digesting",
"operation",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1276-L1282
|
11,529 |
miekg/pkcs11
|
pkcs11.go
|
DigestKey
|
func (c *Ctx) DigestKey(sh SessionHandle, key ObjectHandle) error {
e := C.DigestKey(c.ctx, C.CK_SESSION_HANDLE(sh), C.CK_OBJECT_HANDLE(key))
if toError(e) != nil {
return toError(e)
}
return nil
}
|
go
|
func (c *Ctx) DigestKey(sh SessionHandle, key ObjectHandle) error {
e := C.DigestKey(c.ctx, C.CK_SESSION_HANDLE(sh), C.CK_OBJECT_HANDLE(key))
if toError(e) != nil {
return toError(e)
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"DigestKey",
"(",
"sh",
"SessionHandle",
",",
"key",
"ObjectHandle",
")",
"error",
"{",
"e",
":=",
"C",
".",
"DigestKey",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"C",
".",
"CK_OBJECT_HANDLE",
"(",
"key",
")",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// DigestKey continues a multi-part message-digesting
// operation, by digesting the value of a secret key as part of
// the data already digested.
|
[
"DigestKey",
"continues",
"a",
"multi",
"-",
"part",
"message",
"-",
"digesting",
"operation",
"by",
"digesting",
"the",
"value",
"of",
"a",
"secret",
"key",
"as",
"part",
"of",
"the",
"data",
"already",
"digested",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1287-L1293
|
11,530 |
miekg/pkcs11
|
pkcs11.go
|
DigestFinal
|
func (c *Ctx) DigestFinal(sh SessionHandle) ([]byte, error) {
var (
hash C.CK_BYTE_PTR
hashlen C.CK_ULONG
)
e := C.DigestFinal(c.ctx, C.CK_SESSION_HANDLE(sh), &hash, &hashlen)
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(hash), C.int(hashlen))
C.free(unsafe.Pointer(hash))
return h, nil
}
|
go
|
func (c *Ctx) DigestFinal(sh SessionHandle) ([]byte, error) {
var (
hash C.CK_BYTE_PTR
hashlen C.CK_ULONG
)
e := C.DigestFinal(c.ctx, C.CK_SESSION_HANDLE(sh), &hash, &hashlen)
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(hash), C.int(hashlen))
C.free(unsafe.Pointer(hash))
return h, nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"DigestFinal",
"(",
"sh",
"SessionHandle",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"(",
"hash",
"C",
".",
"CK_BYTE_PTR",
"\n",
"hashlen",
"C",
".",
"CK_ULONG",
"\n",
")",
"\n",
"e",
":=",
"C",
".",
"DigestFinal",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"&",
"hash",
",",
"&",
"hashlen",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"h",
":=",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"hash",
")",
",",
"C",
".",
"int",
"(",
"hashlen",
")",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"hash",
")",
")",
"\n",
"return",
"h",
",",
"nil",
"\n",
"}"
] |
// DigestFinal finishes a multiple-part message-digesting operation.
|
[
"DigestFinal",
"finishes",
"a",
"multiple",
"-",
"part",
"message",
"-",
"digesting",
"operation",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1296-L1308
|
11,531 |
miekg/pkcs11
|
pkcs11.go
|
SignRecover
|
func (c *Ctx) SignRecover(sh SessionHandle, data []byte) ([]byte, error) {
var (
sig C.CK_BYTE_PTR
siglen C.CK_ULONG
)
e := C.SignRecover(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(data), C.CK_ULONG(len(data)), &sig, &siglen)
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(sig), C.int(siglen))
C.free(unsafe.Pointer(sig))
return h, nil
}
|
go
|
func (c *Ctx) SignRecover(sh SessionHandle, data []byte) ([]byte, error) {
var (
sig C.CK_BYTE_PTR
siglen C.CK_ULONG
)
e := C.SignRecover(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(data), C.CK_ULONG(len(data)), &sig, &siglen)
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(sig), C.int(siglen))
C.free(unsafe.Pointer(sig))
return h, nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"SignRecover",
"(",
"sh",
"SessionHandle",
",",
"data",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"(",
"sig",
"C",
".",
"CK_BYTE_PTR",
"\n",
"siglen",
"C",
".",
"CK_ULONG",
"\n",
")",
"\n",
"e",
":=",
"C",
".",
"SignRecover",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"cMessage",
"(",
"data",
")",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"data",
")",
")",
",",
"&",
"sig",
",",
"&",
"siglen",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"h",
":=",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"sig",
")",
",",
"C",
".",
"int",
"(",
"siglen",
")",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"sig",
")",
")",
"\n",
"return",
"h",
",",
"nil",
"\n",
"}"
] |
// SignRecover signs data in a single operation, where the data can be recovered from the signature.
|
[
"SignRecover",
"signs",
"data",
"in",
"a",
"single",
"operation",
"where",
"the",
"data",
"can",
"be",
"recovered",
"from",
"the",
"signature",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1368-L1380
|
11,532 |
miekg/pkcs11
|
pkcs11.go
|
VerifyUpdate
|
func (c *Ctx) VerifyUpdate(sh SessionHandle, part []byte) error {
e := C.VerifyUpdate(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(part), C.CK_ULONG(len(part)))
return toError(e)
}
|
go
|
func (c *Ctx) VerifyUpdate(sh SessionHandle, part []byte) error {
e := C.VerifyUpdate(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(part), C.CK_ULONG(len(part)))
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"VerifyUpdate",
"(",
"sh",
"SessionHandle",
",",
"part",
"[",
"]",
"byte",
")",
"error",
"{",
"e",
":=",
"C",
".",
"VerifyUpdate",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"cMessage",
"(",
"part",
")",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"part",
")",
")",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// VerifyUpdate continues a multiple-part verification
// operation, where the signature is an appendix to the data,
// and plaintext cannot be recovered from the signature.
|
[
"VerifyUpdate",
"continues",
"a",
"multiple",
"-",
"part",
"verification",
"operation",
"where",
"the",
"signature",
"is",
"an",
"appendix",
"to",
"the",
"data",
"and",
"plaintext",
"cannot",
"be",
"recovered",
"from",
"the",
"signature",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1403-L1406
|
11,533 |
miekg/pkcs11
|
pkcs11.go
|
VerifyFinal
|
func (c *Ctx) VerifyFinal(sh SessionHandle, signature []byte) error {
e := C.VerifyFinal(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(signature), C.CK_ULONG(len(signature)))
return toError(e)
}
|
go
|
func (c *Ctx) VerifyFinal(sh SessionHandle, signature []byte) error {
e := C.VerifyFinal(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(signature), C.CK_ULONG(len(signature)))
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"VerifyFinal",
"(",
"sh",
"SessionHandle",
",",
"signature",
"[",
"]",
"byte",
")",
"error",
"{",
"e",
":=",
"C",
".",
"VerifyFinal",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"cMessage",
"(",
"signature",
")",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"signature",
")",
")",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// VerifyFinal finishes a multiple-part verification
// operation, checking the signature.
|
[
"VerifyFinal",
"finishes",
"a",
"multiple",
"-",
"part",
"verification",
"operation",
"checking",
"the",
"signature",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1410-L1413
|
11,534 |
miekg/pkcs11
|
pkcs11.go
|
VerifyRecover
|
func (c *Ctx) VerifyRecover(sh SessionHandle, signature []byte) ([]byte, error) {
var (
data C.CK_BYTE_PTR
datalen C.CK_ULONG
)
e := C.DecryptVerifyUpdate(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(signature), C.CK_ULONG(len(signature)), &data, &datalen)
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(data), C.int(datalen))
C.free(unsafe.Pointer(data))
return h, nil
}
|
go
|
func (c *Ctx) VerifyRecover(sh SessionHandle, signature []byte) ([]byte, error) {
var (
data C.CK_BYTE_PTR
datalen C.CK_ULONG
)
e := C.DecryptVerifyUpdate(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(signature), C.CK_ULONG(len(signature)), &data, &datalen)
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(data), C.int(datalen))
C.free(unsafe.Pointer(data))
return h, nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"VerifyRecover",
"(",
"sh",
"SessionHandle",
",",
"signature",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"(",
"data",
"C",
".",
"CK_BYTE_PTR",
"\n",
"datalen",
"C",
".",
"CK_ULONG",
"\n",
")",
"\n",
"e",
":=",
"C",
".",
"DecryptVerifyUpdate",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"cMessage",
"(",
"signature",
")",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"signature",
")",
")",
",",
"&",
"data",
",",
"&",
"datalen",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"h",
":=",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"data",
")",
",",
"C",
".",
"int",
"(",
"datalen",
")",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"data",
")",
")",
"\n",
"return",
"h",
",",
"nil",
"\n",
"}"
] |
// VerifyRecover verifies a signature in a single-part
// operation, where the data is recovered from the signature.
|
[
"VerifyRecover",
"verifies",
"a",
"signature",
"in",
"a",
"single",
"-",
"part",
"operation",
"where",
"the",
"data",
"is",
"recovered",
"from",
"the",
"signature",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1426-L1438
|
11,535 |
miekg/pkcs11
|
pkcs11.go
|
DecryptDigestUpdate
|
func (c *Ctx) DecryptDigestUpdate(sh SessionHandle, cipher []byte) ([]byte, error) {
var (
part C.CK_BYTE_PTR
partlen C.CK_ULONG
)
e := C.DecryptDigestUpdate(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(cipher), C.CK_ULONG(len(cipher)), &part, &partlen)
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(part), C.int(partlen))
C.free(unsafe.Pointer(part))
return h, nil
}
|
go
|
func (c *Ctx) DecryptDigestUpdate(sh SessionHandle, cipher []byte) ([]byte, error) {
var (
part C.CK_BYTE_PTR
partlen C.CK_ULONG
)
e := C.DecryptDigestUpdate(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(cipher), C.CK_ULONG(len(cipher)), &part, &partlen)
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(part), C.int(partlen))
C.free(unsafe.Pointer(part))
return h, nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"DecryptDigestUpdate",
"(",
"sh",
"SessionHandle",
",",
"cipher",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"(",
"part",
"C",
".",
"CK_BYTE_PTR",
"\n",
"partlen",
"C",
".",
"CK_ULONG",
"\n",
")",
"\n",
"e",
":=",
"C",
".",
"DecryptDigestUpdate",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"cMessage",
"(",
"cipher",
")",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"cipher",
")",
")",
",",
"&",
"part",
",",
"&",
"partlen",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"h",
":=",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"part",
")",
",",
"C",
".",
"int",
"(",
"partlen",
")",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"part",
")",
")",
"\n",
"return",
"h",
",",
"nil",
"\n",
"}"
] |
// DecryptDigestUpdate continues a multiple-part decryption and digesting operation.
|
[
"DecryptDigestUpdate",
"continues",
"a",
"multiple",
"-",
"part",
"decryption",
"and",
"digesting",
"operation",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1456-L1468
|
11,536 |
miekg/pkcs11
|
pkcs11.go
|
SignEncryptUpdate
|
func (c *Ctx) SignEncryptUpdate(sh SessionHandle, part []byte) ([]byte, error) {
var (
enc C.CK_BYTE_PTR
enclen C.CK_ULONG
)
e := C.SignEncryptUpdate(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(part), C.CK_ULONG(len(part)), &enc, &enclen)
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(enc), C.int(enclen))
C.free(unsafe.Pointer(enc))
return h, nil
}
|
go
|
func (c *Ctx) SignEncryptUpdate(sh SessionHandle, part []byte) ([]byte, error) {
var (
enc C.CK_BYTE_PTR
enclen C.CK_ULONG
)
e := C.SignEncryptUpdate(c.ctx, C.CK_SESSION_HANDLE(sh), cMessage(part), C.CK_ULONG(len(part)), &enc, &enclen)
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(enc), C.int(enclen))
C.free(unsafe.Pointer(enc))
return h, nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"SignEncryptUpdate",
"(",
"sh",
"SessionHandle",
",",
"part",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"(",
"enc",
"C",
".",
"CK_BYTE_PTR",
"\n",
"enclen",
"C",
".",
"CK_ULONG",
"\n",
")",
"\n",
"e",
":=",
"C",
".",
"SignEncryptUpdate",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"cMessage",
"(",
"part",
")",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"part",
")",
")",
",",
"&",
"enc",
",",
"&",
"enclen",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"h",
":=",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"enc",
")",
",",
"C",
".",
"int",
"(",
"enclen",
")",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"enc",
")",
")",
"\n",
"return",
"h",
",",
"nil",
"\n",
"}"
] |
// SignEncryptUpdate continues a multiple-part signing and encryption operation.
|
[
"SignEncryptUpdate",
"continues",
"a",
"multiple",
"-",
"part",
"signing",
"and",
"encryption",
"operation",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1471-L1483
|
11,537 |
miekg/pkcs11
|
pkcs11.go
|
DeriveKey
|
func (c *Ctx) DeriveKey(sh SessionHandle, m []*Mechanism, basekey ObjectHandle, a []*Attribute) (ObjectHandle, error) {
var key C.CK_OBJECT_HANDLE
attrarena, ac, aclen := cAttributeList(a)
defer attrarena.Free()
mecharena, mech := cMechanism(m)
defer mecharena.Free()
e := C.DeriveKey(c.ctx, C.CK_SESSION_HANDLE(sh), mech, C.CK_OBJECT_HANDLE(basekey), ac, aclen, &key)
return ObjectHandle(key), toError(e)
}
|
go
|
func (c *Ctx) DeriveKey(sh SessionHandle, m []*Mechanism, basekey ObjectHandle, a []*Attribute) (ObjectHandle, error) {
var key C.CK_OBJECT_HANDLE
attrarena, ac, aclen := cAttributeList(a)
defer attrarena.Free()
mecharena, mech := cMechanism(m)
defer mecharena.Free()
e := C.DeriveKey(c.ctx, C.CK_SESSION_HANDLE(sh), mech, C.CK_OBJECT_HANDLE(basekey), ac, aclen, &key)
return ObjectHandle(key), toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"DeriveKey",
"(",
"sh",
"SessionHandle",
",",
"m",
"[",
"]",
"*",
"Mechanism",
",",
"basekey",
"ObjectHandle",
",",
"a",
"[",
"]",
"*",
"Attribute",
")",
"(",
"ObjectHandle",
",",
"error",
")",
"{",
"var",
"key",
"C",
".",
"CK_OBJECT_HANDLE",
"\n",
"attrarena",
",",
"ac",
",",
"aclen",
":=",
"cAttributeList",
"(",
"a",
")",
"\n",
"defer",
"attrarena",
".",
"Free",
"(",
")",
"\n",
"mecharena",
",",
"mech",
":=",
"cMechanism",
"(",
"m",
")",
"\n",
"defer",
"mecharena",
".",
"Free",
"(",
")",
"\n",
"e",
":=",
"C",
".",
"DeriveKey",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"mech",
",",
"C",
".",
"CK_OBJECT_HANDLE",
"(",
"basekey",
")",
",",
"ac",
",",
"aclen",
",",
"&",
"key",
")",
"\n",
"return",
"ObjectHandle",
"(",
"key",
")",
",",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// DeriveKey derives a key from a base key, creating a new key object.
|
[
"DeriveKey",
"derives",
"a",
"key",
"from",
"a",
"base",
"key",
"creating",
"a",
"new",
"key",
"object",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1564-L1572
|
11,538 |
miekg/pkcs11
|
pkcs11.go
|
SeedRandom
|
func (c *Ctx) SeedRandom(sh SessionHandle, seed []byte) error {
e := C.SeedRandom(c.ctx, C.CK_SESSION_HANDLE(sh), C.CK_BYTE_PTR(unsafe.Pointer(&seed[0])), C.CK_ULONG(len(seed)))
return toError(e)
}
|
go
|
func (c *Ctx) SeedRandom(sh SessionHandle, seed []byte) error {
e := C.SeedRandom(c.ctx, C.CK_SESSION_HANDLE(sh), C.CK_BYTE_PTR(unsafe.Pointer(&seed[0])), C.CK_ULONG(len(seed)))
return toError(e)
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"SeedRandom",
"(",
"sh",
"SessionHandle",
",",
"seed",
"[",
"]",
"byte",
")",
"error",
"{",
"e",
":=",
"C",
".",
"SeedRandom",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"C",
".",
"CK_BYTE_PTR",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"seed",
"[",
"0",
"]",
")",
")",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"seed",
")",
")",
")",
"\n",
"return",
"toError",
"(",
"e",
")",
"\n",
"}"
] |
// SeedRandom mixes additional seed material into the token's
// random number generator.
|
[
"SeedRandom",
"mixes",
"additional",
"seed",
"material",
"into",
"the",
"token",
"s",
"random",
"number",
"generator",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1576-L1579
|
11,539 |
miekg/pkcs11
|
pkcs11.go
|
GenerateRandom
|
func (c *Ctx) GenerateRandom(sh SessionHandle, length int) ([]byte, error) {
var rand C.CK_BYTE_PTR
e := C.GenerateRandom(c.ctx, C.CK_SESSION_HANDLE(sh), &rand, C.CK_ULONG(length))
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(rand), C.int(length))
C.free(unsafe.Pointer(rand))
return h, nil
}
|
go
|
func (c *Ctx) GenerateRandom(sh SessionHandle, length int) ([]byte, error) {
var rand C.CK_BYTE_PTR
e := C.GenerateRandom(c.ctx, C.CK_SESSION_HANDLE(sh), &rand, C.CK_ULONG(length))
if toError(e) != nil {
return nil, toError(e)
}
h := C.GoBytes(unsafe.Pointer(rand), C.int(length))
C.free(unsafe.Pointer(rand))
return h, nil
}
|
[
"func",
"(",
"c",
"*",
"Ctx",
")",
"GenerateRandom",
"(",
"sh",
"SessionHandle",
",",
"length",
"int",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"rand",
"C",
".",
"CK_BYTE_PTR",
"\n",
"e",
":=",
"C",
".",
"GenerateRandom",
"(",
"c",
".",
"ctx",
",",
"C",
".",
"CK_SESSION_HANDLE",
"(",
"sh",
")",
",",
"&",
"rand",
",",
"C",
".",
"CK_ULONG",
"(",
"length",
")",
")",
"\n",
"if",
"toError",
"(",
"e",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"toError",
"(",
"e",
")",
"\n",
"}",
"\n",
"h",
":=",
"C",
".",
"GoBytes",
"(",
"unsafe",
".",
"Pointer",
"(",
"rand",
")",
",",
"C",
".",
"int",
"(",
"length",
")",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"rand",
")",
")",
"\n",
"return",
"h",
",",
"nil",
"\n",
"}"
] |
// GenerateRandom generates random data.
|
[
"GenerateRandom",
"generates",
"random",
"data",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/pkcs11.go#L1582-L1591
|
11,540 |
miekg/pkcs11
|
p11/slot.go
|
Info
|
func (s Slot) Info() (pkcs11.SlotInfo, error) {
return s.ctx.GetSlotInfo(s.id)
}
|
go
|
func (s Slot) Info() (pkcs11.SlotInfo, error) {
return s.ctx.GetSlotInfo(s.id)
}
|
[
"func",
"(",
"s",
"Slot",
")",
"Info",
"(",
")",
"(",
"pkcs11",
".",
"SlotInfo",
",",
"error",
")",
"{",
"return",
"s",
".",
"ctx",
".",
"GetSlotInfo",
"(",
"s",
".",
"id",
")",
"\n",
"}"
] |
// Info returns information about the Slot.
|
[
"Info",
"returns",
"information",
"about",
"the",
"Slot",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/p11/slot.go#L12-L14
|
11,541 |
miekg/pkcs11
|
p11/slot.go
|
TokenInfo
|
func (s Slot) TokenInfo() (pkcs11.TokenInfo, error) {
return s.ctx.GetTokenInfo(s.id)
}
|
go
|
func (s Slot) TokenInfo() (pkcs11.TokenInfo, error) {
return s.ctx.GetTokenInfo(s.id)
}
|
[
"func",
"(",
"s",
"Slot",
")",
"TokenInfo",
"(",
")",
"(",
"pkcs11",
".",
"TokenInfo",
",",
"error",
")",
"{",
"return",
"s",
".",
"ctx",
".",
"GetTokenInfo",
"(",
"s",
".",
"id",
")",
"\n",
"}"
] |
// TokenInfo returns information about the token in a Slot, if applicable.
|
[
"TokenInfo",
"returns",
"information",
"about",
"the",
"token",
"in",
"a",
"Slot",
"if",
"applicable",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/p11/slot.go#L17-L19
|
11,542 |
miekg/pkcs11
|
p11/slot.go
|
Mechanisms
|
func (s Slot) Mechanisms() ([]Mechanism, error) {
list, err := s.ctx.GetMechanismList(s.id)
if err != nil {
return nil, err
}
result := make([]Mechanism, len(list))
for i, mech := range list {
result[i] = Mechanism{
mechanism: mech,
slot: s,
}
}
return result, nil
}
|
go
|
func (s Slot) Mechanisms() ([]Mechanism, error) {
list, err := s.ctx.GetMechanismList(s.id)
if err != nil {
return nil, err
}
result := make([]Mechanism, len(list))
for i, mech := range list {
result[i] = Mechanism{
mechanism: mech,
slot: s,
}
}
return result, nil
}
|
[
"func",
"(",
"s",
"Slot",
")",
"Mechanisms",
"(",
")",
"(",
"[",
"]",
"Mechanism",
",",
"error",
")",
"{",
"list",
",",
"err",
":=",
"s",
".",
"ctx",
".",
"GetMechanismList",
"(",
"s",
".",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"result",
":=",
"make",
"(",
"[",
"]",
"Mechanism",
",",
"len",
"(",
"list",
")",
")",
"\n",
"for",
"i",
",",
"mech",
":=",
"range",
"list",
"{",
"result",
"[",
"i",
"]",
"=",
"Mechanism",
"{",
"mechanism",
":",
"mech",
",",
"slot",
":",
"s",
",",
"}",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] |
// Mechanisms returns a list of Mechanisms available on the token in this
// slot.
|
[
"Mechanisms",
"returns",
"a",
"list",
"of",
"Mechanisms",
"available",
"on",
"the",
"token",
"in",
"this",
"slot",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/p11/slot.go#L50-L63
|
11,543 |
miekg/pkcs11
|
p11/slot.go
|
Info
|
func (m *Mechanism) Info() (pkcs11.MechanismInfo, error) {
return m.slot.ctx.GetMechanismInfo(m.slot.id, []*pkcs11.Mechanism{m.mechanism})
}
|
go
|
func (m *Mechanism) Info() (pkcs11.MechanismInfo, error) {
return m.slot.ctx.GetMechanismInfo(m.slot.id, []*pkcs11.Mechanism{m.mechanism})
}
|
[
"func",
"(",
"m",
"*",
"Mechanism",
")",
"Info",
"(",
")",
"(",
"pkcs11",
".",
"MechanismInfo",
",",
"error",
")",
"{",
"return",
"m",
".",
"slot",
".",
"ctx",
".",
"GetMechanismInfo",
"(",
"m",
".",
"slot",
".",
"id",
",",
"[",
"]",
"*",
"pkcs11",
".",
"Mechanism",
"{",
"m",
".",
"mechanism",
"}",
")",
"\n",
"}"
] |
// Info returns information about this mechanism.
|
[
"Info",
"returns",
"information",
"about",
"this",
"mechanism",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/p11/slot.go#L92-L94
|
11,544 |
miekg/pkcs11
|
p11/crypto.go
|
Sign
|
func (priv PrivateKey) Sign(mechanism pkcs11.Mechanism, message []byte) ([]byte, error) {
s := priv.session
s.Lock()
defer s.Unlock()
err := s.ctx.SignInit(s.handle, []*pkcs11.Mechanism{&mechanism}, priv.objectHandle)
if err != nil {
return nil, err
}
out, err := s.ctx.Sign(s.handle, message)
if err != nil {
return nil, err
}
return out, nil
}
|
go
|
func (priv PrivateKey) Sign(mechanism pkcs11.Mechanism, message []byte) ([]byte, error) {
s := priv.session
s.Lock()
defer s.Unlock()
err := s.ctx.SignInit(s.handle, []*pkcs11.Mechanism{&mechanism}, priv.objectHandle)
if err != nil {
return nil, err
}
out, err := s.ctx.Sign(s.handle, message)
if err != nil {
return nil, err
}
return out, nil
}
|
[
"func",
"(",
"priv",
"PrivateKey",
")",
"Sign",
"(",
"mechanism",
"pkcs11",
".",
"Mechanism",
",",
"message",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"s",
":=",
"priv",
".",
"session",
"\n",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"err",
":=",
"s",
".",
"ctx",
".",
"SignInit",
"(",
"s",
".",
"handle",
",",
"[",
"]",
"*",
"pkcs11",
".",
"Mechanism",
"{",
"&",
"mechanism",
"}",
",",
"priv",
".",
"objectHandle",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"s",
".",
"ctx",
".",
"Sign",
"(",
"s",
".",
"handle",
",",
"message",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] |
// Sign signs the input with a given mechanism.
|
[
"Sign",
"signs",
"the",
"input",
"with",
"a",
"given",
"mechanism",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/p11/crypto.go#L34-L47
|
11,545 |
miekg/pkcs11
|
p11/crypto.go
|
Verify
|
func (pub PublicKey) Verify(mechanism pkcs11.Mechanism, message, signature []byte) error {
s := pub.session
s.Lock()
defer s.Unlock()
err := s.ctx.VerifyInit(s.handle, []*pkcs11.Mechanism{&mechanism}, pub.objectHandle)
if err != nil {
return err
}
err = s.ctx.Verify(s.handle, message, signature)
if err != nil {
return err
}
return nil
}
|
go
|
func (pub PublicKey) Verify(mechanism pkcs11.Mechanism, message, signature []byte) error {
s := pub.session
s.Lock()
defer s.Unlock()
err := s.ctx.VerifyInit(s.handle, []*pkcs11.Mechanism{&mechanism}, pub.objectHandle)
if err != nil {
return err
}
err = s.ctx.Verify(s.handle, message, signature)
if err != nil {
return err
}
return nil
}
|
[
"func",
"(",
"pub",
"PublicKey",
")",
"Verify",
"(",
"mechanism",
"pkcs11",
".",
"Mechanism",
",",
"message",
",",
"signature",
"[",
"]",
"byte",
")",
"error",
"{",
"s",
":=",
"pub",
".",
"session",
"\n",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"err",
":=",
"s",
".",
"ctx",
".",
"VerifyInit",
"(",
"s",
".",
"handle",
",",
"[",
"]",
"*",
"pkcs11",
".",
"Mechanism",
"{",
"&",
"mechanism",
"}",
",",
"pub",
".",
"objectHandle",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"ctx",
".",
"Verify",
"(",
"s",
".",
"handle",
",",
"message",
",",
"signature",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Verify verifies a signature over a message with a given mechanism.
|
[
"Verify",
"verifies",
"a",
"signature",
"over",
"a",
"message",
"with",
"a",
"given",
"mechanism",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/p11/crypto.go#L50-L63
|
11,546 |
miekg/pkcs11
|
p11/crypto.go
|
Encrypt
|
func (pub PublicKey) Encrypt(mechanism pkcs11.Mechanism, plaintext []byte) ([]byte, error) {
s := pub.session
s.Lock()
defer s.Unlock()
err := s.ctx.EncryptInit(s.handle, []*pkcs11.Mechanism{&mechanism}, pub.objectHandle)
if err != nil {
return nil, err
}
out, err := s.ctx.Encrypt(s.handle, plaintext)
if err != nil {
return nil, err
}
return out, nil
}
|
go
|
func (pub PublicKey) Encrypt(mechanism pkcs11.Mechanism, plaintext []byte) ([]byte, error) {
s := pub.session
s.Lock()
defer s.Unlock()
err := s.ctx.EncryptInit(s.handle, []*pkcs11.Mechanism{&mechanism}, pub.objectHandle)
if err != nil {
return nil, err
}
out, err := s.ctx.Encrypt(s.handle, plaintext)
if err != nil {
return nil, err
}
return out, nil
}
|
[
"func",
"(",
"pub",
"PublicKey",
")",
"Encrypt",
"(",
"mechanism",
"pkcs11",
".",
"Mechanism",
",",
"plaintext",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"s",
":=",
"pub",
".",
"session",
"\n",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"err",
":=",
"s",
".",
"ctx",
".",
"EncryptInit",
"(",
"s",
".",
"handle",
",",
"[",
"]",
"*",
"pkcs11",
".",
"Mechanism",
"{",
"&",
"mechanism",
"}",
",",
"pub",
".",
"objectHandle",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"s",
".",
"ctx",
".",
"Encrypt",
"(",
"s",
".",
"handle",
",",
"plaintext",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] |
// Encrypt encrypts a plaintext with a given mechanism.
|
[
"Encrypt",
"encrypts",
"a",
"plaintext",
"with",
"a",
"given",
"mechanism",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/p11/crypto.go#L66-L79
|
11,547 |
miekg/pkcs11
|
types.go
|
cBBool
|
func cBBool(x bool) C.CK_BBOOL {
if x {
return C.CK_BBOOL(C.CK_TRUE)
}
return C.CK_BBOOL(C.CK_FALSE)
}
|
go
|
func cBBool(x bool) C.CK_BBOOL {
if x {
return C.CK_BBOOL(C.CK_TRUE)
}
return C.CK_BBOOL(C.CK_FALSE)
}
|
[
"func",
"cBBool",
"(",
"x",
"bool",
")",
"C",
".",
"CK_BBOOL",
"{",
"if",
"x",
"{",
"return",
"C",
".",
"CK_BBOOL",
"(",
"C",
".",
"CK_TRUE",
")",
"\n",
"}",
"\n",
"return",
"C",
".",
"CK_BBOOL",
"(",
"C",
".",
"CK_FALSE",
")",
"\n",
"}"
] |
// cBBool converts a bool to a CK_BBOOL.
|
[
"cBBool",
"converts",
"a",
"bool",
"to",
"a",
"CK_BBOOL",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/types.go#L61-L66
|
11,548 |
miekg/pkcs11
|
types.go
|
NewAttribute
|
func NewAttribute(typ uint, x interface{}) *Attribute {
// This function nicely transforms *to* an attribute, but there is
// no corresponding function that transform back *from* an attribute,
// which in PKCS#11 is just an byte array.
a := new(Attribute)
a.Type = typ
if x == nil {
return a
}
switch v := x.(type) {
case bool:
if v {
a.Value = []byte{1}
} else {
a.Value = []byte{0}
}
case int:
a.Value = uintToBytes(uint64(v))
case uint:
a.Value = uintToBytes(uint64(v))
case string:
a.Value = []byte(v)
case []byte:
a.Value = v
case time.Time: // for CKA_DATE
a.Value = cDate(v)
default:
panic("pkcs11: unhandled attribute type")
}
return a
}
|
go
|
func NewAttribute(typ uint, x interface{}) *Attribute {
// This function nicely transforms *to* an attribute, but there is
// no corresponding function that transform back *from* an attribute,
// which in PKCS#11 is just an byte array.
a := new(Attribute)
a.Type = typ
if x == nil {
return a
}
switch v := x.(type) {
case bool:
if v {
a.Value = []byte{1}
} else {
a.Value = []byte{0}
}
case int:
a.Value = uintToBytes(uint64(v))
case uint:
a.Value = uintToBytes(uint64(v))
case string:
a.Value = []byte(v)
case []byte:
a.Value = v
case time.Time: // for CKA_DATE
a.Value = cDate(v)
default:
panic("pkcs11: unhandled attribute type")
}
return a
}
|
[
"func",
"NewAttribute",
"(",
"typ",
"uint",
",",
"x",
"interface",
"{",
"}",
")",
"*",
"Attribute",
"{",
"// This function nicely transforms *to* an attribute, but there is",
"// no corresponding function that transform back *from* an attribute,",
"// which in PKCS#11 is just an byte array.",
"a",
":=",
"new",
"(",
"Attribute",
")",
"\n",
"a",
".",
"Type",
"=",
"typ",
"\n",
"if",
"x",
"==",
"nil",
"{",
"return",
"a",
"\n",
"}",
"\n",
"switch",
"v",
":=",
"x",
".",
"(",
"type",
")",
"{",
"case",
"bool",
":",
"if",
"v",
"{",
"a",
".",
"Value",
"=",
"[",
"]",
"byte",
"{",
"1",
"}",
"\n",
"}",
"else",
"{",
"a",
".",
"Value",
"=",
"[",
"]",
"byte",
"{",
"0",
"}",
"\n",
"}",
"\n",
"case",
"int",
":",
"a",
".",
"Value",
"=",
"uintToBytes",
"(",
"uint64",
"(",
"v",
")",
")",
"\n",
"case",
"uint",
":",
"a",
".",
"Value",
"=",
"uintToBytes",
"(",
"uint64",
"(",
"v",
")",
")",
"\n",
"case",
"string",
":",
"a",
".",
"Value",
"=",
"[",
"]",
"byte",
"(",
"v",
")",
"\n",
"case",
"[",
"]",
"byte",
":",
"a",
".",
"Value",
"=",
"v",
"\n",
"case",
"time",
".",
"Time",
":",
"// for CKA_DATE",
"a",
".",
"Value",
"=",
"cDate",
"(",
"v",
")",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"a",
"\n",
"}"
] |
// NewAttribute allocates a Attribute and returns a pointer to it.
// Note that this is merely a convenience function, as values returned
// from the HSM are not converted back to Go values, those are just raw
// byte slices.
|
[
"NewAttribute",
"allocates",
"a",
"Attribute",
"and",
"returns",
"a",
"pointer",
"to",
"it",
".",
"Note",
"that",
"this",
"is",
"merely",
"a",
"convenience",
"function",
"as",
"values",
"returned",
"from",
"the",
"HSM",
"are",
"not",
"converted",
"back",
"to",
"Go",
"values",
"those",
"are",
"just",
"raw",
"byte",
"slices",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/types.go#L167-L197
|
11,549 |
miekg/pkcs11
|
types.go
|
cAttributeList
|
func cAttributeList(a []*Attribute) (arena, C.CK_ATTRIBUTE_PTR, C.CK_ULONG) {
var arena arena
if len(a) == 0 {
return nil, nil, 0
}
pa := make([]C.CK_ATTRIBUTE, len(a))
for i, attr := range a {
pa[i]._type = C.CK_ATTRIBUTE_TYPE(attr.Type)
if len(attr.Value) != 0 {
buf, len := arena.Allocate(attr.Value)
// field is unaligned on windows so this has to call into C
C.putAttributePval(&pa[i], buf)
pa[i].ulValueLen = len
}
}
return arena, &pa[0], C.CK_ULONG(len(a))
}
|
go
|
func cAttributeList(a []*Attribute) (arena, C.CK_ATTRIBUTE_PTR, C.CK_ULONG) {
var arena arena
if len(a) == 0 {
return nil, nil, 0
}
pa := make([]C.CK_ATTRIBUTE, len(a))
for i, attr := range a {
pa[i]._type = C.CK_ATTRIBUTE_TYPE(attr.Type)
if len(attr.Value) != 0 {
buf, len := arena.Allocate(attr.Value)
// field is unaligned on windows so this has to call into C
C.putAttributePval(&pa[i], buf)
pa[i].ulValueLen = len
}
}
return arena, &pa[0], C.CK_ULONG(len(a))
}
|
[
"func",
"cAttributeList",
"(",
"a",
"[",
"]",
"*",
"Attribute",
")",
"(",
"arena",
",",
"C",
".",
"CK_ATTRIBUTE_PTR",
",",
"C",
".",
"CK_ULONG",
")",
"{",
"var",
"arena",
"arena",
"\n",
"if",
"len",
"(",
"a",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"nil",
",",
"0",
"\n",
"}",
"\n",
"pa",
":=",
"make",
"(",
"[",
"]",
"C",
".",
"CK_ATTRIBUTE",
",",
"len",
"(",
"a",
")",
")",
"\n",
"for",
"i",
",",
"attr",
":=",
"range",
"a",
"{",
"pa",
"[",
"i",
"]",
".",
"_type",
"=",
"C",
".",
"CK_ATTRIBUTE_TYPE",
"(",
"attr",
".",
"Type",
")",
"\n",
"if",
"len",
"(",
"attr",
".",
"Value",
")",
"!=",
"0",
"{",
"buf",
",",
"len",
":=",
"arena",
".",
"Allocate",
"(",
"attr",
".",
"Value",
")",
"\n",
"// field is unaligned on windows so this has to call into C",
"C",
".",
"putAttributePval",
"(",
"&",
"pa",
"[",
"i",
"]",
",",
"buf",
")",
"\n",
"pa",
"[",
"i",
"]",
".",
"ulValueLen",
"=",
"len",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"arena",
",",
"&",
"pa",
"[",
"0",
"]",
",",
"C",
".",
"CK_ULONG",
"(",
"len",
"(",
"a",
")",
")",
"\n",
"}"
] |
// cAttribute returns the start address and the length of an attribute list.
|
[
"cAttribute",
"returns",
"the",
"start",
"address",
"and",
"the",
"length",
"of",
"an",
"attribute",
"list",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/types.go#L200-L216
|
11,550 |
miekg/pkcs11
|
types.go
|
NewMechanism
|
func NewMechanism(mech uint, x interface{}) *Mechanism {
m := new(Mechanism)
m.Mechanism = mech
if x == nil {
return m
}
switch p := x.(type) {
case *GCMParams, *OAEPParams, *ECDH1DeriveParams:
// contains pointers; defer serialization until cMechanism
m.generator = p
case []byte:
m.Parameter = p
default:
panic("parameter must be one of type: []byte, *GCMParams, *OAEPParams, *ECDH1DeriveParams")
}
return m
}
|
go
|
func NewMechanism(mech uint, x interface{}) *Mechanism {
m := new(Mechanism)
m.Mechanism = mech
if x == nil {
return m
}
switch p := x.(type) {
case *GCMParams, *OAEPParams, *ECDH1DeriveParams:
// contains pointers; defer serialization until cMechanism
m.generator = p
case []byte:
m.Parameter = p
default:
panic("parameter must be one of type: []byte, *GCMParams, *OAEPParams, *ECDH1DeriveParams")
}
return m
}
|
[
"func",
"NewMechanism",
"(",
"mech",
"uint",
",",
"x",
"interface",
"{",
"}",
")",
"*",
"Mechanism",
"{",
"m",
":=",
"new",
"(",
"Mechanism",
")",
"\n",
"m",
".",
"Mechanism",
"=",
"mech",
"\n",
"if",
"x",
"==",
"nil",
"{",
"return",
"m",
"\n",
"}",
"\n\n",
"switch",
"p",
":=",
"x",
".",
"(",
"type",
")",
"{",
"case",
"*",
"GCMParams",
",",
"*",
"OAEPParams",
",",
"*",
"ECDH1DeriveParams",
":",
"// contains pointers; defer serialization until cMechanism",
"m",
".",
"generator",
"=",
"p",
"\n",
"case",
"[",
"]",
"byte",
":",
"m",
".",
"Parameter",
"=",
"p",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"m",
"\n",
"}"
] |
// NewMechanism returns a pointer to an initialized Mechanism.
|
[
"NewMechanism",
"returns",
"a",
"pointer",
"to",
"an",
"initialized",
"Mechanism",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/types.go#L238-L256
|
11,551 |
miekg/pkcs11
|
p11/object.go
|
Label
|
func (o Object) Label() (string, error) {
labelBytes, err := o.Attribute(pkcs11.CKA_LABEL)
if err != nil {
return "", err
}
return string(labelBytes), nil
}
|
go
|
func (o Object) Label() (string, error) {
labelBytes, err := o.Attribute(pkcs11.CKA_LABEL)
if err != nil {
return "", err
}
return string(labelBytes), nil
}
|
[
"func",
"(",
"o",
"Object",
")",
"Label",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"labelBytes",
",",
"err",
":=",
"o",
".",
"Attribute",
"(",
"pkcs11",
".",
"CKA_LABEL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"string",
"(",
"labelBytes",
")",
",",
"nil",
"\n",
"}"
] |
// Label returns the label of an object.
|
[
"Label",
"returns",
"the",
"label",
"of",
"an",
"object",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/p11/object.go#L19-L25
|
11,552 |
miekg/pkcs11
|
p11/object.go
|
Set
|
func (o Object) Set(attributeType uint, value []byte) error {
o.session.Lock()
defer o.session.Unlock()
err := o.session.ctx.SetAttributeValue(o.session.handle, o.objectHandle,
[]*pkcs11.Attribute{pkcs11.NewAttribute(attributeType, value)})
if err != nil {
return err
}
return nil
}
|
go
|
func (o Object) Set(attributeType uint, value []byte) error {
o.session.Lock()
defer o.session.Unlock()
err := o.session.ctx.SetAttributeValue(o.session.handle, o.objectHandle,
[]*pkcs11.Attribute{pkcs11.NewAttribute(attributeType, value)})
if err != nil {
return err
}
return nil
}
|
[
"func",
"(",
"o",
"Object",
")",
"Set",
"(",
"attributeType",
"uint",
",",
"value",
"[",
"]",
"byte",
")",
"error",
"{",
"o",
".",
"session",
".",
"Lock",
"(",
")",
"\n",
"defer",
"o",
".",
"session",
".",
"Unlock",
"(",
")",
"\n\n",
"err",
":=",
"o",
".",
"session",
".",
"ctx",
".",
"SetAttributeValue",
"(",
"o",
".",
"session",
".",
"handle",
",",
"o",
".",
"objectHandle",
",",
"[",
"]",
"*",
"pkcs11",
".",
"Attribute",
"{",
"pkcs11",
".",
"NewAttribute",
"(",
"attributeType",
",",
"value",
")",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Set sets exactly one attribute on this object.
|
[
"Set",
"sets",
"exactly",
"one",
"attribute",
"on",
"this",
"object",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/p11/object.go#L62-L72
|
11,553 |
miekg/pkcs11
|
p11/object.go
|
Copy
|
func (o Object) Copy(template []*pkcs11.Attribute) (Object, error) {
s := o.session
s.Lock()
defer s.Unlock()
newHandle, err := s.ctx.CopyObject(s.handle, o.objectHandle, template)
if err != nil {
return Object{}, err
}
return Object{
session: s,
objectHandle: newHandle,
}, nil
}
|
go
|
func (o Object) Copy(template []*pkcs11.Attribute) (Object, error) {
s := o.session
s.Lock()
defer s.Unlock()
newHandle, err := s.ctx.CopyObject(s.handle, o.objectHandle, template)
if err != nil {
return Object{}, err
}
return Object{
session: s,
objectHandle: newHandle,
}, nil
}
|
[
"func",
"(",
"o",
"Object",
")",
"Copy",
"(",
"template",
"[",
"]",
"*",
"pkcs11",
".",
"Attribute",
")",
"(",
"Object",
",",
"error",
")",
"{",
"s",
":=",
"o",
".",
"session",
"\n",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"newHandle",
",",
"err",
":=",
"s",
".",
"ctx",
".",
"CopyObject",
"(",
"s",
".",
"handle",
",",
"o",
".",
"objectHandle",
",",
"template",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Object",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"Object",
"{",
"session",
":",
"s",
",",
"objectHandle",
":",
"newHandle",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Copy makes a copy of this object, with the attributes in template applied on
// top of it, if possible.
|
[
"Copy",
"makes",
"a",
"copy",
"of",
"this",
"object",
"with",
"the",
"attributes",
"in",
"template",
"applied",
"on",
"top",
"of",
"it",
"if",
"possible",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/p11/object.go#L76-L88
|
11,554 |
miekg/pkcs11
|
p11/object.go
|
Destroy
|
func (o Object) Destroy() error {
s := o.session
s.Lock()
defer s.Unlock()
return s.ctx.DestroyObject(s.handle, o.objectHandle)
}
|
go
|
func (o Object) Destroy() error {
s := o.session
s.Lock()
defer s.Unlock()
return s.ctx.DestroyObject(s.handle, o.objectHandle)
}
|
[
"func",
"(",
"o",
"Object",
")",
"Destroy",
"(",
")",
"error",
"{",
"s",
":=",
"o",
".",
"session",
"\n",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"return",
"s",
".",
"ctx",
".",
"DestroyObject",
"(",
"s",
".",
"handle",
",",
"o",
".",
"objectHandle",
")",
"\n",
"}"
] |
// Destroy destroys this object.
|
[
"Destroy",
"destroys",
"this",
"object",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/p11/object.go#L91-L96
|
11,555 |
miekg/pkcs11
|
p11/module.go
|
Slots
|
func (m Module) Slots() ([]Slot, error) {
ids, err := m.ctx.GetSlotList(true)
if err != nil {
return nil, err
}
result := make([]Slot, len(ids))
for i, id := range ids {
result[i] = Slot{
ctx: m.ctx,
id: id,
}
}
return result, nil
}
|
go
|
func (m Module) Slots() ([]Slot, error) {
ids, err := m.ctx.GetSlotList(true)
if err != nil {
return nil, err
}
result := make([]Slot, len(ids))
for i, id := range ids {
result[i] = Slot{
ctx: m.ctx,
id: id,
}
}
return result, nil
}
|
[
"func",
"(",
"m",
"Module",
")",
"Slots",
"(",
")",
"(",
"[",
"]",
"Slot",
",",
"error",
")",
"{",
"ids",
",",
"err",
":=",
"m",
".",
"ctx",
".",
"GetSlotList",
"(",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"result",
":=",
"make",
"(",
"[",
"]",
"Slot",
",",
"len",
"(",
"ids",
")",
")",
"\n",
"for",
"i",
",",
"id",
":=",
"range",
"ids",
"{",
"result",
"[",
"i",
"]",
"=",
"Slot",
"{",
"ctx",
":",
"m",
".",
"ctx",
",",
"id",
":",
"id",
",",
"}",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] |
// Slots returns all available Slots that have a token present.
|
[
"Slots",
"returns",
"all",
"available",
"Slots",
"that",
"have",
"a",
"token",
"present",
"."
] |
a667d056470f6e0da7facaff2466f0d2645e35d7
|
https://github.com/miekg/pkcs11/blob/a667d056470f6e0da7facaff2466f0d2645e35d7/p11/module.go#L112-L125
|
11,556 |
jacobsa/fuse
|
fuseutil/dirent.go
|
WriteDirent
|
func WriteDirent(buf []byte, d Dirent) (n int) {
// We want to write bytes with the layout of fuse_dirent
// (http://goo.gl/BmFxob) in host order. The struct must be aligned according
// to FUSE_DIRENT_ALIGN (http://goo.gl/UziWvH), which dictates 8-byte
// alignment.
type fuse_dirent struct {
ino uint64
off uint64
namelen uint32
type_ uint32
name [0]byte
}
const direntAlignment = 8
const direntSize = 8 + 8 + 4 + 4
// Compute the number of bytes of padding we'll need to maintain alignment
// for the next entry.
var padLen int
if len(d.Name)%direntAlignment != 0 {
padLen = direntAlignment - (len(d.Name) % direntAlignment)
}
// Do we have enough room?
totalLen := direntSize + len(d.Name) + padLen
if totalLen > len(buf) {
return
}
// Write the header.
de := fuse_dirent{
ino: uint64(d.Inode),
off: uint64(d.Offset),
namelen: uint32(len(d.Name)),
type_: uint32(d.Type),
}
n += copy(buf[n:], (*[direntSize]byte)(unsafe.Pointer(&de))[:])
// Write the name afterward.
n += copy(buf[n:], d.Name)
// Add any necessary padding.
if padLen != 0 {
var padding [direntAlignment]byte
n += copy(buf[n:], padding[:padLen])
}
return
}
|
go
|
func WriteDirent(buf []byte, d Dirent) (n int) {
// We want to write bytes with the layout of fuse_dirent
// (http://goo.gl/BmFxob) in host order. The struct must be aligned according
// to FUSE_DIRENT_ALIGN (http://goo.gl/UziWvH), which dictates 8-byte
// alignment.
type fuse_dirent struct {
ino uint64
off uint64
namelen uint32
type_ uint32
name [0]byte
}
const direntAlignment = 8
const direntSize = 8 + 8 + 4 + 4
// Compute the number of bytes of padding we'll need to maintain alignment
// for the next entry.
var padLen int
if len(d.Name)%direntAlignment != 0 {
padLen = direntAlignment - (len(d.Name) % direntAlignment)
}
// Do we have enough room?
totalLen := direntSize + len(d.Name) + padLen
if totalLen > len(buf) {
return
}
// Write the header.
de := fuse_dirent{
ino: uint64(d.Inode),
off: uint64(d.Offset),
namelen: uint32(len(d.Name)),
type_: uint32(d.Type),
}
n += copy(buf[n:], (*[direntSize]byte)(unsafe.Pointer(&de))[:])
// Write the name afterward.
n += copy(buf[n:], d.Name)
// Add any necessary padding.
if padLen != 0 {
var padding [direntAlignment]byte
n += copy(buf[n:], padding[:padLen])
}
return
}
|
[
"func",
"WriteDirent",
"(",
"buf",
"[",
"]",
"byte",
",",
"d",
"Dirent",
")",
"(",
"n",
"int",
")",
"{",
"// We want to write bytes with the layout of fuse_dirent",
"// (http://goo.gl/BmFxob) in host order. The struct must be aligned according",
"// to FUSE_DIRENT_ALIGN (http://goo.gl/UziWvH), which dictates 8-byte",
"// alignment.",
"type",
"fuse_dirent",
"struct",
"{",
"ino",
"uint64",
"\n",
"off",
"uint64",
"\n",
"namelen",
"uint32",
"\n",
"type_",
"uint32",
"\n",
"name",
"[",
"0",
"]",
"byte",
"\n",
"}",
"\n\n",
"const",
"direntAlignment",
"=",
"8",
"\n",
"const",
"direntSize",
"=",
"8",
"+",
"8",
"+",
"4",
"+",
"4",
"\n\n",
"// Compute the number of bytes of padding we'll need to maintain alignment",
"// for the next entry.",
"var",
"padLen",
"int",
"\n",
"if",
"len",
"(",
"d",
".",
"Name",
")",
"%",
"direntAlignment",
"!=",
"0",
"{",
"padLen",
"=",
"direntAlignment",
"-",
"(",
"len",
"(",
"d",
".",
"Name",
")",
"%",
"direntAlignment",
")",
"\n",
"}",
"\n\n",
"// Do we have enough room?",
"totalLen",
":=",
"direntSize",
"+",
"len",
"(",
"d",
".",
"Name",
")",
"+",
"padLen",
"\n",
"if",
"totalLen",
">",
"len",
"(",
"buf",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"// Write the header.",
"de",
":=",
"fuse_dirent",
"{",
"ino",
":",
"uint64",
"(",
"d",
".",
"Inode",
")",
",",
"off",
":",
"uint64",
"(",
"d",
".",
"Offset",
")",
",",
"namelen",
":",
"uint32",
"(",
"len",
"(",
"d",
".",
"Name",
")",
")",
",",
"type_",
":",
"uint32",
"(",
"d",
".",
"Type",
")",
",",
"}",
"\n\n",
"n",
"+=",
"copy",
"(",
"buf",
"[",
"n",
":",
"]",
",",
"(",
"*",
"[",
"direntSize",
"]",
"byte",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"de",
")",
")",
"[",
":",
"]",
")",
"\n\n",
"// Write the name afterward.",
"n",
"+=",
"copy",
"(",
"buf",
"[",
"n",
":",
"]",
",",
"d",
".",
"Name",
")",
"\n\n",
"// Add any necessary padding.",
"if",
"padLen",
"!=",
"0",
"{",
"var",
"padding",
"[",
"direntAlignment",
"]",
"byte",
"\n",
"n",
"+=",
"copy",
"(",
"buf",
"[",
"n",
":",
"]",
",",
"padding",
"[",
":",
"padLen",
"]",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Write the supplied directory entry intto the given buffer in the format
// expected in fuseops.ReadFileOp.Data, returning the number of bytes written.
// Return zero if the entry would not fit.
|
[
"Write",
"the",
"supplied",
"directory",
"entry",
"intto",
"the",
"given",
"buffer",
"in",
"the",
"format",
"expected",
"in",
"fuseops",
".",
"ReadFileOp",
".",
"Data",
"returning",
"the",
"number",
"of",
"bytes",
"written",
".",
"Return",
"zero",
"if",
"the",
"entry",
"would",
"not",
"fit",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/fuseutil/dirent.go#L56-L105
|
11,557 |
jacobsa/fuse
|
conversions.go
|
convertExpirationTime
|
func convertExpirationTime(t time.Time) (secs uint64, nsecs uint32) {
// Fuse represents durations as unsigned 64-bit counts of seconds and 32-bit
// counts of nanoseconds (cf. http://goo.gl/EJupJV). So negative durations
// are right out. There is no need to cap the positive magnitude, because
// 2^64 seconds is well longer than the 2^63 ns range of time.Duration.
d := t.Sub(time.Now())
if d > 0 {
secs = uint64(d / time.Second)
nsecs = uint32((d % time.Second) / time.Nanosecond)
}
return
}
|
go
|
func convertExpirationTime(t time.Time) (secs uint64, nsecs uint32) {
// Fuse represents durations as unsigned 64-bit counts of seconds and 32-bit
// counts of nanoseconds (cf. http://goo.gl/EJupJV). So negative durations
// are right out. There is no need to cap the positive magnitude, because
// 2^64 seconds is well longer than the 2^63 ns range of time.Duration.
d := t.Sub(time.Now())
if d > 0 {
secs = uint64(d / time.Second)
nsecs = uint32((d % time.Second) / time.Nanosecond)
}
return
}
|
[
"func",
"convertExpirationTime",
"(",
"t",
"time",
".",
"Time",
")",
"(",
"secs",
"uint64",
",",
"nsecs",
"uint32",
")",
"{",
"// Fuse represents durations as unsigned 64-bit counts of seconds and 32-bit",
"// counts of nanoseconds (cf. http://goo.gl/EJupJV). So negative durations",
"// are right out. There is no need to cap the positive magnitude, because",
"// 2^64 seconds is well longer than the 2^63 ns range of time.Duration.",
"d",
":=",
"t",
".",
"Sub",
"(",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"if",
"d",
">",
"0",
"{",
"secs",
"=",
"uint64",
"(",
"d",
"/",
"time",
".",
"Second",
")",
"\n",
"nsecs",
"=",
"uint32",
"(",
"(",
"d",
"%",
"time",
".",
"Second",
")",
"/",
"time",
".",
"Nanosecond",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Convert an absolute cache expiration time to a relative time from now for
// consumption by the fuse kernel module.
|
[
"Convert",
"an",
"absolute",
"cache",
"expiration",
"time",
"to",
"a",
"relative",
"time",
"from",
"now",
"for",
"consumption",
"by",
"the",
"fuse",
"kernel",
"module",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/conversions.go#L863-L875
|
11,558 |
jacobsa/fuse
|
samples/memfs/inode.go
|
SetAttributes
|
func (in *inode) SetAttributes(
size *uint64,
mode *os.FileMode,
mtime *time.Time) {
// Update the modification time.
in.attrs.Mtime = time.Now()
// Truncate?
if size != nil {
intSize := int(*size)
// Update contents.
if intSize <= len(in.contents) {
in.contents = in.contents[:intSize]
} else {
padding := make([]byte, intSize-len(in.contents))
in.contents = append(in.contents, padding...)
}
// Update attributes.
in.attrs.Size = *size
}
// Change mode?
if mode != nil {
in.attrs.Mode = *mode
}
// Change mtime?
if mtime != nil {
in.attrs.Mtime = *mtime
}
}
|
go
|
func (in *inode) SetAttributes(
size *uint64,
mode *os.FileMode,
mtime *time.Time) {
// Update the modification time.
in.attrs.Mtime = time.Now()
// Truncate?
if size != nil {
intSize := int(*size)
// Update contents.
if intSize <= len(in.contents) {
in.contents = in.contents[:intSize]
} else {
padding := make([]byte, intSize-len(in.contents))
in.contents = append(in.contents, padding...)
}
// Update attributes.
in.attrs.Size = *size
}
// Change mode?
if mode != nil {
in.attrs.Mode = *mode
}
// Change mtime?
if mtime != nil {
in.attrs.Mtime = *mtime
}
}
|
[
"func",
"(",
"in",
"*",
"inode",
")",
"SetAttributes",
"(",
"size",
"*",
"uint64",
",",
"mode",
"*",
"os",
".",
"FileMode",
",",
"mtime",
"*",
"time",
".",
"Time",
")",
"{",
"// Update the modification time.",
"in",
".",
"attrs",
".",
"Mtime",
"=",
"time",
".",
"Now",
"(",
")",
"\n\n",
"// Truncate?",
"if",
"size",
"!=",
"nil",
"{",
"intSize",
":=",
"int",
"(",
"*",
"size",
")",
"\n\n",
"// Update contents.",
"if",
"intSize",
"<=",
"len",
"(",
"in",
".",
"contents",
")",
"{",
"in",
".",
"contents",
"=",
"in",
".",
"contents",
"[",
":",
"intSize",
"]",
"\n",
"}",
"else",
"{",
"padding",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"intSize",
"-",
"len",
"(",
"in",
".",
"contents",
")",
")",
"\n",
"in",
".",
"contents",
"=",
"append",
"(",
"in",
".",
"contents",
",",
"padding",
"...",
")",
"\n",
"}",
"\n\n",
"// Update attributes.",
"in",
".",
"attrs",
".",
"Size",
"=",
"*",
"size",
"\n",
"}",
"\n\n",
"// Change mode?",
"if",
"mode",
"!=",
"nil",
"{",
"in",
".",
"attrs",
".",
"Mode",
"=",
"*",
"mode",
"\n",
"}",
"\n\n",
"// Change mtime?",
"if",
"mtime",
"!=",
"nil",
"{",
"in",
".",
"attrs",
".",
"Mtime",
"=",
"*",
"mtime",
"\n",
"}",
"\n",
"}"
] |
// Update attributes from non-nil parameters.
|
[
"Update",
"attributes",
"from",
"non",
"-",
"nil",
"parameters",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/samples/memfs/inode.go#L352-L384
|
11,559 |
jacobsa/fuse
|
connection.go
|
Init
|
func (c *Connection) Init() (err error) {
// Read the init op.
ctx, op, err := c.ReadOp()
if err != nil {
err = fmt.Errorf("Reading init op: %v", err)
return
}
initOp, ok := op.(*initOp)
if !ok {
c.Reply(ctx, syscall.EPROTO)
err = fmt.Errorf("Expected *initOp, got %T", op)
return
}
// Make sure the protocol version spoken by the kernel is new enough.
min := fusekernel.Protocol{
fusekernel.ProtoVersionMinMajor,
fusekernel.ProtoVersionMinMinor,
}
if initOp.Kernel.LT(min) {
c.Reply(ctx, syscall.EPROTO)
err = fmt.Errorf("Version too old: %v", initOp.Kernel)
return
}
// Downgrade our protocol if necessary.
c.protocol = fusekernel.Protocol{
fusekernel.ProtoVersionMaxMajor,
fusekernel.ProtoVersionMaxMinor,
}
if initOp.Kernel.LT(c.protocol) {
c.protocol = initOp.Kernel
}
// Respond to the init op.
initOp.Library = c.protocol
initOp.MaxReadahead = maxReadahead
initOp.MaxWrite = buffer.MaxWriteSize
initOp.Flags = 0
// Tell the kernel not to use pitifully small 4 KiB writes.
initOp.Flags |= fusekernel.InitBigWrites
// Enable writeback caching if the user hasn't asked us not to.
if !c.cfg.DisableWritebackCaching {
initOp.Flags |= fusekernel.InitWritebackCache
}
c.Reply(ctx, nil)
return
}
|
go
|
func (c *Connection) Init() (err error) {
// Read the init op.
ctx, op, err := c.ReadOp()
if err != nil {
err = fmt.Errorf("Reading init op: %v", err)
return
}
initOp, ok := op.(*initOp)
if !ok {
c.Reply(ctx, syscall.EPROTO)
err = fmt.Errorf("Expected *initOp, got %T", op)
return
}
// Make sure the protocol version spoken by the kernel is new enough.
min := fusekernel.Protocol{
fusekernel.ProtoVersionMinMajor,
fusekernel.ProtoVersionMinMinor,
}
if initOp.Kernel.LT(min) {
c.Reply(ctx, syscall.EPROTO)
err = fmt.Errorf("Version too old: %v", initOp.Kernel)
return
}
// Downgrade our protocol if necessary.
c.protocol = fusekernel.Protocol{
fusekernel.ProtoVersionMaxMajor,
fusekernel.ProtoVersionMaxMinor,
}
if initOp.Kernel.LT(c.protocol) {
c.protocol = initOp.Kernel
}
// Respond to the init op.
initOp.Library = c.protocol
initOp.MaxReadahead = maxReadahead
initOp.MaxWrite = buffer.MaxWriteSize
initOp.Flags = 0
// Tell the kernel not to use pitifully small 4 KiB writes.
initOp.Flags |= fusekernel.InitBigWrites
// Enable writeback caching if the user hasn't asked us not to.
if !c.cfg.DisableWritebackCaching {
initOp.Flags |= fusekernel.InitWritebackCache
}
c.Reply(ctx, nil)
return
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"Init",
"(",
")",
"(",
"err",
"error",
")",
"{",
"// Read the init op.",
"ctx",
",",
"op",
",",
"err",
":=",
"c",
".",
"ReadOp",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"initOp",
",",
"ok",
":=",
"op",
".",
"(",
"*",
"initOp",
")",
"\n",
"if",
"!",
"ok",
"{",
"c",
".",
"Reply",
"(",
"ctx",
",",
"syscall",
".",
"EPROTO",
")",
"\n",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"op",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Make sure the protocol version spoken by the kernel is new enough.",
"min",
":=",
"fusekernel",
".",
"Protocol",
"{",
"fusekernel",
".",
"ProtoVersionMinMajor",
",",
"fusekernel",
".",
"ProtoVersionMinMinor",
",",
"}",
"\n\n",
"if",
"initOp",
".",
"Kernel",
".",
"LT",
"(",
"min",
")",
"{",
"c",
".",
"Reply",
"(",
"ctx",
",",
"syscall",
".",
"EPROTO",
")",
"\n",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"initOp",
".",
"Kernel",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Downgrade our protocol if necessary.",
"c",
".",
"protocol",
"=",
"fusekernel",
".",
"Protocol",
"{",
"fusekernel",
".",
"ProtoVersionMaxMajor",
",",
"fusekernel",
".",
"ProtoVersionMaxMinor",
",",
"}",
"\n\n",
"if",
"initOp",
".",
"Kernel",
".",
"LT",
"(",
"c",
".",
"protocol",
")",
"{",
"c",
".",
"protocol",
"=",
"initOp",
".",
"Kernel",
"\n",
"}",
"\n\n",
"// Respond to the init op.",
"initOp",
".",
"Library",
"=",
"c",
".",
"protocol",
"\n",
"initOp",
".",
"MaxReadahead",
"=",
"maxReadahead",
"\n",
"initOp",
".",
"MaxWrite",
"=",
"buffer",
".",
"MaxWriteSize",
"\n\n",
"initOp",
".",
"Flags",
"=",
"0",
"\n\n",
"// Tell the kernel not to use pitifully small 4 KiB writes.",
"initOp",
".",
"Flags",
"|=",
"fusekernel",
".",
"InitBigWrites",
"\n\n",
"// Enable writeback caching if the user hasn't asked us not to.",
"if",
"!",
"c",
".",
"cfg",
".",
"DisableWritebackCaching",
"{",
"initOp",
".",
"Flags",
"|=",
"fusekernel",
".",
"InitWritebackCache",
"\n",
"}",
"\n\n",
"c",
".",
"Reply",
"(",
"ctx",
",",
"nil",
")",
"\n",
"return",
"\n",
"}"
] |
// Init performs the work necessary to cause the mount process to complete.
|
[
"Init",
"performs",
"the",
"work",
"necessary",
"to",
"cause",
"the",
"mount",
"process",
"to",
"complete",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/connection.go#L119-L173
|
11,560 |
jacobsa/fuse
|
connection.go
|
readMessage
|
func (c *Connection) readMessage() (m *buffer.InMessage, err error) {
// Allocate a message.
m = c.getInMessage()
// Loop past transient errors.
for {
// Attempt a reaed.
err = m.Init(c.dev)
// Special cases:
//
// * ENODEV means fuse has hung up.
//
// * EINTR means we should try again. (This seems to happen often on
// OS X, cf. http://golang.org/issue/11180)
//
if pe, ok := err.(*os.PathError); ok {
switch pe.Err {
case syscall.ENODEV:
err = io.EOF
case syscall.EINTR:
err = nil
continue
}
}
if err != nil {
c.putInMessage(m)
m = nil
return
}
return
}
}
|
go
|
func (c *Connection) readMessage() (m *buffer.InMessage, err error) {
// Allocate a message.
m = c.getInMessage()
// Loop past transient errors.
for {
// Attempt a reaed.
err = m.Init(c.dev)
// Special cases:
//
// * ENODEV means fuse has hung up.
//
// * EINTR means we should try again. (This seems to happen often on
// OS X, cf. http://golang.org/issue/11180)
//
if pe, ok := err.(*os.PathError); ok {
switch pe.Err {
case syscall.ENODEV:
err = io.EOF
case syscall.EINTR:
err = nil
continue
}
}
if err != nil {
c.putInMessage(m)
m = nil
return
}
return
}
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"readMessage",
"(",
")",
"(",
"m",
"*",
"buffer",
".",
"InMessage",
",",
"err",
"error",
")",
"{",
"// Allocate a message.",
"m",
"=",
"c",
".",
"getInMessage",
"(",
")",
"\n\n",
"// Loop past transient errors.",
"for",
"{",
"// Attempt a reaed.",
"err",
"=",
"m",
".",
"Init",
"(",
"c",
".",
"dev",
")",
"\n\n",
"// Special cases:",
"//",
"// * ENODEV means fuse has hung up.",
"//",
"// * EINTR means we should try again. (This seems to happen often on",
"// OS X, cf. http://golang.org/issue/11180)",
"//",
"if",
"pe",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"os",
".",
"PathError",
")",
";",
"ok",
"{",
"switch",
"pe",
".",
"Err",
"{",
"case",
"syscall",
".",
"ENODEV",
":",
"err",
"=",
"io",
".",
"EOF",
"\n\n",
"case",
"syscall",
".",
"EINTR",
":",
"err",
"=",
"nil",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"putInMessage",
"(",
"m",
")",
"\n",
"m",
"=",
"nil",
"\n",
"return",
"\n",
"}",
"\n\n",
"return",
"\n",
"}",
"\n",
"}"
] |
// Read the next message from the kernel. The message must later be destroyed
// using destroyInMessage.
|
[
"Read",
"the",
"next",
"message",
"from",
"the",
"kernel",
".",
"The",
"message",
"must",
"later",
"be",
"destroyed",
"using",
"destroyInMessage",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/connection.go#L310-L345
|
11,561 |
jacobsa/fuse
|
connection.go
|
writeMessage
|
func (c *Connection) writeMessage(msg []byte) (err error) {
// Avoid the retry loop in os.File.Write.
n, err := syscall.Write(int(c.dev.Fd()), msg)
if err != nil {
return
}
if n != len(msg) {
err = fmt.Errorf("Wrote %d bytes; expected %d", n, len(msg))
return
}
return
}
|
go
|
func (c *Connection) writeMessage(msg []byte) (err error) {
// Avoid the retry loop in os.File.Write.
n, err := syscall.Write(int(c.dev.Fd()), msg)
if err != nil {
return
}
if n != len(msg) {
err = fmt.Errorf("Wrote %d bytes; expected %d", n, len(msg))
return
}
return
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"writeMessage",
"(",
"msg",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"// Avoid the retry loop in os.File.Write.",
"n",
",",
"err",
":=",
"syscall",
".",
"Write",
"(",
"int",
"(",
"c",
".",
"dev",
".",
"Fd",
"(",
")",
")",
",",
"msg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"n",
"!=",
"len",
"(",
"msg",
")",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"n",
",",
"len",
"(",
"msg",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Write the supplied message to the kernel.
|
[
"Write",
"the",
"supplied",
"message",
"to",
"the",
"kernel",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/connection.go#L348-L361
|
11,562 |
jacobsa/fuse
|
connection.go
|
shouldLogError
|
func (c *Connection) shouldLogError(
op interface{},
err error) bool {
// We don't log non-errors.
if err == nil {
return false
}
// We can't log if there's nothing to log to.
if c.errorLogger == nil {
return false
}
switch op.(type) {
case *fuseops.LookUpInodeOp:
// It is totally normal for the kernel to ask to look up an inode by name
// and find the name doesn't exist. For example, this happens when linking
// a new file.
if err == syscall.ENOENT {
return false
}
case *fuseops.GetXattrOp:
if err == syscall.ENODATA || err == syscall.ERANGE {
return false
}
case *unknownOp:
// Don't bother the user with methods we intentionally don't support.
if err == syscall.ENOSYS {
return false
}
}
return true
}
|
go
|
func (c *Connection) shouldLogError(
op interface{},
err error) bool {
// We don't log non-errors.
if err == nil {
return false
}
// We can't log if there's nothing to log to.
if c.errorLogger == nil {
return false
}
switch op.(type) {
case *fuseops.LookUpInodeOp:
// It is totally normal for the kernel to ask to look up an inode by name
// and find the name doesn't exist. For example, this happens when linking
// a new file.
if err == syscall.ENOENT {
return false
}
case *fuseops.GetXattrOp:
if err == syscall.ENODATA || err == syscall.ERANGE {
return false
}
case *unknownOp:
// Don't bother the user with methods we intentionally don't support.
if err == syscall.ENOSYS {
return false
}
}
return true
}
|
[
"func",
"(",
"c",
"*",
"Connection",
")",
"shouldLogError",
"(",
"op",
"interface",
"{",
"}",
",",
"err",
"error",
")",
"bool",
"{",
"// We don't log non-errors.",
"if",
"err",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"// We can't log if there's nothing to log to.",
"if",
"c",
".",
"errorLogger",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"switch",
"op",
".",
"(",
"type",
")",
"{",
"case",
"*",
"fuseops",
".",
"LookUpInodeOp",
":",
"// It is totally normal for the kernel to ask to look up an inode by name",
"// and find the name doesn't exist. For example, this happens when linking",
"// a new file.",
"if",
"err",
"==",
"syscall",
".",
"ENOENT",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"case",
"*",
"fuseops",
".",
"GetXattrOp",
":",
"if",
"err",
"==",
"syscall",
".",
"ENODATA",
"||",
"err",
"==",
"syscall",
".",
"ERANGE",
"{",
"return",
"false",
"\n",
"}",
"\n",
"case",
"*",
"unknownOp",
":",
"// Don't bother the user with methods we intentionally don't support.",
"if",
"err",
"==",
"syscall",
".",
"ENOSYS",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// Skip errors that happen as a matter of course, since they spook users.
|
[
"Skip",
"errors",
"that",
"happen",
"as",
"a",
"matter",
"of",
"course",
"since",
"they",
"spook",
"users",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/connection.go#L414-L448
|
11,563 |
jacobsa/fuse
|
internal/buffer/out_message.go
|
init
|
func init() {
a := unsafe.Offsetof(OutMessage{}.header) + uintptr(OutMessageHeaderSize)
b := unsafe.Offsetof(OutMessage{}.payload)
if a != b {
log.Panicf(
"header ends at offset %d, but payload starts at offset %d",
a, b)
}
}
|
go
|
func init() {
a := unsafe.Offsetof(OutMessage{}.header) + uintptr(OutMessageHeaderSize)
b := unsafe.Offsetof(OutMessage{}.payload)
if a != b {
log.Panicf(
"header ends at offset %d, but payload starts at offset %d",
a, b)
}
}
|
[
"func",
"init",
"(",
")",
"{",
"a",
":=",
"unsafe",
".",
"Offsetof",
"(",
"OutMessage",
"{",
"}",
".",
"header",
")",
"+",
"uintptr",
"(",
"OutMessageHeaderSize",
")",
"\n",
"b",
":=",
"unsafe",
".",
"Offsetof",
"(",
"OutMessage",
"{",
"}",
".",
"payload",
")",
"\n\n",
"if",
"a",
"!=",
"b",
"{",
"log",
".",
"Panicf",
"(",
"\"",
"\"",
",",
"a",
",",
"b",
")",
"\n",
"}",
"\n",
"}"
] |
// Make sure that the header and payload are contiguous.
|
[
"Make",
"sure",
"that",
"the",
"header",
"and",
"payload",
"are",
"contiguous",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/buffer/out_message.go#L44-L53
|
11,564 |
jacobsa/fuse
|
internal/buffer/out_message.go
|
Reset
|
func (m *OutMessage) Reset() {
// Ideally we'd like to write:
//
// m.payloadOffset = 0
// m.header = fusekernel.OutHeader{}
//
// But Go 1.8 beta 2 generates bad code for this
// (https://golang.org/issue/18370). Encourage it to generate the same code
// as Go 1.7.4 did.
if unsafe.Offsetof(m.payload) != 24 {
panic("unexpected OutMessage layout")
}
a := (*[3]uint64)(unsafe.Pointer(m))
a[0] = 0
a[1] = 0
a[2] = 0
}
|
go
|
func (m *OutMessage) Reset() {
// Ideally we'd like to write:
//
// m.payloadOffset = 0
// m.header = fusekernel.OutHeader{}
//
// But Go 1.8 beta 2 generates bad code for this
// (https://golang.org/issue/18370). Encourage it to generate the same code
// as Go 1.7.4 did.
if unsafe.Offsetof(m.payload) != 24 {
panic("unexpected OutMessage layout")
}
a := (*[3]uint64)(unsafe.Pointer(m))
a[0] = 0
a[1] = 0
a[2] = 0
}
|
[
"func",
"(",
"m",
"*",
"OutMessage",
")",
"Reset",
"(",
")",
"{",
"// Ideally we'd like to write:",
"//",
"// m.payloadOffset = 0",
"// m.header = fusekernel.OutHeader{}",
"//",
"// But Go 1.8 beta 2 generates bad code for this",
"// (https://golang.org/issue/18370). Encourage it to generate the same code",
"// as Go 1.7.4 did.",
"if",
"unsafe",
".",
"Offsetof",
"(",
"m",
".",
"payload",
")",
"!=",
"24",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"a",
":=",
"(",
"*",
"[",
"3",
"]",
"uint64",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"m",
")",
")",
"\n",
"a",
"[",
"0",
"]",
"=",
"0",
"\n",
"a",
"[",
"1",
"]",
"=",
"0",
"\n",
"a",
"[",
"2",
"]",
"=",
"0",
"\n",
"}"
] |
// Reset resets m so that it's ready to be used again. Afterward, the contents
// are solely a zeroed fusekernel.OutHeader struct.
|
[
"Reset",
"resets",
"m",
"so",
"that",
"it",
"s",
"ready",
"to",
"be",
"used",
"again",
".",
"Afterward",
"the",
"contents",
"are",
"solely",
"a",
"zeroed",
"fusekernel",
".",
"OutHeader",
"struct",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/buffer/out_message.go#L57-L74
|
11,565 |
jacobsa/fuse
|
internal/buffer/out_message.go
|
Grow
|
func (m *OutMessage) Grow(n int) (p unsafe.Pointer) {
p = m.GrowNoZero(n)
if p != nil {
memclr(p, uintptr(n))
}
return
}
|
go
|
func (m *OutMessage) Grow(n int) (p unsafe.Pointer) {
p = m.GrowNoZero(n)
if p != nil {
memclr(p, uintptr(n))
}
return
}
|
[
"func",
"(",
"m",
"*",
"OutMessage",
")",
"Grow",
"(",
"n",
"int",
")",
"(",
"p",
"unsafe",
".",
"Pointer",
")",
"{",
"p",
"=",
"m",
".",
"GrowNoZero",
"(",
"n",
")",
"\n",
"if",
"p",
"!=",
"nil",
"{",
"memclr",
"(",
"p",
",",
"uintptr",
"(",
"n",
")",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Grow grows m's buffer by the given number of bytes, returning a pointer to
// the start of the new segment, which is guaranteed to be zeroed. If there is
// insufficient space, it returns nil.
|
[
"Grow",
"grows",
"m",
"s",
"buffer",
"by",
"the",
"given",
"number",
"of",
"bytes",
"returning",
"a",
"pointer",
"to",
"the",
"start",
"of",
"the",
"new",
"segment",
"which",
"is",
"guaranteed",
"to",
"be",
"zeroed",
".",
"If",
"there",
"is",
"insufficient",
"space",
"it",
"returns",
"nil",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/buffer/out_message.go#L84-L91
|
11,566 |
jacobsa/fuse
|
internal/buffer/out_message.go
|
GrowNoZero
|
func (m *OutMessage) GrowNoZero(n int) (p unsafe.Pointer) {
// Will we overflow the buffer?
o := m.payloadOffset
if len(m.payload)-o < n {
return
}
p = unsafe.Pointer(uintptr(unsafe.Pointer(&m.payload)) + uintptr(o))
m.payloadOffset = o + n
return
}
|
go
|
func (m *OutMessage) GrowNoZero(n int) (p unsafe.Pointer) {
// Will we overflow the buffer?
o := m.payloadOffset
if len(m.payload)-o < n {
return
}
p = unsafe.Pointer(uintptr(unsafe.Pointer(&m.payload)) + uintptr(o))
m.payloadOffset = o + n
return
}
|
[
"func",
"(",
"m",
"*",
"OutMessage",
")",
"GrowNoZero",
"(",
"n",
"int",
")",
"(",
"p",
"unsafe",
".",
"Pointer",
")",
"{",
"// Will we overflow the buffer?",
"o",
":=",
"m",
".",
"payloadOffset",
"\n",
"if",
"len",
"(",
"m",
".",
"payload",
")",
"-",
"o",
"<",
"n",
"{",
"return",
"\n",
"}",
"\n\n",
"p",
"=",
"unsafe",
".",
"Pointer",
"(",
"uintptr",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"m",
".",
"payload",
")",
")",
"+",
"uintptr",
"(",
"o",
")",
")",
"\n",
"m",
".",
"payloadOffset",
"=",
"o",
"+",
"n",
"\n\n",
"return",
"\n",
"}"
] |
// GrowNoZero is equivalent to Grow, except the new segment is not zeroed. Use
// with caution!
|
[
"GrowNoZero",
"is",
"equivalent",
"to",
"Grow",
"except",
"the",
"new",
"segment",
"is",
"not",
"zeroed",
".",
"Use",
"with",
"caution!"
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/buffer/out_message.go#L95-L106
|
11,567 |
jacobsa/fuse
|
internal/buffer/out_message.go
|
AppendString
|
func (m *OutMessage) AppendString(src string) {
p := m.GrowNoZero(len(src))
if p == nil {
panic(fmt.Sprintf("Can't grow %d bytes", len(src)))
}
sh := (*reflect.StringHeader)(unsafe.Pointer(&src))
memmove(p, unsafe.Pointer(sh.Data), uintptr(sh.Len))
return
}
|
go
|
func (m *OutMessage) AppendString(src string) {
p := m.GrowNoZero(len(src))
if p == nil {
panic(fmt.Sprintf("Can't grow %d bytes", len(src)))
}
sh := (*reflect.StringHeader)(unsafe.Pointer(&src))
memmove(p, unsafe.Pointer(sh.Data), uintptr(sh.Len))
return
}
|
[
"func",
"(",
"m",
"*",
"OutMessage",
")",
"AppendString",
"(",
"src",
"string",
")",
"{",
"p",
":=",
"m",
".",
"GrowNoZero",
"(",
"len",
"(",
"src",
")",
")",
"\n",
"if",
"p",
"==",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"len",
"(",
"src",
")",
")",
")",
"\n",
"}",
"\n\n",
"sh",
":=",
"(",
"*",
"reflect",
".",
"StringHeader",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"src",
")",
")",
"\n",
"memmove",
"(",
"p",
",",
"unsafe",
".",
"Pointer",
"(",
"sh",
".",
"Data",
")",
",",
"uintptr",
"(",
"sh",
".",
"Len",
")",
")",
"\n\n",
"return",
"\n",
"}"
] |
// AppendString is like Append, but accepts string input.
|
[
"AppendString",
"is",
"like",
"Append",
"but",
"accepts",
"string",
"input",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/buffer/out_message.go#L136-L146
|
11,568 |
jacobsa/fuse
|
internal/buffer/out_message.go
|
Bytes
|
func (m *OutMessage) Bytes() []byte {
l := m.Len()
sh := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(&m.header)),
Len: l,
Cap: l,
}
return *(*[]byte)(unsafe.Pointer(&sh))
}
|
go
|
func (m *OutMessage) Bytes() []byte {
l := m.Len()
sh := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(&m.header)),
Len: l,
Cap: l,
}
return *(*[]byte)(unsafe.Pointer(&sh))
}
|
[
"func",
"(",
"m",
"*",
"OutMessage",
")",
"Bytes",
"(",
")",
"[",
"]",
"byte",
"{",
"l",
":=",
"m",
".",
"Len",
"(",
")",
"\n",
"sh",
":=",
"reflect",
".",
"SliceHeader",
"{",
"Data",
":",
"uintptr",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"m",
".",
"header",
")",
")",
",",
"Len",
":",
"l",
",",
"Cap",
":",
"l",
",",
"}",
"\n\n",
"return",
"*",
"(",
"*",
"[",
"]",
"byte",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"sh",
")",
")",
"\n",
"}"
] |
// Bytes returns a reference to the current contents of the buffer, including
// the leading header.
|
[
"Bytes",
"returns",
"a",
"reference",
"to",
"the",
"current",
"contents",
"of",
"the",
"buffer",
"including",
"the",
"leading",
"header",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/buffer/out_message.go#L155-L164
|
11,569 |
jacobsa/fuse
|
internal/buffer/in_message.go
|
Init
|
func (m *InMessage) Init(r io.Reader) (err error) {
n, err := r.Read(m.storage[:])
if err != nil {
return
}
// Make sure the message is long enough.
const headerSize = unsafe.Sizeof(fusekernel.InHeader{})
if uintptr(n) < headerSize {
err = fmt.Errorf("Unexpectedly read only %d bytes.", n)
return
}
m.remaining = m.storage[headerSize:n]
// Check the header's length.
if int(m.Header().Len) != n {
err = fmt.Errorf(
"Header says %d bytes, but we read %d",
m.Header().Len,
n)
return
}
return
}
|
go
|
func (m *InMessage) Init(r io.Reader) (err error) {
n, err := r.Read(m.storage[:])
if err != nil {
return
}
// Make sure the message is long enough.
const headerSize = unsafe.Sizeof(fusekernel.InHeader{})
if uintptr(n) < headerSize {
err = fmt.Errorf("Unexpectedly read only %d bytes.", n)
return
}
m.remaining = m.storage[headerSize:n]
// Check the header's length.
if int(m.Header().Len) != n {
err = fmt.Errorf(
"Header says %d bytes, but we read %d",
m.Header().Len,
n)
return
}
return
}
|
[
"func",
"(",
"m",
"*",
"InMessage",
")",
"Init",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"err",
"error",
")",
"{",
"n",
",",
"err",
":=",
"r",
".",
"Read",
"(",
"m",
".",
"storage",
"[",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"// Make sure the message is long enough.",
"const",
"headerSize",
"=",
"unsafe",
".",
"Sizeof",
"(",
"fusekernel",
".",
"InHeader",
"{",
"}",
")",
"\n",
"if",
"uintptr",
"(",
"n",
")",
"<",
"headerSize",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"n",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"m",
".",
"remaining",
"=",
"m",
".",
"storage",
"[",
"headerSize",
":",
"n",
"]",
"\n\n",
"// Check the header's length.",
"if",
"int",
"(",
"m",
".",
"Header",
"(",
")",
".",
"Len",
")",
"!=",
"n",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"m",
".",
"Header",
"(",
")",
".",
"Len",
",",
"n",
")",
"\n\n",
"return",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Initialize with the data read by a single call to r.Read. The first call to
// Consume will consume the bytes directly after the fusekernel.InHeader
// struct.
|
[
"Initialize",
"with",
"the",
"data",
"read",
"by",
"a",
"single",
"call",
"to",
"r",
".",
"Read",
".",
"The",
"first",
"call",
"to",
"Consume",
"will",
"consume",
"the",
"bytes",
"directly",
"after",
"the",
"fusekernel",
".",
"InHeader",
"struct",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/buffer/in_message.go#L52-L78
|
11,570 |
jacobsa/fuse
|
internal/buffer/in_message.go
|
Header
|
func (m *InMessage) Header() (h *fusekernel.InHeader) {
h = (*fusekernel.InHeader)(unsafe.Pointer(&m.storage[0]))
return
}
|
go
|
func (m *InMessage) Header() (h *fusekernel.InHeader) {
h = (*fusekernel.InHeader)(unsafe.Pointer(&m.storage[0]))
return
}
|
[
"func",
"(",
"m",
"*",
"InMessage",
")",
"Header",
"(",
")",
"(",
"h",
"*",
"fusekernel",
".",
"InHeader",
")",
"{",
"h",
"=",
"(",
"*",
"fusekernel",
".",
"InHeader",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"m",
".",
"storage",
"[",
"0",
"]",
")",
")",
"\n",
"return",
"\n",
"}"
] |
// Return a reference to the header read in the most recent call to Init.
|
[
"Return",
"a",
"reference",
"to",
"the",
"header",
"read",
"in",
"the",
"most",
"recent",
"call",
"to",
"Init",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/buffer/in_message.go#L81-L84
|
11,571 |
jacobsa/fuse
|
internal/buffer/in_message.go
|
Consume
|
func (m *InMessage) Consume(n uintptr) (p unsafe.Pointer) {
if m.Len() == 0 || n > m.Len() {
return
}
p = unsafe.Pointer(&m.remaining[0])
m.remaining = m.remaining[n:]
return
}
|
go
|
func (m *InMessage) Consume(n uintptr) (p unsafe.Pointer) {
if m.Len() == 0 || n > m.Len() {
return
}
p = unsafe.Pointer(&m.remaining[0])
m.remaining = m.remaining[n:]
return
}
|
[
"func",
"(",
"m",
"*",
"InMessage",
")",
"Consume",
"(",
"n",
"uintptr",
")",
"(",
"p",
"unsafe",
".",
"Pointer",
")",
"{",
"if",
"m",
".",
"Len",
"(",
")",
"==",
"0",
"||",
"n",
">",
"m",
".",
"Len",
"(",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"p",
"=",
"unsafe",
".",
"Pointer",
"(",
"&",
"m",
".",
"remaining",
"[",
"0",
"]",
")",
"\n",
"m",
".",
"remaining",
"=",
"m",
".",
"remaining",
"[",
"n",
":",
"]",
"\n\n",
"return",
"\n",
"}"
] |
// Consume the next n bytes from the message, returning a nil pointer if there
// are fewer than n bytes available.
|
[
"Consume",
"the",
"next",
"n",
"bytes",
"from",
"the",
"message",
"returning",
"a",
"nil",
"pointer",
"if",
"there",
"are",
"fewer",
"than",
"n",
"bytes",
"available",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/buffer/in_message.go#L93-L102
|
11,572 |
jacobsa/fuse
|
internal/buffer/in_message.go
|
ConsumeBytes
|
func (m *InMessage) ConsumeBytes(n uintptr) (b []byte) {
if n > m.Len() {
return
}
b = m.remaining[:n]
m.remaining = m.remaining[n:]
return
}
|
go
|
func (m *InMessage) ConsumeBytes(n uintptr) (b []byte) {
if n > m.Len() {
return
}
b = m.remaining[:n]
m.remaining = m.remaining[n:]
return
}
|
[
"func",
"(",
"m",
"*",
"InMessage",
")",
"ConsumeBytes",
"(",
"n",
"uintptr",
")",
"(",
"b",
"[",
"]",
"byte",
")",
"{",
"if",
"n",
">",
"m",
".",
"Len",
"(",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"b",
"=",
"m",
".",
"remaining",
"[",
":",
"n",
"]",
"\n",
"m",
".",
"remaining",
"=",
"m",
".",
"remaining",
"[",
"n",
":",
"]",
"\n\n",
"return",
"\n",
"}"
] |
// Equivalent to Consume, except returns a slice of bytes. The result will be
// nil if Consume would fail.
|
[
"Equivalent",
"to",
"Consume",
"except",
"returns",
"a",
"slice",
"of",
"bytes",
".",
"The",
"result",
"will",
"be",
"nil",
"if",
"Consume",
"would",
"fail",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/buffer/in_message.go#L106-L115
|
11,573 |
jacobsa/fuse
|
debug.go
|
opName
|
func opName(op interface{}) string {
// We expect all ops to be pointers.
t := reflect.TypeOf(op).Elem()
// Strip the "Op" from "FooOp".
return strings.TrimSuffix(t.Name(), "Op")
}
|
go
|
func opName(op interface{}) string {
// We expect all ops to be pointers.
t := reflect.TypeOf(op).Elem()
// Strip the "Op" from "FooOp".
return strings.TrimSuffix(t.Name(), "Op")
}
|
[
"func",
"opName",
"(",
"op",
"interface",
"{",
"}",
")",
"string",
"{",
"// We expect all ops to be pointers.",
"t",
":=",
"reflect",
".",
"TypeOf",
"(",
"op",
")",
".",
"Elem",
"(",
")",
"\n\n",
"// Strip the \"Op\" from \"FooOp\".",
"return",
"strings",
".",
"TrimSuffix",
"(",
"t",
".",
"Name",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// Decide on the name of the given op.
|
[
"Decide",
"on",
"the",
"name",
"of",
"the",
"given",
"op",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/debug.go#L26-L32
|
11,574 |
jacobsa/fuse
|
mount.go
|
Mount
|
func Mount(
dir string,
server Server,
config *MountConfig) (mfs *MountedFileSystem, err error) {
// Sanity check: make sure the mount point exists and is a directory. This
// saves us from some confusing errors later on OS X.
fi, err := os.Stat(dir)
switch {
case os.IsNotExist(err):
return
case err != nil:
err = fmt.Errorf("Statting mount point: %v", err)
return
case !fi.IsDir():
err = fmt.Errorf("Mount point %s is not a directory", dir)
return
}
// Initialize the struct.
mfs = &MountedFileSystem{
dir: dir,
joinStatusAvailable: make(chan struct{}),
}
// Begin the mounting process, which will continue in the background.
ready := make(chan error, 1)
dev, err := mount(dir, config, ready)
if err != nil {
err = fmt.Errorf("mount: %v", err)
return
}
// Choose a parent context for ops.
cfgCopy := *config
if cfgCopy.OpContext == nil {
cfgCopy.OpContext = context.Background()
}
// Create a Connection object wrapping the device.
connection, err := newConnection(
cfgCopy,
config.DebugLogger,
config.ErrorLogger,
dev)
if err != nil {
err = fmt.Errorf("newConnection: %v", err)
return
}
// Serve the connection in the background. When done, set the join status.
go func() {
server.ServeOps(connection)
mfs.joinStatus = connection.close()
close(mfs.joinStatusAvailable)
}()
// Wait for the mount process to complete.
if err = <-ready; err != nil {
err = fmt.Errorf("mount (background): %v", err)
return
}
return
}
|
go
|
func Mount(
dir string,
server Server,
config *MountConfig) (mfs *MountedFileSystem, err error) {
// Sanity check: make sure the mount point exists and is a directory. This
// saves us from some confusing errors later on OS X.
fi, err := os.Stat(dir)
switch {
case os.IsNotExist(err):
return
case err != nil:
err = fmt.Errorf("Statting mount point: %v", err)
return
case !fi.IsDir():
err = fmt.Errorf("Mount point %s is not a directory", dir)
return
}
// Initialize the struct.
mfs = &MountedFileSystem{
dir: dir,
joinStatusAvailable: make(chan struct{}),
}
// Begin the mounting process, which will continue in the background.
ready := make(chan error, 1)
dev, err := mount(dir, config, ready)
if err != nil {
err = fmt.Errorf("mount: %v", err)
return
}
// Choose a parent context for ops.
cfgCopy := *config
if cfgCopy.OpContext == nil {
cfgCopy.OpContext = context.Background()
}
// Create a Connection object wrapping the device.
connection, err := newConnection(
cfgCopy,
config.DebugLogger,
config.ErrorLogger,
dev)
if err != nil {
err = fmt.Errorf("newConnection: %v", err)
return
}
// Serve the connection in the background. When done, set the join status.
go func() {
server.ServeOps(connection)
mfs.joinStatus = connection.close()
close(mfs.joinStatusAvailable)
}()
// Wait for the mount process to complete.
if err = <-ready; err != nil {
err = fmt.Errorf("mount (background): %v", err)
return
}
return
}
|
[
"func",
"Mount",
"(",
"dir",
"string",
",",
"server",
"Server",
",",
"config",
"*",
"MountConfig",
")",
"(",
"mfs",
"*",
"MountedFileSystem",
",",
"err",
"error",
")",
"{",
"// Sanity check: make sure the mount point exists and is a directory. This",
"// saves us from some confusing errors later on OS X.",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"dir",
")",
"\n",
"switch",
"{",
"case",
"os",
".",
"IsNotExist",
"(",
"err",
")",
":",
"return",
"\n\n",
"case",
"err",
"!=",
"nil",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n\n",
"case",
"!",
"fi",
".",
"IsDir",
"(",
")",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"dir",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Initialize the struct.",
"mfs",
"=",
"&",
"MountedFileSystem",
"{",
"dir",
":",
"dir",
",",
"joinStatusAvailable",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n\n",
"// Begin the mounting process, which will continue in the background.",
"ready",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"dev",
",",
"err",
":=",
"mount",
"(",
"dir",
",",
"config",
",",
"ready",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Choose a parent context for ops.",
"cfgCopy",
":=",
"*",
"config",
"\n",
"if",
"cfgCopy",
".",
"OpContext",
"==",
"nil",
"{",
"cfgCopy",
".",
"OpContext",
"=",
"context",
".",
"Background",
"(",
")",
"\n",
"}",
"\n\n",
"// Create a Connection object wrapping the device.",
"connection",
",",
"err",
":=",
"newConnection",
"(",
"cfgCopy",
",",
"config",
".",
"DebugLogger",
",",
"config",
".",
"ErrorLogger",
",",
"dev",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Serve the connection in the background. When done, set the join status.",
"go",
"func",
"(",
")",
"{",
"server",
".",
"ServeOps",
"(",
"connection",
")",
"\n",
"mfs",
".",
"joinStatus",
"=",
"connection",
".",
"close",
"(",
")",
"\n",
"close",
"(",
"mfs",
".",
"joinStatusAvailable",
")",
"\n",
"}",
"(",
")",
"\n\n",
"// Wait for the mount process to complete.",
"if",
"err",
"=",
"<-",
"ready",
";",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Mount attempts to mount a file system on the given directory, using the
// supplied Server to serve connection requests. It blocks until the file
// system is successfully mounted.
|
[
"Mount",
"attempts",
"to",
"mount",
"a",
"file",
"system",
"on",
"the",
"given",
"directory",
"using",
"the",
"supplied",
"Server",
"to",
"serve",
"connection",
"requests",
".",
"It",
"blocks",
"until",
"the",
"file",
"system",
"is",
"successfully",
"mounted",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/mount.go#L35-L101
|
11,575 |
jacobsa/fuse
|
mount_config.go
|
toMap
|
func (c *MountConfig) toMap() (opts map[string]string) {
isDarwin := runtime.GOOS == "darwin"
opts = make(map[string]string)
// Enable permissions checking in the kernel. See the comments on
// InodeAttributes.Mode.
opts["default_permissions"] = ""
// HACK(jacobsa): Work around what appears to be a bug in systemd v219, as
// shipped in Ubuntu 15.04, where it automatically unmounts any file system
// that doesn't set an explicit name.
//
// When Ubuntu contains systemd v220, this workaround should be removed and
// the systemd bug reopened if the problem persists.
//
// Cf. https://github.com/bazil/fuse/issues/89
// Cf. https://bugs.freedesktop.org/show_bug.cgi?id=90907
fsname := c.FSName
if runtime.GOOS == "linux" && fsname == "" {
fsname = "some_fuse_file_system"
}
// Special file system name?
if fsname != "" {
opts["fsname"] = fsname
}
subtype := c.Subtype
if subtype != "" {
opts["subtype"] = subtype
}
// Read only?
if c.ReadOnly {
opts["ro"] = ""
}
// Handle OS X options.
if isDarwin {
if !c.EnableVnodeCaching {
opts["novncache"] = ""
}
if c.VolumeName != "" {
// Cf. https://github.com/osxfuse/osxfuse/wiki/Mount-options#volname
opts["volname"] = c.VolumeName
}
}
// OS X: disable the use of "Apple Double" (._foo and .DS_Store) files, which
// just add noise to debug output and can have significant cost on
// network-based file systems.
//
// Cf. https://github.com/osxfuse/osxfuse/wiki/Mount-options
if isDarwin {
opts["noappledouble"] = ""
}
// Last but not least: other user-supplied options.
for k, v := range c.Options {
opts[k] = v
}
return
}
|
go
|
func (c *MountConfig) toMap() (opts map[string]string) {
isDarwin := runtime.GOOS == "darwin"
opts = make(map[string]string)
// Enable permissions checking in the kernel. See the comments on
// InodeAttributes.Mode.
opts["default_permissions"] = ""
// HACK(jacobsa): Work around what appears to be a bug in systemd v219, as
// shipped in Ubuntu 15.04, where it automatically unmounts any file system
// that doesn't set an explicit name.
//
// When Ubuntu contains systemd v220, this workaround should be removed and
// the systemd bug reopened if the problem persists.
//
// Cf. https://github.com/bazil/fuse/issues/89
// Cf. https://bugs.freedesktop.org/show_bug.cgi?id=90907
fsname := c.FSName
if runtime.GOOS == "linux" && fsname == "" {
fsname = "some_fuse_file_system"
}
// Special file system name?
if fsname != "" {
opts["fsname"] = fsname
}
subtype := c.Subtype
if subtype != "" {
opts["subtype"] = subtype
}
// Read only?
if c.ReadOnly {
opts["ro"] = ""
}
// Handle OS X options.
if isDarwin {
if !c.EnableVnodeCaching {
opts["novncache"] = ""
}
if c.VolumeName != "" {
// Cf. https://github.com/osxfuse/osxfuse/wiki/Mount-options#volname
opts["volname"] = c.VolumeName
}
}
// OS X: disable the use of "Apple Double" (._foo and .DS_Store) files, which
// just add noise to debug output and can have significant cost on
// network-based file systems.
//
// Cf. https://github.com/osxfuse/osxfuse/wiki/Mount-options
if isDarwin {
opts["noappledouble"] = ""
}
// Last but not least: other user-supplied options.
for k, v := range c.Options {
opts[k] = v
}
return
}
|
[
"func",
"(",
"c",
"*",
"MountConfig",
")",
"toMap",
"(",
")",
"(",
"opts",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"isDarwin",
":=",
"runtime",
".",
"GOOS",
"==",
"\"",
"\"",
"\n",
"opts",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n\n",
"// Enable permissions checking in the kernel. See the comments on",
"// InodeAttributes.Mode.",
"opts",
"[",
"\"",
"\"",
"]",
"=",
"\"",
"\"",
"\n\n",
"// HACK(jacobsa): Work around what appears to be a bug in systemd v219, as",
"// shipped in Ubuntu 15.04, where it automatically unmounts any file system",
"// that doesn't set an explicit name.",
"//",
"// When Ubuntu contains systemd v220, this workaround should be removed and",
"// the systemd bug reopened if the problem persists.",
"//",
"// Cf. https://github.com/bazil/fuse/issues/89",
"// Cf. https://bugs.freedesktop.org/show_bug.cgi?id=90907",
"fsname",
":=",
"c",
".",
"FSName",
"\n",
"if",
"runtime",
".",
"GOOS",
"==",
"\"",
"\"",
"&&",
"fsname",
"==",
"\"",
"\"",
"{",
"fsname",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"// Special file system name?",
"if",
"fsname",
"!=",
"\"",
"\"",
"{",
"opts",
"[",
"\"",
"\"",
"]",
"=",
"fsname",
"\n",
"}",
"\n\n",
"subtype",
":=",
"c",
".",
"Subtype",
"\n",
"if",
"subtype",
"!=",
"\"",
"\"",
"{",
"opts",
"[",
"\"",
"\"",
"]",
"=",
"subtype",
"\n",
"}",
"\n\n",
"// Read only?",
"if",
"c",
".",
"ReadOnly",
"{",
"opts",
"[",
"\"",
"\"",
"]",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"// Handle OS X options.",
"if",
"isDarwin",
"{",
"if",
"!",
"c",
".",
"EnableVnodeCaching",
"{",
"opts",
"[",
"\"",
"\"",
"]",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"VolumeName",
"!=",
"\"",
"\"",
"{",
"// Cf. https://github.com/osxfuse/osxfuse/wiki/Mount-options#volname",
"opts",
"[",
"\"",
"\"",
"]",
"=",
"c",
".",
"VolumeName",
"\n",
"}",
"\n",
"}",
"\n\n",
"// OS X: disable the use of \"Apple Double\" (._foo and .DS_Store) files, which",
"// just add noise to debug output and can have significant cost on",
"// network-based file systems.",
"//",
"// Cf. https://github.com/osxfuse/osxfuse/wiki/Mount-options",
"if",
"isDarwin",
"{",
"opts",
"[",
"\"",
"\"",
"]",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"// Last but not least: other user-supplied options.",
"for",
"k",
",",
"v",
":=",
"range",
"c",
".",
"Options",
"{",
"opts",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Create a map containing all of the key=value mount options to be given to
// the mount helper.
|
[
"Create",
"a",
"map",
"containing",
"all",
"of",
"the",
"key",
"=",
"value",
"mount",
"options",
"to",
"be",
"given",
"to",
"the",
"mount",
"helper",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/mount_config.go#L153-L217
|
11,576 |
jacobsa/fuse
|
mount_config.go
|
toOptionsString
|
func (c *MountConfig) toOptionsString() string {
var components []string
for k, v := range c.toMap() {
k = escapeOptionsKey(k)
component := k
if v != "" {
component = fmt.Sprintf("%s=%s", k, v)
}
components = append(components, component)
}
return strings.Join(components, ",")
}
|
go
|
func (c *MountConfig) toOptionsString() string {
var components []string
for k, v := range c.toMap() {
k = escapeOptionsKey(k)
component := k
if v != "" {
component = fmt.Sprintf("%s=%s", k, v)
}
components = append(components, component)
}
return strings.Join(components, ",")
}
|
[
"func",
"(",
"c",
"*",
"MountConfig",
")",
"toOptionsString",
"(",
")",
"string",
"{",
"var",
"components",
"[",
"]",
"string",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"c",
".",
"toMap",
"(",
")",
"{",
"k",
"=",
"escapeOptionsKey",
"(",
"k",
")",
"\n\n",
"component",
":=",
"k",
"\n",
"if",
"v",
"!=",
"\"",
"\"",
"{",
"component",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"k",
",",
"v",
")",
"\n",
"}",
"\n\n",
"components",
"=",
"append",
"(",
"components",
",",
"component",
")",
"\n",
"}",
"\n\n",
"return",
"strings",
".",
"Join",
"(",
"components",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// Create an options string suitable for passing to the mount helper.
|
[
"Create",
"an",
"options",
"string",
"suitable",
"for",
"passing",
"to",
"the",
"mount",
"helper",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/mount_config.go#L227-L241
|
11,577 |
jacobsa/fuse
|
internal/freelist/freelist.go
|
Get
|
func (fl *Freelist) Get() (p unsafe.Pointer) {
l := len(fl.list)
if l == 0 {
return
}
p = fl.list[l-1]
fl.list = fl.list[:l-1]
return
}
|
go
|
func (fl *Freelist) Get() (p unsafe.Pointer) {
l := len(fl.list)
if l == 0 {
return
}
p = fl.list[l-1]
fl.list = fl.list[:l-1]
return
}
|
[
"func",
"(",
"fl",
"*",
"Freelist",
")",
"Get",
"(",
")",
"(",
"p",
"unsafe",
".",
"Pointer",
")",
"{",
"l",
":=",
"len",
"(",
"fl",
".",
"list",
")",
"\n",
"if",
"l",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n\n",
"p",
"=",
"fl",
".",
"list",
"[",
"l",
"-",
"1",
"]",
"\n",
"fl",
".",
"list",
"=",
"fl",
".",
"list",
"[",
":",
"l",
"-",
"1",
"]",
"\n\n",
"return",
"\n",
"}"
] |
// Get an element from the freelist, returning nil if empty.
|
[
"Get",
"an",
"element",
"from",
"the",
"freelist",
"returning",
"nil",
"if",
"empty",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/freelist/freelist.go#L25-L35
|
11,578 |
jacobsa/fuse
|
internal/freelist/freelist.go
|
Put
|
func (fl *Freelist) Put(p unsafe.Pointer) {
fl.list = append(fl.list, p)
}
|
go
|
func (fl *Freelist) Put(p unsafe.Pointer) {
fl.list = append(fl.list, p)
}
|
[
"func",
"(",
"fl",
"*",
"Freelist",
")",
"Put",
"(",
"p",
"unsafe",
".",
"Pointer",
")",
"{",
"fl",
".",
"list",
"=",
"append",
"(",
"fl",
".",
"list",
",",
"p",
")",
"\n",
"}"
] |
// Contribute an element back to the freelist.
|
[
"Contribute",
"an",
"element",
"back",
"to",
"the",
"freelist",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/freelist/freelist.go#L38-L40
|
11,579 |
jacobsa/fuse
|
internal/fusekernel/protocol.go
|
LT
|
func (a Protocol) LT(b Protocol) bool {
return a.Major < b.Major ||
(a.Major == b.Major && a.Minor < b.Minor)
}
|
go
|
func (a Protocol) LT(b Protocol) bool {
return a.Major < b.Major ||
(a.Major == b.Major && a.Minor < b.Minor)
}
|
[
"func",
"(",
"a",
"Protocol",
")",
"LT",
"(",
"b",
"Protocol",
")",
"bool",
"{",
"return",
"a",
".",
"Major",
"<",
"b",
".",
"Major",
"||",
"(",
"a",
".",
"Major",
"==",
"b",
".",
"Major",
"&&",
"a",
".",
"Minor",
"<",
"b",
".",
"Minor",
")",
"\n",
"}"
] |
// LT returns whether a is less than b.
|
[
"LT",
"returns",
"whether",
"a",
"is",
"less",
"than",
"b",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/fusekernel/protocol.go#L18-L21
|
11,580 |
jacobsa/fuse
|
internal/fusekernel/protocol.go
|
GE
|
func (a Protocol) GE(b Protocol) bool {
return a.Major > b.Major ||
(a.Major == b.Major && a.Minor >= b.Minor)
}
|
go
|
func (a Protocol) GE(b Protocol) bool {
return a.Major > b.Major ||
(a.Major == b.Major && a.Minor >= b.Minor)
}
|
[
"func",
"(",
"a",
"Protocol",
")",
"GE",
"(",
"b",
"Protocol",
")",
"bool",
"{",
"return",
"a",
".",
"Major",
">",
"b",
".",
"Major",
"||",
"(",
"a",
".",
"Major",
"==",
"b",
".",
"Major",
"&&",
"a",
".",
"Minor",
">=",
"b",
".",
"Minor",
")",
"\n",
"}"
] |
// GE returns whether a is greater than or equal to b.
|
[
"GE",
"returns",
"whether",
"a",
"is",
"greater",
"than",
"or",
"equal",
"to",
"b",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/internal/fusekernel/protocol.go#L24-L27
|
11,581 |
jacobsa/fuse
|
samples/subprocess.go
|
SetUp
|
func (t *SubprocessTest) SetUp(ti *ogletest.TestInfo) {
err := t.initialize(ti.Ctx)
if err != nil {
panic(err)
}
}
|
go
|
func (t *SubprocessTest) SetUp(ti *ogletest.TestInfo) {
err := t.initialize(ti.Ctx)
if err != nil {
panic(err)
}
}
|
[
"func",
"(",
"t",
"*",
"SubprocessTest",
")",
"SetUp",
"(",
"ti",
"*",
"ogletest",
".",
"TestInfo",
")",
"{",
"err",
":=",
"t",
".",
"initialize",
"(",
"ti",
".",
"Ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// Mount the file system and initialize the other exported fields of the
// struct. Panics on error.
|
[
"Mount",
"the",
"file",
"system",
"and",
"initialize",
"the",
"other",
"exported",
"fields",
"of",
"the",
"struct",
".",
"Panics",
"on",
"error",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/samples/subprocess.go#L70-L75
|
11,582 |
jacobsa/fuse
|
samples/subprocess.go
|
getToolContentsImpl
|
func getToolContentsImpl() (contents []byte, err error) {
// Fast path: has the user set the flag?
if *fToolPath != "" {
contents, err = ioutil.ReadFile(*fToolPath)
if err != nil {
err = fmt.Errorf("Reading mount_sample contents: %v", err)
return
}
return
}
// Create a temporary directory into which we will compile the tool.
tempDir, err := ioutil.TempDir("", "sample_test")
if err != nil {
err = fmt.Errorf("TempDir: %v", err)
return
}
toolPath := path.Join(tempDir, "mount_sample")
// Ensure that we kill the temporary directory when we're finished here.
defer os.RemoveAll(tempDir)
// Run "go build".
cmd := exec.Command(
"go",
"build",
"-o",
toolPath,
"github.com/jacobsa/fuse/samples/mount_sample")
output, err := cmd.CombinedOutput()
if err != nil {
err = fmt.Errorf(
"mount_sample exited with %v, output:\n%s",
err,
string(output))
return
}
// Slurp the tool contents.
contents, err = ioutil.ReadFile(toolPath)
if err != nil {
err = fmt.Errorf("ReadFile: %v", err)
return
}
return
}
|
go
|
func getToolContentsImpl() (contents []byte, err error) {
// Fast path: has the user set the flag?
if *fToolPath != "" {
contents, err = ioutil.ReadFile(*fToolPath)
if err != nil {
err = fmt.Errorf("Reading mount_sample contents: %v", err)
return
}
return
}
// Create a temporary directory into which we will compile the tool.
tempDir, err := ioutil.TempDir("", "sample_test")
if err != nil {
err = fmt.Errorf("TempDir: %v", err)
return
}
toolPath := path.Join(tempDir, "mount_sample")
// Ensure that we kill the temporary directory when we're finished here.
defer os.RemoveAll(tempDir)
// Run "go build".
cmd := exec.Command(
"go",
"build",
"-o",
toolPath,
"github.com/jacobsa/fuse/samples/mount_sample")
output, err := cmd.CombinedOutput()
if err != nil {
err = fmt.Errorf(
"mount_sample exited with %v, output:\n%s",
err,
string(output))
return
}
// Slurp the tool contents.
contents, err = ioutil.ReadFile(toolPath)
if err != nil {
err = fmt.Errorf("ReadFile: %v", err)
return
}
return
}
|
[
"func",
"getToolContentsImpl",
"(",
")",
"(",
"contents",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"// Fast path: has the user set the flag?",
"if",
"*",
"fToolPath",
"!=",
"\"",
"\"",
"{",
"contents",
",",
"err",
"=",
"ioutil",
".",
"ReadFile",
"(",
"*",
"fToolPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"return",
"\n",
"}",
"\n\n",
"// Create a temporary directory into which we will compile the tool.",
"tempDir",
",",
"err",
":=",
"ioutil",
".",
"TempDir",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"toolPath",
":=",
"path",
".",
"Join",
"(",
"tempDir",
",",
"\"",
"\"",
")",
"\n\n",
"// Ensure that we kill the temporary directory when we're finished here.",
"defer",
"os",
".",
"RemoveAll",
"(",
"tempDir",
")",
"\n\n",
"// Run \"go build\".",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"toolPath",
",",
"\"",
"\"",
")",
"\n\n",
"output",
",",
"err",
":=",
"cmd",
".",
"CombinedOutput",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
",",
"string",
"(",
"output",
")",
")",
"\n\n",
"return",
"\n",
"}",
"\n\n",
"// Slurp the tool contents.",
"contents",
",",
"err",
"=",
"ioutil",
".",
"ReadFile",
"(",
"toolPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Implementation detail of getToolPath.
|
[
"Implementation",
"detail",
"of",
"getToolPath",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/samples/subprocess.go#L83-L133
|
11,583 |
jacobsa/fuse
|
samples/subprocess.go
|
getToolContents
|
func getToolContents() (contents []byte, err error) {
// Get hold of the binary contents, if we haven't yet.
getToolContents_Once.Do(func() {
getToolContents_Contents, getToolContents_Err = getToolContentsImpl()
})
contents, err = getToolContents_Contents, getToolContents_Err
return
}
|
go
|
func getToolContents() (contents []byte, err error) {
// Get hold of the binary contents, if we haven't yet.
getToolContents_Once.Do(func() {
getToolContents_Contents, getToolContents_Err = getToolContentsImpl()
})
contents, err = getToolContents_Contents, getToolContents_Err
return
}
|
[
"func",
"getToolContents",
"(",
")",
"(",
"contents",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"// Get hold of the binary contents, if we haven't yet.",
"getToolContents_Once",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"getToolContents_Contents",
",",
"getToolContents_Err",
"=",
"getToolContentsImpl",
"(",
")",
"\n",
"}",
")",
"\n\n",
"contents",
",",
"err",
"=",
"getToolContents_Contents",
",",
"getToolContents_Err",
"\n",
"return",
"\n",
"}"
] |
// Build the mount_sample tool if it has not yet been built for this process.
// Return its contents.
|
[
"Build",
"the",
"mount_sample",
"tool",
"if",
"it",
"has",
"not",
"yet",
"been",
"built",
"for",
"this",
"process",
".",
"Return",
"its",
"contents",
"."
] |
cd3959611bcb6bb23d49f1598d98f2bf44476805
|
https://github.com/jacobsa/fuse/blob/cd3959611bcb6bb23d49f1598d98f2bf44476805/samples/subprocess.go#L137-L145
|
11,584 |
tebeka/go2xunit
|
lib/lex.go
|
NewLineScanner
|
func NewLineScanner(r io.Reader) *LineScanner {
br := bufio.NewReader(r)
ls := &LineScanner{
Reader: br,
}
return ls
}
|
go
|
func NewLineScanner(r io.Reader) *LineScanner {
br := bufio.NewReader(r)
ls := &LineScanner{
Reader: br,
}
return ls
}
|
[
"func",
"NewLineScanner",
"(",
"r",
"io",
".",
"Reader",
")",
"*",
"LineScanner",
"{",
"br",
":=",
"bufio",
".",
"NewReader",
"(",
"r",
")",
"\n",
"ls",
":=",
"&",
"LineScanner",
"{",
"Reader",
":",
"br",
",",
"}",
"\n",
"return",
"ls",
"\n",
"}"
] |
// NewLineScanner creates a new line scanner from r
|
[
"NewLineScanner",
"creates",
"a",
"new",
"line",
"scanner",
"from",
"r"
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/lib/lex.go#L71-L77
|
11,585 |
tebeka/go2xunit
|
lib/lex.go
|
Scan
|
func (ls *LineScanner) Scan() bool {
if ls.text, _, ls.err = ls.Reader.ReadLine(); ls.err != nil {
if ls.err == io.EOF {
ls.err = nil
}
return false
}
ls.lnum++
return true
}
|
go
|
func (ls *LineScanner) Scan() bool {
if ls.text, _, ls.err = ls.Reader.ReadLine(); ls.err != nil {
if ls.err == io.EOF {
ls.err = nil
}
return false
}
ls.lnum++
return true
}
|
[
"func",
"(",
"ls",
"*",
"LineScanner",
")",
"Scan",
"(",
")",
"bool",
"{",
"if",
"ls",
".",
"text",
",",
"_",
",",
"ls",
".",
"err",
"=",
"ls",
".",
"Reader",
".",
"ReadLine",
"(",
")",
";",
"ls",
".",
"err",
"!=",
"nil",
"{",
"if",
"ls",
".",
"err",
"==",
"io",
".",
"EOF",
"{",
"ls",
".",
"err",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"ls",
".",
"lnum",
"++",
"\n",
"return",
"true",
"\n",
"}"
] |
// Scan advances to next line.
|
[
"Scan",
"advances",
"to",
"next",
"line",
"."
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/lib/lex.go#L80-L89
|
11,586 |
tebeka/go2xunit
|
lib/lex.go
|
Scan
|
func (lex *GotestLexer) Scan() bool {
if !lex.scanner.Scan() {
return false
}
if lex.scanner.Err() != nil {
return false
}
line := lex.scanner.Text()
lnum := lex.scanner.Line()
found := false
for _, typ := range gtTypes {
if typ.re.MatchString(line) {
found = true
lex.tok = &Token{lnum, typ.typ, line}
break
}
}
if !found {
lex.tok = &Token{lnum, DataToken, line}
}
return true
}
|
go
|
func (lex *GotestLexer) Scan() bool {
if !lex.scanner.Scan() {
return false
}
if lex.scanner.Err() != nil {
return false
}
line := lex.scanner.Text()
lnum := lex.scanner.Line()
found := false
for _, typ := range gtTypes {
if typ.re.MatchString(line) {
found = true
lex.tok = &Token{lnum, typ.typ, line}
break
}
}
if !found {
lex.tok = &Token{lnum, DataToken, line}
}
return true
}
|
[
"func",
"(",
"lex",
"*",
"GotestLexer",
")",
"Scan",
"(",
")",
"bool",
"{",
"if",
"!",
"lex",
".",
"scanner",
".",
"Scan",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"lex",
".",
"scanner",
".",
"Err",
"(",
")",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"line",
":=",
"lex",
".",
"scanner",
".",
"Text",
"(",
")",
"\n",
"lnum",
":=",
"lex",
".",
"scanner",
".",
"Line",
"(",
")",
"\n",
"found",
":=",
"false",
"\n",
"for",
"_",
",",
"typ",
":=",
"range",
"gtTypes",
"{",
"if",
"typ",
".",
"re",
".",
"MatchString",
"(",
"line",
")",
"{",
"found",
"=",
"true",
"\n",
"lex",
".",
"tok",
"=",
"&",
"Token",
"{",
"lnum",
",",
"typ",
".",
"typ",
",",
"line",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"found",
"{",
"lex",
".",
"tok",
"=",
"&",
"Token",
"{",
"lnum",
",",
"DataToken",
",",
"line",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// Scan scans the next token. Return true if there's a new one
|
[
"Scan",
"scans",
"the",
"next",
"token",
".",
"Return",
"true",
"if",
"there",
"s",
"a",
"new",
"one"
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/lib/lex.go#L180-L203
|
11,587 |
tebeka/go2xunit
|
lib/parsers.go
|
hasDatarace
|
func hasDatarace(lines []string) bool {
for _, line := range lines {
if matchDatarace(line) {
return true
}
}
return false
}
|
go
|
func hasDatarace(lines []string) bool {
for _, line := range lines {
if matchDatarace(line) {
return true
}
}
return false
}
|
[
"func",
"hasDatarace",
"(",
"lines",
"[",
"]",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"line",
":=",
"range",
"lines",
"{",
"if",
"matchDatarace",
"(",
"line",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// hasDatarace checks if there's a data race warning in the line
|
[
"hasDatarace",
"checks",
"if",
"there",
"s",
"a",
"data",
"race",
"warning",
"in",
"the",
"line"
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/lib/parsers.go#L16-L23
|
11,588 |
tebeka/go2xunit
|
lib/types.go
|
numStatus
|
func (suite *Suite) numStatus(status Status) int {
count := 0
for _, test := range suite.Tests {
if test.Status == status {
count++
}
}
return count
}
|
go
|
func (suite *Suite) numStatus(status Status) int {
count := 0
for _, test := range suite.Tests {
if test.Status == status {
count++
}
}
return count
}
|
[
"func",
"(",
"suite",
"*",
"Suite",
")",
"numStatus",
"(",
"status",
"Status",
")",
"int",
"{",
"count",
":=",
"0",
"\n",
"for",
"_",
",",
"test",
":=",
"range",
"suite",
".",
"Tests",
"{",
"if",
"test",
".",
"Status",
"==",
"status",
"{",
"count",
"++",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"count",
"\n",
"}"
] |
// numStatus returns the number of tests in status
|
[
"numStatus",
"returns",
"the",
"number",
"of",
"tests",
"in",
"status"
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/lib/types.go#L46-L54
|
11,589 |
tebeka/go2xunit
|
lib/types.go
|
HasFailures
|
func (s Suites) HasFailures() bool {
for _, suite := range s {
if suite.NumFailed() > 0 {
return true
}
}
return false
}
|
go
|
func (s Suites) HasFailures() bool {
for _, suite := range s {
if suite.NumFailed() > 0 {
return true
}
}
return false
}
|
[
"func",
"(",
"s",
"Suites",
")",
"HasFailures",
"(",
")",
"bool",
"{",
"for",
"_",
",",
"suite",
":=",
"range",
"s",
"{",
"if",
"suite",
".",
"NumFailed",
"(",
")",
">",
"0",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// HasFailures return true is there's at least one failing suite
|
[
"HasFailures",
"return",
"true",
"is",
"there",
"s",
"at",
"least",
"one",
"failing",
"suite"
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/lib/types.go#L65-L72
|
11,590 |
tebeka/go2xunit
|
lib/types.go
|
Push
|
func (s *SuiteStack) Push(n *Suite) {
s.nodes = append(s.nodes[:s.count], n)
s.count++
}
|
go
|
func (s *SuiteStack) Push(n *Suite) {
s.nodes = append(s.nodes[:s.count], n)
s.count++
}
|
[
"func",
"(",
"s",
"*",
"SuiteStack",
")",
"Push",
"(",
"n",
"*",
"Suite",
")",
"{",
"s",
".",
"nodes",
"=",
"append",
"(",
"s",
".",
"nodes",
"[",
":",
"s",
".",
"count",
"]",
",",
"n",
")",
"\n",
"s",
".",
"count",
"++",
"\n",
"}"
] |
// Push adds a node to the stack.
|
[
"Push",
"adds",
"a",
"node",
"to",
"the",
"stack",
"."
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/lib/types.go#L81-L84
|
11,591 |
tebeka/go2xunit
|
lib/types.go
|
Pop
|
func (s *SuiteStack) Pop() *Suite {
if s.count == 0 {
return nil
}
s.count--
return s.nodes[s.count]
}
|
go
|
func (s *SuiteStack) Pop() *Suite {
if s.count == 0 {
return nil
}
s.count--
return s.nodes[s.count]
}
|
[
"func",
"(",
"s",
"*",
"SuiteStack",
")",
"Pop",
"(",
")",
"*",
"Suite",
"{",
"if",
"s",
".",
"count",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"s",
".",
"count",
"--",
"\n",
"return",
"s",
".",
"nodes",
"[",
"s",
".",
"count",
"]",
"\n",
"}"
] |
// Pop removes and returns a node from the stack in last to first order.
|
[
"Pop",
"removes",
"and",
"returns",
"a",
"node",
"from",
"the",
"stack",
"in",
"last",
"to",
"first",
"order",
"."
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/lib/types.go#L87-L93
|
11,592 |
tebeka/go2xunit
|
lib/parsers2.go
|
NewGtParser
|
func NewGtParser(in io.Reader) Parser {
return &GtParser{
suite: nil,
tests: make(map[string]*Test),
lex: NewGotestLexer(in),
}
}
|
go
|
func NewGtParser(in io.Reader) Parser {
return &GtParser{
suite: nil,
tests: make(map[string]*Test),
lex: NewGotestLexer(in),
}
}
|
[
"func",
"NewGtParser",
"(",
"in",
"io",
".",
"Reader",
")",
"Parser",
"{",
"return",
"&",
"GtParser",
"{",
"suite",
":",
"nil",
",",
"tests",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Test",
")",
",",
"lex",
":",
"NewGotestLexer",
"(",
"in",
")",
",",
"}",
"\n",
"}"
] |
// NewGtParser return a new gotest parser
|
[
"NewGtParser",
"return",
"a",
"new",
"gotest",
"parser"
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/lib/parsers2.go#L35-L41
|
11,593 |
tebeka/go2xunit
|
cmdline.go
|
validateArgs
|
func validateArgs() error {
if flag.NArg() > 0 {
return fmt.Errorf("%s does not take parameters (did you mean -input?)", os.Args[0])
}
if args.bambooOut && args.xunitnetOut {
return fmt.Errorf("-bamboo and -xunitnet are mutually exclusive")
}
return nil
}
|
go
|
func validateArgs() error {
if flag.NArg() > 0 {
return fmt.Errorf("%s does not take parameters (did you mean -input?)", os.Args[0])
}
if args.bambooOut && args.xunitnetOut {
return fmt.Errorf("-bamboo and -xunitnet are mutually exclusive")
}
return nil
}
|
[
"func",
"validateArgs",
"(",
")",
"error",
"{",
"if",
"flag",
".",
"NArg",
"(",
")",
">",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"os",
".",
"Args",
"[",
"0",
"]",
")",
"\n",
"}",
"\n\n",
"if",
"args",
".",
"bambooOut",
"&&",
"args",
".",
"xunitnetOut",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// validateArgs validates command line arguments
|
[
"validateArgs",
"validates",
"command",
"line",
"arguments"
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/cmdline.go#L41-L51
|
11,594 |
tebeka/go2xunit
|
main.go
|
getInput
|
func getInput(filename string) (*os.File, error) {
if filename == "-" || filename == "" {
return os.Stdin, nil
}
return os.Open(filename)
}
|
go
|
func getInput(filename string) (*os.File, error) {
if filename == "-" || filename == "" {
return os.Stdin, nil
}
return os.Open(filename)
}
|
[
"func",
"getInput",
"(",
"filename",
"string",
")",
"(",
"*",
"os",
".",
"File",
",",
"error",
")",
"{",
"if",
"filename",
"==",
"\"",
"\"",
"||",
"filename",
"==",
"\"",
"\"",
"{",
"return",
"os",
".",
"Stdin",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"os",
".",
"Open",
"(",
"filename",
")",
"\n",
"}"
] |
// getInput return input io.File from file name, if file name is - it will
// return os.Stdin
|
[
"getInput",
"return",
"input",
"io",
".",
"File",
"from",
"file",
"name",
"if",
"file",
"name",
"is",
"-",
"it",
"will",
"return",
"os",
".",
"Stdin"
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/main.go#L20-L26
|
11,595 |
tebeka/go2xunit
|
main.go
|
getOutput
|
func getOutput(filename string) (*os.File, error) {
if filename == "-" || filename == "" {
return os.Stdout, nil
}
return os.Create(filename)
}
|
go
|
func getOutput(filename string) (*os.File, error) {
if filename == "-" || filename == "" {
return os.Stdout, nil
}
return os.Create(filename)
}
|
[
"func",
"getOutput",
"(",
"filename",
"string",
")",
"(",
"*",
"os",
".",
"File",
",",
"error",
")",
"{",
"if",
"filename",
"==",
"\"",
"\"",
"||",
"filename",
"==",
"\"",
"\"",
"{",
"return",
"os",
".",
"Stdout",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"os",
".",
"Create",
"(",
"filename",
")",
"\n",
"}"
] |
// getInput return output io.File from file name, if file name is - it will
// return os.Stdout
|
[
"getInput",
"return",
"output",
"io",
".",
"File",
"from",
"file",
"name",
"if",
"file",
"name",
"is",
"-",
"it",
"will",
"return",
"os",
".",
"Stdout"
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/main.go#L30-L36
|
11,596 |
tebeka/go2xunit
|
main.go
|
getIO
|
func getIO(inFile, outFile string) (*os.File, io.Writer, error) {
input, err := getInput(inFile)
if err != nil {
return nil, nil, fmt.Errorf("can't open %s for reading: %s", inFile, err)
}
output, err := getOutput(outFile)
if err != nil {
return nil, nil, fmt.Errorf("can't open %s for writing: %s", outFile, err)
}
return input, output, nil
}
|
go
|
func getIO(inFile, outFile string) (*os.File, io.Writer, error) {
input, err := getInput(inFile)
if err != nil {
return nil, nil, fmt.Errorf("can't open %s for reading: %s", inFile, err)
}
output, err := getOutput(outFile)
if err != nil {
return nil, nil, fmt.Errorf("can't open %s for writing: %s", outFile, err)
}
return input, output, nil
}
|
[
"func",
"getIO",
"(",
"inFile",
",",
"outFile",
"string",
")",
"(",
"*",
"os",
".",
"File",
",",
"io",
".",
"Writer",
",",
"error",
")",
"{",
"input",
",",
"err",
":=",
"getInput",
"(",
"inFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"inFile",
",",
"err",
")",
"\n",
"}",
"\n\n",
"output",
",",
"err",
":=",
"getOutput",
"(",
"outFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"outFile",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"input",
",",
"output",
",",
"nil",
"\n",
"}"
] |
// getIO returns input and output streams from file names
|
[
"getIO",
"returns",
"input",
"and",
"output",
"streams",
"from",
"file",
"names"
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/main.go#L39-L51
|
11,597 |
tebeka/go2xunit
|
lib/xmlout.go
|
calcTotals
|
func (r *TestResults) calcTotals() {
totalTime, _ := strconv.ParseFloat(r.Time, 64)
for _, suite := range r.Suites {
r.NumPassed += suite.NumPassed()
r.NumFailed += suite.NumFailed()
r.NumSkipped += suite.NumSkipped()
suiteTime, _ := strconv.ParseFloat(suite.Time, 64)
totalTime += suiteTime
r.Time = fmt.Sprintf("%.3f", totalTime)
}
r.Len = r.NumPassed + r.NumSkipped + r.NumFailed
}
|
go
|
func (r *TestResults) calcTotals() {
totalTime, _ := strconv.ParseFloat(r.Time, 64)
for _, suite := range r.Suites {
r.NumPassed += suite.NumPassed()
r.NumFailed += suite.NumFailed()
r.NumSkipped += suite.NumSkipped()
suiteTime, _ := strconv.ParseFloat(suite.Time, 64)
totalTime += suiteTime
r.Time = fmt.Sprintf("%.3f", totalTime)
}
r.Len = r.NumPassed + r.NumSkipped + r.NumFailed
}
|
[
"func",
"(",
"r",
"*",
"TestResults",
")",
"calcTotals",
"(",
")",
"{",
"totalTime",
",",
"_",
":=",
"strconv",
".",
"ParseFloat",
"(",
"r",
".",
"Time",
",",
"64",
")",
"\n",
"for",
"_",
",",
"suite",
":=",
"range",
"r",
".",
"Suites",
"{",
"r",
".",
"NumPassed",
"+=",
"suite",
".",
"NumPassed",
"(",
")",
"\n",
"r",
".",
"NumFailed",
"+=",
"suite",
".",
"NumFailed",
"(",
")",
"\n",
"r",
".",
"NumSkipped",
"+=",
"suite",
".",
"NumSkipped",
"(",
")",
"\n\n",
"suiteTime",
",",
"_",
":=",
"strconv",
".",
"ParseFloat",
"(",
"suite",
".",
"Time",
",",
"64",
")",
"\n",
"totalTime",
"+=",
"suiteTime",
"\n",
"r",
".",
"Time",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"totalTime",
")",
"\n",
"}",
"\n",
"r",
".",
"Len",
"=",
"r",
".",
"NumPassed",
"+",
"r",
".",
"NumSkipped",
"+",
"r",
".",
"NumFailed",
"\n",
"}"
] |
// calcTotals calculates grand total for all suites
|
[
"calcTotals",
"calculates",
"grand",
"total",
"for",
"all",
"suites"
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/lib/xmlout.go#L85-L97
|
11,598 |
tebeka/go2xunit
|
lib/xmlout.go
|
WriteXML
|
func WriteXML(suites []*Suite, out io.Writer, xmlTemplate string, testTime time.Time) {
testsResult := TestResults{
Suites: suites,
Assembly: suites[len(suites)-1].Name,
RunDate: testTime.Format("2006-01-02"),
RunTime: testTime.Format("15:04:05"),
Skipped: Skipped,
Passed: Passed,
Failed: Failed,
}
testsResult.calcTotals()
t := template.New("test template").Funcs(template.FuncMap{
"escape": escapeForXML,
})
t, err := t.Parse(xml.Header + xmlTemplate)
if err != nil {
fmt.Printf("Error in parse %v\n", err)
return
}
err = t.Execute(out, testsResult)
if err != nil {
fmt.Printf("Error in execute %v\n", err)
return
}
}
|
go
|
func WriteXML(suites []*Suite, out io.Writer, xmlTemplate string, testTime time.Time) {
testsResult := TestResults{
Suites: suites,
Assembly: suites[len(suites)-1].Name,
RunDate: testTime.Format("2006-01-02"),
RunTime: testTime.Format("15:04:05"),
Skipped: Skipped,
Passed: Passed,
Failed: Failed,
}
testsResult.calcTotals()
t := template.New("test template").Funcs(template.FuncMap{
"escape": escapeForXML,
})
t, err := t.Parse(xml.Header + xmlTemplate)
if err != nil {
fmt.Printf("Error in parse %v\n", err)
return
}
err = t.Execute(out, testsResult)
if err != nil {
fmt.Printf("Error in execute %v\n", err)
return
}
}
|
[
"func",
"WriteXML",
"(",
"suites",
"[",
"]",
"*",
"Suite",
",",
"out",
"io",
".",
"Writer",
",",
"xmlTemplate",
"string",
",",
"testTime",
"time",
".",
"Time",
")",
"{",
"testsResult",
":=",
"TestResults",
"{",
"Suites",
":",
"suites",
",",
"Assembly",
":",
"suites",
"[",
"len",
"(",
"suites",
")",
"-",
"1",
"]",
".",
"Name",
",",
"RunDate",
":",
"testTime",
".",
"Format",
"(",
"\"",
"\"",
")",
",",
"RunTime",
":",
"testTime",
".",
"Format",
"(",
"\"",
"\"",
")",
",",
"Skipped",
":",
"Skipped",
",",
"Passed",
":",
"Passed",
",",
"Failed",
":",
"Failed",
",",
"}",
"\n",
"testsResult",
".",
"calcTotals",
"(",
")",
"\n",
"t",
":=",
"template",
".",
"New",
"(",
"\"",
"\"",
")",
".",
"Funcs",
"(",
"template",
".",
"FuncMap",
"{",
"\"",
"\"",
":",
"escapeForXML",
",",
"}",
")",
"\n\n",
"t",
",",
"err",
":=",
"t",
".",
"Parse",
"(",
"xml",
".",
"Header",
"+",
"xmlTemplate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"err",
"=",
"t",
".",
"Execute",
"(",
"out",
",",
"testsResult",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}"
] |
// WriteXML exits xunit XML of tests to out
|
[
"WriteXML",
"exits",
"xunit",
"XML",
"of",
"tests",
"to",
"out"
] |
a6d2debe0214087450ec59555dd656c9f76ef85e
|
https://github.com/tebeka/go2xunit/blob/a6d2debe0214087450ec59555dd656c9f76ef85e/lib/xmlout.go#L108-L133
|
11,599 |
hashicorp/go-checkpoint
|
telemetry.go
|
Report
|
func Report(ctx context.Context, r *ReportParams) error {
if disabled := os.Getenv("CHECKPOINT_DISABLE"); disabled != "" {
return nil
}
req, err := ReportRequest(r)
if err != nil {
return err
}
client := cleanhttp.DefaultClient()
resp, err := client.Do(req.WithContext(ctx))
if err != nil {
return err
}
if resp.StatusCode != 201 {
return fmt.Errorf("Unknown status: %d", resp.StatusCode)
}
return nil
}
|
go
|
func Report(ctx context.Context, r *ReportParams) error {
if disabled := os.Getenv("CHECKPOINT_DISABLE"); disabled != "" {
return nil
}
req, err := ReportRequest(r)
if err != nil {
return err
}
client := cleanhttp.DefaultClient()
resp, err := client.Do(req.WithContext(ctx))
if err != nil {
return err
}
if resp.StatusCode != 201 {
return fmt.Errorf("Unknown status: %d", resp.StatusCode)
}
return nil
}
|
[
"func",
"Report",
"(",
"ctx",
"context",
".",
"Context",
",",
"r",
"*",
"ReportParams",
")",
"error",
"{",
"if",
"disabled",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
";",
"disabled",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"ReportRequest",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"client",
":=",
"cleanhttp",
".",
"DefaultClient",
"(",
")",
"\n",
"resp",
",",
"err",
":=",
"client",
".",
"Do",
"(",
"req",
".",
"WithContext",
"(",
"ctx",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"201",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"resp",
".",
"StatusCode",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Report sends telemetry information to checkpoint
|
[
"Report",
"sends",
"telemetry",
"information",
"to",
"checkpoint"
] |
bbe6c410aa4be4194cb490a2bde8c3c33f295541
|
https://github.com/hashicorp/go-checkpoint/blob/bbe6c410aa4be4194cb490a2bde8c3c33f295541/telemetry.go#L57-L77
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.