func (p *principal) Sign(message []byte) (security.Signature, error) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jSig, err := jutil.CallObjectMethod(env, p.jPrincipal, "sign", []jutil.Sign{jutil.ArraySign(jutil.ByteSign)}, signatureSign, message)
if err != nil {
return security.Signature{}, err
}
return GoSignature(env, jSig)
}
func (s *signer) Sign(purpose, message []byte) (security.Signature, error) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
signatureSign := jutil.ClassSign("io.v.v23.security.VSignature")
jSig, err := jutil.CallObjectMethod(env, s.jSigner, "sign", []jutil.Sign{jutil.ArraySign(jutil.ByteSign), jutil.ArraySign(jutil.ByteSign)}, signatureSign, purpose, message)
if err != nil {
return security.Signature{}, err
}
return GoSignature(env, jSig)
}
func (chooser *jniAddressChooser) ChooseAddresses(protocol string, candidates []net.Addr) ([]net.Addr, error) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jCandidates, err := JavaNetworkAddressArray(env, candidates)
if err != nil {
return nil, err
}
addrsSign := jutil.ArraySign(jutil.ClassSign("io.v.v23.rpc.NetworkAddress"))
jAddrs, err := jutil.CallObjectMethod(env, chooser.jChooser, "choose", []jutil.Sign{jutil.StringSign, addrsSign}, addrsSign, protocol, jCandidates)
if err != nil {
return nil, err
}
return GoNetworkAddressArray(env, jAddrs)
}
func (c *callImpl) MethodTags() []*vdl.Value {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jTags, err := jutil.CallObjectMethod(env, c.jCall, "methodTags", nil, jutil.ArraySign(jutil.VdlValueSign))
if err != nil {
log.Println("Couldn't call Java methodTags method: ", err)
return nil
}
tags, err := jutil.GoVDLValueArray(env, jTags)
if err != nil {
log.Println("Couldn't convert Java tags to Go: ", err)
return nil
}
return tags
}
// GoListenSpec converts the provided Go ListenSpec into a Java ListenSpec.
func JavaListenSpec(env jutil.Env, spec rpc.ListenSpec) (jutil.Object, error) {
jAddrs, err := JavaListenAddrArray(env, spec.Addrs)
if err != nil {
return jutil.NullObject, err
}
jChooser, err := JavaAddressChooser(env, spec.AddressChooser)
if err != nil {
return jutil.NullObject, err
}
addressSign := jutil.ClassSign("io.v.v23.rpc.ListenSpec$Address")
jSpec, err := jutil.NewObject(env, jListenSpecClass, []jutil.Sign{jutil.ArraySign(addressSign), jutil.StringSign, addressChooserSign}, jAddrs, spec.Proxy, jChooser)
if err != nil {
return jutil.NullObject, err
}
return jSpec, nil
}
func (d *driver) StartScan(uuids []string, baseUuid, maskUuid string, handler ble.ScanHandler) error {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
handlerRef := jutil.GoNewRef(&handler) // Un-refed when jNativeScanHandler is finalized.
jNativeScanHandler, err := jutil.NewObject(env, jNativeScanHandlerClass, []jutil.Sign{jutil.LongSign}, int64(handlerRef))
if err != nil {
jutil.GoDecRef(handlerRef)
return err
}
err = jutil.CallVoidMethod(env, d.jDriver, "startScan", []jutil.Sign{jutil.ArraySign(jutil.StringSign), jutil.StringSign, jutil.StringSign, scanHandlerSign}, uuids, baseUuid, maskUuid, jNativeScanHandler)
if err != nil {
jutil.GoDecRef(handlerRef)
return err
}
return nil
}
// GoListenSpec converts the provided Java ListenSpec into a Go ListenSpec.
func GoListenSpec(env jutil.Env, jSpec jutil.Object) (rpc.ListenSpec, error) {
jAddrs, err := jutil.CallObjectMethod(env, jSpec, "getAddresses", nil, jutil.ArraySign(listenAddrSign))
if err != nil {
return rpc.ListenSpec{}, err
}
addrs, err := GoListenAddrs(env, jAddrs)
if err != nil {
return rpc.ListenSpec{}, err
}
proxy, err := jutil.CallStringMethod(env, jSpec, "getProxy", nil)
if err != nil {
return rpc.ListenSpec{}, err
}
jChooser, err := jutil.CallObjectMethod(env, jSpec, "getChooser", nil, addressChooserSign)
if err != nil {
return rpc.ListenSpec{}, err
}
chooser := GoAddressChooser(env, jChooser)
return rpc.ListenSpec{
Addrs: addrs,
Proxy: proxy,
AddressChooser: chooser,
}, nil
}
func (s *blessingStore) ForPeer(peerBlessings ...string) security.Blessings {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jBlessings, err := jutil.CallObjectMethod(env, s.jBlessingStore, "forPeer", []jutil.Sign{jutil.ArraySign(jutil.StringSign)}, blessingsSign, peerBlessings)
if err != nil {
log.Printf("Couldn't call Java forPeer method: %v", err)
return security.Blessings{}
}
blessings, err := GoBlessings(env, jBlessings)
if err != nil {
log.Printf("Couldn't convert Java Blessings into Go: %v", err)
return security.Blessings{}
}
return blessings
}
func (p *principal) BlessSelf(name string, caveats ...security.Caveat) (security.Blessings, error) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jCaveats, err := JavaCaveatArray(env, caveats)
if err != nil {
return security.Blessings{}, err
}
jBlessings, err := jutil.CallObjectMethod(env, p.jPrincipal, "blessSelf", []jutil.Sign{jutil.StringSign, jutil.ArraySign(caveatSign)}, blessingsSign, name, jCaveats)
if err != nil {
return security.Blessings{}, err
}
return GoBlessings(env, jBlessings)
}
func (p *principal) Bless(key security.PublicKey, with security.Blessings, extension string, caveat security.Caveat, additionalCaveats ...security.Caveat) (security.Blessings, error) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jKey, err := JavaPublicKey(env, key)
if err != nil {
return security.Blessings{}, err
}
jWith, err := JavaBlessings(env, with)
if err != nil {
return security.Blessings{}, err
}
jCaveat, err := JavaCaveat(env, caveat)
if err != nil {
return security.Blessings{}, err
}
jAdditionalCaveats, err := JavaCaveatArray(env, additionalCaveats)
if err != nil {
return security.Blessings{}, err
}
jBlessings, err := jutil.CallObjectMethod(env, p.jPrincipal, "bless", []jutil.Sign{publicKeySign, blessingsSign, jutil.StringSign, caveatSign, jutil.ArraySign(caveatSign)}, blessingsSign, jKey, jWith, extension, jCaveat, jAdditionalCaveats)
if err != nil {
return security.Blessings{}, err
}
return GoBlessings(env, jBlessings)
}
func (i *invoker) Invoke(ctx *context.T, call rpc.StreamServerCall, method string, argptrs []interface{}) (results []interface{}, err error) {
env, freeFunc := jutil.GetEnv()
jContext, err := jcontext.JavaContext(env, ctx, nil)
if err != nil {
freeFunc()
return nil, err
}
jStreamServerCall, err := javaStreamServerCall(env, jContext, call)
if err != nil {
freeFunc()
return nil, err
}
vomArgs := make([][]byte, len(argptrs))
for i, argptr := range argptrs {
arg := interface{}(jutil.DerefOrDie(argptr))
var err error
if vomArgs[i], err = vom.Encode(arg); err != nil {
freeFunc()
return nil, err
}
}
// This method will invoke the freeFunc().
jResult, err := jutil.CallStaticFutureMethod(env, freeFunc, jServerRPCHelperClass, "invoke", []jutil.Sign{invokerSign, contextSign, streamServerCallSign, jutil.StringSign, jutil.ArraySign(jutil.ArraySign(jutil.ByteSign))}, i.jInvoker, jContext, jStreamServerCall, jutil.CamelCase(method), vomArgs)
if err != nil {
return nil, err
}
env, freeFunc = jutil.GetEnv()
defer freeFunc()
defer jutil.DeleteGlobalRef(env, jResult)
vomResults, err := jutil.GoByteArrayArray(env, jResult)
if err != nil {
return nil, err
}
results = make([]interface{}, len(vomResults))
for i, vomResult := range vomResults {
var err error
if results[i], err = jutil.VomDecodeToValue(vomResult); err != nil {
return nil, err
}
}
return results, nil
}
// JavaPublicKeyFromDER converts a DER-encoded public key into a Java PublicKey object.
func JavaPublicKeyFromDER(env jutil.Env, der []byte) (jutil.Object, error) {
jPublicKey, err := jutil.CallStaticObjectMethod(env, jUtilClass, "decodePublicKey", []jutil.Sign{jutil.ArraySign(jutil.ByteSign)}, publicKeySign, der)
if err != nil {
return jutil.NullObject, err
}
return jPublicKey, nil
}
// JavaServerStatus converts the provided rpc.ServerStatus value into a Java
// ServerStatus object.
func JavaServerStatus(env jutil.Env, status rpc.ServerStatus) (jutil.Object, error) {
// Create Java state enum value.
jState, err := JavaServerState(env, status.State)
if err != nil {
return jutil.NullObject, err
}
// Create Java array of publisher entries.
pubarr := make([]jutil.Object, len(status.PublisherStatus))
for i, e := range status.PublisherStatus {
var err error
if pubarr[i], err = JavaPublisherEntry(env, e); err != nil {
return jutil.NullObject, err
}
}
jPublisherStatus, err := jutil.JObjectArray(env, pubarr, jPublisherEntryClass)
if err != nil {
return jutil.NullObject, err
}
// Create an array of endpoint strings.
eps := make([]string, len(status.Endpoints))
for i, ep := range status.Endpoints {
eps[i] = ep.String()
}
lnErrors := make(map[jutil.Object]jutil.Object)
for addr, lerr := range status.ListenErrors {
jAddr, err := JavaListenAddr(env, addr.Protocol, addr.Address)
if err != nil {
return jutil.NullObject, err
}
jVExp, err := jutil.JVException(env, lerr)
if err != nil {
return jutil.NullObject, err
}
lnErrors[jAddr] = jVExp
}
jLnErrors, err := jutil.JObjectMap(env, lnErrors)
if err != nil {
return jutil.NullObject, err
}
proxyErrors := make(map[jutil.Object]jutil.Object)
for s, perr := range status.ProxyErrors {
jVExp, err := jutil.JVException(env, perr)
if err != nil {
return jutil.NullObject, err
}
proxyErrors[jutil.JString(env, s)] = jVExp
}
jProxyErrors, err := jutil.JObjectMap(env, proxyErrors)
if err != nil {
return jutil.NullObject, err
}
// Create final server status.
publisherEntrySign := jutil.ClassSign("io.v.v23.rpc.PublisherEntry")
jServerStatus, err := jutil.NewObject(env, jServerStatusClass, []jutil.Sign{serverStateSign, jutil.BoolSign, jutil.ArraySign(publisherEntrySign), jutil.ArraySign(jutil.StringSign), jutil.MapSign, jutil.MapSign}, jState, status.ServesMountTable, jPublisherStatus, eps, jLnErrors, jProxyErrors)
if err != nil {
return jutil.NullObject, err
}
return jServerStatus, nil
}