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 }