// Copyright 2020 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
|
// Use of this source code is governed by a BSD-style license that can be
|
// found in the LICENSE file.
|
|
#include <stdio.h>
|
#include <assert.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <errno.h>
|
#include <stdbool.h>
|
#include <sys/types.h>
|
#include <unistd.h>
|
#include <ctype.h>
|
#include <inttypes.h>
|
|
#include <glib.h>
|
|
#include <pthread.h>
|
#include <gdbus.h>
|
|
#include "json-c/json.h"
|
#include "call_fun_ipc.h"
|
#include "shared_memory.h"
|
#include "dbus.h"
|
|
static DBusConnection *dbus_conn_s = NULL;
|
static struct FunMap *fun_map = NULL;
|
static int fun_num = 0;
|
char *DbusName = NULL;
|
char *DbusPath = NULL;
|
char *DbusIf = NULL;
|
char *SharePath = NULL;
|
|
struct Share_s {
|
char *addr;
|
int shmid;
|
struct Share_s* next;
|
};
|
|
static struct Share_s* share_client_list = NULL;
|
static struct Share_s* share_server_list = NULL;
|
|
void client_list_add(struct Share_s* share)
|
{
|
if (share_client_list == NULL) {
|
share_client_list = share;
|
} else {
|
struct Share_s* tmp = share_client_list;
|
while (tmp->next) {
|
tmp = tmp->next;
|
}
|
tmp->next = share;
|
}
|
}
|
|
void client_list_del(int shmid)
|
{
|
if (share_client_list) {
|
if (share_client_list->shmid == shmid) {
|
struct Share_s* tmp = share_client_list->next;
|
free(share_client_list);
|
share_client_list = tmp;
|
} else {
|
struct Share_s* tmp = share_client_list;
|
while (tmp->next) {
|
if (tmp->next->shmid == shmid) {
|
struct Share_s* tmp_next = tmp->next;
|
tmp->next = tmp_next->next;
|
free(tmp_next);
|
}
|
}
|
}
|
}
|
}
|
|
void server_list_add(struct Share_s* share)
|
{
|
if (share_server_list == NULL) {
|
share_server_list = share;
|
} else {
|
struct Share_s* tmp = share_server_list;
|
while (tmp->next) {
|
tmp = tmp->next;
|
}
|
tmp->next = share;
|
}
|
}
|
|
void server_list_del(int shmid)
|
{
|
if (share_server_list) {
|
if (share_server_list->shmid == shmid) {
|
struct Share_s* tmp = share_server_list->next;
|
free(share_server_list);
|
share_server_list = tmp;
|
} else {
|
struct Share_s* tmp = share_server_list;
|
while (tmp->next) {
|
if (tmp->next->shmid == shmid) {
|
struct Share_s* tmp_next = tmp->next;
|
tmp->next = tmp_next->next;
|
free(tmp_next);
|
}
|
}
|
}
|
}
|
}
|
|
DBusMessage *dbus_message_new_method_return_string(DBusMessage *msg, char *str)
|
{
|
DBusMessageIter array;
|
DBusMessage *reply = dbus_message_new_method_return(msg);
|
if (!reply)
|
return NULL;
|
|
dbus_message_iter_init_append(reply, &array);
|
dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &str);
|
|
return reply;
|
}
|
|
DBusMessage *method_callfun(DBusConnection *conn,
|
DBusMessage *msg, void *data)
|
{
|
int ret = 0;
|
char *json_str;
|
json_object *j_cfg;
|
|
dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &json_str,
|
DBUS_TYPE_INVALID);
|
|
j_cfg = json_tokener_parse(json_str);
|
//printf("%s, json_str = %s\n", __func__, json_str);
|
char *FunName = (char *)json_object_get_string(json_object_object_get(j_cfg, "FunName"));
|
|
for (int i = 0; i < fun_num; i++) {
|
if (fun_map[i].fun_name && fun_map[i].fun) {
|
if (!strcmp(fun_map[i].fun_name, FunName)) {
|
void *addr = NULL;
|
char *SharePath = (char *)json_object_get_string(json_object_object_get(j_cfg, "SharePath"));
|
int ShareId = (int)json_object_get_int(json_object_object_get(j_cfg, "ShareId"));
|
int ShareSize = (int)json_object_get_int(json_object_object_get(j_cfg, "ShareSize"));
|
int shmid = GetShm(SharePath, ShareId, ShareSize);
|
if (ShareSize > 0) {
|
struct Share_s *share_server;
|
addr = (void *)Shmat(shmid);
|
share_server = calloc(sizeof(struct Share_s), 1);
|
share_server->shmid = shmid;
|
share_server->addr = addr;
|
server_list_add(share_server);
|
}
|
fun_map[i].fun(addr);
|
if (ShareSize > 0) {
|
Shmdt((char *)addr);
|
server_list_del(shmid);
|
}
|
}
|
}
|
}
|
|
json_object_put(j_cfg);
|
|
json_object *j_ret = json_object_new_object();
|
json_object_object_add(j_ret, "Return", json_object_new_int(ret));
|
char *str = (char *)json_object_to_json_string(j_ret);
|
|
DBusMessage *reply = dbus_message_new_method_return_string(msg, str);
|
json_object_put(j_ret);
|
|
return reply;
|
}
|
|
const GDBusMethodTable methods[] = {
|
{
|
GDBUS_ASYNC_METHOD("callfun",
|
GDBUS_ARGS({ "json", "s" }), GDBUS_ARGS({ "json", "s" }),
|
method_callfun)
|
},
|
{ },
|
};
|
|
const GDBusSignalTable signals[] = {
|
{
|
GDBUS_SIGNAL("callback",
|
GDBUS_ARGS({ "json", "s" }))
|
},
|
{ },
|
};
|
|
static int dbus_manager_init(DBusConnection *dbus_conn, char *dbus_if, char *dbus_path)
|
{
|
g_dbus_register_interface(dbus_conn, dbus_path,
|
dbus_if,
|
methods,
|
signals, NULL, dbus_path, NULL);
|
|
return 0;
|
}
|
|
void call_fun_ipc_server_init(struct FunMap *map, int num, char *dbus_name, char *dbus_if, char *dbus_path, int needloop)
|
{
|
DBusError dbus_err;
|
|
if (needloop == 0)
|
callfunipc_disable_loop();
|
dbus_error_init(&dbus_err);
|
dbus_conn_s = g_dbus_setup_bus(DBUS_BUS_SYSTEM, dbus_name, &dbus_err);
|
fun_map = map;
|
fun_num = num;
|
dbus_manager_init(dbus_conn_s, dbus_if, dbus_path);
|
}
|
|
void call_fun_ipc_server_deinit(void)
|
{
|
struct Share_s* tmp = share_server_list;
|
|
share_server_list = NULL;
|
while (tmp) {
|
struct Share_s* tmp1 = tmp;
|
|
if (tmp->addr >= 0)
|
Shmdt((char *)tmp->addr);
|
tmp = tmp->next;
|
free(tmp1);
|
}
|
}
|
|
int call_fun_ipc_call(char *funname, void *data, int len, int restore)
|
{
|
int retry_cnt = 0;
|
static int projid = 0;
|
int ret = 0xfefefefe;
|
char *str_ret = NULL;
|
int shmid;
|
void *addr;
|
json_object *j_cfg = json_object_new_object();
|
|
if (len > 0) {
|
struct Share_s *share_client;
|
projid++;
|
|
shmid = CreateShm((char *)SharePath, projid, len);
|
if (shmid < 0)
|
return ret;
|
addr = (void *)Shmat(shmid);
|
share_client = calloc(sizeof(struct Share_s), 1);
|
share_client->shmid = shmid;
|
share_client->addr = addr;
|
client_list_add(share_client);
|
memcpy(addr, data, len);
|
}
|
json_object_object_add(j_cfg, "FunName", json_object_new_string(funname));
|
json_object_object_add(j_cfg, "SharePath", json_object_new_string(SharePath));
|
json_object_object_add(j_cfg, "ShareId", json_object_new_int(projid));
|
json_object_object_add(j_cfg, "ShareSize", json_object_new_int(len));
|
|
struct UserData* userdata;
|
userdata = callfunipc_dbus_connection();
|
retry_cnt = 0;
|
retry:
|
callfunipc_dbus_method_call(userdata->connection,
|
DbusName, DbusPath,
|
DbusIf, "callfun",
|
callfunipc_populate_get, userdata, callfunipc_append_path, (char *)json_object_to_json_string(j_cfg));
|
if (callfunipc_dbus_async(userdata) == -1 && retry_cnt++ < 2)
|
goto retry;
|
|
str_ret = userdata->json_str;
|
callfunipc_dbus_deconnection(userdata);
|
|
json_object_put(j_cfg);
|
|
if (str_ret) {
|
json_object *j_ret = json_tokener_parse(str_ret);
|
ret = (int)json_object_get_int(json_object_object_get(j_ret, "Return"));
|
json_object_put(j_ret);
|
g_free(str_ret);
|
}
|
if (len > 0) {
|
if (restore)
|
memcpy(data, addr, len);
|
Shmdt((char *)addr);
|
DestroyShm(shmid);
|
client_list_del(shmid);
|
}
|
|
return ret;
|
}
|
|
void call_fun_ipc_client_init(char *dbus_name, char *dbus_if, char *dbus_path, char *share_path, int needloop)
|
{
|
DBusError dbus_err;
|
|
if (needloop == 0)
|
callfunipc_disable_loop();
|
dbus_error_init(&dbus_err);
|
dbus_conn_s = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &dbus_err);
|
printf("%s dbus_conn_s = %d\n", __func__, dbus_conn_s);
|
DbusName = g_strdup(dbus_name);
|
DbusPath = g_strdup(dbus_path);
|
DbusIf = g_strdup(dbus_if);
|
SharePath = g_strdup(share_path);
|
while (call_fun_ipc_call("", NULL, 0, 0) == 0xfefefefe) {
|
usleep(100000);
|
//printf("%s wait\n", __func__);
|
}
|
}
|
|
void call_fun_ipc_client_deinit(void)
|
{
|
struct Share_s* tmp = share_client_list;
|
|
share_client_list = NULL;
|
while (tmp) {
|
struct Share_s* tmp1 = tmp;
|
|
if (tmp->addr >= 0)
|
Shmdt((char *)tmp->addr);
|
if (tmp->shmid >= 0)
|
DestroyShm(tmp->shmid);
|
tmp = tmp->next;
|
free(tmp1);
|
}
|
}
|
