amxb_ba_invoke.c File Reference

#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <amxc/amxc.h>
#include <amxp/amxp.h>
#include <amxd/amxd_dm.h>
#include <amxd/amxd_object.h>
#include <amxb/amxb_be_intf.h>
#include <amxb/amxb.h>
#include "amxb_priv.h"

Go to the source code of this file.

Macros
#define	_GNU_SOURCE

Functions
static int	isdot (int c)
static int	isbrace (int c)
static void	amxb_trim (char *str, amxc_string_is_char_fn_t fn)
static void	amxb_complete_async_invoke (UNUSED const amxc_var_t *const data, void *const priv)
static void	amxb_complete_async_deferred_invoke (const amxc_var_t *const data, void *const priv)
static int	amxb_invoke_local_impl (amxb_invoke_t *invoke_ctx, amxb_bus_ctx_t *ctx, amxc_var_t *args, amxb_request_t *request, bool async)
static int	amxb_invoke_be_impl (amxb_invoke_t *invoke_ctx, amxb_bus_ctx_t *ctx, amxc_var_t *args, amxb_request_t *request, int timeout, bool async)
static int	amxb_invoke_wait_local (amxb_req_t *req, int timeout)
int	amxb_new_invoke (amxb_invoke_t **invoke_ctx, amxb_bus_ctx_t *const ctx, const char *object, const char *interface, const char *method)
	Prepares a remote function invocation. More...
void	amxb_free_invoke (amxb_invoke_t **invoke_ctx)
	Deletes a function invoke context, and frees allocated memory. More...
int	amxb_invoke (amxb_invoke_t *invoke_ctx, amxc_var_t *args, amxc_var_t *ret, amxb_be_cb_fn_t fn, void *priv, int timeout)
	Invokes a remote function, as defined by the function invoke context. More...
int	amxb_async_invoke (amxb_invoke_t *invoke_ctx, amxc_var_t *args, amxb_be_cb_fn_t fn, amxb_be_done_cb_fn_t done_fn, void *priv, amxb_request_t **request)
	Invokes a remote function, as defined by the function invoke context. More...
int	amxb_wait_for_request (amxb_request_t *request, int timeout)
	Waits for an asynchronous remote function invoke to finish. More...
int	amxb_request_new (amxb_request_t **request)
	Allocates an empty amxb_request_t. More...
amxb_bus_ctx_t *	amxb_request_get_ctx (amxb_request_t *request)
	Get the bus context of the request if any. More...
int	amxb_close_request (amxb_request_t **request)
	Closes a previously create remote function called context. More...

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 56 of file amxb_ba_invoke.c.

Function Documentation

amxb_complete_async_deferred_invoke()

static void amxb_complete_async_deferred_invoke ( const amxc_var_t *const  data, void *const  priv  )

static

Definition at line 126 of file amxb_ba_invoke.c.

                                                                  {
    amxc_var_t* rv = GET_ARG(data, "retval");
    amxb_req_t* req = (amxb_req_t*) priv;
    amxb_request_t* request = &req->data;
 
    amxc_var_set_type(request->result, AMXC_VAR_ID_LIST);
    amxc_var_take_it(rv);
    amxc_var_set_index(request->result, 0, rv, AMXC_VAR_FLAG_DEFAULT);
    request->bus_retval = GET_UINT32(data, "status");
 
    amxb_complete_async_invoke(NULL, priv);
 
    return;
}

amxb_complete_async_invoke()

static void amxb_complete_async_invoke ( UNUSED const amxc_var_t *const  data, void *const  priv  )

static

Definition at line 100 of file amxb_ba_invoke.c.

                                                         {
    amxb_req_t* req = (amxb_req_t*) priv;
    amxb_request_t* request = &req->data;
    amxb_bus_ctx_t* ctx = amxb_request_get_ctx(request);
    req->in_flight = false;
 
    if(req->closed) {
        if(!req->wait) {
            amxb_close_request(&request);
        }
 
        goto exit;
    }
 
    if((request->cb_fn != NULL) && (request->bus_retval == 0)) {
        request->cb_fn(ctx, request->result, request->priv);
    }
    if(request->done_fn != NULL) {
        request->done_fn(ctx, request, request->bus_retval, request->priv);
    }
 
exit:
    return;
}

amxb_invoke_be_impl()

static int amxb_invoke_be_impl ( amxb_invoke_t *  invoke_ctx, amxb_bus_ctx_t *  ctx, amxc_var_t *  args, amxb_request_t *  request, int  timeout, bool  async  )

static

