I would appreciate any donations. Wishlist or send e-mail type donations to maekawa AT daemon-systems.org.

Thank you.


evrpc(3)                   Library Functions Manual                   evrpc(3)



NAME
       evrpc -

       This header files provides basic support for an RPC server and client.


SYNOPSIS
       #include <event2/rpc.h>

   Macros
           #define EVRPC_GENERATE(rpcname, reqstruct, rplystruct)
           Generates the code for receiving and sending an RPC message.
           #define EVRPC_HEADER(rpcname, reqstruct, rplystruct)
           Creates the definitions and prototypes for an RPC.  #define
           EVRPC_MAKE_CTX(rpcname, reqstruct, rplystruct, pool, request,
           reply, cb, cbarg)
           Creates a context structure that contains rpc specific information.
           #define EVRPC_MAKE_REQUEST(name, pool, request, reply, cb, cbarg)
           evrpc_send_request_##name((pool), (request), (reply), (cb),
           (cbarg))
           launches an RPC and sends it to the server  #define
           EVRPC_REGISTER(base, name, request, reply, callback, cbarg)
           register RPCs with the HTTP Server  #define
           EVRPC_REQUEST_DONE(rpc_req)
           Creates the reply to an RPC request.  #define
           EVRPC_REQUEST_HTTP(rpc_req)   (rpc_req)->http_req
           Provides access to the HTTP request object underlying an RPC.
           #define EVRPC_STRUCT(rpcname)   struct evrpc_req__##rpcname
           The type of a specific RPC Message.  #define EVRPC_UNREGISTER(base,
           name)   evrpc_unregister_rpc((base), #name)
           Unregisters an already registered RPC.  #define
           EVTAG_ARRAY_ADD(msg, member)   (*(msg)->base->member##_add)(msg)
           Allocates a new entry in the array and returns it.  #define
           EVTAG_ARRAY_ADD_VALUE(msg, member, value)
           (*(msg)->base->member##_add)((msg), (value))
           Adds a value to an array.  #define EVTAG_ARRAY_GET(msg, member,
           offset, pvalue)   (*(msg)->base->member##_get)((msg), (offset),
           (pvalue))
           Gets a variable at the specified offset from the array.  #define
           EVTAG_ARRAY_LEN(msg, member)   ((msg)->member##_length)
           Returns the number of entries in the array.  #define
           EVTAG_ASSIGN(msg, member, value)
           (*(msg)->base->member##_assign)((msg), (value))
           Assigns a value to the member in the message.  #define
           EVTAG_ASSIGN_WITH_LEN(msg, member, value, len)
           (*(msg)->base->member##_assign)((msg), (value), (len))
           Assigns a value to the member in the message.  #define
           EVTAG_GET(msg, member, pvalue)
           (*(msg)->base->member##_get)((msg), (pvalue))
           Returns the value for a member.  #define EVTAG_GET_WITH_LEN(msg,
           member, pvalue, plen)   (*(msg)->base->member##_get)((msg),
           (pvalue), (plen))
           Returns the value for a member.  #define EVTAG_HAS(msg, member)
           ((msg)->member##_set == 1)
           Determines if the member has been set in the message.  #define
           INPUT   EVRPC_INPUT
           Deprecated alias for EVRPC_INPUT.  #define OUTPUT   EVRPC_OUTPUT
           Deprecated alias for EVRPC_OUTPUT.

   Enumerations
           enum EVRPC_HOOK_RESULT { EVRPC_TERMINATE = -1, EVRPC_CONTINUE = 0,
           EVRPC_PAUSE = 1 }
           Return value from hook processing functions.  enum EVRPC_HOOK_TYPE
           { EVRPC_INPUT, EVRPC_OUTPUT }
           Hooks for changing the input and output of RPCs; this can be used
           to implement compression, authentication, encryption, ...

   Functions
           void * evrpc_add_hook (void *vbase, enum EVRPC_HOOK_TYPE hook_type,
           int(*cb)(void *, struct evhttp_request *, struct evbuffer *, void
           *), void *cb_arg)
           adds a processing hook to either an rpc base or rpc pool  void
           evrpc_free (struct evrpc_base *base)
           Frees the evrpc base.  void * evrpc_get_reply (struct
           evrpc_req_generic *req)
           void * evrpc_get_request (struct evrpc_req_generic *req)
           accessors for request and reply  void evrpc_hook_add_meta (void
           *ctx, const char *key, const void *data, size_t data_size)
           adds meta data to request  int evrpc_hook_find_meta (void *ctx,
           const char *key, void **data, size_t *data_size)
           retrieves meta data previously associated  struct evhttp_connection
           * evrpc_hook_get_connection (void *ctx)
           returns the connection object associated with the request  struct
           evrpc_base * evrpc_init (struct evhttp *server)
           Creates a new rpc base from which RPC requests can be received.
           int evrpc_make_request (struct evrpc_request_wrapper *ctx)
           Makes an RPC request based on the provided context.  struct
           evrpc_request_wrapper * evrpc_make_request_ctx (struct evrpc_pool
           *pool, void *request, void *reply, const char *rpcname,
           void(*req_marshal)(struct evbuffer *, void *),
           void(*rpl_clear)(void *), int(*rpl_unmarshal)(void *, struct
           evbuffer *), void(*cb)(struct evrpc_status *, void *, void *, void
           *), void *cbarg)
           use EVRPC_GENERATE instead  void evrpc_pool_add_connection (struct
           evrpc_pool *pool, struct evhttp_connection *evcon)
           Adds a connection over which rpc can be dispatched to the pool.
           void evrpc_pool_free (struct evrpc_pool *pool)
           frees an rpc connection pool  struct evrpc_pool * evrpc_pool_new
           (struct event_base *base)
           creates an rpc connection pool  void evrpc_pool_remove_connection
           (struct evrpc_pool *pool, struct evhttp_connection *evcon)
           Removes a connection from the pool.  void evrpc_pool_set_timeout
           (struct evrpc_pool *pool, int timeout_in_secs)
           Sets the timeout in secs after which a request has to complete.
           int evrpc_register_generic (struct evrpc_base *base, const char
           *name, void(*callback)(struct evrpc_req_generic *, void *), void
           *cbarg, void *(*req_new)(void *), void *req_new_arg,
           void(*req_free)(void *), int(*req_unmarshal)(void *, struct
           evbuffer *), void *(*rpl_new)(void *), void *rpl_new_arg,
           void(*rpl_free)(void *), int(*rpl_complete)(void *),
           void(*rpl_marshal)(struct evbuffer *, void *))
           Function for registering a generic RPC with the RPC base.  int
           evrpc_register_rpc (struct evrpc_base *, struct evrpc *,
           void(*)(struct evrpc_req_generic *, void *), void *)
           Low level function for registering an RPC with a server.  int
           evrpc_remove_hook (void *vbase, enum EVRPC_HOOK_TYPE hook_type,
           void *handle)
           removes a previously added hook  void evrpc_request_done (struct
           evrpc_req_generic *req)
           completes the server response to an rpc request  struct evrpc_pool
           * evrpc_request_get_pool (struct evrpc_request_wrapper *ctx)
           accessors for obscure and undocumented functionality  void
           evrpc_request_set_cb (struct evrpc_request_wrapper *ctx,
           void(*cb)(struct evrpc_status *, void *request, void *reply, void
           *arg), void *cb_arg)
           void evrpc_request_set_pool (struct evrpc_request_wrapper *ctx,
           struct evrpc_pool *pool)
           int evrpc_resume_request (void *vbase, void *ctx, enum
           EVRPC_HOOK_RESULT res)
           resume a paused request  int evrpc_send_request_generic (struct
           evrpc_pool *pool, void *request, void *reply, void(*cb)(struct
           evrpc_status *, void *, void *, void *), void *cb_arg, const char
           *rpcname, void(*req_marshal)(struct evbuffer *, void *),
           void(*rpl_clear)(void *), int(*rpl_unmarshal)(void *, struct
           evbuffer *))
           Function for sending a generic RPC request.  int
           evrpc_unregister_rpc (struct evrpc_base *base, const char *name)

Detailed Description
       This header files provides basic support for an RPC server and client.

       To support RPCs in a server, every supported RPC command needs to be
       defined and registered.

       EVRPC_HEADER(SendCommand, Request, Reply);

       SendCommand is the name of the RPC command. Request is the name of a
       structure generated by event_rpcgen.py. It contains all parameters
       relating to the SendCommand RPC. The server needs to fill in the Reply
       structure. Reply is the name of a structure generated by
       event_rpcgen.py. It contains the answer to the RPC.

       To register an RPC with an HTTP server, you need to first create an RPC
       base with:

       struct evrpc_base *base = evrpc_init(http);

       A specific RPC can then be registered with

       EVRPC_REGISTER(base, SendCommand, Request, Reply,  FunctionCB, arg);

       when the server receives an appropriately formatted RPC, the user
       callback is invoked. The callback needs to fill in the reply structure.

       void FunctionCB(EVRPC_STRUCT(SendCommand)* rpc, void *arg);

       To send the reply, call EVRPC_REQUEST_DONE(rpc);

       See the regression test for an example.

Macro Definition Documentation
   #define EVRPC_GENERATE(rpcname, reqstruct, rplystruct)
       Value:

       int evrpc_send_request_##rpcname(struct evrpc_pool *pool,         struct reqstruct *request, struct rplystruct *reply,            void (*cb)(struct evrpc_status *,                       struct reqstruct *, struct rplystruct *, void *cbarg),          void *cbarg) {                          return evrpc_send_request_generic(pool, request, reply,         (void (*)(struct evrpc_status *, void *, void *, void *))cb,         cbarg,                                  #rpcname,                                   (void (*)(struct evbuffer *, void *))reqstruct##_marshal,           (void (*)(void *))rplystruct##_clear,                   (int (*)(void *, struct evbuffer *))rplystruct##_unmarshal); }

       Generates the code for receiving and sending an RPC message.
       EVRPC_GENERATE is used to create the code corresponding to sending and
       receiving a particular RPC message

       Parameters:
           rpcname the name of the RPC
           reqstruct the name of the RPC request structure
           replystruct the name of the RPC reply structure

       See Also:
           EVRPC_HEADER()


   #define EVRPC_HEADER(rpcname, reqstruct, rplystruct)
       Value:

       EVRPC_STRUCT(rpcname) {     struct evrpc_hook_meta *hook_meta;     struct reqstruct* request;     struct rplystruct* reply;     struct evrpc* rpc;     struct evhttp_request* http_req;     struct evbuffer* rpc_data; };                                   int evrpc_send_request_##rpcname(struct evrpc_pool *,     struct reqstruct *, struct rplystruct *,     void (*)(struct evrpc_status *,     struct reqstruct *, struct rplystruct *, void *cbarg),      void *);

       Creates the definitions and prototypes for an RPC. You need to use
       EVRPC_HEADER to create structures and function prototypes needed by the
       server and client implementation. The structures have to be defined in
       an .rpc file and converted to source code via event_rpcgen.py

       Parameters:
           rpcname the name of the RPC
           reqstruct the name of the RPC request structure
           replystruct the name of the RPC reply structure

       See Also:
           EVRPC_GENERATE()


   #define EVRPC_MAKE_CTX(rpcname, reqstruct, rplystruct, pool, request,
   reply, cb, cbarg)
       Value:

       evrpc_make_request_ctx(pool, request, reply,                 #rpcname,                                   (void (*)(struct evbuffer *, void *))reqstruct##_marshal,           (void (*)(void *))rplystruct##_clear,                   (int (*)(void *, struct evbuffer *))rplystruct##_unmarshal,         (void (*)(struct evrpc_status *, void *, void *, void *))cb,         cbarg)

       Creates a context structure that contains rpc specific information.
       EVRPC_MAKE_CTX is used to populate a RPC specific context that contains
       information about marshaling the RPC data types.

       Parameters:
           rpcname the name of the RPC
           reqstruct the name of the RPC request structure
           replystruct the name of the RPC reply structure
           pool the evrpc_pool over which to make the request
           request a pointer to the RPC request structure object
           reply a pointer to the RPC reply structure object
           cb the callback function to call when the RPC has completed
           cbarg the argument to supply to the callback


   #define EVRPC_MAKE_REQUEST(name, pool, request, reply, cb, cbarg)
   evrpc_send_request_##name((pool), (request), (reply), (cb), (cbarg))
       launches an RPC and sends it to the server EVRPC_MAKE_REQUEST() is used
       by the client to send an RPC to the server.

       Parameters:
           name the name of the RPC
           pool the evrpc_pool that contains the connection objects over which
           the request should be sent.
           request a pointer to the RPC request structure - it contains the
           data to be sent to the server.
           reply a pointer to the RPC reply structure. It is going to be
           filled if the request was answered successfully
           cb the callback to invoke when the RPC request has been answered
           cbarg an additional argument to be passed to the client

       Returns:
           0 on success, -1 on failure


   #define EVRPC_REGISTER(base, name, request, reply, callback, cbarg)
       Value:

       evrpc_register_generic(base, #name,                     (void (*)(struct evrpc_req_generic *, void *))callback, cbarg,         (void *(*)(void *))request##_new, NULL,                 (void (*)(void *))request##_free,                       (int (*)(void *, struct evbuffer *))request##_unmarshal,            (void *(*)(void *))reply##_new, NULL,                   (void (*)(void *))reply##_free,         (int (*)(void *))reply##_complete,         (void (*)(struct evbuffer *, void *))reply##_marshal)

       register RPCs with the HTTP Server registers a new RPC with the HTTP
       server, each RPC needs to have a unique name under which it can be
       identified.

       Parameters:
           base the evrpc_base structure in which the RPC should be
           registered.
           name the name of the RPC
           request the name of the RPC request structure
           reply the name of the RPC reply structure
           callback the callback that should be invoked when the RPC is
           received. The callback has the following prototype void
           (callback)(EVRPC_STRUCT(Message) rpc, void *arg)
           cbarg an additional parameter that can be passed to the callback.
           The parameter can be used to carry around state.


   #define EVRPC_REQUEST_DONE(rpc_req)
       Value:

       do {   struct evrpc_req_generic *_req = (struct evrpc_req_generic *)(rpc_req);   evrpc_request_done(_req);                 } while (/*CONSTCOND*/0)

       Creates the reply to an RPC request. EVRPC_REQUEST_DONE is used to
       answer a request; the reply is expected to have been filled in. The
       request and reply pointers become invalid after this call has finished.

       Parameters:
           rpc_req the rpc request structure provided to the server callback


   #define EVRPC_REQUEST_HTTP(rpc_req)   (rpc_req)->http_req
       Provides access to the HTTP request object underlying an RPC. Access to
       the underlying http object; can be used to look at headers or for
       getting the remote ip address

       Parameters:
           rpc_req the rpc request structure provided to the server callback

       Returns:
           an struct evhttp_request object that can be inspected for HTTP
           headers or sender information.


   #define EVRPC_STRUCT(rpcname)   struct evrpc_req__##rpcname
       The type of a specific RPC Message. Parameters:
           rpcname the name of the RPC message


   #define EVRPC_UNREGISTER(base, name)   evrpc_unregister_rpc((base), #name)
       Unregisters an already registered RPC. Parameters:
           base the evrpc_base object from which to unregister an RPC
           name the name of the rpc to unregister

       Returns:
           -1 on error or 0 when successful.

       See Also:
           EVRPC_REGISTER()


   #define EVTAG_ASSIGN(msg, member, value)
   (*(msg)->base->member##_assign)((msg), (value))
       Assigns a value to the member in the message. Parameters:
           msg the message to which to assign a value
           member the name of the member variable
           value the value to assign


   #define EVTAG_ASSIGN_WITH_LEN(msg, member, value, len)
   (*(msg)->base->member##_assign)((msg), (value), (len))
       Assigns a value to the member in the message. Parameters:
           msg the message to which to assign a value
           member the name of the member variable
           value the value to assign
           len the length of the value


   #define EVTAG_GET(msg, member, pvalue)
   (*(msg)->base->member##_get)((msg), (pvalue))
       Returns the value for a member. Parameters:
           msg the message from which to get the value
           member the name of the member variable
           pvalue a pointer to the variable to hold the value

       Returns:
           0 on success, -1 otherwise.


   #define EVTAG_GET_WITH_LEN(msg, member, pvalue, plen)
   (*(msg)->base->member##_get)((msg), (pvalue), (plen))
       Returns the value for a member. Parameters:
           msg the message from which to get the value
           member the name of the member variable
           pvalue a pointer to the variable to hold the value
           plen a pointer to the length of the value

       Returns:
           0 on success, -1 otherwise.


   #define EVTAG_HAS(msg, member)   ((msg)->member##_set == 1)
       Determines if the member has been set in the message. Parameters:
           msg the message to inspect
           member the member variable to test for presences

       Returns:
           1 if it's present or 0 otherwise.


   #define INPUT   EVRPC_INPUT
       Deprecated alias for EVRPC_INPUT. Not available on windows, where it
       conflicts with platform headers.

   #define OUTPUT   EVRPC_OUTPUT
       Deprecated alias for EVRPC_OUTPUT. Not available on windows, where it
       conflicts with platform headers.

Enumeration Type Documentation
   enum EVRPC_HOOK_RESULT
       Return value from hook processing functions.

       Enumerator

       EVRPC_TERMINATE
              indicates the rpc should be terminated

       EVRPC_CONTINUE
              continue processing the rpc

       EVRPC_PAUSE
              pause processing request until resumed

   enum EVRPC_HOOK_TYPE
       Hooks for changing the input and output of RPCs; this can be used to
       implement compression, authentication, encryption, ...

       Enumerator

       EVRPC_INPUT
              apply the function to an input hook

       EVRPC_OUTPUT
              apply the function to an output hook

Function Documentation
   void* evrpc_add_hook (void *vbase, enum EVRPC_HOOK_TYPEhook_type,
   int(*)(void *, struct evhttp_request *, struct evbuffer *, void *)cb, void
   *cb_arg)
       adds a processing hook to either an rpc base or rpc pool If a hook
       returns TERMINATE, the processing is aborted. On CONTINUE, the request
       is immediately processed after the hook returns. If the hook returns
       PAUSE, request processing stops until evrpc_resume_request() has been
       called.

       The add functions return handles that can be used for removing hooks.

       Parameters:
           vbase a pointer to either struct evrpc_base or struct evrpc_pool
           hook_type either INPUT or OUTPUT
           cb the callback to call when the hook is activated
           cb_arg an additional argument for the callback

       Returns:
           a handle to the hook so it can be removed later

       See Also:
           evrpc_remove_hook()


   void evrpc_free (struct evrpc_base *base)
       Frees the evrpc base. For now, you are responsible for making sure that
       no rpcs are ongoing.

       Parameters:
           base the evrpc_base object to be freed

       See Also:
           evrpc_init


   void evrpc_hook_add_meta (void *ctx, const char *key, const void *data,
   size_tdata_size)
       adds meta data to request evrpc_hook_add_meta() allows hooks to add
       meta data to a request. for a client request, the meta data can be
       inserted by an outgoing request hook and retrieved by the incoming
       request hook.

       Parameters:
           ctx the context provided to the hook call
           key a NUL-terminated c-string
           data the data to be associated with the key
           data_size the size of the data


   int evrpc_hook_find_meta (void *ctx, const char *key, void **data, size_t
   *data_size)
       retrieves meta data previously associated evrpc_hook_find_meta() can be
       used to retrieve meta data associated to a request by a previous hook.

       Parameters:
           ctx the context provided to the hook call
           key a NUL-terminated c-string
           data pointer to a data pointer that will contain the retrieved data
           data_size pointer to the size of the data

       Returns:
           0 on success or -1 on failure


   struct evhttp_connection* evrpc_hook_get_connection (void *ctx) [read]
       returns the connection object associated with the request Parameters:
           ctx the context provided to the hook call

       Returns:
           a pointer to the evhttp_connection object


   struct evrpc_base* evrpc_init (struct evhttp *server) [read]
       Creates a new rpc base from which RPC requests can be received.
       Parameters:
           server a pointer to an existing HTTP server

       Returns:
           a newly allocated evrpc_base struct

       See Also:
           evrpc_free()


   int evrpc_make_request (struct evrpc_request_wrapper *ctx)
       Makes an RPC request based on the provided context. This is a low-level
       function and should not be used directly unless a custom context object
       is provided. Use EVRPC_MAKE_REQUEST() instead.

       Parameters:
           ctx a context from EVRPC_MAKE_CTX()

       Returns:
           0 on success, -1 otherwise.

       See Also:
           EVRPC_MAKE_REQUEST(), EVRPC_MAKE_CTX()


   void evrpc_pool_add_connection (struct evrpc_pool *pool, struct
   evhttp_connection *evcon)
       Adds a connection over which rpc can be dispatched to the pool. The
       connection object must have been newly created.

       Parameters:
           pool the pool to which to add the connection
           evcon the connection to add to the pool.


   void evrpc_pool_free (struct evrpc_pool *pool)
       frees an rpc connection pool Parameters:
           pool a pointer to an evrpc_pool allocated via evrpc_pool_new()

       See Also:
           evrpc_pool_new()


   struct evrpc_pool* evrpc_pool_new (struct event_base *base) [read]
       creates an rpc connection pool a pool has a number of connections
       associated with it. rpc requests are always made via a pool.

       Parameters:
           base a pointer to an struct event_based object; can be left NULL in
           singled-threaded applications

       Returns:
           a newly allocated struct evrpc_pool object

       See Also:
           evrpc_pool_free()


   void evrpc_pool_remove_connection (struct evrpc_pool *pool, struct
   evhttp_connection *evcon)
       Removes a connection from the pool. The connection object must have
       been newly created.

       Parameters:
           pool the pool from which to remove the connection
           evcon the connection to remove from the pool.


   void evrpc_pool_set_timeout (struct evrpc_pool *pool, inttimeout_in_secs)
       Sets the timeout in secs after which a request has to complete. The RPC
       is completely aborted if it does not complete by then. Setting the
       timeout to 0 means that it never timeouts and can be used to implement
       callback type RPCs.

       Any connection already in the pool will be updated with the new
       timeout. Connections added to the pool after set_timeout has be called
       receive the pool timeout only if no timeout has been set for the
       connection itself.

       Parameters:
           pool a pointer to a struct evrpc_pool object
           timeout_in_secs the number of seconds after which a request should
           timeout and a failure be returned to the callback.


   int evrpc_register_generic (struct evrpc_base *base, const char *name,
   void(*)(struct evrpc_req_generic *, void *)callback, void *cbarg, void
   *(*)(void *)req_new, void *req_new_arg, void(*)(void *)req_free,
   int(*)(void *, struct evbuffer *)req_unmarshal, void *(*)(void *)rpl_new,
   void *rpl_new_arg, void(*)(void *)rpl_free, int(*)(void *)rpl_complete,
   void(*)(struct evbuffer *, void *)rpl_marshal)
       Function for registering a generic RPC with the RPC base. Do not call
       this function directly, use EVRPC_REGISTER() instead.

       See Also:
           EVRPC_REGISTER()


   int evrpc_register_rpc (struct evrpc_base *, struct evrpc *, void(*)(struct
   evrpc_req_generic *, void *), void *)
       Low level function for registering an RPC with a server. Use
       EVRPC_REGISTER() instead.

       See Also:
           EVRPC_REGISTER()


   int evrpc_remove_hook (void *vbase, enum EVRPC_HOOK_TYPEhook_type, void
   *handle)
       removes a previously added hook Parameters:
           vbase a pointer to either struct evrpc_base or struct evrpc_pool
           hook_type either INPUT or OUTPUT
           handle a handle returned by evrpc_add_hook()

       Returns:
           1 on success or 0 on failure

       See Also:
           evrpc_add_hook()


   int evrpc_resume_request (void *vbase, void *ctx, enum
   EVRPC_HOOK_RESULTres)
       resume a paused request Parameters:
           vbase a pointer to either struct evrpc_base or struct evrpc_pool
           ctx the context pointer provided to the original hook call


   int evrpc_send_request_generic (struct evrpc_pool *pool, void *request,
   void *reply, void(*)(struct evrpc_status *, void *, void *, void *)cb, void
   *cb_arg, const char *rpcname, void(*)(struct evbuffer *, void
   *)req_marshal, void(*)(void *)rpl_clear, int(*)(void *, struct evbuffer
   *)rpl_unmarshal)
       Function for sending a generic RPC request. Do not call this function
       directly, use EVRPC_MAKE_REQUEST() instead.

       See Also:
           EVRPC_MAKE_REQUEST()


Author
       Generated automatically by Doxygen for libevent from the source code.



libevent                        Wed Apr 10 2013                       evrpc(3)