//export swift_io_v_v23_security_simple_nativeSetBlessings
func swift_io_v_v23_security_simple_nativeSetBlessings(ctxHandle C.GoContextHandle, encodedSwiftBlessings C.SwiftByteArray, errOut *C.SwiftVError) {
ctx := context.GoContext(uint64(ctxHandle))
encodedBlessings := util.GoBytesNoCopy(unsafe.Pointer(&encodedSwiftBlessings))
var blessings security.Blessings
if err := vom.Decode(encodedBlessings, &blessings); err != nil {
ctx.Error("Unable to decode:", err)
util.ThrowSwiftError(nil, err, unsafe.Pointer(errOut))
return
}
principal := v23.GetPrincipal(ctx)
if err := principal.BlessingStore().SetDefault(blessings); err != nil {
util.ThrowSwiftError(nil, err, unsafe.Pointer(errOut))
return
}
}
//export swift_io_v_impl_google_rpc_ClientImpl_nativeStartCallAsync
func swift_io_v_impl_google_rpc_ClientImpl_nativeStartCallAsync(ctxHandle C.GoContextHandle, cName *C.char, cMethod *C.char, cVomArgs C.SwiftByteArrayArray, skipServerAuth bool, asyncId C.AsyncCallbackIdentifier, successCallback C.SwiftAsyncSuccessHandleCallback, failureCallback C.SwiftAsyncFailureCallback) {
name := C.GoString(cName)
method := C.GoString(cMethod)
ctx := scontext.GoContext(uint64(ctxHandle))
client := v23.GetClient(ctx)
// TODO Get args (we don't have VOM yet in Swift so nothing to get until then)
// args, err := decodeArgs(env, jVomArgs)
// if err != nil {
// sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
// return C.GoClientCallHandle(0)
// }
args := make([]interface{}, 0)
go func() {
result, err := doStartCall(ctx, name, method, skipServerAuth == true, client, args)
if err != nil {
var swiftVError C.SwiftVError
sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(&swiftVError))
sutil.DoFailureCallback(unsafe.Pointer(failureCallback), int32(asyncId), unsafe.Pointer(&swiftVError))
} else {
handle := C.GoClientCallHandle(SwiftClientCall(result))
sutil.DoSuccessHandlerCallback(unsafe.Pointer(successCallback), int32(asyncId), uint64(handle))
}
}()
}
// Exports the discovery scan API to CGO using JSON to marshal ads
//export swift_io_v_v23_discovery_scan
func swift_io_v_v23_discovery_scan(ctxHandle C.GoContextHandle, discoveryHandle C.GoDiscoveryHandle, query C.SwiftCString, asyncId C.AsyncCallbackIdentifier, callbackBlock C.SwiftAsyncJsonCallback, errOut *C.SwiftVError) bool {
ctx := scontext.GoContext(uint64(ctxHandle))
d := GoDiscoveryT(uint64(discoveryHandle))
goQuery := sutil.GoString(unsafe.Pointer(&query), false)
ch, err := d.Scan(ctx, goQuery)
if err != nil {
sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
return false
}
go func() {
for update := range ch {
data := struct {
IsLost bool
Ad discovery.Advertisement
}{
IsLost: update.IsLost(),
Ad: update.Advertisement(),
}
b, err := json.Marshal(data)
if err != nil {
ctx.Fatal("Unable to JSON serialize discovery update: ", err)
}
ba := swiftBytesCopy(b)
C.CallScanCallback(callbackBlock, asyncId, ba)
C.free(ba.data)
}
C.CallScanCallback(callbackBlock, asyncId, emptySwiftByteArray())
}()
return true
}
//export swift_io_v_impl_google_rpc_ClientCallImpl_nativeCloseSend
func swift_io_v_impl_google_rpc_ClientCallImpl_nativeCloseSend(ctxHandle C.GoContextHandle, callHandle C.GoClientCallHandle, errOut *C.SwiftVError) {
ctx := scontext.GoContext(uint64(ctxHandle))
call := GoClientCall(uint64(callHandle))
if err := call.CloseSend(); err != nil {
sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
return
}
}
//export swift_io_v_v23_V_nativeInitLogging
func swift_io_v_v23_V_nativeInitLogging(logDir *C.char, logToStderr bool, logLevel int, moduleSpec *C.char, errOut *C.SwiftVError) {
dir, toStderr, level, vmodule, err := loggingOpts(C.GoString(logDir), logToStderr, logLevel, C.GoString(moduleSpec))
if err != nil {
sutil.ThrowSwiftError(nil, err, unsafe.Pointer(errOut))
return
}
vlog.Log.Configure(vlog.OverridePriorConfiguration(true), dir, toStderr, level, vmodule)
}
//export swift_io_v_v23_discovery_new
func swift_io_v_v23_discovery_new(ctxHandle C.GoContextHandle, errOut *C.SwiftVError) C.GoDiscoveryHandle {
ctx := scontext.GoContext(uint64(ctxHandle))
d, err := v23.NewDiscovery(ctx)
if err != nil {
sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
return C.GoDiscoveryHandle(0)
}
return C.GoDiscoveryHandle(sutil.GoNewRef(&d))
}
//export swift_io_v_v23_V_nativeInitGlobal
func swift_io_v_v23_V_nativeInitGlobal(credentialsDir *C.char, errOut *C.SwiftVError) {
// Send all vlog logs to stderr during the init so that we don't crash on android trying
// to create a log file. These settings will be overwritten in nativeInitLogging below.
vlog.Log.Configure(vlog.OverridePriorConfiguration(true), vlog.LogToStderr(true))
if credentialsDir != nil {
dir := C.GoString(credentialsDir)
os.Setenv(ref.EnvCredentials, dir)
}
if err := sv23.Init(); err != nil {
sutil.ThrowSwiftError(nil, err, unsafe.Pointer(errOut))
return
}
if err := sgoogle.Init(); err != nil {
sutil.ThrowSwiftError(nil, err, unsafe.Pointer(errOut))
return
}
}
//export swift_io_v_v23_context_VContext_nativeWithCancel
func swift_io_v_v23_context_VContext_nativeWithCancel(ctxHandle C.GoContextHandle, errOut C.SwiftVErrorPtr) C.GoCancelableContextHandle {
ctx := GoContext(uint64(ctxHandle))
ctx, cancelFunc := context.WithCancel(ctx)
swiftCtx, err := SwiftCancelableContext(ctx, cancelFunc)
if err != nil {
sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
return C.GoCancelableContextHandle(0)
}
return C.GoCancelableContextHandle(swiftCtx)
}
//export swift_io_v_v23_security_simple_nativePublicKey
func swift_io_v_v23_security_simple_nativePublicKey(ctxHandle C.GoContextHandle, errOut *C.SwiftVError) *C.char {
ctx := context.GoContext(uint64(ctxHandle))
der, err := v23.GetPrincipal(ctx).PublicKey().MarshalBinary()
if err != nil {
util.ThrowSwiftError(nil, err, unsafe.Pointer(errOut))
return nil
}
// Swift will have to free the allocation
return C.CString(base64.URLEncoding.EncodeToString(der))
}
//export swift_io_v_impl_google_rt_VRuntimeImpl_nativeWithNewClient
func swift_io_v_impl_google_rt_VRuntimeImpl_nativeWithNewClient(ctxHandle C.GoContextHandle, errOut *C.SwiftVError) C.GoContextHandle {
ctx := scontext.GoContext(uint64(ctxHandle))
// No options supported yet.
newCtx, _, err := v23.WithNewClient(ctx)
if err != nil {
sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
return C.GoContextHandle(0)
}
return C.GoContextHandle(scontext.SwiftContext(newCtx))
}
//export swift_io_v_v23_context_VContext_nativeWithTimeout
func swift_io_v_v23_context_VContext_nativeWithTimeout(ctxHandle C.GoContextHandle, nsTimeout C.double, errOut *C.SwiftVError) C.GoCancelableContextHandle {
ctx := GoContext(uint64(ctxHandle))
timeout := sutil.GoDuration(float64(nsTimeout))
ctx, cancelFunc := context.WithTimeout(ctx, timeout)
swiftCtx, err := SwiftCancelableContext(ctx, cancelFunc)
if err != nil {
sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
return C.GoCancelableContextHandle(0)
}
return C.GoCancelableContextHandle(swiftCtx)
}
//export swift_io_v_v23_context_VContext_nativeWithDeadline
func swift_io_v_v23_context_VContext_nativeWithDeadline(ctxHandle C.GoContextHandle, deadlineEpoch C.double, errOut C.SwiftVErrorPtr) C.GoCancelableContextHandle {
ctx := GoContext(uint64(ctxHandle))
deadline := sutil.GoTime(float64(deadlineEpoch))
ctx, cancelFunc := context.WithDeadline(ctx, deadline)
swiftCtx, err := SwiftCancelableContext(ctx, cancelFunc)
if err != nil {
sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
return C.GoCancelableContextHandle(0)
}
return C.GoCancelableContextHandle(swiftCtx)
}
//export swift_io_v_impl_google_rpc_ClientCallImpl_nativeFinishAsync
func swift_io_v_impl_google_rpc_ClientCallImpl_nativeFinishAsync(ctxHandle C.GoContextHandle, callHandle C.GoClientCallHandle, numResults int, asyncId C.AsyncCallbackIdentifier, successCallback C.SwiftAsyncSuccessByteArrayArrayCallback, failureCallback C.SwiftAsyncFailureCallback) {
ctx := scontext.GoContext(uint64(ctxHandle))
call := GoClientCall(uint64(callHandle))
go func() {
result, err := doFinish(call, numResults)
if err != nil {
var swiftVError C.SwiftVError
sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(&swiftVError))
sutil.DoFailureCallback(unsafe.Pointer(failureCallback), int32(asyncId), unsafe.Pointer(&swiftVError))
} else {
sutil.DoSuccessByteArrayArrayCallback(unsafe.Pointer(successCallback), int32(asyncId), unsafe.Pointer(&result))
}
}()
}
// Exports the discovery advertise API to CGO using JSON to marshal ads
//export swift_io_v_v23_discovery_advertise
func swift_io_v_v23_discovery_advertise(ctxHandle C.GoContextHandle, discoveryHandle C.GoDiscoveryHandle, adJson C.SwiftByteArray, visibilityArray C.SwiftCStringArray, asyncId C.AsyncCallbackIdentifier, doneCallback C.SwiftAsyncSuccessCallback, errOut *C.SwiftVError) bool {
ctx := scontext.GoContext(uint64(ctxHandle))
d := GoDiscoveryT(uint64(discoveryHandle))
ad := discovery.Advertisement{}
if err := json.Unmarshal(sutil.GoBytesNoCopy(unsafe.Pointer(&adJson)), &ad); err != nil {
sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
return false
}
var visibility []security.BlessingPattern
for _, v := range visibilityArray.toStrings() {
visibility = append(visibility, security.BlessingPattern(v))
}
doneChan, err := d.Advertise(ctx, &ad, visibility)
if err != nil {
sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
return false
}
go func() {
<-doneChan
C.CallAdvertisingCallback(doneCallback, asyncId)
}()
return true
}