func (w *javaOutputWriter) Write(b []byte) (int, error) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
if err := jutil.CallVoidMethod(env, w.obj, "write", []jutil.Sign{jutil.StringSign}, string(b)); err != nil {
return 0, err
}
return len(b), nil
}
func (s *blessingStore) SetDefault(blessings security.Blessings) error {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jBlessings, err := JavaBlessings(env, blessings)
if err != nil {
return err
}
return jutil.CallVoidMethod(env, s.jBlessingStore, "setDefaultBlessings", []jutil.Sign{blessingsSign}, jBlessings)
}
func (c *btReadWriteCloser) Write(b []byte) (n int, err error) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
if err := jutil.CallVoidMethod(env, c.jStream, "write", []jutil.Sign{jutil.ByteArraySign}, b); err != nil {
return 0, err
}
return len(b), nil
}
func (r *blessingRoots) Recognized(root []byte, blessing string) error {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jRoot, err := JavaPublicKeyFromDER(env, root)
if err != nil {
return err
}
return jutil.CallVoidMethod(env, r.jBlessingRoots, "recognized", []jutil.Sign{publicKeySign, jutil.StringSign}, jRoot, blessing)
}
//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
})
}
func handleInvite(invite discovery.Invite, handler jutil.Object) error {
env, free := jutil.GetEnv()
defer free()
jInvite, err := jutil.NewObject(env, jInviteClass,
[]jutil.Sign{jutil.StringSign, jutil.StringSign},
invite.Syncgroup.Blessing, invite.Syncgroup.Name)
if err != nil {
return err
}
return jutil.CallVoidMethod(env, handler, "handleInvite",
[]jutil.Sign{inviteSign}, jInvite)
}
func (r *blessingRoots) Add(root []byte, pattern security.BlessingPattern) error {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jRoot, err := JavaPublicKeyFromDER(env, root)
if err != nil {
return err
}
jPattern, err := JavaBlessingPattern(env, pattern)
if err != nil {
return err
}
return jutil.CallVoidMethod(env, r.jBlessingRoots, "add", []jutil.Sign{publicKeySign, blessingPatternSign}, jRoot, jPattern)
}
func (a *authorizer) Authorize(ctx *context.T, call security.Call) error {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jCtx, err := jcontext.JavaContext(env, ctx, nil)
if err != nil {
return err
}
jCall, err := JavaCall(env, call)
if err != nil {
return err
}
// Run Java Authorizer.
return jutil.CallVoidMethod(env, a.jAuth, "authorize", []jutil.Sign{contextSign, callSign}, jCtx, jCall)
}
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
}
func (d *driver) AddService(uuid string, characteristics map[string][]byte) error {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
csObjMap := make(map[jutil.Object]jutil.Object, len(characteristics))
for uuid, characteristic := range characteristics {
jUuid := jutil.JString(env, uuid)
jCharacteristic, err := jutil.JByteArray(env, characteristic)
if err != nil {
return err
}
csObjMap[jUuid] = jCharacteristic
}
jCharacteristics, err := jutil.JObjectMap(env, csObjMap)
if err != nil {
return err
}
return jutil.CallVoidMethod(env, d.jDriver, "addService", []jutil.Sign{jutil.StringSign, jutil.MapSign}, uuid, jCharacteristics)
}
func (s *blessingStore) ClearDischarges(discharges ...security.Discharge) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jDischarges := make([]jutil.Object, len(discharges))
for i := 0; i < len(discharges); i++ {
jDischarge, err := JavaDischarge(env, discharges[i])
if err != nil {
log.Printf("Couldn't get Java discharge: %v", err)
return
}
jDischarges[i] = jDischarge
}
jDischargeList, err := jutil.JObjectList(env, jDischarges, jDischargeClass)
if err != nil {
log.Printf("Couldn't get Java discharge list: %v", err)
return
}
err = jutil.CallVoidMethod(env, s.jBlessingStore, "clearDischarges", []jutil.Sign{jutil.ListSign}, jDischargeList)
if err != nil {
log.Printf("Couldn't call Java clearDischarges method: %v", err)
}
}
func (s *blessingStore) CacheDischarge(discharge security.Discharge, caveat security.Caveat, impetus security.DischargeImpetus) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jDischarge, err := JavaDischarge(env, discharge)
if err != nil {
log.Printf("Couldn't get Java discharge: %v", err)
return
}
jCaveat, err := JavaCaveat(env, caveat)
if err != nil {
log.Printf("Couldn't get Java caveat: %v", err)
return
}
jImpetus, err := jutil.JVomCopy(env, impetus, jDischargeImpetusClass)
if err != nil {
log.Printf("Couldn't get Java DischargeImpetus: %v", err)
return
}
err = jutil.CallVoidMethod(env, s.jBlessingStore, "cacheDischarge", []jutil.Sign{dischargeSign, caveatSign, dischargeImpetusSign}, jDischarge, jCaveat, jImpetus)
if err != nil {
log.Printf("Couldn't call cacheDischarge: %v", err)
}
}
func (d *driver) StopScan() {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.CallVoidMethod(env, d.jDriver, "stopScan", nil)
}
func (d *driver) RemoveService(uuid string) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.CallVoidMethod(env, d.jDriver, "removeService", []jutil.Sign{jutil.StringSign}, uuid)
}
func (c *btReadWriteCloser) Close() error {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
return jutil.CallVoidMethod(env, c.jStream, "close", nil)
}
func (l *btListener) Close() error {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
return jutil.CallVoidMethod(env, l.jListener, "close", nil)
}
