//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_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_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_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_VPrincipalImpl_nativeBless func Java_io_v_v23_security_VPrincipalImpl_nativeBless(jenv *C.JNIEnv, jVPrincipalImpl C.jobject, goRef C.jlong, jKey C.jobject, jWith C.jobject, jExtension C.jstring, jCaveat C.jobject, jAdditionalCaveats C.jobjectArray) C.jobject { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) key, err := GoPublicKey(env, jutil.Object(uintptr(unsafe.Pointer(jKey)))) if err != nil { jutil.JThrowV(env, err) return nil } with, err := GoBlessings(env, jutil.Object(uintptr(unsafe.Pointer(jWith)))) if err != nil { jutil.JThrowV(env, err) return nil } extension := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jExtension)))) caveat, err := GoCaveat(env, jutil.Object(uintptr(unsafe.Pointer(jCaveat)))) if err != nil { jutil.JThrowV(env, err) return nil } additionalCaveats, err := GoCaveats(env, jutil.Object(uintptr(unsafe.Pointer(jAdditionalCaveats)))) if err != nil { jutil.JThrowV(env, err) return nil } blessings, err := (*(*security.Principal)(jutil.GoRefValue(jutil.Ref(goRef)))).Bless(key, with, extension, caveat, additionalCaveats...) if err != nil { jutil.JThrowV(env, err) return nil } jBlessings, err := JavaBlessings(env, blessings) if err != nil { jutil.JThrowV(env, err) return nil } return C.jobject(unsafe.Pointer(jBlessings)) }
//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)) }
func unmountArgs(env jutil.Env, jName, jServer C.jstring, jContext, jOptions C.jobject) (name, server string, context *context.T, options []naming.NamespaceOpt, err error) { name = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) server = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jServer)))) context, _, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } options, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) return }
//export Java_io_v_impl_google_lib_discovery_DiscoveryImpl_nativeAdvertise func Java_io_v_impl_google_lib_discovery_DiscoveryImpl_nativeAdvertise(jenv *C.JNIEnv, _ C.jobject, goRef C.jlong, jCtx C.jobject, jAdObj C.jobject, jVisibilityObj C.jobject, 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 } d := *(*discovery.T)(jutil.GoRefValue(jutil.Ref(goRef))) jAd := jutil.Object(uintptr(unsafe.Pointer(jAdObj))) jVisibility := jutil.Object(uintptr(unsafe.Pointer(jVisibilityObj))) var ad discovery.Advertisement if err := jutil.GoVomCopy(env, jAd, jAdvertisementClass, &ad); err != nil { jutil.JThrowV(env, err) return } jVisibilityList, err := jutil.GoObjectList(env, jVisibility) if err != nil { jutil.JThrowV(env, err) return } visibility := make([]security.BlessingPattern, len(jVisibilityList)) for i, jPattern := range jVisibilityList { if err := jutil.GoVomCopy(env, jPattern, jBlessingPatternClass, &visibility[i]); err != nil { jutil.JThrowV(env, err) return } } done, err := d.Advertise(ctx, &ad, visibility) if err != nil { jutil.JThrowV(env, err) return } // Copy back the advertisement id. jId, err := jutil.JVomCopy(env, &ad.Id, jAdIdClass) if err != nil { jutil.JThrowV(env, err) return } if err = jutil.CallVoidMethod(env, jAd, "setId", []jutil.Sign{adIdSign}, jId); err != nil { jutil.JThrowV(env, err) return } jCb := jutil.Object(uintptr(unsafe.Pointer(jCbObj))) jutil.DoAsyncCall(env, jCb, func() (jutil.Object, error) { <-done return jutil.NullObject, nil }) }
//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_rpc_StreamImpl_nativeSend func Java_io_v_impl_google_rpc_StreamImpl_nativeSend(jenv *C.JNIEnv, jStream C.jobject, goRef C.jlong, jVomItem C.jbyteArray, jCallbackObj C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj))) vomItem := jutil.GoByteArray(env, jutil.Object(uintptr(unsafe.Pointer(jVomItem)))) jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) { item, err := jutil.VomDecodeToValue(vomItem) if err != nil { return jutil.NullObject, err } return jutil.NullObject, (*(*rpc.Stream)(jutil.GoRefValue(jutil.Ref(goRef)))).Send(item) }) }
func globArgs(env jutil.Env, jContext C.jobject, jPattern C.jstring, jOptions C.jobject) (context *context.T, cancel func(), pattern string, opts []naming.NamespaceOpt, err error) { context, cancel, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } opts, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) if err != nil { return } pattern = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jPattern)))) return }
func getPermissionsArgs(env jutil.Env, jContext C.jobject, jName C.jstring, jOptions C.jobject) (context *context.T, name string, options []naming.NamespaceOpt, err error) { context, _, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } options, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) if err != nil { return } name = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) return }
func resolveToMountTableArgs(env jutil.Env, jContext, jOptions C.jobject, jName C.jstring) (context *context.T, options []naming.NamespaceOpt, name string, err error) { context, _, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } options, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) if err != nil { return } name = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) return }
func deleteArgs(env jutil.Env, jContext, jOptions C.jobject, jName C.jstring, jDeleteSubtree C.jboolean) (context *context.T, options []naming.NamespaceOpt, name string, deleteSubtree bool, err error) { context, _, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } options, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) if err != nil { return } name = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) deleteSubtree = jDeleteSubtree == C.JNI_TRUE return }
//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() }() }
func setPermissionsArgs(env jutil.Env, jContext, jPermissions C.jobject, jName, jVersion C.jstring, jOptions C.jobject) (context *context.T, permissions access.Permissions, name, version string, options []naming.NamespaceOpt, err error) { context, _, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } err = jutil.GoVomCopy(env, jutil.Object(uintptr(unsafe.Pointer(jPermissions))), jPermissionsClass, &permissions) if err != nil { return } options, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) name = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) version = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jVersion)))) return }
func mountArgs(env jutil.Env, jContext C.jobject, jName, jServer C.jstring, jDuration, jOptions C.jobject) (context *context.T, name, server string, duration time.Duration, options []naming.NamespaceOpt, err error) { context, _, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } name = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) server = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jServer)))) duration, err = jutil.GoDuration(env, jutil.Object(uintptr(unsafe.Pointer(jDuration)))) if err != nil { return } options, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) return }
//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_impl_google_namespace_NamespaceImpl_nativeFlushCacheEntry func Java_io_v_impl_google_namespace_NamespaceImpl_nativeFlushCacheEntry(jenv *C.JNIEnv, jNamespaceClass C.jclass, goRef C.jlong, jContext C.jobject, jName C.jstring) C.jboolean { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) n := *(*namespace.T)(jutil.GoRefValue(jutil.Ref(goRef))) context, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { jutil.JThrowV(env, err) return C.JNI_FALSE } result := n.FlushCacheEntry(context, jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName))))) if result { return C.JNI_TRUE } else { return C.JNI_FALSE } }
//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_rpc_ClientCallImpl_nativeCloseSend func Java_io_v_impl_google_rpc_ClientCallImpl_nativeCloseSend(jenv *C.JNIEnv, jCall C.jobject, goRef C.jlong, jCallbackObj C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj))) jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) { return jutil.NullObject, (*(*rpc.ClientCall)(jutil.GoRefValue(jutil.Ref(goRef)))).CloseSend() }) }
//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_impl_google_rpc_StreamImpl_nativeRecv func Java_io_v_impl_google_rpc_StreamImpl_nativeRecv(jenv *C.JNIEnv, jStream C.jobject, goRef C.jlong, jCallbackObj C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj))) result := new(vdl.Value) jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) { if err := (*(*rpc.Stream)(jutil.GoRefValue(jutil.Ref(goRef)))).Recv(&result); err != nil { if err == io.EOF { // Java uses EndOfFile error to detect EOF. err = verror.NewErrEndOfFile(nil) } return jutil.NullObject, err } vomResult, err := vom.Encode(result) if err != nil { return jutil.NullObject, err } env, freeFunc := jutil.GetEnv() defer freeFunc() jResult, err := jutil.JByteArray(env, vomResult) 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, jResult), nil // Un-refed in DoAsyncCall }) }
//export Java_io_v_v23_i18n_Catalog_nativeFormatParams func Java_io_v_v23_i18n_Catalog_nativeFormatParams(jenv *C.JNIEnv, jCatalog C.jclass, jFormat C.jstring, jParams C.jobjectArray) C.jstring { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) format := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jFormat)))) strParams, err := jutil.GoStringArray(env, jutil.Object(uintptr(unsafe.Pointer(jParams)))) if err != nil { jutil.JThrowV(env, err) return nil } params := make([]interface{}, len(strParams)) for i, strParam := range strParams { params[i] = strParam } result := i18n.FormatParams(format, params...) jRet := jutil.JString(env, result) return C.jstring(unsafe.Pointer(jRet)) }
//export Java_io_v_impl_google_rpc_ClientCallImpl_nativeFinish func Java_io_v_impl_google_rpc_ClientCallImpl_nativeFinish(jenv *C.JNIEnv, jCall C.jobject, goRef C.jlong, jNumResults C.jint, jCallbackObj C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) numResults := int(jNumResults) jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj))) jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) { return doFinish(goRef, numResults) }) }
//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_impl_google_channel_OutputChannelImpl_nativeSend func Java_io_v_impl_google_channel_OutputChannelImpl_nativeSend(jenv *C.JNIEnv, jOutputChannelClass C.jclass, goConvertRef C.jlong, goSendRef C.jlong, jItemObj C.jobject, jCallbackObj C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) convert := *(*func(jutil.Object) (interface{}, error))(jutil.GoRefValue(jutil.Ref(goConvertRef))) send := *(*func(interface{}) error)(jutil.GoRefValue(jutil.Ref(goSendRef))) jItem := jutil.Object(uintptr(unsafe.Pointer(jItemObj))) jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj))) // NOTE(spetrovic): Conversion must be done outside of DoAsyncCall as it references a Java // object. item, err := convert(jItem) if err != nil { jutil.CallbackOnFailure(env, jCallback, err) return } jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) { return jutil.NullObject, send(item) }) }
//export Java_io_v_impl_google_channel_OutputChannelImpl_nativeClose func Java_io_v_impl_google_channel_OutputChannelImpl_nativeClose(jenv *C.JNIEnv, jOutputChannelClass C.jclass, goCloseRef C.jlong, jCallbackObj C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) close := *(*func() error)(jutil.GoRefValue(jutil.Ref(goCloseRef))) jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj))) jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) { return jutil.NullObject, close() }) }