Definition at line 205 of file amxb_ba_invoke.c.

                                           {
    amxc_var_t* func_args = args;
    const amxb_be_funcs_t* fns = NULL;
    int retval = -1;
 
    if((amxc_var_type_of(args) == AMXC_VAR_ID_NULL) ||
       ( amxc_var_type_of(args) == AMXC_VAR_ID_INVALID)) {
        func_args = NULL;
    }
 
    fns = ctx->bus_fn;
    if(async) {
        if(amxb_is_valid_be_func(fns, invoke, fns->async_invoke)) {
            retval = fns->async_invoke(ctx->bus_ctx,
                                       invoke_ctx,
                                       func_args,
                                       request);
        } else {
            retval = AMXB_ERROR_NOT_SUPPORTED_OP;
        }
    } else {
        if(amxb_is_valid_be_func(fns, invoke, fns->invoke)) {
            retval = fns->invoke(ctx->bus_ctx,
                                 invoke_ctx,
                                 func_args,
                                 request,
                                 timeout);
        } else {
            retval = AMXB_ERROR_NOT_SUPPORTED_OP;
        }
    }
 
    return retval;
}

amxb_invoke_local_impl()

static int amxb_invoke_local_impl ( amxb_invoke_t *  invoke_ctx, amxb_bus_ctx_t *  ctx, amxc_var_t *  args, amxb_request_t *  request, bool  async  )

static

Definition at line 142 of file amxb_ba_invoke.c.

                                              {
    int retval = -1;
    amxb_req_t* req = amxc_container_of(request, amxb_req_t, data);
    amxc_var_t empty_args;
    amxc_var_t* fn_rv = NULL;
    amxc_var_t* out_args = NULL;
    amxd_object_t* object = NULL;
    amxc_var_init(&empty_args);
    amxc_var_set_type(&empty_args, AMXC_VAR_ID_HTABLE);
 
    object = amxb_fetch_local_object(ctx, invoke_ctx->object);
    when_null_status(object, exit, retval = amxd_status_object_not_found);
 
    if(args == NULL) {
        args = &empty_args;
    }
 
    amxc_var_set_type(request->result, AMXC_VAR_ID_LIST);
    fn_rv = amxc_var_add_new(request->result);
 
    retval = amxd_object_invoke_function(object, invoke_ctx->method, args, fn_rv);
    if(!amxc_htable_is_empty(amxc_var_constcast(amxc_htable_t, args))) {
        out_args = amxc_var_add_new(request->result);
        amxc_var_move(out_args, args);
    }
 
    request->bus_retval = retval;
 
    if(async) {
        if((request->done_fn != NULL) || (request->cb_fn != NULL)) {
            req->in_flight = true;
            if(retval == amxd_status_deferred) {
                uint64_t call_id = amxc_var_constcast(uint64_t, fn_rv);
                amxd_function_set_deferred_cb(call_id, amxb_complete_async_deferred_invoke, req);
                retval = 0;
            } else {
                amxp_sigmngr_deferred_call(NULL, amxb_complete_async_invoke, NULL, req);
                retval = 0;
            }
        }
    } else {
        if(retval == amxd_status_deferred) {
            uint64_t call_id = 0;
            req->in_flight = true;
            call_id = amxc_var_constcast(uint64_t, fn_rv);
            amxd_function_set_deferred_cb(call_id, amxb_complete_async_deferred_invoke, req);
        } else {
            when_failed(retval, exit);
            if(request->cb_fn != NULL) {
                request->cb_fn(ctx, request->result, request->priv);
            }
        }
    }
 
exit:
    amxc_var_clean(&empty_args);
    return retval;
}

amxb_invoke_wait_local()

static int amxb_invoke_wait_local ( amxb_req_t *  req, int  timeout  )

static

Definition at line 245 of file amxb_ba_invoke.c.

                                                                {
    int retval = -1;
    if(req->in_flight) {
        int fd = amxp_signal_fd();
        struct timeval t = {
            .tv_sec = timeout,
            .tv_usec = 0
        };
 
        fd_set readset;
        FD_ZERO(&readset);
        FD_SET(fd, &readset);
 
        req->wait = true;
        while(req->in_flight) {
            retval = select(fd + 1, &readset, NULL, NULL, &t);
            if(retval <= 0) {
                // timeout or error
                retval = -1;
                break;
            }
            amxp_signal_read();
        }
        req->wait = false;
    }
    if(!req->in_flight) {
        retval = req->data.bus_retval;
        if(req->closed) {
            amxb_request_t* request = &req->data;
            amxb_close_request(&request);
        }
    }
 
    return retval;
}

amxb_trim()

static void amxb_trim ( char *  str, amxc_string_is_char_fn_t  fn  )

static

Definition at line 91 of file amxb_ba_invoke.c.

                                                              {
    amxc_string_t txt;
    amxc_string_init(&txt, 0);
    amxc_string_push_buffer(&txt, str, strlen(str) + 1);
    amxc_string_trimr(&txt, fn);
    amxc_string_take_buffer(&txt);
    amxc_string_clean(&txt);
}

isbrace()

static int isbrace ( int  c )

static

Definition at line 83 of file amxb_ba_invoke.c.

                          {
    if((c == '(') || (c == ')')) {
        return 1;
    }
 
    return 0;
}

isdot()

static int isdot ( int  c )

static

Definition at line 75 of file amxb_ba_invoke.c.

                        {
    if(c == '.') {
        return 1;
    }
 
    return 0;
}