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)
}
//export Java_io_v_android_v23_V_nativeInitGlobalAndroid
func Java_io_v_android_v23_V_nativeInitGlobalAndroid(jenv *C.JNIEnv, _ C.jclass, jOptions C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
jOpts := jutil.Object(uintptr(unsafe.Pointer(jOptions)))
// Don't allow broken stderr/out to kill our program due to
// sigpipe. Note that we just ignore all these signals.
ch := make(chan os.Signal)
signal.Notify(ch, syscall.SIGPIPE)
if err := Init(env); err != nil {
jutil.JThrowV(env, err)
return
}
// Setup logging.
_, _, level, vmodule, err := loggingOpts(env, jOpts)
if err != nil {
jutil.JThrowV(env, err)
return
}
// Disable any logging to STDERR.
// This assumes that vlog.Log is the underlying logging system for.
vlog.Log.Configure(vlog.OverridePriorConfiguration(true), vlog.LogToStderr(false), vlog.AlsoLogToStderr(false), level, vmodule)
// Setup discovery plugins.
if err := jdplugins.Init(env); err != nil {
jutil.JThrowV(env, err)
return
}
// Setup namespace.
android.SetNamespaceFactory(func(ctx *context.T, ns namespace.T, _ ...string) (namespace.T, error) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jContext, err := jcontext.JavaContext(env, ctx, nil)
if err != nil {
return nil, err
}
contextSign := jutil.ClassSign("io.v.v23.context.VContext")
wakeupMountRoot, err := jutil.CallStaticStringMethod(env, jVClass, "getWakeupMountRoot", []jutil.Sign{contextSign}, jContext)
if err != nil {
return nil, err
}
if wakeupMountRoot == "" {
return ns, nil
}
if !naming.Rooted(wakeupMountRoot) {
return nil, fmt.Errorf("wakeup mount root %s must be ... rooted.", wakeupMountRoot)
}
return &wakeupNamespace{
wakeupMountRoot: wakeupMountRoot,
ns: ns,
}, nil
})
}
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) Context() *context.T {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
contextSign := jutil.ClassSign("io.v.v23.context.VContext")
jCtx, err := jutil.CallObjectMethod(env, c.jCall, "context", nil, contextSign)
if err != nil {
log.Printf("Couldn't get Java Vanadium context: %v", err)
}
ctx, _, err := jcontext.GoContext(env, jCtx)
if err != nil {
log.Printf("Couldn't convert Java Vanadium context to Go: %v", err)
}
return ctx
}
// 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 (j javaGlobber) Glob__(ctx *context.T, call rpc.GlobServerCall, g *glob.Glob) error {
// TODO(sjr,rthellend): Update the Java API to match the new GO API.
env, freeFunc := jutil.GetEnv()
jContext, err := jcontext.JavaContext(env, ctx, nil)
if err != nil {
freeFunc()
return err
}
jServerCall, err := JavaServerCall(env, call)
if err != nil {
freeFunc()
return err
}
convert := func(input jutil.Object) (interface{}, error) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
var reply naming.GlobReply
if err := jutil.GoVomCopy(env, input, jGlobReplyClass, &reply); err != nil {
return nil, err
}
return reply, nil
}
send := func(item interface{}) error {
reply, ok := item.(naming.GlobReply)
if !ok {
return fmt.Errorf("Expected item of type naming.GlobReply, got: %T", reply)
}
return call.SendStream().Send(reply)
}
close := func() error {
return nil
}
jOutputChannel, err := jchannel.JavaOutputChannel(env, ctx, nil, convert, send, close)
if err != nil {
freeFunc()
return err
}
channelSign := jutil.ClassSign("io.v.v23.OutputChannel")
// This method will invoke the freeFunc().
_, err = jutil.CallStaticFutureMethod(env, freeFunc, jServerRPCHelperClass, "glob", []jutil.Sign{invokerSign, contextSign, serverCallSign, jutil.StringSign, channelSign}, j.i.jInvoker, jContext, jServerCall, g.String(), jOutputChannel)
return err
}
// javaStreamServerCall converts the provided Go serverCall into a Java StreamServerCall
// object.
func javaStreamServerCall(env jutil.Env, jContext jutil.Object, call rpc.StreamServerCall) (jutil.Object, error) {
if call == nil {
return jutil.NullObject, fmt.Errorf("Go StreamServerCall value cannot be nil")
}
jStream, err := javaStream(env, jContext, call)
if err != nil {
return jutil.NullObject, err
}
jServerCall, err := JavaServerCall(env, call)
if err != nil {
return jutil.NullObject, err
}
serverCallSign := jutil.ClassSign("io.v.v23.rpc.ServerCall")
ref := jutil.GoNewRef(&call) // Un-refed when the Java StreamServerCall object is finalized.
jStreamServerCall, err := jutil.NewObject(env, jStreamServerCallImplClass, []jutil.Sign{jutil.LongSign, streamSign, serverCallSign}, int64(ref), jStream, jServerCall)
if err != nil {
jutil.GoDecRef(ref)
return jutil.NullObject, err
}
return jStreamServerCall, nil
}
func (s *signer) PublicKey() security.PublicKey {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
publicKeySign := jutil.ClassSign("java.security.interfaces.ECPublicKey")
jPublicKey, err := jutil.CallObjectMethod(env, s.jSigner, "publicKey", nil, publicKeySign)
if err != nil {
log.Printf("Couldn't get Java public key: %v", err)
return nil
}
// Get the encoded version of the public key.
encoded, err := jutil.CallByteArrayMethod(env, jPublicKey, "getEncoded", nil)
if err != nil {
log.Printf("Couldn't get encoded data for Java public key: %v", err)
return nil
}
key, err := security.UnmarshalPublicKey(encoded)
if err != nil {
log.Printf("Couldn't parse Java ECDSA public key: " + err.Error())
return nil
}
return key
}
"v.io/x/ref/lib/dispatcher"
"v.io/x/ref/services/syncbase/discovery"
"v.io/x/ref/services/syncbase/server"
"v.io/x/ref/services/syncbase/vsync"
jrpc "v.io/x/jni/impl/google/rpc"
jutil "v.io/x/jni/util"
jcontext "v.io/x/jni/v23/context"
jaccess "v.io/x/jni/v23/security/access"
)
// #include "jni.h"
import "C"
var (
permissionsSign = jutil.ClassSign("io.v.v23.security.access.Permissions")
contextSign = jutil.ClassSign("io.v.v23.context.VContext")
storageEngineSign = jutil.ClassSign("io.v.impl.google.services.syncbase.SyncbaseServer$StorageEngine")
serverSign = jutil.ClassSign("io.v.v23.rpc.Server")
idSign = jutil.ClassSign("io.v.v23.services.syncbase.Id")
inviteSign = jutil.ClassSign("io.v.v23.syncbase.Invite")
jVRuntimeImplClass jutil.Class
jInviteClass jutil.Class
)
// Init initializes the JNI code with the given Java environment. This method
// must be invoked before any other method in this package and must be called
// from the main Java thread (e.g., On_Load()).
func Init(env jutil.Env) error {
var err error
"v.io/v23/naming"
"v.io/v23/options"
"v.io/v23/rpc"
"v.io/v23/security"
jnamespace "v.io/x/jni/impl/google/namespace"
jutil "v.io/x/jni/util"
jsecurity "v.io/x/jni/v23/security"
)
// #include "jni.h"
import "C"
var (
authorizerSign = jutil.ClassSign("io.v.v23.security.Authorizer")
mountEntrySign = jutil.ClassSign("io.v.v23.naming.MountEntry")
)
func getAuthorizer(env jutil.Env, obj jutil.Object, field string) (security.Authorizer, error) {
jAuthorizer, err := jutil.JObjectField(env, obj, field, authorizerSign)
if err != nil {
return nil, err
}
if !jAuthorizer.IsNull() {
auth, err := jsecurity.GoAuthorizer(env, jAuthorizer)
if err != nil {
return nil, err
}
return auth, nil
// +build java android
package channel
import (
"unsafe"
jutil "v.io/x/jni/util"
)
// #include "jni.h"
import "C"
var (
contextSign = jutil.ClassSign("io.v.v23.context.VContext")
// Global reference for io.v.impl.google.channel.InputChannelImpl class.
jInputChannelImplClass jutil.Class
// Global reference for io.v.impl.google.channel.OutputChannelImpl class.
jOutputChannelImplClass jutil.Class
)
// Init initializes the JNI code with the given Java environment. This method
// must be invoked before any other method in this package and must be called
// from the main Java thread (e.g., On_Load()).
func Init(env jutil.Env) error {
var err error
jInputChannelImplClass, err = jutil.JFindClass(env, "io/v/impl/google/channel/InputChannelImpl")
if err != nil {
return err
}
jutil "v.io/x/jni/util"
jcontext "v.io/x/jni/v23/context"
"v.io/x/ref/runtime/protocols/lib/framer"
)
const (
bluetoothWithPortClassName = "BluetoothWithPort"
bluetoothWithSdpClassName = "BluetoothWithSdp"
// TODO(jhahn,suharshs): Which one is more reliable?
btClassName = bluetoothWithSdpClassName
)
var (
contextSign = jutil.ClassSign("io.v.v23.context.VContext")
streamSign = jutil.ClassSign("io.v.android.impl.google.rpc.protocols.bt." + btClassName + "$Stream")
listenerSign = jutil.ClassSign("io.v.android.impl.google.rpc.protocols.bt." + btClassName + "$Listener")
// Global reference for io.v.impl.google.rpc.protocols.bt.Bluetooth class.
jBluetoothClass jutil.Class
)
// Init initializes the JNI code with the given Java environment. This method
// must be called from the main Java thread.
func Init(env jutil.Env) error {
// Cache global references to all Java classes used by the package. This is
// necessary because JNI gets access to the class loader only in the system
// thread, so we aren't able to invoke FindClass in other threads.
var err error
jBluetoothClass, err = jutil.JFindClass(env, "io/v/android/impl/google/rpc/protocols/bt/"+btClassName)
package context
import (
"errors"
"unsafe"
"v.io/v23/context"
jutil "v.io/x/jni/util"
)
// #include "jni.h"
// #include <stdlib.h>
import "C"
var (
classSign = jutil.ClassSign("java.lang.Class")
doneReasonSign = jutil.ClassSign("io.v.v23.context.VContext$DoneReason")
// Global reference for io.v.v23.context.VContext class.
jVContextClass jutil.Class
// Global reference for io.v.v23.context.VContext$DoneReason
jDoneReasonClass jutil.Class
)
// Init initializes the JNI code with the given Java environment. This method
// must be called from the main Java thread.
func Init(env jutil.Env) error {
// Cache global references to all Java classes used by the package. This is
// necessary because JNI gets access to the class loader only in the system
// thread, so we aren't able to invoke FindClass in other threads.
var err error
jVContextClass, err = jutil.JFindClass(env, "io/v/v23/context/VContext")
"v.io/v23"
"v.io/v23/security/access"
"v.io/x/ref/services/mounttable/mounttablelib"
"v.io/v23/options"
jrpc "v.io/x/jni/impl/google/rpc"
jutil "v.io/x/jni/util"
jcontext "v.io/x/jni/v23/context"
jaccess "v.io/x/jni/v23/security/access"
)
// #include "jni.h"
import "C"
var (
permissionsSign = jutil.ClassSign("io.v.v23.security.access.Permissions")
contextSign = jutil.ClassSign("io.v.v23.context.VContext")
serverSign = jutil.ClassSign("io.v.v23.rpc.Server")
jVRuntimeImplClass jutil.Class
)
// Init initializes the JNI code with the given Java environment. This method
// must be invoked before any other method in this package and must be called
// from the main Java thread (e.g., On_Load()).
func Init(env jutil.Env) error {
var err error
jVRuntimeImplClass, err = jutil.JFindClass(env, "io/v/impl/google/rt/VRuntimeImpl")
if err != nil {
return err
}
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build java android
package naming
import (
jutil "v.io/x/jni/util"
)
// #include "jni.h"
import "C"
var (
endpointSign = jutil.ClassSign("io.v.v23.naming.Endpoint")
// Global reference for io.v.impl.google.naming.EndpointImpl.
jEndpointImplClass jutil.Class
)
func Init(env jutil.Env) error {
// Cache global references to all Java classes used by the package. This is
// necessary because JNI gets access to the class loader only in the system
// thread, so we aren't able to invoke FindClass in other threads.
var err error
jEndpointImplClass, err = jutil.JFindClass(env, "io/v/impl/google/naming/EndpointImpl")
if err != nil {
return err
}
return 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
}
"v.io/x/lib/vlog"
jble "v.io/x/jni/impl/google/rpc/protocols/ble"
jbt "v.io/x/jni/impl/google/rpc/protocols/bt"
jutil "v.io/x/jni/util"
jcontext "v.io/x/jni/v23/context"
jnaming "v.io/x/jni/v23/naming"
jopts "v.io/x/jni/v23/options"
jsecurity "v.io/x/jni/v23/security"
)
// #include "jni.h"
import "C"
var (
contextSign = jutil.ClassSign("io.v.v23.context.VContext")
dispatcherSign = jutil.ClassSign("io.v.v23.rpc.Dispatcher")
invokerSign = jutil.ClassSign("io.v.v23.rpc.Invoker")
serverCallSign = jutil.ClassSign("io.v.v23.rpc.ServerCall")
streamServerCallSign = jutil.ClassSign("io.v.v23.rpc.StreamServerCall")
listenAddrSign = jutil.ClassSign("io.v.v23.rpc.ListenSpec$Address")
addressChooserSign = jutil.ClassSign("io.v.v23.rpc.AddressChooser")
serverStateSign = jutil.ClassSign("io.v.v23.rpc.ServerState")
streamSign = jutil.ClassSign("io.v.v23.rpc.Stream")
// Global reference for io.v.impl.google.rpc.AddressChooserImpl class.
jAddressChooserImplClass jutil.Class
// Global reference for io.v.impl.google.rpc.ServerImpl class.
jServerImplClass jutil.Class
// Global reference for io.v.impl.google.rpc.ClientImpl class.
jClientImplClass jutil.Class
"path/filepath"
"unsafe"
"v.io/v23"
"v.io/x/ref/services/groups/lib"
jrpc "v.io/x/jni/impl/google/rpc"
jutil "v.io/x/jni/util"
jcontext "v.io/x/jni/v23/context"
)
// #include "jni.h"
import "C"
var (
contextSign = jutil.ClassSign("io.v.v23.context.VContext")
storageEngineSign = jutil.ClassSign("io.v.impl.google.services.groups.GroupServer$StorageEngine")
serverSign = jutil.ClassSign("io.v.v23.rpc.Server")
jVRuntimeImplClass jutil.Class
)
// Init initializes the JNI code with the given Java environment. This method
// must be invoked before any other method in this package and must be called
// from the main Java thread (e.g., On_Load()).
func Init(env jutil.Env) error {
var err error
jVRuntimeImplClass, err = jutil.JFindClass(env, "io/v/impl/google/rt/VRuntimeImpl")
if err != nil {
return err
}
"v.io/v23/verror"
idiscovery "v.io/x/ref/lib/discovery"
gdiscovery "v.io/x/ref/lib/discovery/global"
jchannel "v.io/x/jni/impl/google/channel"
jutil "v.io/x/jni/util"
jcontext "v.io/x/jni/v23/context"
)
// #include "jni.h"
// #include <stdlib.h>
import "C"
var (
adIdSign = jutil.ClassSign("io.v.v23.discovery.AdId")
advertisementSign = jutil.ClassSign("io.v.v23.discovery.Advertisement")
jAdIdClass jutil.Class // io.v.v23.discovery.AdId
jAdvertisementClass jutil.Class // io.v.v23.discovery.Advertisement
jBlessingPatternClass jutil.Class // io.v.v23.security.BlessingPattern
jDiscoveryImplClass jutil.Class // io.v.impl.google.lib.discovery.DiscoveryImpl
jUpdateImplClass jutil.Class // io.v.impl.google.lib.discovery.UpdateImpl
jUUIDClass jutil.Class // java.util.UUID
)
// Init initializes the JNI code with the given Java environment. This method
// must be called from the main Java thread.
func Init(env jutil.Env) error {
// Cache global references to all Java classes used by the package. This is
// necessary because JNI gets access to the class loader only in the system
import (
"fmt"
"unsafe"
"v.io/v23/security"
jutil "v.io/x/jni/util"
jcontext "v.io/x/jni/v23/context"
vsecurity "v.io/x/ref/lib/security"
)
// #include "jni.h"
import "C"
var (
contextSign = jutil.ClassSign("io.v.v23.context.VContext")
dischargeSign = jutil.ClassSign("io.v.v23.security.Discharge")
dischargeImpetusSign = jutil.ClassSign("io.v.v23.security.DischargeImpetus")
principalSign = jutil.ClassSign("io.v.v23.security.VPrincipal")
blessingsSign = jutil.ClassSign("io.v.v23.security.Blessings")
wireBlessingsSign = jutil.ClassSign("io.v.v23.security.WireBlessings")
wireDischargeSign = jutil.ClassSign("io.v.v23.security.WireDischarge")
blessingStoreSign = jutil.ClassSign("io.v.v23.security.BlessingStore")
blessingRootsSign = jutil.ClassSign("io.v.v23.security.BlessingRoots")
blessingPatternSign = jutil.ClassSign("io.v.v23.security.BlessingPattern")
signerSign = jutil.ClassSign("io.v.v23.security.VSigner")
caveatSign = jutil.ClassSign("io.v.v23.security.Caveat")
callSign = jutil.ClassSign("io.v.v23.security.Call")
signatureSign = jutil.ClassSign("io.v.v23.security.VSignature")
idSign = jutil.ClassSign("io.v.v23.uniqueid.Id")
publicKeySign = jutil.ClassSign("java.security.interfaces.ECPublicKey")