static void
test_nc_rpc_cancel(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
/* create cancel rpc with NC_PARAMTYPE_CONST*/
rpc = nc_rpc_cancel("persist-id", NC_PARAMTYPE_CONST);
assert_non_null(rpc);
check_cancel_rpc(rpc, "persist-id");
nc_rpc_free(rpc);
/* create cancel rpc with NC_PARAMTYPE_FREE*/
char *str = strdup("string");
rpc = nc_rpc_cancel(str, NC_PARAMTYPE_FREE);
assert_non_null(rpc);
check_cancel_rpc(rpc, str);
nc_rpc_free(rpc);
/* create cancel rpc with NC_PARAMTYPE_DUP_AND_FREE*/
rpc = nc_rpc_cancel("id", NC_PARAMTYPE_DUP_AND_FREE);
assert_non_null(rpc);
check_cancel_rpc(rpc, "id");
nc_rpc_free(rpc);
}
static void
test_nc_rpc_get(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
/* create get rpc with NC_PARAMTYPE_CONST */
rpc = nc_rpc_get("filter", NC_WD_ALL, NC_PARAMTYPE_CONST);
assert_non_null(rpc);
check_get_rpc(rpc, "filter", NC_WD_ALL);
nc_rpc_free(rpc);
/* create get rpc with NC_PARAMTYPE_FREE */
char *str = strdup("string");
rpc = nc_rpc_get(str, NC_WD_EXPLICIT, NC_PARAMTYPE_FREE);
assert_non_null(rpc);
check_get_rpc(rpc, str, NC_WD_EXPLICIT);
nc_rpc_free(rpc);
/* create get rpc with NC_PARAMTYPE_DUP_AND_FREE */
rpc = nc_rpc_get("filter-string", NC_WD_UNKNOWN, NC_PARAMTYPE_DUP_AND_FREE);
assert_non_null(rpc);
check_get_rpc(rpc, "filter-string", NC_WD_UNKNOWN);
nc_rpc_free(rpc);
}
static void
test_nc_rpc_copy(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
/* create copy rpc with NC_PARAMTYPE_CONST */
rpc = nc_rpc_copy(NC_DATASTORE_RUNNING, "target-url", NC_DATASTORE_RUNNING, "src-url",
NC_WD_ALL, NC_PARAMTYPE_CONST);
assert_non_null(rpc);
check_copy(rpc, NC_DATASTORE_RUNNING, "target-url", NC_DATASTORE_RUNNING, "src-url", NC_WD_ALL);
nc_rpc_free(rpc);
/* create copy rpc with NC_PARAMTYPE_FREE */
char *target = strdup("target");
char *src = strdup("src");
rpc = nc_rpc_copy(NC_DATASTORE_STARTUP, target, NC_DATASTORE_RUNNING, src,
NC_WD_ALL_TAG, NC_PARAMTYPE_FREE);
assert_non_null(rpc);
check_copy(rpc, NC_DATASTORE_STARTUP, target, NC_DATASTORE_RUNNING, src, NC_WD_ALL_TAG);
nc_rpc_free(rpc);
/* create copy rpc with NC_PARAMTYPE_DUP_AND_FREE */
rpc = nc_rpc_copy(NC_DATASTORE_STARTUP, "url", NC_DATASTORE_CANDIDATE, "url",
NC_WD_TRIM, NC_PARAMTYPE_DUP_AND_FREE);
assert_non_null(rpc);
check_copy(rpc, NC_DATASTORE_STARTUP, "url", NC_DATASTORE_CANDIDATE, "url", NC_WD_TRIM);
nc_rpc_free(rpc);
}
static void
test_nc_rpc_delete(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
/* create delete rpc with NC_PARAMTYPE_CONST */
rpc = nc_rpc_delete(NC_DATASTORE_RUNNING, "target-url", NC_PARAMTYPE_CONST);
assert_non_null(rpc);
check_delete(rpc, NC_DATASTORE_RUNNING, "target-url");
nc_rpc_free(rpc);
/* create delete rpc with NC_PARAMTYPE_FREE */
char *url = strdup("url");
rpc = nc_rpc_delete(NC_DATASTORE_CANDIDATE, url, NC_PARAMTYPE_FREE);
assert_non_null(rpc);
check_delete(rpc, NC_DATASTORE_CANDIDATE, url);
nc_rpc_free(rpc);
/* create delete rpc with NC_PARAMTYPE_DUP_AND_FREE */
rpc = nc_rpc_delete(NC_DATASTORE_CONFIG, "target", NC_PARAMTYPE_DUP_AND_FREE);
assert_non_null(rpc);
check_delete(rpc, NC_DATASTORE_CONFIG, "target");
nc_rpc_free(rpc);
}
static void
test_nc_rpc_getconfig(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
/* create getconfig rpc with NC_PARAMTYPE_CONST */
rpc = nc_rpc_getconfig(NC_DATASTORE_CANDIDATE, "filter-string", NC_WD_UNKNOWN, NC_PARAMTYPE_CONST);
assert_non_null(rpc);
check_getconfig(rpc, NC_DATASTORE_CANDIDATE, "filter-string", NC_PARAMTYPE_CONST);
nc_rpc_free(rpc);
/* create getconfig rpc with NC_PARAMTYPE_FREE */
char *filter = strdup("string");
rpc = nc_rpc_getconfig(NC_DATASTORE_CONFIG, filter, NC_WD_EXPLICIT, NC_PARAMTYPE_FREE);
assert_non_null(rpc);
check_getconfig(rpc, NC_DATASTORE_CONFIG, filter, NC_WD_EXPLICIT);
nc_rpc_free(rpc);
/* create getconfig rpc with NC_PARAMTYPE_DUP_AND_FREE */
rpc = nc_rpc_getconfig(NC_DATASTORE_RUNNING, "filter", NC_WD_ALL, NC_PARAMTYPE_DUP_AND_FREE);
assert_non_null(rpc);
check_getconfig(rpc, NC_DATASTORE_RUNNING, "filter", NC_WD_ALL);
nc_rpc_free(rpc);
}
static void
test_nc_rpc_edit(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
/* create edit rpc with NC_PARAMTYPE_CONST */
rpc = nc_rpc_edit(NC_DATASTORE_RUNNING, NC_RPC_EDIT_DFLTOP_REPLACE, NC_RPC_EDIT_TESTOPT_TESTSET,
NC_RPC_EDIT_ERROPT_STOP, "url", NC_PARAMTYPE_CONST);
assert_non_null(rpc);
check_edit(rpc, NC_DATASTORE_RUNNING, NC_RPC_EDIT_DFLTOP_REPLACE,
NC_RPC_EDIT_TESTOPT_TESTSET, NC_RPC_EDIT_ERROPT_STOP, "url");
nc_rpc_free(rpc);
/* create edit rpc with NC_PARAMTYPE_FREE */
char *str = strdup("string");
rpc = nc_rpc_edit(NC_DATASTORE_CANDIDATE, NC_RPC_EDIT_DFLTOP_MERGE, NC_RPC_EDIT_TESTOPT_SET,
NC_RPC_EDIT_ERROPT_ROLLBACK, str, NC_PARAMTYPE_FREE);
assert_non_null(rpc);
check_edit(rpc, NC_DATASTORE_CANDIDATE, NC_RPC_EDIT_DFLTOP_MERGE,
NC_RPC_EDIT_TESTOPT_SET, NC_RPC_EDIT_ERROPT_ROLLBACK, str);
nc_rpc_free(rpc);
/* create edit rpc with NC_PARAMTYPE_DUP_AND_FREE */
rpc = nc_rpc_edit(NC_DATASTORE_CONFIG, NC_RPC_EDIT_DFLTOP_NONE, NC_RPC_EDIT_TESTOPT_TEST,
NC_RPC_EDIT_ERROPT_CONTINUE, "url1", NC_PARAMTYPE_DUP_AND_FREE);
assert_non_null(rpc);
check_edit(rpc, NC_DATASTORE_CONFIG, NC_RPC_EDIT_DFLTOP_NONE,
NC_RPC_EDIT_TESTOPT_TEST, NC_RPC_EDIT_ERROPT_CONTINUE, "url1");
nc_rpc_free(rpc);
}
static void
test_nc_rpc_validate(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
/* create validate rpc with NC_PARAMTYPE_CONST */
rpc = nc_rpc_validate(NC_DATASTORE_RUNNING, "url", NC_PARAMTYPE_CONST);
assert_non_null(rpc);
check_validate_rpc(rpc, NC_DATASTORE_RUNNING, "url");
nc_rpc_free(rpc);
/* create validate rpc with NC_PARAMTYPE_FREE */
char *str = strdup("string");
rpc = nc_rpc_validate(NC_DATASTORE_CANDIDATE, str, NC_PARAMTYPE_FREE);
assert_non_null(rpc);
check_validate_rpc(rpc, NC_DATASTORE_CANDIDATE, str);
nc_rpc_free(rpc);
/* create validate rpc with NC_PARAMTYPE_DUP_AND_FREE */
rpc = nc_rpc_validate(NC_DATASTORE_CONFIG, "url1", NC_PARAMTYPE_DUP_AND_FREE);
assert_non_null(rpc);
check_validate_rpc(rpc, NC_DATASTORE_CONFIG, "url1");
nc_rpc_free(rpc);
}
static void
test_nc_rpc_getschema(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
/* create getchema with NC_PARAMTYPE_CONST*/
rpc = nc_rpc_getschema("id", "version", "format", NC_PARAMTYPE_CONST);
assert_non_null(rpc);
check_getschema_rpc(rpc, "id", "version", "format");
nc_rpc_free(rpc);
/* create getchema with NC_PARAMTYPE_FREE*/
char *str1 = strdup("str1");
char *str2 = strdup("str2");
char *str3 = strdup("str3");
rpc = nc_rpc_getschema(str1, str2, str3, NC_PARAMTYPE_FREE);
assert_non_null(rpc);
check_getschema_rpc(rpc, str1, str2, str3);
nc_rpc_free(rpc);
/* create getchema with NC_PARAMTYPE_DUP_AND_FREE*/
rpc = nc_rpc_getschema("id1", "version1", "format1", NC_PARAMTYPE_DUP_AND_FREE);
assert_non_null(rpc);
check_getschema_rpc(rpc, "id1", "version1", "format1");
nc_rpc_free(rpc);
}
static void
test_nc_rpc_subscribe(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
/* create subscribe rpc with NC_PARAMTYPE_CONST*/
rpc = nc_rpc_subscribe("stream-name", "filter", "start-time", "stop-time", NC_PARAMTYPE_CONST);
assert_non_null(rpc);
check_subscribe_rpc(rpc, "stream-name", "filter", "start-time", "stop-time");
nc_rpc_free(rpc);
/* create subscribe rpc with NC_PARAMTYPE_FREE*/
char *str1 = strdup("str1");
char *str2 = strdup("str2");
char *str3 = strdup("str3");
char *str4 = strdup("str4");
rpc = nc_rpc_subscribe(str1, str2, str3, str4, NC_PARAMTYPE_FREE);
assert_non_null(rpc);
check_subscribe_rpc(rpc, str1, str2, str3, str4);
nc_rpc_free(rpc);
/* create subscribe rpc with NC_PARAMTYPE_DUP_AND_FREE*/
rpc = nc_rpc_subscribe("name", "filter-str", "start", "stop", NC_PARAMTYPE_DUP_AND_FREE);
assert_non_null(rpc);
check_subscribe_rpc(rpc, "name", "filter-str", "start", "stop");
nc_rpc_free(rpc);
}
static void
test_nc_rpc_commit(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
/* create commit rpc with NC_PARAMTYPE_CONST*/
rpc = nc_rpc_commit(1, 100, "persist", "persist-id", NC_PARAMTYPE_CONST);
assert_non_null(rpc);
check_commit_rpc(rpc, 1, 100, "persist", "persist-id");
nc_rpc_free(rpc);
/* create commit rpc with NC_PARAMTYPE_FREE*/
char *str1 = strdup("str1");
char *str2 = strdup("str2");
rpc = nc_rpc_commit(2, 5, str1, str2, NC_PARAMTYPE_FREE);
assert_non_null(rpc);
check_commit_rpc(rpc, 2, 5, str1, str2);
nc_rpc_free(rpc);
/* create commit rpc with NC_PARAMTYPE_DUP_AND_FREE*/
rpc = nc_rpc_commit(10, 200, "persistent", "persistent-id", NC_PARAMTYPE_DUP_AND_FREE);
assert_non_null(rpc);
check_commit_rpc(rpc, 10, 200, "persistent", "persistent-id");
nc_rpc_free(rpc);
}
static void
test_nc_rpc_act_generic_xml(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
struct nc_rpc_act_generic *generic_rpc = NULL;
/* create generic rpc with NC_PARAMTYPE_CONST */
rpc = nc_rpc_act_generic_xml("xml", NC_PARAMTYPE_CONST);
assert_int_equal(nc_rpc_get_type(rpc), NC_RPC_ACT_GENERIC);
generic_rpc = (struct nc_rpc_act_generic *)rpc;
assert_int_equal(generic_rpc->type, NC_RPC_ACT_GENERIC);
assert_int_equal(generic_rpc->has_data, 0);
assert_string_equal(generic_rpc->content.xml_str, "xml");
nc_rpc_free(rpc);
/* create generic rpc with NC_PARAMTYPE_FREE */
char *str = strdup("str");
rpc = nc_rpc_act_generic_xml(str, NC_PARAMTYPE_FREE);
assert_int_equal(nc_rpc_get_type(rpc), NC_RPC_ACT_GENERIC);
generic_rpc = (struct nc_rpc_act_generic *)rpc;
assert_int_equal(generic_rpc->type, NC_RPC_ACT_GENERIC);
assert_int_equal(generic_rpc->has_data, 0);
assert_string_equal(generic_rpc->content.xml_str, str);
nc_rpc_free(rpc);
/* create generic rpc with NC_PARAMTYPE_DUP_AND_FREE */
rpc = nc_rpc_act_generic_xml("xml", NC_PARAMTYPE_DUP_AND_FREE);
assert_int_equal(nc_rpc_get_type(rpc), NC_RPC_ACT_GENERIC);
generic_rpc = (struct nc_rpc_act_generic *)rpc;
assert_int_equal(generic_rpc->type, NC_RPC_ACT_GENERIC);
assert_int_equal(generic_rpc->has_data, 0);
assert_string_equal(generic_rpc->content.xml_str, "xml");
nc_rpc_free(rpc);
}
static PyObject *get_common(ncSessionObject *self, const char *filter, int wdmode, int datastore)
{
char *data = NULL;
struct nc_filter *st_filter = NULL;
nc_rpc *rpc = NULL;
PyObject *result = NULL;
/* create filter if specified */
if (filter) {
if ((st_filter = nc_filter_new(NC_FILTER_SUBTREE, filter)) == NULL) {
return (NULL);
}
}
/* check datastore */
switch(datastore) {
case NC_DATASTORE_STARTUP:
if (!nc_cpblts_enabled(self->session, NETCONF_CAP_STARTUP)) {
PyErr_SetString(libnetconfError, ":startup capability not supported.");
return (NULL);
}
break;
case NC_DATASTORE_CANDIDATE:
if (!nc_cpblts_enabled(self->session, NETCONF_CAP_CANDIDATE)) {
PyErr_SetString(libnetconfError, ":candidate capability not supported.");
return (NULL);
}
break;
}
/* create RPC */
if (datastore == NC_DATASTORE_ERROR) {
rpc = nc_rpc_get(st_filter);
} else {
rpc = nc_rpc_getconfig(datastore, st_filter);
}
nc_filter_free(st_filter);
if (!rpc) {
return(NULL);
}
/* set with defaults settings */
if (wdmode) {
if (nc_rpc_capability_attr(rpc, NC_CAP_ATTR_WITHDEFAULTS_MODE, wdmode) != EXIT_SUCCESS) {
nc_rpc_free(rpc);
return (NULL);
}
}
/* send request ... */
if (op_send_recv(self, rpc, &data) == EXIT_SUCCESS && data != NULL) {
/* ... and prepare the result */
result = PyUnicode_FromString(data);
free(data);
}
return (result);
}
void* client_notif_thread(void* arg) {
struct ntf_thread_config *config = (struct ntf_thread_config*)arg;
ncntf_dispatch_send(config->session, config->subscribe_rpc);
nc_rpc_free(config->subscribe_rpc);
free(config);
return NULL;
}
static void
test_nc_rpc_discard(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
rpc = nc_rpc_discard();
assert_non_null(rpc);
assert_int_equal(nc_rpc_get_type(rpc), NC_RPC_DISCARD);
nc_rpc_free(rpc);
}
static int
teardown_write(void **state)
{
struct wr *w = (struct wr *)*state;
nc_rpc_free(w->rpc);
w->session->ti.fd.in = -1;
w->session->ti.fd.out = -1;
nc_session_free(w->session);
free(w);
*state = NULL;
return 0;
}
static void
test_nc_rpc_unlock(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
struct nc_rpc_lock *unlock_rpc = NULL;
rpc = nc_rpc_unlock(NC_DATASTORE_RUNNING);
assert_non_null(rpc);
assert_int_equal(nc_rpc_get_type(rpc), NC_RPC_UNLOCK);
unlock_rpc = (struct nc_rpc_lock *)rpc;
assert_int_equal(unlock_rpc->type, NC_RPC_UNLOCK);
assert_int_equal(unlock_rpc->target, NC_DATASTORE_RUNNING);
nc_rpc_free(rpc);
}
/* rpc parameter is freed after the function call */
static int op_send_recv(ncSessionObject *self, nc_rpc* rpc, char **data)
{
nc_reply *reply = NULL;
int ret = EXIT_SUCCESS;
/* send the request and get the reply */
switch (nc_session_send_recv(self->session, rpc, &reply)) {
case NC_MSG_UNKNOWN:
if (nc_session_get_status(self->session) != NC_SESSION_STATUS_WORKING) {
PyErr_SetString(libnetconfError, "Session damaged, closing.");
/* free the Session */
nc_session_free(self->session);
self->session = NULL;
}
ret = EXIT_FAILURE;
break;
case NC_MSG_NONE:
/* error occurred, but processed by callback */
break;
case NC_MSG_REPLY:
switch (nc_reply_get_type(reply)) {
case NC_REPLY_OK:
break;
case NC_REPLY_DATA:
if (data) {
*data = nc_reply_get_data (reply);
}
break;
case NC_REPLY_ERROR:
ret = EXIT_FAILURE;
break;
default:
PyErr_SetString(libnetconfError, "Unexpected operation result.");
ret = EXIT_FAILURE;
break;
}
break;
default:
PyErr_SetString(libnetconfError, "Unknown error occurred.");
ret = EXIT_FAILURE;
break;
}
nc_rpc_free(rpc);
nc_reply_free(reply);
return (ret);
}
static void
test_nc_rpc_kill(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
struct nc_rpc_kill *kill_rpc = NULL;
rpc = nc_rpc_kill(10);
assert_non_null(rpc);
assert_int_equal(nc_rpc_get_type(rpc), NC_RPC_KILL);
kill_rpc = (struct nc_rpc_kill *)rpc;
assert_int_equal(kill_rpc->type, NC_RPC_KILL);
assert_int_equal(kill_rpc->sid, 10);
nc_rpc_free(rpc);
}
static void
test_nc_rpc_act_generic(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
struct nc_rpc_act_generic *generic_rpc = NULL;
struct lyd_node node;
node.next = NULL;
node.prev = &node;
rpc = nc_rpc_act_generic(&node, NC_PARAMTYPE_CONST);
assert_non_null(rpc);
assert_int_equal(nc_rpc_get_type(rpc), NC_RPC_ACT_GENERIC);
generic_rpc = (struct nc_rpc_act_generic *)rpc;
assert_int_equal(generic_rpc->type, NC_RPC_ACT_GENERIC);
assert_int_equal(generic_rpc->has_data, 1);
assert_ptr_equal(generic_rpc->content.data, &node);
nc_rpc_free(rpc);
}
static void
test_send_recv_error(void)
{
int ret;
uint64_t msgid;
NC_MSG_TYPE msgtype;
struct nc_rpc *rpc;
struct nc_reply *reply;
struct nc_pollsession *ps;
/* client RPC */
rpc = nc_rpc_kill(1);
assert_non_null(rpc);
msgtype = nc_send_rpc(client_session, rpc, 0, &msgid);
assert_int_equal(msgtype, NC_MSG_RPC);
/* server RPC, send reply */
ps = nc_ps_new();
assert_non_null(ps);
nc_ps_add_session(ps, server_session);
ret = nc_ps_poll(ps, 0);
assert_int_equal(ret, 1);
/* server finished */
nc_ps_free(ps);
/* client reply */
msgtype = nc_recv_reply(client_session, rpc, msgid, 0, &reply);
assert_int_equal(msgtype, NC_MSG_REPLY);
nc_rpc_free(rpc);
assert_int_equal(reply->type, NC_RPL_ERROR);
assert_string_equal(((struct nc_reply_error *)reply)->err->tag, "operation-not-supported");
nc_reply_free(reply);
}
static void
test_send_recv_data(void)
{
int ret;
uint64_t msgid;
NC_MSG_TYPE msgtype;
struct nc_rpc *rpc;
struct nc_reply *reply;
struct nc_pollsession *ps;
/* client RPC */
rpc = nc_rpc_getconfig(NC_DATASTORE_RUNNING, NULL, 0, 0);
assert_non_null(rpc);
msgtype = nc_send_rpc(client_session, rpc, 0, &msgid);
assert_int_equal(msgtype, NC_MSG_RPC);
/* server RPC, send reply */
ps = nc_ps_new();
assert_non_null(ps);
nc_ps_add_session(ps, server_session);
ret = nc_ps_poll(ps, 0);
assert_int_equal(ret, 1);
/* server finished */
nc_ps_free(ps);
/* client reply */
msgtype = nc_recv_reply(client_session, rpc, msgid, 0, &reply);
assert_int_equal(msgtype, NC_MSG_REPLY);
nc_rpc_free(rpc);
assert_int_equal(reply->type, NC_RPL_DATA);
nc_reply_free(reply);
}
static PyObject *ncProcessRPC(ncSessionObject *self)
{
NC_MSG_TYPE ret;
NC_RPC_TYPE req_type;
NC_OP req_op;
nc_rpc *rpc = NULL;
nc_reply *reply = NULL;
struct nc_err* e = NULL;
SESSION_CHECK(self);
/* receive incoming message */
ret = nc_session_recv_rpc(self->session, -1, &rpc);
if (ret != NC_MSG_RPC) {
if (nc_session_get_status(self->session) != NC_SESSION_STATUS_WORKING) {
/* something really bad happend, and communication is not possible anymore */
nc_session_free(self->session);
self->session = NULL;
}
Py_RETURN_NONE;
}
/* process it */
req_type = nc_rpc_get_type(rpc);
req_op = nc_rpc_get_op(rpc);
if (req_type == NC_RPC_SESSION) {
/* process operations affectinf session */
switch(req_op) {
case NC_OP_CLOSESESSION:
/* exit the event loop immediately without processing any following request */
reply = nc_reply_ok();
break;
case NC_OP_KILLSESSION:
/* todo: kill the requested session */
reply = nc_reply_error(nc_err_new(NC_ERR_OP_NOT_SUPPORTED));
break;
default:
reply = nc_reply_error(nc_err_new(NC_ERR_OP_NOT_SUPPORTED));
break;
}
} else if (req_type == NC_RPC_DATASTORE_READ) {
/* process operations reading datastore */
switch (req_op) {
case NC_OP_GET:
case NC_OP_GETCONFIG:
reply = ncds_apply_rpc2all(self->session, rpc, NULL);
break;
default:
reply = nc_reply_error(nc_err_new(NC_ERR_OP_NOT_SUPPORTED));
break;
}
} else if (req_type == NC_RPC_DATASTORE_WRITE) {
/* process operations affecting datastore */
switch (req_op) {
case NC_OP_LOCK:
case NC_OP_UNLOCK:
case NC_OP_COPYCONFIG:
case NC_OP_DELETECONFIG:
case NC_OP_EDITCONFIG:
reply = ncds_apply_rpc2all(self->session, rpc, NULL);
break;
default:
reply = nc_reply_error(nc_err_new(NC_ERR_OP_NOT_SUPPORTED));
break;
}
} else {
/* process other operations */
reply = ncds_apply_rpc2all(self->session, rpc, NULL);
}
/* create reply */
if (reply == NULL) {
reply = nc_reply_error(nc_err_new(NC_ERR_OP_FAILED));
} else if (reply == NCDS_RPC_NOT_APPLICABLE) {
e = nc_err_new(NC_ERR_OP_FAILED);
nc_err_set(e, NC_ERR_PARAM_MSG, "Requested operation cannot be performed on the managed datastore.");
reply = nc_reply_error(e);
}
/* and send the reply to the client */
nc_session_send_reply(self->session, rpc, reply);
nc_rpc_free(rpc);
nc_reply_free(reply);
if (req_op == NC_OP_CLOSESESSION) {
/* free the Session */
nc_session_free(self->session);
self->session = NULL;
}
Py_RETURN_NONE;
}
static PyObject *ncOpCopyConfig(ncSessionObject *self, PyObject *args, PyObject *keywords)
{
int wdmode = NCWD_MODE_NOTSET;
int source = NC_DATASTORE_ERROR, target = NC_DATASTORE_ERROR;
char *data1 = NULL, *data2 = NULL;
int i;
PyObject *PySource, *PyTarget;
nc_rpc *rpc = NULL;
char *kwlist[] = {"source", "target", "wd", NULL};
SESSION_CHECK(self);
/* Get input parameters */
if (! PyArg_ParseTupleAndKeywords(args, keywords, "OO|i", kwlist, &PySource, &PyTarget, &wdmode)) {
return (NULL);
}
/* get source type */
if (strcmp(Py_TYPE(PySource)->tp_name, "int") == 0) {
if (!PyArg_Parse(PySource, "i", &source)) {
return (NULL);
}
} else if (strcmp(Py_TYPE(PySource)->tp_name, "str") == 0) {
if (!PyArg_Parse(PySource, "s", &data1)) {
return (NULL);
}
for (i = 0; data1[i] != '\0' && isspace(data1[i]); i++);
if (data1[i] == '<') {
source = NC_DATASTORE_CONFIG;
} else {
if (strcasestr(data1, "://") != NULL) {
source = NC_DATASTORE_URL;
} else {
PyErr_SetString(PyExc_ValueError, "Invalid \'source\' value.");
return (NULL);
}
}
}
/* get target type */
if (strcmp(Py_TYPE(PyTarget)->tp_name, "int") == 0) {
if (!PyArg_Parse(PyTarget, "i", &target)) {
return (NULL);
}
} else if (strcmp(Py_TYPE(PyTarget)->tp_name, "str") == 0) {
if (!PyArg_Parse(PyTarget, "s", &data2)) {
return (NULL);
}
if (strcasestr(data2, "://") != NULL) {
target = NC_DATASTORE_URL;
} else {
PyErr_SetString(PyExc_ValueError, "Invalid \'target\' value.");
return (NULL);
}
if (data1 == NULL) {
/* 3rd and 4th argument to nc_rpc_copyconfig() are variadic - if the
* source is not config or URL, the target URL must be placed as
* 3rd argument, not 4th
*/
data1 = data2;
data2 = NULL;
}
}
/* create RPC */
rpc = nc_rpc_copyconfig(source, target, data1, data2);
/* set with defaults settings */
if (wdmode) {
if (nc_rpc_capability_attr(rpc, NC_CAP_ATTR_WITHDEFAULTS_MODE, wdmode) != EXIT_SUCCESS) {
nc_rpc_free(rpc);
return (NULL);
}
}
/* send request ... */
if (op_send_recv(self, rpc, NULL) == EXIT_SUCCESS) {
/* ... and return the result */
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
int main(int argc, char** argv)
{
struct nc_session* dummy_session;
struct nc_cpblts* capabs;
struct ncds_ds* ds;
nc_rpc* rpc;
nc_reply* reply;
char* new_startup_config;
xmlDocPtr startup_doc = NULL;
int ret = 0, i, j;
if (argc < 2 || argv[1][0] == '-') {
help(argv[0]);
return 1;
}
/* set message printing callback */
nc_callback_print(my_print);
/* init libnetconf for messages from transAPI function */
if (nc_init(NC_INIT_ALL | NC_INIT_MULTILAYER) == -1) {
my_print(NC_VERB_ERROR, "Could not initialize libnetconf.");
return 1;
}
/* register the datastore */
if ((ds = ncds_new(NCDS_TYPE_FILE, "./model/ietf-interfaces.yin", NULL)) == NULL) {
nc_close();
return 1;
}
/* add imports and augments */
if (ncds_add_model("./model/ietf-yang-types.yin") != 0 || ncds_add_model("./model/ietf-inet-types.yin") != 0 ||
ncds_add_model("./model/ietf-ip.yin") != 0) {
nc_verb_error("Could not add import and augment models.");
nc_close();
return 1;
}
/* enable features */
for (i = 2; i < argc; ++i) {
if (strcmp(argv[i], "ipv4-non-contiguous-netmasks") == 0 || strcmp(argv[i], "ipv6-privacy-autoconf") == 0) {
j = ncds_feature_enable("ietf-ip", argv[i]);
} else {
j = ncds_feature_enable("ietf-interfaces", argv[i]);
}
if (j != 0) {
nc_verb_error("Could not enable feature \"%s\".", argv[i]);
nc_close();
return 1;
}
}
/* set the path to the target file */
if (ncds_file_set_path(ds, argv[1]) != 0) {
nc_verb_error("Could not set \"%s\" to the datastore.", argv[1]);
nc_close();
return 1;
}
if (ncds_init(ds) < 0) {
nc_verb_error("Failed to nitialize datastore.");
nc_close();
return 1;
}
if (ncds_consolidate() != 0) {
nc_verb_error("Could not consolidate the datastore.");
nc_close();
return 1;
}
if (transapi_init(&startup_doc) != EXIT_SUCCESS) {
nc_close();
return 1;
}
if (startup_doc == NULL || startup_doc->children == NULL) {
/* nothing to do */
nc_close();
return 0;
}
/* create the dummy session */
capabs = nc_cpblts_new(capabilities);
if ((dummy_session = nc_session_dummy("session0", "root", NULL, capabs)) == NULL) {
nc_verb_error("Could not create a dummy session.");
nc_close();
return 1;
}
/* dump the new config */
xmlDocDumpMemory(startup_doc, (xmlChar**)&new_startup_config, NULL);
xmlFreeDoc(startup_doc);
/* apply edit-config rpc on the datastore */
if ((rpc = nc_rpc_editconfig(NC_DATASTORE_STARTUP, NC_DATASTORE_CONFIG, 0, 0, 0, new_startup_config)) == NULL) {
nc_verb_error("Could not create edit-config RPC.");
nc_close();
return 1;
}
free(new_startup_config);
reply = ncds_apply_rpc2all(dummy_session, rpc, NULL);
if (nc_reply_get_type(reply) != NC_REPLY_OK) {
nc_verb_error("Edit-config RPC failed.");
nc_close();
return 1;
}
nc_reply_free(reply);
nc_rpc_free(rpc);
nc_cpblts_free(capabs);
nc_session_free(dummy_session);
nc_close();
return ret;
}
