/********************************************************************
* FUNCTION y_simple_list_test_init
*
* initialize the simple_list_test server instrumentation library
*
* INPUTS:
* modname == requested module name
* revision == requested version (NULL for any)
*
* RETURNS:
* error status
********************************************************************/
status_t y_simple_list_test_init (
const xmlChar *modname,
const xmlChar *revision)
{
status_t res = NO_ERR;
agt_profile_t *agt_profile = agt_get_profile();
y_simple_list_test_init_static_vars();
/* change if custom handling done */
if (xml_strcmp(modname, y_simple_list_test_M_simple_list_test)) {
return ERR_NCX_UNKNOWN_MODULE;
}
if (revision && xml_strcmp(revision, y_simple_list_test_R_simple_list_test)) {
return ERR_NCX_WRONG_VERSION;
}
res = ncxmod_load_module(
y_simple_list_test_M_simple_list_test,
y_simple_list_test_R_simple_list_test,
&agt_profile->agt_savedevQ,
&simple_list_test_mod);
if (res != NO_ERR) {
return res;
}
simple_list_obj = ncx_find_object(
simple_list_test_mod,
y_simple_list_test_N_simple_list);
if (simple_list_test_mod == NULL) {
return SET_ERROR(ERR_NCX_DEF_NOT_FOUND);
}
inc_counter_obj = ncx_find_object(
simple_list_test_mod,
y_simple_list_test_N_inc_counter);
if (simple_list_test_mod == NULL) {
return SET_ERROR(ERR_NCX_DEF_NOT_FOUND);
}
get_counter_obj = ncx_find_object(
simple_list_test_mod,
y_simple_list_test_N_get_counter);
if (simple_list_test_mod == NULL) {
return SET_ERROR(ERR_NCX_DEF_NOT_FOUND);
}
res = agt_rpc_register_method(
y_simple_list_test_M_simple_list_test,
y_simple_list_test_N_inc_counter,
AGT_RPC_PH_VALIDATE,
y_simple_list_test_inc_counter_validate);
if (res != NO_ERR) {
return res;
}
res = agt_rpc_register_method(
y_simple_list_test_M_simple_list_test,
y_simple_list_test_N_inc_counter,
AGT_RPC_PH_INVOKE,
y_simple_list_test_inc_counter_invoke);
if (res != NO_ERR) {
return res;
}
res = agt_rpc_register_method(
y_simple_list_test_M_simple_list_test,
y_simple_list_test_N_get_counter,
AGT_RPC_PH_VALIDATE,
y_simple_list_test_get_counter_validate);
if (res != NO_ERR) {
return res;
}
res = agt_rpc_register_method(
y_simple_list_test_M_simple_list_test,
y_simple_list_test_N_get_counter,
AGT_RPC_PH_INVOKE,
y_simple_list_test_get_counter_invoke);
if (res != NO_ERR) {
return res;
}
res = agt_cb_register_callback(
y_simple_list_test_M_simple_list_test,
(const xmlChar *)"/simple_list",
y_simple_list_test_R_simple_list_test,
simple_list_test_simple_list_edit);
if (res != NO_ERR) {
return res;
}
res = agt_cb_register_callback(
y_simple_list_test_M_simple_list_test,
(const xmlChar *)"/simple_list/theList",
y_simple_list_test_R_simple_list_test,
simple_list_test_simple_list_theList_edit);
if (res != NO_ERR) {
return res;
}
res = agt_cb_register_callback(
y_simple_list_test_M_simple_list_test,
(const xmlChar *)"/simple_list/theList/theKey",
y_simple_list_test_R_simple_list_test,
simple_list_test_simple_list_theList_theKey_edit);
if (res != NO_ERR) {
return res;
}
res = agt_cb_register_callback(
y_simple_list_test_M_simple_list_test,
(const xmlChar *)"/simple_list/theList/theVal",
y_simple_list_test_R_simple_list_test,
simple_list_test_simple_list_theList_theVal_edit);
if (res != NO_ERR) {
return res;
}
/* put your module initialization code here */
return res;
} /* y_simple_list_test_init */
/********************************************************************
* FUNCTION agt_cli_process_input
*
* Process the param line parameters against the hardwired
* parmset for the netconfd program
*
* INPUTS:
* argc == argument count
* argv == array of command line argument strings
* agt_profile == agent profile struct to fill in
* showver == address of version return quick-exit status
* showhelpmode == address of help return quick-exit status
*
* OUTPUTS:
* *agt_profile is filled in, with parms gathered or defaults
* *showver == TRUE if user requsted version quick-exit mode
* *showhelpmode == requested help mode
* (none, breief, normal, full)
*
* RETURNS:
* NO_ERR if all goes well
*********************************************************************/
status_t
agt_cli_process_input (int argc,
char *argv[],
agt_profile_t *agt_profile,
boolean *showver,
help_mode_t *showhelpmode)
{
ncx_module_t *mod;
obj_template_t *obj;
val_value_t *valset, *val;
FILE *fp;
status_t res;
boolean test;
#ifdef DEBUG
if (!argv || !agt_profile || !showver || !showhelpmode) {
return SET_ERROR(ERR_INTERNAL_PTR);
}
#endif
*showver = FALSE;
*showhelpmode = HELP_MODE_NONE;
/* find the parmset definition in the registry */
obj = NULL;
mod = ncx_find_module(AGT_CLI_MODULE, NULL);
if (mod) {
obj = ncx_find_object(mod, AGT_CLI_CONTAINER);
}
if (!obj) {
log_error("\nError: netconfd module with CLI definitions not loaded");
return ERR_NCX_NOT_FOUND;
}
/* parse the command line against the object template */
res = NO_ERR;
valset = NULL;
if (argc > 0) {
valset = cli_parse(NULL,
argc,
argv,
obj,
FULLTEST,
PLAINMODE,
TRUE,
CLI_MODE_PROGRAM,
&res);
if (res != NO_ERR) {
if (valset) {
val_free_value(valset);
}
return res;
}
}
if (valset != NULL) {
/* transfer the parmset values */
set_server_profile(valset, agt_profile);
/* next get any params from the conf file */
val = val_find_child(valset,
AGT_CLI_MODULE,
NCX_EL_CONFIG);
if (val) {
if (val->res == NO_ERR) {
/* try the specified config location */
agt_profile->agt_conffile = VAL_STR(val);
res = conf_parse_val_from_filespec(VAL_STR(val),
valset,
TRUE,
TRUE);
if (res != NO_ERR) {
val_free_value(valset);
return res;
} else {
/* transfer the parmset values again */
set_server_profile(valset, agt_profile);
}
}
} else {
fp = fopen((const char *)AGT_DEF_CONF_FILE, "r");
if (fp != NULL) {
fclose(fp);
/* use default config location */
res = conf_parse_val_from_filespec(AGT_DEF_CONF_FILE,
valset,
TRUE,
TRUE);
if (res != NO_ERR) {
val_free_value(valset);
return res;
} else {
/* transfer the parmset values again */
set_server_profile(valset, agt_profile);
}
}
}
/* set the logging control parameters */
val_set_logging_parms(valset);
/* audit-log-append param */
val = val_find_child(valset,
AGT_CLI_MODULE,
NCX_EL_AUDIT_LOG_APPEND);
if (val && val->res == NO_ERR) {
test = TRUE;
} else {
test = FALSE;
}
/* audit-log param */
val = val_find_child(valset, AGT_CLI_MODULE, NCX_EL_AUDIT_LOG);
if (val && val->res == NO_ERR) {
xmlChar *filespec = ncx_get_source(VAL_STR(val), &res);
if (filespec == NULL) {
log_error("\nError: get source for audit log failed");
return res;
}
res = log_audit_open((const char *)filespec, test, TRUE);
if (res == NO_ERR) {
if (LOGDEBUG) {
log_debug("\nAudit log '%s' opened for %s",
filespec,
(test) ? "append" : "write");
}
} else {
log_error("\nError: open audit log '%s' failed",
filespec);
}
m__free(filespec);
if (res != NO_ERR) {
return res;
}
}
/* set the file search path parms */
res = val_set_path_parms(valset);
if (res != NO_ERR) {
return res;
}
/* set the warning control parameters */
res = val_set_warning_parms(valset);
if (res != NO_ERR) {
return res;
}
/* set the feature code generation parameters */
res = val_set_feature_parms(valset);
if (res != NO_ERR) {
return res;
}
/* check the subdirs parameter */
res = val_set_subdirs_parm(valset);
if (res != NO_ERR) {
return res;
}
/* check the protocols parameter */
res = val_set_protocols_parm(valset);
if (res != NO_ERR) {
return res;
}
/* check the system-sorted param */
val = val_find_child(valset, AGT_CLI_MODULE, NCX_EL_SYSTEM_SORTED);
if (val && val->res == NO_ERR) {
agt_profile->agt_system_sorted = VAL_BOOL(val);
}
/* version param handled externally */
/* check if version mode requested */
val = val_find_child(valset, AGT_CLI_MODULE, NCX_EL_VERSION);
*showver = (val) ? TRUE : FALSE;
/* check if help mode requested */
val = val_find_child(valset, AGT_CLI_MODULE, NCX_EL_HELP);
if (val) {
*showhelpmode = HELP_MODE_NORMAL;
/* help submode parameter (brief/normal/full) */
val = val_find_child(valset, AGT_CLI_MODULE, NCX_EL_BRIEF);
if (val) {
*showhelpmode = HELP_MODE_BRIEF;
} else {
/* full parameter */
val = val_find_child(valset, AGT_CLI_MODULE, NCX_EL_FULL);
if (val) {
*showhelpmode = HELP_MODE_FULL;
}
}
}
}
/* cleanup and exit
* handoff the malloced 'valset' memory here
*/
cli_val = valset;
return res;
} /* agt_cli_process_input */
/********************************************************************
* FUNCTION mgr_rpc_dispatch
*
* Dispatch an incoming <rpc-reply> response
* handle the <rpc-reply> element
* called by mgr_top.c:
* This function is registered with top_register_node
* for the module 'netconf', top-node 'rpc-reply'
*
* INPUTS:
* scb == session control block
* top == top element descriptor
*********************************************************************/
void
mgr_rpc_dispatch (ses_cb_t *scb,
xml_node_t *top)
{
obj_template_t *rpyobj;
mgr_rpc_rpy_t *rpy;
mgr_rpc_req_t *req;
xml_attr_t *attr;
xmlChar *msg_id;
ncx_module_t *mod;
mgr_rpc_cbfn_t handler;
ncx_num_t num;
status_t res;
#ifdef DEBUG
if (!scb || !top) {
SET_ERROR(ERR_INTERNAL_PTR);
return;
}
#endif
/* init local vars */
res = NO_ERR;
msg_id = NULL;
req = NULL;
/* make sure any real session has been properly established */
if (scb->type != SES_TYP_DUMMY && scb->state != SES_ST_IDLE) {
log_error("\nError: mgr_rpc: skipping incoming message '%s'",
top->qname);
mgr_xml_skip_subtree(scb->reader, top);
return;
}
/* check if the reply template is already cached */
rpyobj = NULL;
mod = ncx_find_module(NC_MODULE, NULL);
if (mod != NULL) {
rpyobj = ncx_find_object(mod, NC_RPC_REPLY_TYPE);
}
if (rpyobj == NULL) {
SET_ERROR(ERR_NCX_DEF_NOT_FOUND);
mgr_xml_skip_subtree(scb->reader, top);
return;
}
/* get the NC RPC message-id attribute; should be present
* because the send-rpc function put a message-id in <rpc>
*/
attr = xml_find_attr(top, 0, NCX_EL_MESSAGE_ID);
if (attr && attr->attr_val) {
msg_id = xml_strdup(attr->attr_val);
}
if (msg_id == NULL) {
mgr_xml_skip_subtree(scb->reader, top);
log_info("\nmgr_rpc: incoming message with no message-id");
return;
}
/* the current node is 'rpc-reply' in the netconf namespace
* First get a new RPC reply struct
*/
rpy = new_reply();
if (rpy == NULL) {
m__free(msg_id);
log_error("\nError: mgr_rpc: skipping incoming message");
mgr_xml_skip_subtree(scb->reader, top);
return;
} else {
rpy->msg_id = msg_id;
}
/* get the NCX RPC group-id attribute if present */
attr = xml_find_attr(top, xmlns_ncx_id(), NCX_EL_GROUP_ID);
if (attr && attr->attr_val) {
res = ncx_decode_num(attr->attr_val, NCX_BT_UINT32, &num);
if (res == NO_ERR) {
rpy->group_id = num.u;
}
}
/* find the request that goes with this reply */
if (rpy->msg_id != NULL) {
req = find_request(scb, rpy->msg_id);
if (req == NULL) {
#ifdef MGR_RPC_DEBUG
log_debug("\nmgr_rpc: got request found for msg (%s) "
"on session %d",
rpy->msg_id,
scb->sid);
#endif
mgr_xml_skip_subtree(scb->reader, top);
mgr_rpc_free_reply(rpy);
return;
} else {
dlq_remove(req);
}
}
/* have a request/reply pair, so parse the reply
* as a val_value_t tree, stored in rpy->reply
*/
rpy->res = mgr_val_parse_reply(scb,
rpyobj,
(req != NULL) ?
req->rpc : ncx_get_gen_anyxml(),
top,
rpy->reply);
if (rpy->res != NO_ERR && LOGINFO) {
log_info("\nmgr_rpc: got invalid reply on session %d (%s)",
scb->sid, get_error_string(rpy->res));
}
/* check that there is nothing after the <rpc-reply> element */
if (rpy->res==NO_ERR &&
!xml_docdone(scb->reader) && LOGINFO) {
log_info("\nmgr_rpc: got extra nodes in reply on session %d",
scb->sid);
}
/* invoke the reply handler */
if (req != NULL) {
handler = (mgr_rpc_cbfn_t)req->replycb;
(*handler)(scb, req, rpy);
}
/* only reset the session state to idle if was not changed
* to SES_ST_SHUTDOWN_REQ during this RPC call
*/
if (scb->state == SES_ST_IN_MSG) {
scb->state = SES_ST_IDLE;
}
#ifdef MGR_RPC_DEBUG
print_errors();
clear_errors();
#endif
} /* mgr_rpc_dispatch */
/********************************************************************
* FUNCTION y_toaster_init
*
* initialize the toaster server instrumentation library
*
* INPUTS:
* modname == requested module name
* revision == requested version (NULL for any)
*
* RETURNS:
* error status
********************************************************************/
status_t
y_toaster_init (
const xmlChar *modname,
const xmlChar *revision)
{
agt_profile_t *agt_profile;
status_t res;
y_toaster_init_static_vars();
/* change if custom handling done */
if (xml_strcmp(modname, y_toaster_M_toaster)) {
return ERR_NCX_UNKNOWN_MODULE;
}
if (revision && xml_strcmp(revision, y_toaster_R_toaster)) {
return ERR_NCX_WRONG_VERSION;
}
agt_profile = agt_get_profile();
res = ncxmod_load_module(
y_toaster_M_toaster,
y_toaster_R_toaster,
&agt_profile->agt_savedevQ,
&toaster_mod);
if (res != NO_ERR) {
return res;
}
toaster_obj = ncx_find_object(
toaster_mod,
y_toaster_N_toaster);
if (toaster_mod == NULL) {
return SET_ERROR(ERR_NCX_DEF_NOT_FOUND);
}
make_toast_obj = ncx_find_object(
toaster_mod,
y_toaster_N_make_toast);
if (toaster_mod == NULL) {
return SET_ERROR(ERR_NCX_DEF_NOT_FOUND);
}
cancel_toast_obj = ncx_find_object(
toaster_mod,
y_toaster_N_cancel_toast);
if (toaster_mod == NULL) {
return SET_ERROR(ERR_NCX_DEF_NOT_FOUND);
}
toastDone_obj = ncx_find_object(
toaster_mod,
y_toaster_N_toastDone);
if (toaster_mod == NULL) {
return SET_ERROR(ERR_NCX_DEF_NOT_FOUND);
}
res = agt_rpc_register_method(
y_toaster_M_toaster,
y_toaster_N_make_toast,
AGT_RPC_PH_VALIDATE,
y_toaster_make_toast_validate);
if (res != NO_ERR) {
return res;
}
res = agt_rpc_register_method(
y_toaster_M_toaster,
y_toaster_N_make_toast,
AGT_RPC_PH_INVOKE,
y_toaster_make_toast_invoke);
if (res != NO_ERR) {
return res;
}
res = agt_rpc_register_method(
y_toaster_M_toaster,
y_toaster_N_cancel_toast,
AGT_RPC_PH_VALIDATE,
y_toaster_cancel_toast_validate);
if (res != NO_ERR) {
return res;
}
res = agt_rpc_register_method(
y_toaster_M_toaster,
y_toaster_N_cancel_toast,
AGT_RPC_PH_INVOKE,
y_toaster_cancel_toast_invoke);
if (res != NO_ERR) {
return res;
}
res = agt_cb_register_callback(
y_toaster_M_toaster,
(const xmlChar *)"/toaster",
(const xmlChar *)"2009-11-20",
y_toaster_toaster_edit);
if (res != NO_ERR) {
return res;
}
/* put your module initialization code here */
return res;
} /* y_toaster_init */
/********************************************************************
* FUNCTION mgr_hello_dispatch
*
* Handle an incoming <hello> message from the client
*
* INPUTS:
* scb == session control block
* top == top element descriptor
*********************************************************************/
void
mgr_hello_dispatch (ses_cb_t *scb,
xml_node_t *top)
{
assert( scb && "scb is NULL!" );
assert( top && "top is NULL!" );
#ifdef MGR_HELLO_DEBUG
if (LOGDEBUG) {
log_debug("\nmgr_hello got node");
}
if (LOGDEBUG2) {
xml_dump_node(top);
}
#endif
mgr_scb_t *mscb = mgr_ses_get_mscb(scb);
/* only process this message in hello wait state */
if (scb->state != SES_ST_HELLO_WAIT) {
/* TBD: stats update */
if (LOGINFO) {
log_info("\nmgr_hello dropped, wrong state for session %d",
scb->sid);
}
return;
}
/* init local vars */
status_t res = NO_ERR;
obj_template_t *obj = NULL;
ncx_module_t *mod = NULL;
xml_msg_hdr_t msg;
xml_msg_init_hdr(&msg);
/* get a value struct to hold the server hello msg */
val_value_t *val = val_new_value();
if (!val) {
res = ERR_INTERNAL_MEM;
}
/* get the type definition from the registry */
if (res == NO_ERR) {
mod = ncx_find_module(NC_MODULE, NULL);
if (mod) {
obj = ncx_find_object(mod, MGR_SERVER_HELLO_OBJ);
}
if (!obj) {
/* netconf module should have loaded this definition */
res = SET_ERROR(ERR_INTERNAL_PTR);
}
}
/* parse an server hello message */
if (res == NO_ERR) {
res = mgr_val_parse(scb, obj, top, val);
}
/* examine the server capability list
* and it matches the server protocol version
*/
if (res == NO_ERR) {
res = process_server_hello(scb, val);
}
/* report first error and close session */
if (res != NO_ERR) {
if (LOGINFO) {
log_info("\nmgr_connect error (%s)\n dropping session %u (a:%u)",
get_error_string(res), scb->sid, mscb->agtsid);
}
} else {
scb->state = SES_ST_IDLE;
if (LOGDEBUG) {
log_debug("\nmgr_hello manager hello ok");
}
}
if (val) {
val_free_value(val);
}
} /* mgr_hello_dispatch */
