#ifdef __cplusplus
|
extern "C"{
|
#endif
|
|
#include <dlfcn.h>
|
#include <stdlib.h>
|
#include <stdio.h>
|
|
#include "libcsoftbus.h"
|
|
#ifdef __cplusplus
|
}
|
#endif
|
|
#define check_only(fn, lib) \
|
do{ \
|
if(!fn){ \
|
dlclose(lib); \
|
printf("run func %s error\n", #fn); \
|
return; \
|
} \
|
}while(0)
|
|
#define check_with_ret(fn, lib, flag) \
|
do{ \
|
if(!fn){ \
|
dlclose(lib); \
|
printf("run func %s error\n", #fn); \
|
return flag; \
|
} \
|
}while(0)
|
|
|
hcsoftbus c_softbus_handle(const char *so){
|
hcsoftbus lib = dlopen(so, RTLD_LAZY);
|
if(lib){
|
|
fn_shm_destroy = (tfn_shm_destroy)dlsym(lib, l_shm_destroy);
|
check_with_ret(fn_shm_destroy, lib, NULL);
|
}else{
|
printf("softbus dlopen - %s\n", dlerror());
|
}
|
return lib;
|
}
|
|
void c_softbus_release(hcsoftbus lib){
|
if(lib) {
|
dlclose(lib);
|
}
|
}
|
|
void wrap_fn_shm_init(hcsoftbus lib, int size){
|
if (!fn_shm_init){
|
fn_shm_init = (tfn_shm_init)dlsym(lib, l_shm_init);
|
check_only(fn_shm_init, lib);
|
}
|
fn_shm_init(size);
|
}
|
|
int wrap_fn_shm_alloc_key(hcsoftbus lib){
|
if (!fn_shm_alloc_key){
|
fn_shm_alloc_key = (tfn_shm_alloc_key)dlsym(lib, l_shm_alloc_key);
|
check_with_ret(fn_shm_alloc_key, lib, -1);
|
}
|
return fn_shm_alloc_key();
|
}
|
|
void wrap_fn_shm_destroy(hcsoftbus lib){
|
if (!fn_shm_destroy){
|
printf("shm destroy failed\n");
|
return;
|
}
|
fn_shm_destroy();
|
}
|
|
void wrap_fn_shm_rm_dead_queue(hcsoftbus lib, void *array, int len){
|
if (!fn_shm_rm_dead_queue){
|
fn_shm_rm_dead_queue = (tfn_shm_rm_dead_queue)dlsym(lib, l_shm_rm_dead_queue);
|
check_only(fn_shm_rm_dead_queue, lib);
|
}
|
fn_shm_rm_dead_queue(array, len);
|
}
|
|
void* wrap_fn_queue_create(hcsoftbus lib, int *key, int queue_size){
|
if (!fn_queue_create){
|
fn_queue_create = (tfn_queue_create)dlsym(lib, l_queue_create);
|
check_with_ret(fn_queue_create, lib, NULL);
|
}
|
return fn_queue_create(key, queue_size);
|
}
|
|
void* wrap_fn_queue_attach(hcsoftbus lib, int key){
|
if (!fn_queue_attach){
|
fn_queue_attach = (tfn_queue_attach)dlsym(lib, l_queue_attach);
|
check_with_ret(fn_queue_attach, lib, NULL);
|
}
|
return fn_queue_attach(key);
|
}
|
|
void wrap_fn_queue_drop(hcsoftbus lib, void* shmq){
|
if (!fn_queue_drop){
|
fn_queue_drop = (tfn_queue_drop)dlsym(lib, l_queue_drop);
|
check_only(fn_queue_drop, lib);
|
}
|
fn_queue_drop(shmq);
|
}
|
|
int wrap_fn_queue_size(hcsoftbus lib, void *shmq){
|
if (!fn_queue_size){
|
fn_queue_size = (tfn_queue_size)dlsym(lib, l_queue_size);
|
check_with_ret(fn_queue_size, lib, 0);
|
}
|
return fn_queue_size(shmq);
|
}
|
|
int wrap_fn_queue_full(hcsoftbus lib, void *shmq){
|
if (!fn_queue_full){
|
fn_queue_full = (tfn_queue_full)dlsym(lib, l_queue_full);
|
check_with_ret(fn_queue_full, lib, 1);
|
}
|
return fn_queue_full(shmq);
|
}
|
|
int wrap_fn_queue_empty(hcsoftbus lib, void *shmq){
|
if (!fn_queue_empty){
|
fn_queue_empty = (tfn_queue_empty)dlsym(lib, l_queue_empty);
|
check_with_ret(fn_queue_empty, lib, 0);
|
}
|
return fn_queue_empty(shmq);
|
}
|
|
int wrap_fn_queue_push(hcsoftbus lib, void *shmq, void *ele, int ele_size){
|
if (!fn_queue_push){
|
fn_queue_push = (tfn_queue_push)dlsym(lib, l_queue_push);
|
check_with_ret(fn_queue_push, lib, 0);
|
}
|
|
return fn_queue_push(shmq, ele, ele_size);
|
}
|
|
int wrap_fn_queue_push_nowait(hcsoftbus lib, void *shmq, void *ele, int ele_size){
|
if (!fn_queue_push_nowait){
|
fn_queue_push_nowait = (tfn_queue_push_nowait)dlsym(lib, l_queue_push_nowait);
|
check_with_ret(fn_queue_push_nowait, lib, 0);
|
}
|
return fn_queue_push_nowait(shmq, ele, ele_size);
|
}
|
|
int wrap_fn_queue_push_timeout(hcsoftbus lib, void *shmq, void *ele, int ele_size, int sec, int nsec){
|
if (!fn_queue_push_timeout){
|
fn_queue_push_timeout = (tfn_queue_push_timeout)dlsym(lib, l_queue_push_timeout);
|
check_with_ret(fn_queue_push_timeout, lib, 0);
|
}
|
return fn_queue_push_timeout(shmq, ele, ele_size, sec, nsec);
|
}
|
|
int wrap_fn_queue_pop(hcsoftbus lib, void *shmq, void **ele, int *ele_size){
|
if (!fn_queue_pop){
|
fn_queue_pop = (tfn_queue_pop)dlsym(lib, l_queue_pop);
|
check_with_ret(fn_queue_pop, lib, 0);
|
}
|
return fn_queue_pop(shmq, ele, ele_size);
|
}
|
|
int wrap_fn_queue_pop_nowait(hcsoftbus lib, void *shmq, void **ele, int *ele_size){
|
if (!fn_queue_pop_nowait){
|
fn_queue_pop_nowait = (tfn_queue_pop_nowait)dlsym(lib, l_queue_pop_nowait);
|
check_with_ret(fn_queue_pop_nowait, lib, 0);
|
}
|
return fn_queue_pop_nowait(shmq, ele, ele_size);
|
}
|
|
int wrap_fn_queue_pop_timeout(hcsoftbus lib, void *shmq, void **ele, int *ele_size, int sec, int nsec){
|
if (!fn_queue_pop_timeout){
|
fn_queue_pop_timeout = (tfn_queue_pop_timeout)dlsym(lib, l_queue_pop_timeout);
|
check_with_ret(fn_queue_pop_timeout, lib, 0);
|
}
|
|
return fn_queue_pop_timeout(shmq, ele, ele_size, sec, nsec);
|
}
|
|
void wrap_fn_queue_free_poped(hcsoftbus lib, void *ptr){
|
if (!fn_queue_free_poped){
|
fn_queue_free_poped = (tfn_queue_free_poped)dlsym(lib, l_queue_free_poped);
|
check_only(fn_queue_free_poped, lib);
|
}
|
fn_queue_free_poped(ptr);
|
}
|
|
////////////////////////////////////////////
|
// socket mode
|
////////////////////////////////////////////
|
void *wrap_fn_socket_open(hcsoftbus lib, int mod){
|
if (!fn_socket_open) {
|
fn_socket_open = (tfn_socket_open)dlsym(lib, l_socket_open);
|
check_with_ret(fn_socket_open, lib, NULL);
|
}
|
return fn_socket_open(mod);
|
}
|
|
int wrap_fn_socket_close(hcsoftbus lib, void* s){
|
if(!fn_socket_close){
|
fn_socket_close = (tfn_socket_close)dlsym(lib, l_socket_close);
|
check_with_ret(fn_socket_close, lib, -1);
|
}
|
return fn_socket_listen(s);
|
}
|
|
int wrap_fn_socket_bind(hcsoftbus lib, void *s, int port){
|
if (!fn_socket_bind){
|
fn_socket_bind = (tfn_socket_bind)dlsym(lib, l_socket_bind);
|
check_with_ret(fn_socket_bind, lib, -1);
|
}
|
|
return fn_socket_bind(s, port);
|
}
|
|
int wrap_fn_socket_listen(hcsoftbus lib, void *s){
|
if (!fn_socket_listen){
|
fn_socket_listen = (tfn_socket_listen)dlsym(lib, l_socket_listen);
|
check_with_ret(fn_socket_listen, lib, -1);
|
}
|
return fn_socket_listen(s);
|
}
|
|
int wrap_fn_socket_connect(hcsoftbus lib, void *s, int port){
|
if (!fn_socket_connect){
|
fn_socket_connect = (tfn_socket_connect)dlsym(lib, l_socket_connect);
|
check_with_ret(fn_socket_connect, lib, -1);
|
}
|
return fn_socket_connect(s, port);
|
}
|
|
int wrap_fn_socket_send(hcsoftbus lib, void *s, const void *buf, const int size){
|
if (!fn_socket_send){
|
fn_socket_send = (tfn_socket_send)dlsym(lib, l_socket_send);
|
check_with_ret(fn_socket_send, lib, -1);
|
}
|
|
return fn_socket_send(s, buf, size);
|
}
|
|
int wrap_fn_socket_recv(hcsoftbus lib, void *s, void **buf, int *size){
|
if (!fn_socket_recv){
|
fn_socket_recv = (tfn_socket_recv)dlsym(lib, l_socket_recv);
|
check_with_ret(fn_socket_recv, lib, -1);
|
}
|
return fn_socket_recv(s, buf, size);
|
}
|
|
void wrap_fn_socket_buf_free(hcsoftbus lib, void *buf){
|
if (!fn_socket_buf_free){
|
fn_socket_buf_free = (tfn_socket_buf_free)dlsym(lib, l_socket_free);
|
}
|
if (fn_socket_buf_free){
|
fn_socket_buf_free(buf);
|
}
|
}
|
|
int wrap_fn_socket_port(hcsoftbus lib, void *s){
|
if (!fn_socket_port){
|
fn_socket_port = (tfn_socket_port)dlsym(lib, l_socket_port);
|
check_with_ret(fn_socket_port, lib, -1);
|
}
|
|
return fn_socket_port(s);
|
}
|
////////////////////////////////////////////
|
// dgram socket mode
|
////////////////////////////////////////////
|
void *wrap_fn_dgram_socket_open(hcsoftbus lib){
|
if (!fn_dgram_socket_open){
|
fn_dgram_socket_open = (tfn_dgram_socket_open)dlsym(lib , l_dgram_socket_open);
|
check_with_ret(fn_dgram_socket_open, lib, NULL);
|
}
|
return fn_dgram_socket_open();
|
}
|
|
int wrap_fn_dgram_socket_close(hcsoftbus lib, void *s){
|
if (!fn_dgram_socket_close){
|
fn_dgram_socket_close = (tfn_dgram_socket_close)dlsym(lib, l_dgram_socket_close);
|
check_with_ret(fn_dgram_socket_close, lib, -1);
|
}
|
return fn_dgram_socket_close(s);
|
}
|
|
int wrap_fn_dgram_socket_bind(hcsoftbus lib, void *s, int port){
|
if (!fn_dgram_socket_bind){
|
fn_dgram_socket_bind = (tfn_dgram_socket_bind)dlsym(lib, l_dgram_socket_bind);
|
check_with_ret(fn_dgram_socket_bind, lib, -1);
|
}
|
return fn_dgram_socket_bind(s, port);
|
}
|
|
int wrap_fn_dgram_socket_force_bind(hcsoftbus lib, void *s, int port){
|
if (!fn_dgram_socket_force_bind){
|
fn_dgram_socket_force_bind = (tfn_dgram_socket_force_bind)dlsym(lib, l_dgram_socket_force_bind);
|
check_with_ret(fn_dgram_socket_force_bind, lib, -1);
|
}
|
return fn_dgram_socket_force_bind(s, port);
|
}
|
|
int wrap_fn_dgram_socket_sendto(hcsoftbus lib, void *s, const void *buf, const int size, const int port){
|
if (!fn_dgram_socket_sendto){
|
fn_dgram_socket_sendto = (tfn_dgram_socket_sendto)dlsym(lib, l_dgram_socket_sendto);
|
check_with_ret(fn_dgram_socket_sendto, lib, -1);
|
}
|
return fn_dgram_socket_sendto(s, buf, size, port);
|
}
|
|
int wrap_fn_dgram_socket_recvfrom(hcsoftbus lib, void *s, void **buf, int *size, int *port){
|
if (!fn_dgram_socket_recvfrom){
|
fn_dgram_socket_recvfrom = (tfn_dgram_socket_recvfrom)dlsym(lib, l_dgram_socket_recvfrom);
|
check_with_ret(fn_dgram_socket_recvfrom, lib, -1);
|
}
|
return fn_dgram_socket_recvfrom(s, buf, size, port);
|
}
|
|
int wrap_fn_dgram_socket_sendandrecv(hcsoftbus lib, void *s, const void *sbuf, const int ssize, const int port, void **rbuf, int *rsize){
|
if (!fn_dgram_socket_sendandrecv){
|
fn_dgram_socket_sendandrecv = (tfn_dgram_socket_sendandrecv)dlsym(lib, l_dgram_socket_sendandrecv);
|
check_with_ret(fn_dgram_socket_sendandrecv, lib, -1);
|
}
|
return fn_dgram_socket_sendandrecv(s, sbuf, ssize, port, rbuf, rsize);
|
}
|
|
int wrap_fn_dgram_socket_start_bus(hcsoftbus lib, void *s){
|
if (!fn_dgram_socket_start_bus){
|
fn_dgram_socket_start_bus = (tfn_dgram_socket_start_bus)dlsym(lib, l_dgram_socket_start_bus);
|
check_with_ret(fn_dgram_socket_start_bus, lib, -1);
|
}
|
return fn_dgram_socket_start_bus(s);
|
}
|
|
int wrap_fn_dgram_socket_sub(hcsoftbus lib, void *s, void *topic, int size, int port){
|
if (!fn_dgram_socket_sub){
|
fn_dgram_socket_sub = (tfn_dgram_socket_sub)dlsym(lib, l_dgram_socket_sub);
|
check_with_ret(fn_dgram_socket_sub, lib, -1);
|
}
|
return fn_dgram_socket_sub(s, topic, size, port);
|
}
|
|
int wrap_fn_dgram_socket_pub(hcsoftbus lib, void *s, void *topic, int tsize, void *content, int csize, int port){
|
if (!fn_dgram_socket_pub){
|
fn_dgram_socket_pub = (tfn_dgram_socket_pub)dlsym(lib, l_dgram_socket_pub);
|
check_with_ret(fn_dgram_socket_pub, lib, -1);
|
}
|
return fn_dgram_socket_pub(s, topic, tsize, content, csize, port);
|
}
|
|
int wrap_fn_dgram_socket_port(hcsoftbus lib, void *s){
|
if (!fn_dgram_socket_port){
|
fn_dgram_socket_port = (tfn_dgram_socket_port)dlsym(lib, l_dgram_socket_port);
|
check_with_ret(fn_dgram_socket_port, lib, -1);
|
}
|
return fn_dgram_socket_port(s);
|
}
|
|
void wrap_fn_dgram_socket_free(hcsoftbus lib, void *buf){
|
if (!fn_dgram_socket_free){
|
fn_dgram_socket_free = (tfn_dgram_socket_free)dlsym(lib, l_dgram_socket_free);
|
}
|
if (fn_dgram_socket_free){
|
fn_dgram_socket_free(buf);
|
}else{
|
free(buf);
|
}
|
}
|
