package softbus
|
|
/*
|
#cgo LDFLAGS: -ldl
|
#include <stdlib.h>
|
#include "libcsoftbus.h"
|
|
void *get_array(const int size){
|
int *arr = (int*)malloc(sizeof(int)*size);
|
return arr;
|
}
|
|
void set_array(void *arr, const int index, const int value){
|
int *iarr = (int*)arr;
|
iarr[index] = value;
|
}
|
*/
|
import "C"
|
import (
|
"errors"
|
"unsafe"
|
)
|
|
var libsoftbus C.hcsoftbus
|
|
// Init Dynamic library
|
func Init(so string) error {
|
cso := C.CString(so)
|
defer C.free(unsafe.Pointer(cso))
|
|
handle := C.c_softbus_handle(cso)
|
if handle == nil {
|
// fmt.Errorf("Go SoftBus Init From %s Error\n", so)
|
return errors.New("Init SoftBus Error")
|
}
|
|
libsoftbus = handle
|
return nil
|
}
|
|
// Release handle of c softbus
|
func Release() {
|
if libsoftbus != nil {
|
C.c_softbus_release(libsoftbus)
|
}
|
}
|
|
// ShmInit block size
|
func ShmInit(size int) error {
|
if libsoftbus == nil {
|
return errors.New("C SoftBus Handle Is Nil")
|
}
|
C.wrap_fn_shm_init(libsoftbus, C.int(size))
|
return nil
|
}
|
|
// ShmAllocKey alloc key
|
func ShmAllocKey() int {
|
if libsoftbus == nil {
|
return -1
|
}
|
r := C.wrap_fn_shm_alloc_key(libsoftbus)
|
return int(r)
|
}
|
|
// ShmDestroy destroy shm block, every softbus proc MUST call it
|
func ShmDestroy() {
|
if libsoftbus != nil {
|
C.wrap_fn_shm_destroy(libsoftbus)
|
}
|
}
|
|
// ShmRmDeadQueue remove dead queue but pass live queue keys
|
func ShmRmDeadQueue(keys []int) error {
|
if libsoftbus == nil {
|
return errors.New("C SoftBus Handle Is Nil")
|
}
|
if len(keys) == 0 {
|
C.wrap_fn_shm_rm_dead_queue(libsoftbus, nil, 0)
|
return nil
|
}
|
|
l := len(keys)
|
ca := C.get_array(C.int(l))
|
defer C.free(ca)
|
for k, v := range keys {
|
C.set_array(ca, C.int(k), C.int(v))
|
}
|
|
C.wrap_fn_shm_rm_dead_queue(libsoftbus, ca, C.int(l))
|
return nil
|
}
|
|
// Queue struct wrap shmqueue pointer
|
type Queue struct {
|
shmqueue unsafe.Pointer
|
key int
|
}
|
|
// Create shm queue
|
func Create(qSize int) *Queue {
|
if libsoftbus == nil {
|
return nil
|
}
|
|
var key C.int
|
csb := C.wrap_fn_queue_create(libsoftbus, &key, C.int(qSize))
|
if csb != nil {
|
return &Queue{
|
shmqueue: csb,
|
key: int(key),
|
}
|
}
|
return nil
|
}
|
|
// Attach shm queue with key
|
func Attach(key int) *Queue {
|
if libsoftbus == nil {
|
return nil
|
}
|
|
csb := C.wrap_fn_queue_attach(libsoftbus, C.int(key))
|
if csb != nil {
|
return &Queue{
|
shmqueue: csb,
|
key: key,
|
}
|
}
|
|
return nil
|
}
|
|
// Drop shm queue
|
func (q *Queue) Drop() error {
|
if libsoftbus == nil {
|
return errors.New("C SoftBus Handle Is Nil")
|
}
|
|
C.wrap_fn_queue_drop(libsoftbus, q.shmqueue)
|
return nil
|
}
|
|
// Size shm queue
|
func (q *Queue) Size() int {
|
if libsoftbus == nil {
|
return 0
|
}
|
|
cs := C.wrap_fn_queue_size(libsoftbus, q.shmqueue)
|
return int(cs)
|
}
|
|
// Full shm queue
|
func (q *Queue) Full() bool {
|
if libsoftbus == nil {
|
return true
|
}
|
|
f := C.wrap_fn_queue_full(libsoftbus, q.shmqueue)
|
if f != 0 {
|
return true
|
}
|
return false
|
}
|
|
// Empty shm queue
|
func (q *Queue) Empty() bool {
|
if libsoftbus == nil {
|
return false
|
}
|
|
f := C.wrap_fn_queue_full(libsoftbus, q.shmqueue)
|
if f != 0 {
|
return true
|
}
|
return false
|
|
}
|
|
// Push shm queue
|
func (q *Queue) Push(data []byte) error {
|
if libsoftbus == nil {
|
return errors.New("C SoftBus Handle Is Nil")
|
}
|
|
r := C.wrap_fn_queue_push(libsoftbus, q.shmqueue, unsafe.Pointer(&data[0]), C.int(len(data)))
|
if r == 0 {
|
return nil
|
}
|
return errors.New("Queue Push Data Error")
|
}
|
|
// PushNoWait shm queue
|
func (q *Queue) PushNoWait(data []byte) error {
|
if libsoftbus == nil {
|
return errors.New("C SoftBus Handle Is Nil")
|
}
|
|
r := C.wrap_fn_queue_push_nowait(libsoftbus, q.shmqueue, unsafe.Pointer(&data[0]), C.int(len(data)))
|
if r == 0 {
|
return nil
|
}
|
return errors.New("Queue PushNoWait Data Error")
|
}
|
|
// PushTimeout shm queue push with timeout
|
func (q *Queue) PushTimeout(data []byte, sec, nsec int) error {
|
if libsoftbus == nil {
|
return errors.New("C SoftBus Handle Is Nil")
|
}
|
|
r := C.wrap_fn_queue_push_timeout(libsoftbus, q.shmqueue, unsafe.Pointer(&data[0]), C.int(len(data)), C.int(sec), C.int(nsec))
|
if r == 0 {
|
return nil
|
}
|
return errors.New("Queue PushTimeout Data Error")
|
}
|
|
// Pop from shm queue
|
func (q *Queue) Pop() ([]byte, error) {
|
if libsoftbus == nil {
|
return nil, errors.New("C SoftBus Handle Is Nil")
|
}
|
|
var data unsafe.Pointer
|
var size C.int
|
r := C.wrap_fn_queue_pop(libsoftbus, q.shmqueue, &data, &size)
|
if r == 0 {
|
gd := C.GoBytes(data, size)
|
C.wrap_fn_queue_free_poped(libsoftbus, data)
|
return gd, nil
|
}
|
return nil, errors.New("Queue Pop Data Error")
|
}
|
|
// PopNoWait from shm queue
|
func (q *Queue) PopNoWait() ([]byte, error) {
|
if libsoftbus == nil {
|
return nil, errors.New("C SoftBus Handle Is Nil")
|
}
|
|
var data unsafe.Pointer
|
var size C.int
|
r := C.wrap_fn_queue_pop_nowait(libsoftbus, q.shmqueue, &data, &size)
|
if r == 0 {
|
gd := C.GoBytes(data, size)
|
C.wrap_fn_queue_free_poped(libsoftbus, data)
|
return gd, nil
|
}
|
return nil, errors.New("Queue Pop Data Error")
|
}
|
|
// PopTimeout from shm queue
|
func (q *Queue) PopTimeout(sec, nsec int) ([]byte, error) {
|
if libsoftbus == nil {
|
return nil, errors.New("C SoftBus Handle Is Nil")
|
}
|
|
var data unsafe.Pointer
|
var size C.int
|
r := C.wrap_fn_queue_pop_timeout(libsoftbus, q.shmqueue, &data, &size, C.int(sec), C.int(nsec))
|
if r == 0 {
|
gd := C.GoBytes(data, size)
|
C.wrap_fn_queue_free_poped(libsoftbus, data)
|
return gd, nil
|
}
|
return nil, errors.New("Queue Pop Data Error")
|
}
|
