path: root/idlc/c_gen/c_stub_body_gen_cb.h

/*
 * Copyright (c) 2017 Samsung Electronics Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef IDLC_C_GEN_C_STUB_BODY_GEN_CB_H_
#define IDLC_C_GEN_C_STUB_BODY_GEN_CB_H_

const char CB_INTERFACE_METHOD[] =
R"__c_cb(
static int __$$_method_$$(rpc_port_h port, rpc_port_parcel_h parcel, void *data)
{
    rpc_port_stub_$$_context_h context = data;
    rpc_port_h callback_port;
    int r = rpc_port_stub_get_port(__$$_stub, RPC_PORT_PORT_CALLBACK,
            context->instance, &callback_port);

    if (r != 0) {
      _E("Failed to get callback port");
    }
$$
    return 0;
}
)__c_cb";

const char CB_INTERFACE_METHOD_TABLE[] =
R"__c_cb(static stub_method __$$_method_table[] = {$$
};
)__c_cb";

const char CB_INTERFACE_METHOD_FORMAT[] =
R"__c_cb(
[$$] = $$,)__c_cb";

const char CB_INTERFACE_ON_CONNECTED[] =
R"__c_cb(
static void __##_on_connected(const char *sender, const char *instance, void *data)
{
    rpc_port_stub_##_context_h context;

    _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance);
    context = __create_##_context(sender, instance);
    if (!context)
        return;

    if (context->callback.create)
        context->callback.create(context, context->user_data);
    __##_contexts = g_list_append(__##_contexts, context);
}
)__c_cb";

const char CB_INTERFACE_ON_DISCONNECTED[] =
R"__c_cb(
static void __##_on_disconnected(const char *sender, const char *instance, void *data)
{
    rpc_port_stub_##_context_h context;

    _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance);
    context = __find_##_context(instance);
    if (!context)
        return;

    if (context->callback.terminate)
        context->callback.terminate(context, context->user_data);
    __##_contexts = g_list_remove(__##_contexts, context);
    __destroy_##_context(context);
}
)__c_cb";

const char CB_INTERFACE_ON_RECEIVED[] =
R"__c_cb(
static int __##_on_received(const char *sender, const char *instance, rpc_port_h port, void *data)
{
    rpc_port_stub_##_context_h context;
    rpc_port_parcel_h parcel;
    int cmd = -1;
    int r;

    _I("[__RPC_PORT__] sender(%s), instance(%s)", sender, instance);
    context = __find_##_context(instance);
    if (!context) {
        _E("Failed to find ## context(%s)", instance);
        return -1;
    }

    context->port = port;
    r = rpc_port_parcel_create_from_port(&parcel, port);
    if (r != 0) {
        _E("Failed to create parcel from port. context(%s)", instance);
        __##_on_disconnected(sender, instance, data);
        return r;
    }

    rpc_port_parcel_read_int32(parcel, &cmd);
    if (cmd > 1 && cmd < (sizeof(__##_method_table) / sizeof(__##_method_table[0]))) {
         if (__##_method_table[cmd])
             r = __##_method_table[cmd](port, parcel, context);
    } else {
         _E("Unknown Command(%d)", cmd);
         r = -1;
    }

    rpc_port_parcel_destroy(parcel);

    return r;
}
)__c_cb";

const char CB_INTERFACE_REGISTER[] =
R"__c_cb(
int rpc_port_stub_##_register(rpc_port_stub_##_callback_s *callback, void *user_data)
{
    int r;

    if (__##_stub) {
        _W("Already exists");
        return -1;
    }

    if (!callback) {
        _E("Invalid parameter");
        return -1;
    }

    __##_callback = *callback;
    __##_user_data = user_data;
    r = rpc_port_stub_create(&__##_stub, "##");
    if (r != 0) {
        _E("Failed to create stub handle");
        return r;
    }

    r = rpc_port_stub_add_received_event_cb(__##_stub, __##_on_received, NULL);
    if (r != 0) {
        _E("Failed to add received event callback");
        rpc_port_stub_destroy(__##_stub);
        __##_stub = NULL;
        return r;
    }

    r = rpc_port_stub_add_connected_event_cb(__##_stub, __##_on_connected, NULL);
    if (r != 0) {
        _E("Failed to add connected event callback");
        rpc_port_stub_destroy(__##_stub);
        __##_stub = NULL;
        return r;
    }

    r = rpc_port_stub_add_disconnected_event_cb(__##_stub, __##_on_disconnected, NULL);
    if (r != 0) {
        _E("Failed to add disconnected event callback");
        rpc_port_stub_destroy(__##_stub);
        __##_stub = NULL;
        return r;
    }

    r = __##_add_privileges();
    if (r != 0) {
        _E("Failed to add privileges");
        rpc_port_stub_destroy(__##_stub);
        __##_stub = NULL;
        return r;
    }

    r = rpc_port_stub_listen(__##_stub);
    if (r != 0) {
        _E("Failed to listen stub");
        rpc_port_stub_destroy(__##_stub);
        __##_stub = NULL;
        return r;
    }

    return 0;
}
)__c_cb";

const char CB_INTERFACE_UNREGISTER[] =
R"__c_cb(
int rpc_port_stub_##_unregister(void)
{
    int r;

    if (!__##_stub)
        return -1;

    if (__##_contexts) {
        g_list_free_full(__##_contexts, __destroy_##_context);
        __##_contexts = NULL;
    }

    r = rpc_port_stub_destroy(__##_stub);
    __##_stub = NULL;

    return r;
}
)__c_cb";

const char CB_GLOBALS[] =
R"__c_cb(
static rpc_port_stub_h __##_stub;
static rpc_port_stub_##_callback_s __##_callback;
static void *__##_user_data;
static GList *__##_contexts;
)__c_cb";

const char CB_INTERFACE_DELEGATOR_DECL[] =
R"__c_cb(
struct $$_s {
    rpc_port_parcelable_t parcelable;
    rpc_port_h port;
    int id;
    int seq_id;
    bool once;
    bool valid;
};
)__c_cb";

const char CB_INTERFACE_DELEGATOR_CTOR[] =
R"__c_cb(
int rpc_port_##_create(rpc_port_##_h *h)
{
    struct ##_s *handle;
    static int seq_num;

    if (!h) {
        _E("Invalid parameter");
        return -1;
    }

    handle = calloc(1, sizeof(struct ##_s));
    if (!handle) {
        _E("Out of memory");
        return -1;
    }

    handle->parcelable.to = __##_to;
    handle->parcelable.from = __##_from;
    handle->id = $$_DELEGATE_$$;
    handle->seq_id = g_atomic_int_add(&seq_num, 1) + 1;
    handle->once = false;
    handle->valid = true;

    *h = handle;

    return 0;
}
)__c_cb";

const char CB_INTERFACE_DELEGATOR_DTOR[] =
R"__c_cb(
int rpc_port_##_destroy(rpc_port_##_h h)
{
    if (!h) {
        _E("Invalid parameter");
        return -1;
    }

    free(h);

    return 0;
}
)__c_cb";

const char CB_INTERFACE_DELEGATOR_SERIALIZER[] =
R"__c_cb(
static void __##_to(rpc_port_parcel_h parcel, void *data)
{
    rpc_port_##_h handle = data;

    if (!handle) {
        _E("Invalid parameter");
        return;
    }

    rpc_port_parcel_write_int32(parcel, handle->id);
    rpc_port_parcel_write_int32(parcel, handle->seq_id);
    rpc_port_parcel_write_bool(parcel, handle->once);
}
)__c_cb";

const char CB_INTERFACE_DELEGATOR_DESERIALIZER[] =
R"__c_cb(
static void __##_from(rpc_port_parcel_h parcel, void *data)
{
    rpc_port_##_h handle = data;

    if (!handle) {
        _E("Invalid parameter");
        return;
    }

    rpc_port_parcel_read_int32(parcel, &handle->id);
    rpc_port_parcel_read_int32(parcel, &handle->seq_id);
    rpc_port_parcel_read_bool(parcel, &handle->once);
}
)__c_cb";

const char CB_INTERFACE_DELEGATOR_CLONER[] =
R"__c_cb(
int rpc_port_##_clone(rpc_port_##_h h, rpc_port_##_h *clone)
{
    rpc_port_##_h handle;

    if (!h || !clone) {
        _E("Invalid parameter");
        return -1;
    }

    handle = calloc(1, sizeof(struct ##_s));
    if (!handle) {
        _E("Out of memory");
        return -1;
    }

    handle->parcelable = h->parcelable;
    handle->port = h->port;
    handle->id = h->id;
    handle->seq_id = h->seq_id;
    handle->once = h->once;
    handle->valid = h->valid;

    *clone = handle;

    return 0;
}
)__c_cb";

const char CB_INTERFACE_DELEGATOR_INVOKER[] =
R"__c_cb(
int rpc_port_$$_invoke($$)
{
    rpc_port_parcel_h parcel = NULL;

    if (!h || !h->port) {
        _E("Invalid parameter");
        return -1;
    }

    if (h->once && !h->valid) {
        _E("Invalid callback");
        return -1;
    }

    rpc_port_parcel_create(&parcel);
    if (!parcel) {
        _E("Failed to create parcel");
        return -1;
    }

    rpc_port_parcel_write_int32(parcel, $$_METHOD_Callback);
    rpc_port_parcel_write(parcel, &h->parcelable, h);
$$
    rpc_port_parcel_send(parcel, h->port);
    rpc_port_parcel_destroy(parcel);
    h->valid = false;

    return 0;
}
)__c_cb";

const char CB_INTERFACE_DELEGATOR_PORT_SETTER[] =
R"__c_cb(
int rpc_port_##_set_port(rpc_port_##_h h, rpc_port_h port)
{
    if (!h || !port) {
        _E("Invalid parameter");
        return -1;
    }

    h->port = port;

    return 0;
}
)__c_cb";

const char CB_INTERFACE_CONTEXT_DECL[] =
R"__c_cb(
struct ##_context_s {
    char *sender;
    char *instance;
    rpc_port_h port;
    void *tag;
    rpc_port_stub_##_callback_s callback;
    void *user_data;
};
)__c_cb";

const char CB_INTERFACE_CONTEXT_CTOR[] =
R"__c_cb(
static struct ##_context_s *__create_##_context(const char *sender, const char *instance)
{
    struct ##_context_s *handle;

    handle = calloc(1, sizeof(struct ##_context_s));
    if (!handle) {
        _E("Out of memory");
        return NULL;
    }

    handle->sender = strdup(sender);
    if (!handle->sender) {
        _E("Out of memory");
        free(handle);
        return NULL;
    }

    handle->instance = strdup(instance);
    if (!handle->instance) {
        _E("Out of memory");
        free(handle->sender);
        free(handle);
        return NULL;
    }

    handle->callback = __##_callback;
    handle->user_data = __##_user_data;

    return handle;
}
)__c_cb";

const char CB_INTERFACE_CONTEXT_DTOR[] =
R"__c_cb(
static void __destroy_##_context(gpointer data)
{
    struct ##_context_s *handle = data;

    if (!handle) {
        _E("Critical error!");
        return;
    }

    free(handle->instance);
    free(handle->sender);
    free(handle);
}
)__c_cb";

const char CB_INTERFACE_CONTEXT_FINDER[] =
R"__c_cb(
static struct ##_context_s *__find_##_context(const char *instance)
{
    struct ##_context_s *handle;
    GList *iter;

    iter = __##_contexts;
    while (iter) {
        handle = (struct ##_context_s *)iter->data;
        if (!strcmp(handle->instance, instance))
            return handle;
        iter = g_list_next(iter);
    }

    return NULL;
}
)__c_cb";

const char CB_INTERFACE_CONTEXT_TAG_SETTER[] =
R"__c_cb(
int rpc_port_stub_##_context_set_tag(rpc_port_stub_##_context_h ctx, void *tag)
{
    if (!ctx) {
        _E("Invalid parameter");
        return -1;
    }

    ctx->tag = tag;

    return 0;
}
)__c_cb";

const char CB_INTERFACE_CONTEXT_TAG_GETTER[] =
R"__c_cb(
int rpc_port_stub_##_context_get_tag(rpc_port_stub_##_context_h ctx, void **tag)
{
    if (!ctx || !tag) {
        _E("Invalid parameter");
        return -1;
    }

    *tag = ctx->tag;

    return 0;
}
)__c_cb";

const char CB_INTERFACE_CONTEXT_GET_SENDER[] =
R"__c_cb(
int rpc_port_stub_##_context_get_sender(rpc_port_stub_##_context_h ctx, char **sender)
{
    if (!ctx || !sender) {
        _E("Invalid parameter");
        return -1;
    }

    *sender = strdup(ctx->sender);
    if (*sender == NULL) {
        _E("Out of memory");
        return -1;
    }

    return 0;
}
)__c_cb";

const char CB_STUB_METHOD_TYPE[] =
R"__c_cb(
typedef int (*stub_method)(rpc_port_h, rpc_port_parcel_h, void *data);
)__c_cb";

const char CB_INTERFACE_ADD_PRIVILEGE[] =
R"__c_cb(
static int __$$_add_privileges(void)
{
$$
    return 0;
}
)__c_cb";

const char CB_INTERFACE_PRIVILEGE_BLOCK[] =
R"__c_cb(r = $$;
if (r != 0) {
    _E("Failed to add privilege($$)");
    return r;
}
)__c_cb";

const char CB_INTERFACE_TRUSTED_MODE_BLOCK[] =
R"__c_cb(r = $$;
if (r != 0) {
    _E("Failed to set trusted mode($$)");
    return r;
}
)__c_cb";

#endif  // IDLC_C_GEN_C_STUB_BODY_GEN_CB_H_