//export Java_io_v_v23_security_PublicKeyThirdPartyCaveatValidator_nativeValidate
func Java_io_v_v23_security_PublicKeyThirdPartyCaveatValidator_nativeValidate(jenv *C.JNIEnv, jThirdPartyValidatorClass C.jclass, jContext C.jobject, jCall C.jobject, jCaveatParam C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
param, err := jutil.GoVomCopyValue(env, jutil.Object(uintptr(unsafe.Pointer(jCaveatParam))))
if err != nil {
jutil.JThrowV(env, err)
return
}
ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext))))
if err != nil {
jutil.JThrowV(env, err)
return
}
call, err := GoCall(env, jutil.Object(uintptr(unsafe.Pointer(jCall))))
if err != nil {
jutil.JThrowV(env, err)
return
}
caveat, err := security.NewCaveat(security.PublicKeyThirdPartyCaveat, param)
if err != nil {
jutil.JThrowV(env, err)
return
}
if err := caveat.Validate(ctx, call); err != nil {
jutil.JThrowV(env, err)
return
}
}
//export Java_io_v_v23_security_BlessingRootsImpl_nativeDump
func Java_io_v_v23_security_BlessingRootsImpl_nativeDump(jenv *C.JNIEnv, jBlessingRootsImpl C.jobject, goRef C.jlong) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
dump := (*(*security.BlessingRoots)(jutil.GoRefValue(jutil.Ref(goRef)))).Dump()
result := make(map[jutil.Object][]jutil.Object)
for pattern, keys := range dump {
jBlessingPattern, err := JavaBlessingPattern(env, pattern)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
jPublicKeys := make([]jutil.Object, len(keys))
for i, key := range keys {
var err error
if jPublicKeys[i], err = JavaPublicKey(env, key); err != nil {
jutil.JThrowV(env, err)
return nil
}
}
result[jBlessingPattern] = jPublicKeys
}
jMap, err := jutil.JObjectMultimap(env, result)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jMap))
}
//export Java_io_v_v23_security_access_PermissionsAuthorizer_nativeCreate
func Java_io_v_v23_security_access_PermissionsAuthorizer_nativeCreate(jenv *C.JNIEnv, jPermissionsAuthorizerClass C.jclass, jPermissions C.jobject, jTagType C.jobject) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
perms, err := GoPermissions(env, jutil.Object(uintptr(unsafe.Pointer(jPermissions))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
tagType, err := jutil.GoVdlType(env, jutil.Object(uintptr(unsafe.Pointer(jTagType))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
authorizer, err := access.PermissionsAuthorizer(perms, tagType)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
ref := jutil.GoNewRef(&authorizer) // Un-refed when the Java PermissionsAuthorizer is finalized
jAuthorizer, err := jutil.NewObject(env, jutil.Class(uintptr(unsafe.Pointer(jPermissionsAuthorizerClass))), []jutil.Sign{jutil.LongSign}, int64(ref))
if err != nil {
jutil.GoDecRef(ref)
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jAuthorizer))
}
//export Java_io_v_impl_google_lib_discovery_GlobalDiscovery_nativeNewDiscovery
func Java_io_v_impl_google_lib_discovery_GlobalDiscovery_nativeNewDiscovery(jenv *C.JNIEnv, jRuntime C.jclass, jContext C.jobject, jPath C.jstring, jMountTTL, jScanInterval C.jobject) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
path := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jPath))))
mountTTL, err := jutil.GoDuration(env, jutil.Object(uintptr(unsafe.Pointer(jMountTTL))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
scanInterval, err := jutil.GoDuration(env, jutil.Object(uintptr(unsafe.Pointer(jScanInterval))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
discovery, err := gdiscovery.NewWithTTL(ctx, path, mountTTL, scanInterval)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
jDiscovery, err := JavaDiscovery(env, discovery)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jDiscovery))
}
//export Java_io_v_v23_security_VPrincipalImpl_nativeCreatePersistentForSigner
func Java_io_v_v23_security_VPrincipalImpl_nativeCreatePersistentForSigner(jenv *C.JNIEnv, jclass C.jclass, jSigner C.jobject, jDir C.jstring) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
signerObj := jutil.Object(uintptr(unsafe.Pointer(jSigner)))
signer, err := GoSigner(env, signerObj)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
dir := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jDir))))
stateSerializer, err := vsecurity.NewPrincipalStateSerializer(dir)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
principal, err := vsecurity.NewPrincipalFromSigner(signer, stateSerializer)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
ref := jutil.GoNewRef(&principal) // Un-refed when the Java VPrincipalImpl is finalized.
jPrincipal, err := jutil.NewObject(env, jVPrincipalImplClass, []jutil.Sign{jutil.LongSign, signerSign, blessingStoreSign, blessingRootsSign}, int64(ref), signerObj, jutil.NullObject, jutil.NullObject)
if err != nil {
jutil.GoDecRef(ref)
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jPrincipal))
}
//export Java_io_v_v23_security_VSecurity_nativeGetSigningBlessingNames
func Java_io_v_v23_security_VSecurity_nativeGetSigningBlessingNames(jenv *C.JNIEnv, jVSecurityClass C.jclass, jCtx C.jobject, jPrincipal C.jobject, jBlessings C.jobject) C.jobjectArray {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jCtx))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
principal, err := GoPrincipal(env, jutil.Object(uintptr(unsafe.Pointer(jPrincipal))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
blessings, err := GoBlessings(env, jutil.Object(uintptr(unsafe.Pointer(jBlessings))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
blessingStrs, _ := security.SigningBlessingNames(ctx, principal, blessings)
jArr, err := jutil.JStringArray(env, blessingStrs)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobjectArray(unsafe.Pointer(jArr))
}
//export Java_io_v_v23_security_VSecurity_nativeCreateAuthorizer
func Java_io_v_v23_security_VSecurity_nativeCreateAuthorizer(jenv *C.JNIEnv, jVSecurityClass C.jclass, kind C.jint, jKey C.jobject) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
var auth security.Authorizer
switch kind {
case 0:
auth = security.AllowEveryone()
case 1:
auth = security.EndpointAuthorizer()
case 2:
auth = security.DefaultAuthorizer()
case 3:
key, err := GoPublicKey(env, jutil.Object(uintptr(unsafe.Pointer(jKey))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
auth = security.PublicKeyAuthorizer(key)
default:
return nil
}
ref := jutil.GoNewRef(&auth) // Un-refed when the Java PermissionsAuthorizer is finalized
jAuthorizer, err := jutil.NewObject(env, jutil.Class(uintptr(unsafe.Pointer(jPermissionsAuthorizerClass))), []jutil.Sign{jutil.LongSign}, int64(ref))
if err != nil {
jutil.GoDecRef(ref)
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jAuthorizer))
}
//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
})
}
//export Java_io_v_v23_security_BlessingStoreImpl_nativeSetDefaultBlessings
func Java_io_v_v23_security_BlessingStoreImpl_nativeSetDefaultBlessings(jenv *C.JNIEnv, jBlessingStoreImpl C.jobject, goRef C.jlong, jBlessings C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
blessings, err := GoBlessings(env, jutil.Object(uintptr(unsafe.Pointer(jBlessings))))
if err != nil {
jutil.JThrowV(env, err)
return
}
if err := (*(*security.BlessingStore)(jutil.GoRefValue(jutil.Ref(goRef)))).SetDefault(blessings); err != nil {
jutil.JThrowV(env, err)
}
}
//export Java_io_v_v23_security_BlessingRootsImpl_nativeRecognized
func Java_io_v_v23_security_BlessingRootsImpl_nativeRecognized(jenv *C.JNIEnv, jBlessingRootsImpl C.jobject, goRef C.jlong, jRoot C.jobject, jBlessing C.jstring) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
root, err := JavaPublicKeyToDER(env, jutil.Object(uintptr(unsafe.Pointer(jRoot))))
if err != nil {
jutil.JThrowV(env, err)
return
}
blessing := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jBlessing))))
if err := (*(*security.BlessingRoots)(jutil.GoRefValue(jutil.Ref(goRef)))).Recognized(root, blessing); err != nil {
jutil.JThrowV(env, err)
}
}
//export Java_io_v_impl_google_namespace_NamespaceImpl_nativeSetRoots
func Java_io_v_impl_google_namespace_NamespaceImpl_nativeSetRoots(jenv *C.JNIEnv, jNamespaceClass C.jclass, goRef C.jlong, jNames C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
n := *(*namespace.T)(jutil.GoRefValue(jutil.Ref(goRef)))
names, err := jutil.GoStringList(env, jutil.Object(uintptr(unsafe.Pointer(jNames))))
if err != nil {
jutil.JThrowV(env, err)
return
}
err = n.SetRoots(names...)
if err != nil {
jutil.JThrowV(env, err)
}
}
//export Java_io_v_v23_syncbase_DatabaseImpl_nativeListenForInvites
func Java_io_v_v23_syncbase_DatabaseImpl_nativeListenForInvites(jenv *C.JNIEnv, jDatabase C.jobject, jContext C.jobject, jInviteHandler C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
database := jutil.Object(uintptr(unsafe.Pointer(jDatabase)))
handler := jutil.Object(uintptr(unsafe.Pointer(jInviteHandler)))
ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext))))
if err != nil {
jutil.JThrowV(env, err)
return
}
jDbId, err := jutil.CallObjectMethod(env, database, "id", nil, idSign)
if err != nil {
jutil.JThrowV(env, err)
return
}
dbName, err := jutil.CallStringMethod(env, jDbId, "getName", nil)
if err != nil {
jutil.JThrowV(env, err)
return
}
dbBlessing, err := jutil.CallStringMethod(env, jDbId, "getBlessing", nil)
if err != nil {
jutil.JThrowV(env, err)
return
}
dbId := wire.Id{Name: dbName, Blessing: dbBlessing}
// Note: There is no need to use a buffered channel here. ListenForInvites
// spawns a goroutine for this listener that acts as an infinite buffer so we can
// process invites at our own pace.
ch := make(chan discovery.Invite)
if err := discovery.ListenForInvites(ctx, dbId, ch); err != nil {
jutil.JThrowV(env, err)
return
}
handler = jutil.NewGlobalRef(env, handler)
go func() {
for invite := range ch {
if err := handleInvite(invite, handler); err != nil {
// TODO(mattr): We should cancel the stream and return an error to
// the user here.
ctx.Errorf("couldn't call invite handler: %v", err)
}
}
env, free := jutil.GetEnv()
jutil.DeleteGlobalRef(env, handler)
free()
}()
}
//export Java_io_v_v23_security_VPrincipalImpl_nativeCreate
func Java_io_v_v23_security_VPrincipalImpl_nativeCreate(jenv *C.JNIEnv, jclass C.jclass) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
principal, err := vsecurity.NewPrincipal()
if err != nil {
jutil.JThrowV(env, err)
return nil
}
jPrincipal, err := JavaPrincipal(env, principal)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jPrincipal))
}
//export Java_io_v_v23_context_VContext_nativeWithTimeout
func Java_io_v_v23_context_VContext_nativeWithTimeout(jenv *C.JNIEnv, jVContext C.jobject, goRef C.jlong, jTimeout C.jobject) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
timeout, err := jutil.GoDuration(env, jutil.Object(uintptr(unsafe.Pointer(jTimeout))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
ctx, cancelFunc := context.WithTimeout((*context.T)(jutil.GoRefValue(jutil.Ref(goRef))), timeout)
jCtx, err := JavaContext(env, ctx, cancelFunc)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jCtx))
}
//export Java_io_v_v23_security_VSecurity_nativeAddToRoots
func Java_io_v_v23_security_VSecurity_nativeAddToRoots(jenv *C.JNIEnv, jVSecurityClass C.jclass, jPrincipal C.jobject, jBlessings C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
principal, err := GoPrincipal(env, jutil.Object(uintptr(unsafe.Pointer(jPrincipal))))
if err != nil {
jutil.JThrowV(env, err)
}
blessings, err := GoBlessings(env, jutil.Object(uintptr(unsafe.Pointer(jBlessings))))
if err != nil {
jutil.JThrowV(env, err)
return
}
if err := security.AddToRoots(principal, blessings); err != nil {
jutil.JThrowV(env, err)
}
}
//export Java_io_v_v23_security_VPrincipalImpl_nativeSign
func Java_io_v_v23_security_VPrincipalImpl_nativeSign(jenv *C.JNIEnv, jVPrincipalImpl C.jobject, goRef C.jlong, jMessage C.jbyteArray) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
message := jutil.GoByteArray(env, jutil.Object(uintptr(unsafe.Pointer(jMessage))))
sig, err := (*(*security.Principal)(jutil.GoRefValue(jutil.Ref(goRef)))).Sign(message)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
jSig, err := JavaSignature(env, sig)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jSig))
}
//export Java_io_v_v23_security_BlessingStoreImpl_nativeForPeer
func Java_io_v_v23_security_BlessingStoreImpl_nativeForPeer(jenv *C.JNIEnv, jBlessingStoreImpl C.jobject, goRef C.jlong, jPeerBlessings C.jobjectArray) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
peerBlessings, err := jutil.GoStringArray(env, jutil.Object(uintptr(unsafe.Pointer(jPeerBlessings))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
blessings := (*(*security.BlessingStore)(jutil.GoRefValue(jutil.Ref(goRef)))).ForPeer(peerBlessings...)
jBlessings, err := JavaBlessings(env, blessings)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jBlessings))
}
//export Java_io_v_v23_context_VContext_nativeWithDeadline
func Java_io_v_v23_context_VContext_nativeWithDeadline(jenv *C.JNIEnv, jVContext C.jobject, goRef C.jlong, jDeadline C.jobject) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
deadline, err := jutil.GoTime(env, jutil.Object(uintptr(unsafe.Pointer(jDeadline))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
ctx, cancelFunc := context.WithDeadline((*context.T)(jutil.GoRefValue(jutil.Ref(goRef))), deadline)
jCtx, err := JavaContext(env, ctx, cancelFunc)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jCtx))
}
//export Java_io_v_v23_security_access_AccessList_nativeAuthorize
func Java_io_v_v23_security_access_AccessList_nativeAuthorize(jenv *C.JNIEnv, jAccessList C.jobject, goRef C.jlong, jCtx C.jobject, jCall C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jCtx))))
if err != nil {
jutil.JThrowV(env, err)
return
}
call, err := jsecurity.GoCall(env, jutil.Object(uintptr(unsafe.Pointer(jCall))))
if err != nil {
jutil.JThrowV(env, err)
}
if err := (*(*access.AccessList)(jutil.GoRefValue(jutil.Ref(goRef)))).Authorize(ctx, call); err != nil {
jutil.JThrowV(env, err)
return
}
}
//export Java_io_v_impl_google_lib_discovery_UpdateImpl_nativeAttachment
func Java_io_v_impl_google_lib_discovery_UpdateImpl_nativeAttachment(jenv *C.JNIEnv, _ C.jobject, goRef C.jlong, jCtx C.jobject, jName C.jstring, jCbObj C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jCtx))))
if err != nil {
jutil.JThrowV(env, err)
return
}
update := *(*discovery.Update)(jutil.GoRefValue(jutil.Ref(goRef)))
name := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName))))
jCb := jutil.Object(uintptr(unsafe.Pointer(jCbObj)))
jutil.DoAsyncCall(env, jCb, func() (jutil.Object, error) {
dataOrErr := <-update.Attachment(ctx, name)
if dataOrErr.Error != nil {
return jutil.NullObject, err
}
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jData, err := jutil.JByteArray(env, dataOrErr.Data)
if err != nil {
return jutil.NullObject, err
}
// Must grab a global reference as we free up the env and all local references that come
// along with it.
return jutil.NewGlobalRef(env, jData), nil // Un-refed in DoAsyncCall
})
}
//export Java_io_v_impl_google_rpc_ServerImpl_nativeAddName
func Java_io_v_impl_google_rpc_ServerImpl_nativeAddName(jenv *C.JNIEnv, jServer C.jobject, goRef C.jlong, jName C.jstring) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
name := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName))))
if err := (*(*rpc.Server)(jutil.GoRefValue(jutil.Ref(goRef)))).AddName(name); err != nil {
jutil.JThrowV(env, err)
return
}
}
//export Java_io_v_v23_services_groups_PermissionsAuthorizer_nativeAuthorize
func Java_io_v_v23_services_groups_PermissionsAuthorizer_nativeAuthorize(jenv *C.JNIEnv, jPermissionsAuthorizer C.jobject, goRef C.jlong, jContext C.jobject, jCall C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext))))
if err != nil {
jutil.JThrowV(env, err)
return
}
call, err := jsecurity.GoCall(env, jutil.Object(uintptr(unsafe.Pointer(jCall))))
if err != nil {
jutil.JThrowV(env, err)
return
}
if err := (*(*security.Authorizer)(jutil.GoRefValue(jutil.Ref(goRef)))).Authorize(ctx, call); err != nil {
jutil.JThrowV(env, err)
return
}
}
//export Java_io_v_v23_security_BlessingRootsImpl_nativeAdd
func Java_io_v_v23_security_BlessingRootsImpl_nativeAdd(jenv *C.JNIEnv, jBlessingRootsImpl C.jobject, goRef C.jlong, jRoot C.jobject, jPattern C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
root, err := JavaPublicKeyToDER(env, jutil.Object(uintptr(unsafe.Pointer(jRoot))))
if err != nil {
jutil.JThrowV(env, err)
return
}
pattern, err := GoBlessingPattern(env, jutil.Object(uintptr(unsafe.Pointer(jPattern))))
if err != nil {
jutil.JThrowV(env, err)
return
}
if err := (*(*security.BlessingRoots)(jutil.GoRefValue(jutil.Ref(goRef)))).Add(root, pattern); err != nil {
jutil.JThrowV(env, err)
return
}
}
//export Java_io_v_impl_google_lib_discovery_FactoryUtil_injectMockPlugin
func Java_io_v_impl_google_lib_discovery_FactoryUtil_injectMockPlugin(jenv *C.JNIEnv, _ C.jclass, jCtx C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jCtx))))
if err != nil {
jutil.JThrowV(env, err)
return
}
injectMockPlugin(ctx)
}
//export Java_io_v_v23_security_VPrincipalImpl_nativeCreatePersistent
func Java_io_v_v23_security_VPrincipalImpl_nativeCreatePersistent(jenv *C.JNIEnv, jclass C.jclass, jPassphrase C.jstring, jDir C.jstring) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
passphrase := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jPassphrase))))
dir := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jDir))))
principal, err := vsecurity.LoadPersistentPrincipal(dir, []byte(passphrase))
if err != nil {
if principal, err = vsecurity.CreatePersistentPrincipal(dir, []byte(passphrase)); err != nil {
jutil.JThrowV(env, err)
return nil
}
}
jPrincipal, err := JavaPrincipal(env, principal)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jPrincipal))
}
//export Java_io_v_impl_google_rpc_ServerCallImpl_nativeRemoteEndpoint
func Java_io_v_impl_google_rpc_ServerCallImpl_nativeRemoteEndpoint(jenv *C.JNIEnv, jServerCall C.jobject, goRef C.jlong) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
jEndpoint, err := jnaming.JavaEndpoint(env, (*(*rpc.ServerCall)(jutil.GoRefValue(jutil.Ref(goRef)))).RemoteEndpoint())
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jEndpoint))
}
//export Java_io_v_impl_google_lib_discovery_UUIDUtil_attributeUUID
func Java_io_v_impl_google_lib_discovery_UUIDUtil_attributeUUID(jenv *C.JNIEnv, _ C.jclass, jName C.jstring) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
name := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName))))
jUuid, err := javaUUID(env, idiscovery.NewAttributeUUID(name))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jUuid))
}
//export Java_io_v_impl_google_rpc_ServerRPCHelper_nativeGoAuthorizer
func Java_io_v_impl_google_rpc_ServerRPCHelper_nativeGoAuthorizer(jenv *C.JNIEnv, jServerRPCHelper C.jclass, jAuthorizer C.jobject) C.jlong {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
auth, err := jsecurity.GoAuthorizer(env, jutil.Object(uintptr(unsafe.Pointer(jAuthorizer))))
if err != nil {
jutil.JThrowV(env, err)
return C.jlong(0)
}
ref := jutil.GoNewRef(&auth) // Un-refed when the Go authorizer is returned to the Go runtime
return C.jlong(ref)
}
//export Java_io_v_impl_google_rpc_ServerCallImpl_nativeServer
func Java_io_v_impl_google_rpc_ServerCallImpl_nativeServer(jenv *C.JNIEnv, jServerCall C.jobject, goRef C.jlong) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
server := (*(*rpc.ServerCall)(jutil.GoRefValue(jutil.Ref(goRef)))).Server()
jServer, err := JavaServer(env, server)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jServer))
}
//export Java_io_v_impl_google_rpc_ServerCallImpl_nativeGrantedBlessings
func Java_io_v_impl_google_rpc_ServerCallImpl_nativeGrantedBlessings(jenv *C.JNIEnv, jServerCall C.jobject, goRef C.jlong) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
blessings := (*(*rpc.ServerCall)(jutil.GoRefValue(jutil.Ref(goRef)))).GrantedBlessings()
jBlessings, err := jsecurity.JavaBlessings(env, blessings)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jBlessings))
}