service.h

Go to the documentation of this file.

/*
 * Copyright 2015-2017 Two Pore Guys, Inc.
 * All rights reserved
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted providing that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef LIBRPC_SERVICE_H
#define LIBRPC_SERVICE_H

#include <rpc/object.h>
#include <rpc/connection.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifndef __APPLE__
#define __unsafe_unretained
#endif

#define RPC_FUNCTION_STILL_RUNNING  ((rpc_object_t)1)

#define RPC_DISCOVERABLE_INTERFACE  "com.twoporeguys.librpc.Discoverable"
#define RPC_INTROSPECTABLE_INTERFACE    "com.twoporeguys.librpc.Introspectable"
#define RPC_OBSERVABLE_INTERFACE    "com.twoporeguys.librpc.Observable"
#define RPC_DEFAULT_INTERFACE       "com.twoporeguys.librpc.Default"

struct rpc_context;

struct rpc_instance;

typedef struct rpc_context *rpc_context_t;

typedef struct rpc_instance *rpc_instance_t;

typedef _Nullable rpc_object_t (^rpc_function_t)(void *_Nonnull cookie,
    _Nonnull rpc_object_t args);

typedef _Nullable rpc_object_t (*rpc_function_f)(void *_Nonnull cookie,
    _Nonnull rpc_object_t args);

typedef _Nullable rpc_object_t (^rpc_property_getter_t)(void *_Nonnull cookie);

typedef void (^rpc_property_setter_t)(void *_Nonnull cookie,
    _Nonnull rpc_object_t value);

typedef void (^rpc_abort_handler_t)(void);

#define RPC_FUNCTION(_fn)                       \
    ^(void *_cookie, rpc_object_t _args) {              \
        return ((rpc_object_t)_fn(_cookie, _args));     \
    }

#define RPC_PROPERTY_GETTER(_fn)                    \
    ^(void *_cookie) {                      \
        return ((rpc_object_t)_fn(_cookie));            \
    }

#define RPC_PROPERTY_SETTER(_fn)                    \
    ^(void *_cookie, rpc_object_t _value) {             \
        _fn(_cookie, _value);                   \
    }

#define RPC_ABORT_HANDLER(_fn, _arg)                    \
    ^(void *_cookie) {                      \
        _fn(_arg);                      \
    }

#define RPC_EVENT(_name)                        \
    {                               \
        .rim_type = RPC_MEMBER_EVENT,               \
        .rim_name = (#_name)                    \
    }

#define RPC_PROPERTY_RO(_name, _getter)                 \
    {                               \
        .rim_type = RPC_MEMBER_PROPERTY,            \
        .rim_name = (#_name),                   \
        .rim_property = {                   \
                        .rp_getter = RPC_PROPERTY_GETTER(_getter),  \
            .rp_setter = NULL,              \
            .rp_arg = NULL                  \
                }                           \
    }

#define RPC_PROPERTY_WO(_name, _setter)                 \
    {                               \
        .rim_type = RPC_MEMBER_PROPERTY,            \
        .rim_name = (#_name),                   \
        .rim_property = {                   \
                        .rp_getter = NULL,              \
            .rp_setter = RPC_PROPERTY_SETTER(_setter),  \
            .rp_arg = NULL                  \
                }                           \
    }

#define RPC_PROPERTY_RW(_name, _getter, _setter)            \
    {                               \
        .rim_type = RPC_MEMBER_PROPERTY,            \
        .rim_name = (#_name),                   \
        .rim_property = {                   \
                        .rp_getter = RPC_PROPERTY_GETTER(_getter),  \
            .rp_setter = RPC_PROPERTY_SETTER(_setter),  \
            .rp_arg = NULL                  \
                }                           \
    }

#define RPC_METHOD(_name, _fn)                      \
    {                               \
        .rim_type = RPC_MEMBER_METHOD,              \
        .rim_name = (#_name),                   \
        .rim_method = {                     \
                        .rm_block = RPC_FUNCTION(_fn),          \
            .rm_arg = NULL                  \
                }                           \
    }

#define RPC_METHOD_BLOCK(_name, _block)                 \
    {                               \
        .rim_type = RPC_MEMBER_METHOD,              \
        .rim_name = (#_name),                   \
        .rim_method = {                     \
                        .rm_block = (_block),               \
                }                           \
    }

#define RPC_MEMBER_END {}

enum rpc_if_member_type
{
    RPC_MEMBER_EVENT,       
    RPC_MEMBER_PROPERTY,        
    RPC_MEMBER_METHOD,      
};

enum rpc_property_rights
{
    RPC_PROPERTY_READ = (1 << 0),   
    RPC_PROPERTY_WRITE = (1 << 1),  
};


struct rpc_if_method
{
    __unsafe_unretained _Nonnull rpc_function_t rm_block;
    void *_Nullable rm_arg;
};

struct rpc_if_property
{
    __unsafe_unretained _Nullable rpc_property_getter_t rp_getter;
    __unsafe_unretained _Nullable rpc_property_setter_t rp_setter;
    void *_Nullable rp_arg;
    bool rp_notify;
};

struct rpc_if_member {
    const char *_Nonnull        rim_name;
    enum rpc_if_member_type     rim_type;
    union {
        struct rpc_if_method    rim_method;
        struct rpc_if_property  rim_property;
    };
};

_Nonnull rpc_context_t rpc_context_create(void);

void rpc_context_free(_Nonnull rpc_context_t context);

_Nullable rpc_instance_t rpc_context_find_instance(
    _Nonnull rpc_context_t context, const char *_Nonnull path);

_Nonnull rpc_instance_t rpc_context_get_root(_Nonnull rpc_context_t context);

int rpc_context_register_instance(_Nonnull rpc_context_t context,
    _Nonnull rpc_instance_t instance);

void rpc_context_unregister_instance(_Nonnull rpc_context_t context,
    const char *_Nonnull path);

int rpc_context_register_member(_Nonnull rpc_context_t context,
    const char *_Nullable interface, struct rpc_if_member *_Nonnull m);

int rpc_context_register_block(_Nonnull rpc_context_t context,
    const char *_Nullable interface, const char *_Nonnull name,
    void *_Nullable arg, _Nonnull rpc_function_t func);

int rpc_context_register_func(_Nonnull rpc_context_t context,
    const char *_Nullable interface, const char *_Nonnull name,
    void *_Nullable arg, _Nonnull rpc_function_f func);

int rpc_context_unregister_member(_Nonnull rpc_context_t context,
    const char *_Nullable interface, const char *_Nonnull name);

void rpc_context_set_pre_call_hook(_Nonnull rpc_context_t context,
    _Nonnull rpc_function_t fn);

void rpc_context_set_post_call_hook(_Nonnull rpc_context_t context,
    _Nonnull rpc_function_t fn);

_Nullable rpc_call_t rpc_context_dispatch_call(_Nonnull rpc_context_t context,
    const char *_Nonnull name, _Nullable rpc_object_t args);

void rpc_context_emit_event(_Nonnull rpc_context_t context,
    const char *_Nullable path, const char *_Nullable interface,
    const char *_Nonnull name, _Nonnull rpc_object_t args);

void *_Nullable rpc_function_get_arg(void *_Nonnull cookie);

_Nonnull rpc_context_t rpc_function_get_context(void *_Nonnull cookie);

_Nullable rpc_connection_t rpc_function_get_connection(void *_Nonnull cookie);

_Nonnull rpc_instance_t rpc_function_get_instance(void *_Nonnull cookie);

const char *_Nonnull rpc_function_get_name(void *_Nonnull cookie);

const char *_Nonnull rpc_function_get_path(void *_Nonnull cookie);

const char *_Nonnull rpc_function_get_interface(void *_Nonnull cookie);

void rpc_function_respond(void *_Nonnull cookie, _Nullable rpc_object_t object);

void rpc_function_error(void *_Nonnull cookie, int code,
    const char *_Nonnull message, ...);

void rpc_function_error_ex(void *_Nonnull cookie,
    _Nonnull rpc_object_t exception);

int rpc_function_start_stream(void *_Nonnull cookie);

int rpc_function_yield(void *_Nonnull cookie, _Nonnull rpc_object_t fragment);

void rpc_function_end(void *_Nonnull cookie);

void rpc_function_kill(void *_Nonnull cookie);

bool rpc_function_should_abort(void *_Nonnull cookie);

void rpc_function_set_async_abort_handler(void *_Nonnull cookie,
    _Nullable rpc_abort_handler_t handler);

int rpc_function_retain(void *_Nonnull cookie);

int  rpc_function_release(void *_Nonnull cookie);

_Nullable rpc_instance_t rpc_instance_new(void *_Nullable arg,
    const char *_Nonnull fmt, ...);

void rpc_instance_set_description(_Nonnull rpc_instance_t instance,
    const char *_Nonnull fmt, ...);

void *_Nullable rpc_instance_get_arg(_Nonnull rpc_instance_t instance);

const char *_Nonnull rpc_instance_get_path(_Nonnull rpc_instance_t instance);

int rpc_instance_register_interface(_Nonnull rpc_instance_t instance,
    const char *_Nonnull interface,
    const struct rpc_if_member *_Nullable vtable, void *_Nullable arg);

void rpc_instance_unregister_interface(_Nonnull rpc_instance_t instance,
    const char *_Nonnull interface);

int rpc_instance_register_member(_Nonnull rpc_instance_t instance,
    const char *_Nonnull interface,
    const struct rpc_if_member *_Nonnull member);

int rpc_instance_unregister_member(_Nonnull rpc_instance_t instance,
    const char *_Nonnull interface, const char *_Nonnull name);

int rpc_instance_register_block(_Nonnull rpc_instance_t instance,
    const char *_Nonnull interface, const char *_Nonnull name,
    void *_Nullable arg, _Nonnull rpc_function_t fn);

int rpc_instance_register_func(_Nonnull rpc_instance_t instance,
    const char *_Nonnull interface, const char *_Nonnull name,
    void *_Nullable arg, _Nonnull rpc_function_f fn);

struct rpc_if_member *_Nullable rpc_instance_find_member(
    _Nonnull rpc_instance_t instance, const char *_Nullable interface,
    const char *_Nonnull name);

bool rpc_instance_has_interface(_Nonnull rpc_instance_t instance,
    const char *_Nonnull interface);

void rpc_instance_emit_event(_Nonnull rpc_instance_t instance,
    const char *_Nonnull interface, const char *_Nonnull name,
    _Nonnull rpc_object_t args);

int rpc_instance_register_property(_Nonnull rpc_instance_t instance,
    const char *_Nonnull interface, const char *_Nonnull name,
    void *_Nullable arg, _Nullable rpc_property_getter_t getter,
    _Nullable rpc_property_setter_t setter);

int rpc_instance_get_property_rights(_Nonnull rpc_instance_t instance,
    const char *_Nonnull interface, const char *_Nonnull name);

int rpc_instance_register_event(_Nonnull rpc_instance_t instance,
    const char *_Nonnull interface, const char *_Nonnull name);

void rpc_instance_property_changed(_Nonnull rpc_instance_t instance,
    const char *_Nonnull interface, const char *_Nonnull name,
    _Nullable rpc_object_t value);

_Nonnull rpc_instance_t rpc_property_get_instance(void *_Nonnull cookie);

void *_Nullable rpc_property_get_arg(void *_Nonnull cookie);

void rpc_property_error(void *_Nonnull cookie, int code,
    const char *_Nonnull fmt, ...);

void rpc_instance_free(_Nonnull rpc_instance_t instance);

#ifdef __cplusplus
}
#endif

#endif /* LIBRPC_SERVICE_H */