agt_rpc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008 - 2012, Andy Bierman, All Rights Reserved.
 * Copyright (c) 2012 - 2023, YumaWorks, Inc., All Rights Reserved.
 *
 * 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 _H_agt_rpc
#define _H_agt_rpc
/*  FILE: agt_rpc.h
*********************************************************************
*                                                                   *
*                         P U R P O S E                             *
*                                                                   *
*********************************************************************/
 
/*********************************************************************
*                                                                   *
*                   C H A N G E         H I S T O R Y               *
*                                                                   *
*********************************************************************
 
date             init     comment
----------------------------------------------------------------------
30-apr-05    abb      Begun.
*/
 
#ifndef _H_cfg
#include "cfg.h"
#endif
 
#ifndef _H_rpc
#include "rpc.h"
#endif
 
#ifndef _H_rpc_err
#include "rpc_err.h"
#endif
 
#ifndef _H_ses
#include "ses.h"
#endif
 
#ifndef _H_status_enum
#include "status_enum.h"
#endif
 
#ifndef _H_xml_util
#include "xml_util.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
/********************************************************************
*                                                                   *
*                         C O N S T A N T S                         *
*                                                                   *
*********************************************************************/
 
#define AGT_RPC_NUM_CALLBACK_PHASES   3
 
/********************************************************************
*                                                                   *
*                         T Y P E S                                 *
*                                                                   *
*********************************************************************/
 
typedef enum agt_rpc_phase_t_ {
    AGT_RPC_PH_VALIDATE,
 
    AGT_RPC_PH_INVOKE,
 
    AGT_RPC_PH_POST_REPLY,
 
    AGT_RPC_PH_PARSE,
 
    AGT_RPC_PH_REPLY
} agt_rpc_phase_t;
 
 
typedef status_t
    (*agt_rpc_method_t) (ses_cb_t *scb,
                         rpc_msg_t *msg,
                         xml_node_t *methnode);
 
 
typedef struct agt_rpc_cbset_t_ {
    agt_rpc_method_t  acb[AGT_RPC_NUM_CALLBACK_PHASES];
 
    boolean regdone;
 
#ifdef WITH_YCONTROL
    dlq_hdr_t subsysQ;  
#endif
 
} agt_rpc_cbset_t;
 
 
typedef status_t
    (*agt_rpc_data_cb_t) (ses_cb_t *scb,
                          rpc_msg_t *msg,
                          uint32 indent);
 
 
typedef struct agt_rpc_subsys_t_ {
    dlq_hdr_t qhdr;
 
    const xmlChar *subsys_id;
 
    status_t res;
} agt_rpc_subsys_t;
 
 
/********************************************************************
*                                                                   *
*                        F U N C T I O N S                          *
*                                                                   *
*********************************************************************/
 
 
extern status_t
    agt_rpc_init (void);
 
 
extern void
    agt_rpc_cleanup (void);
 
 
extern status_t
    agt_rpc_register_method (const xmlChar *module,
                             const xmlChar *method_name,
                             agt_rpc_phase_t  phase,
                             agt_rpc_method_t method);
 
 
extern void
    agt_rpc_support_method (const xmlChar *module,
                            const xmlChar *method_name);
 
 
extern void
    agt_rpc_unsupport_method (const xmlChar *module,
                              const xmlChar *method_name);
 
 
extern void
    agt_rpc_unregister_method (const xmlChar *module,
                               const xmlChar *method_name);
 
 
extern boolean
    agt_rpc_dispatch (ses_cb_t  *scb,
                      xml_node_t *top);
 
 
extern status_t
    agt_rpc_load_config_file (const xmlChar *filespec,
                              cfg_template_t  *cfg,
                              boolean isload,
                              ses_id_t  use_sid,
                              dlq_hdr_t *errQ,
                              boolean do_config_change,
                              const rpc_msg_t *reqmsg);
 
 
extern val_value_t *
    agt_rpc_get_config_file (const xmlChar *filespec,
                             cfg_template_t *targetcfg,
                             ses_id_t  use_sid,
                             dlq_hdr_t *errorQ,
                             status_t *res);
 
 
extern status_t
    agt_rpc_load_config_file_val (const xmlChar *filespec,
                                  ses_id_t use_sid,
                                  val_value_t **configval,
                                  dlq_hdr_t *errorQ);
 
 
extern status_t
    agt_rpc_replay_config (void);
 
 
extern status_t
    agt_rpc_fill_rpc_error (const rpc_err_rec_t *err,
                            val_value_t *rpcerror);
 
 
extern void
    agt_rpc_send_error_reply (ses_cb_t *scb,
                              status_t retres);
 
 
extern status_t
    agt_rpc_send_rpc_error (ses_cb_t *scb,
                            xml_msg_hdr_t *msg,
                            const rpc_err_rec_t *err,
                            int32 indent,
                            boolean isfirst,
                            boolean islast);
 
 
extern ncx_backptr_t *
    agt_rpc_get_first_backptr (void);
 
 
extern ncx_backptr_t *
    agt_rpc_get_next_backptr (ncx_backptr_t *curptr);
 
 
extern status_t
    agt_rpc_check_rpc_invoke (ses_cb_t *scb,
                              rpc_msg_t  *msg,
                              obj_template_t *rpcobj);
 
 
extern status_t
    agt_rpc_parse_rpc_input (ses_cb_t *scb,
                             rpc_msg_t  *msg,
                             obj_template_t *rpcobj,
                             xml_node_t  *method);
 
 
extern status_t
    agt_rpc_post_psd_state (ses_cb_t *scb,
                            rpc_msg_t  *msg,
                            status_t  psdres);
 
 
extern status_t
    agt_rpc_invoke_rpc (ses_cb_t *scb,
                        rpc_msg_t  *msg,
                        xml_node_t *method_node);
 
 
extern status_t
    agt_rpc_invoke_action (ses_cb_t *scb,
                           rpc_msg_t  *msg,
                           xml_node_t *method_node,
                           val_value_t *action_val);
 
 
extern rpc_msg_t *
    agt_rpc_new_dummy_msg (void);
 
 
extern boolean
    agt_rpc_callback_set (obj_template_t *obj);
 
 
extern void
    agt_rpc_callback_regdone (obj_template_t *obj);
 
 
extern boolean
    agt_rpc_callback_is_regdone (obj_template_t *obj);
 
 
#ifdef WITH_YCONTROL
extern status_t
    agt_rpc_register_subsys_callback (const xmlChar *subsys_id,
                                      const xmlChar *modname,
                                      const xmlChar *revision,
                                      const xmlChar *rpcname);
 
 
extern void
    agt_rpc_unregister_subsys_callback (const xmlChar *subsys_id,
                                        const xmlChar *modname,
                                        const xmlChar *revision,
                                        const xmlChar *rpcname);
 
#endif  // WITH_YCONTROL
 
 
extern void
    agt_rpc_add_return_val (val_value_t *return_val,
                            rpc_msg_t *msg);
 
 
extern void
    agt_rpc_add_return_vals (dlq_hdr_t *return_valQ,
                             rpc_msg_t *msg);
 
 
extern void
    agt_rpc_clear_return_data (rpc_msg_t *msg);
 
 
#ifdef WITH_YCONTROL
extern status_t
    agt_rpc_handle_subsys_request (void *sil_sa_cb,
                                   ses_cb_t *scb,
                                   const xmlChar *modname,
                                   const xmlChar *rpcname,
                                   val_value_t *rpc_input_val,
                                   val_value_t *mpid_val,
                                   dlq_hdr_t *return_dataQ);
 
 
extern status_t
    agt_rpc_handle_subsys_action (void *sil_sa_cb,
                                  ses_cb_t *scb,
                                  const xmlChar *path,
                                  val_value_t *action_input_val,
                                  val_value_t *mpid_val,
                                  dlq_hdr_t *return_dataQ);
#endif  // WITH_YCONTROL
 
 
extern void
    agt_rpc_finish_reply (uint32 sid,
                          void *msg);
 
 
extern void
    agt_rpc_reorder_dataQ (rpc_msg_t *msg);
 
 
#ifdef WITH_YCONTROL
extern void
    agt_rpc_free_subsys (agt_rpc_subsys_t *cb);
 
 
extern agt_rpc_subsys_t *
    agt_rpc_new_subsys (const xmlChar *subsys_id);
 
 
extern agt_rpc_subsys_t *
    agt_rpc_find_subsys (dlq_hdr_t *subsysQ,
                         const xmlChar *subsys_id);
 
 
extern status_t
    agt_rpc_subrpc_dispatch (ses_cb_t *scb,
                             rpc_msg_t *msg,
                             const xmlChar *rpc_module,
                             const xmlChar *rpc_name,
                             val_value_t *rpc_method,
                             const xmlChar *out_filespec);
 
#endif // WITH_YCONTROL
 
 
extern void
    agt_rpc_unload_module (ncx_module_t *mod);
 
 
extern status_t
    agt_rpc_process_rpc_request (ses_cb_t *scb,
                                 rpc_msg_t *msg,
                                 val_value_t *action_val,
                                 xml_node_t *method,
                                 obj_template_t *rpcobj);
 
 
#ifdef __cplusplus
}  /* end extern 'C' */
#endif
 
#endif            /* _H_agt_rpc */