blob: 26276ea2333418b155def0124e71810edcdc4a93 [file] [log] [blame]
Radek Krejci469aab82012-07-22 18:42:20 +02001/*!
Michal Vasko30aa3822015-11-25 10:41:54 +01002 * \file netopeerguid.c
3 * \brief NetopeerGUI daemon
Radek Krejci469aab82012-07-22 18:42:20 +02004 * \author Tomas Cejka <cejkat@cesnet.cz>
5 * \author Radek Krejci <rkrejci@cesnet.cz>
Michal Vaskoa53ef882015-11-24 11:02:01 +01006 * \author Michal Vasko <mvasko@cesnet.cz>
Radek Krejci469aab82012-07-22 18:42:20 +02007 * \date 2011
8 * \date 2012
Tomas Cejka94da2c52013-01-08 18:20:30 +01009 * \date 2013
Michal Vaskoa53ef882015-11-24 11:02:01 +010010 * \date 2015
Radek Krejci469aab82012-07-22 18:42:20 +020011 */
12/*
Michal Vaskoa53ef882015-11-24 11:02:01 +010013 * Copyright (C) 2011-2015 CESNET
Radek Krejci469aab82012-07-22 18:42:20 +020014 *
15 * LICENSE TERMS
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions
19 * are met:
20 * 1. Redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer.
22 * 2. Redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in
24 * the documentation and/or other materials provided with the
25 * distribution.
26 * 3. Neither the name of the Company nor the names of its contributors
27 * may be used to endorse or promote products derived from this
28 * software without specific prior written permission.
29 *
30 * ALTERNATIVELY, provided that this notice is retained in full, this
31 * product may be distributed under the terms of the GNU General Public
32 * License (GPL) version 2 or later, in which case the provisions
33 * of the GPL apply INSTEAD OF those given above.
34 *
35 * This software is provided ``as is'', and any express or implied
36 * warranties, including, but not limited to, the implied warranties of
37 * merchantability and fitness for a particular purpose are disclaimed.
38 * In no event shall the company or contributors be liable for any
39 * direct, indirect, incidental, special, exemplary, or consequential
40 * damages (including, but not limited to, procurement of substitute
41 * goods or services; loss of use, data, or profits; or business
42 * interruption) however caused and on any theory of liability, whether
43 * in contract, strict liability, or tort (including negligence or
44 * otherwise) arising in any way out of the use of this software, even
45 * if advised of the possibility of such damage.
46 *
47 */
Michal Vaskoc3146782015-11-04 14:46:41 +010048#define _GNU_SOURCE
Radek Krejci469aab82012-07-22 18:42:20 +020049
Radek Krejci7b4ddd02012-07-30 08:09:58 +020050#include <unistd.h>
51#include <poll.h>
Michal Vaskoc3146782015-11-04 14:46:41 +010052#include <time.h>
Michal Vaskob69dde22016-03-09 11:42:20 +010053#include <fcntl.h>
Radek Krejci469aab82012-07-22 18:42:20 +020054#include <sys/types.h>
55#include <sys/socket.h>
56#include <sys/un.h>
Michal Vaskoda0ab5c2015-11-13 13:24:51 +010057#include <sys/stat.h>
Tomas Cejka04e08f42014-03-27 19:52:34 +010058#include <pwd.h>
Michal Vaskoefdd49f2016-04-06 11:13:27 +020059#include <syslog.h>
Michal Vaskoc3146782015-11-04 14:46:41 +010060#include <errno.h>
Michal Vaskoda0ab5c2015-11-13 13:24:51 +010061#include <limits.h>
Tomas Cejka04e08f42014-03-27 19:52:34 +010062#include <grp.h>
Michal Vaskoc3146782015-11-04 14:46:41 +010063#include <signal.h>
David Kupka8e60a372012-09-04 09:15:20 +020064#include <pthread.h>
65#include <ctype.h>
Radek Krejci7b4ddd02012-07-30 08:09:58 +020066
Michal Vaskof35ea502016-02-24 10:44:54 +010067#include <nc_client.h>
Radek Krejci7b4ddd02012-07-30 08:09:58 +020068
Tomas Cejka04e08f42014-03-27 19:52:34 +010069#include "../config.h"
70
Tomas Cejkad340dbf2013-03-24 20:36:57 +010071#ifdef WITH_NOTIFICATIONS
Michal Vaskoa53ef882015-11-24 11:02:01 +010072#include "notification_server.h"
Tomas Cejkad340dbf2013-03-24 20:36:57 +010073#endif
74
Tomas Cejka94da2c52013-01-08 18:20:30 +010075#include "message_type.h"
Michal Vaskoa53ef882015-11-24 11:02:01 +010076#include "netopeerguid.h"
Radek Krejci469aab82012-07-22 18:42:20 +020077
Michal Vaskoda0ab5c2015-11-13 13:24:51 +010078#define SCHEMA_DIR "/tmp/yang_models"
Radek Krejci469aab82012-07-22 18:42:20 +020079#define MAX_PROCS 5
Michal Vaskoa53ef882015-11-24 11:02:01 +010080#define SOCKET_FILENAME "/var/run/netopeerguid.sock"
Radek Krejci469aab82012-07-22 18:42:20 +020081#define MAX_SOCKET_CL 10
82#define BUFFER_SIZE 4096
Michal Vaskoda0ab5c2015-11-13 13:24:51 +010083#define ACTIVITY_CHECK_INTERVAL 10 /**< timeout in seconds, how often activity is checked */
84#define ACTIVITY_TIMEOUT (60*60) /**< timeout in seconds, after this time, session is automaticaly closed. */
Radek Krejci469aab82012-07-22 18:42:20 +020085
Michal Vasko7732dee2015-11-05 10:22:15 +010086/* sleep in master process for non-blocking socket reading, in msec */
Radek Krejci469aab82012-07-22 18:42:20 +020087#define SLEEP_TIME 200
88
89#ifndef offsetof
90#define offsetof(type, member) ((size_t) ((type *) 0)->member)
91#endif
92
Tomas Cejka027f3bc2012-11-10 20:28:36 +010093/* timeout in msec */
Radek Krejci469aab82012-07-22 18:42:20 +020094struct timeval timeout = { 1, 0 };
95
Michal Vaskoda0ab5c2015-11-13 13:24:51 +010096#define NCWITHDEFAULTS NCWD_MODE_NOTSET
Tomas Cejka5064c232013-01-17 09:30:58 +010097
Radek Krejci469aab82012-07-22 18:42:20 +020098#define MSG_OK 0
99#define MSG_OPEN 1
100#define MSG_DATA 2
101#define MSG_CLOSE 3
102#define MSG_ERROR 4
103#define MSG_UNKNOWN 5
104
Tomas Cejka47387fd2013-06-10 20:37:46 +0200105pthread_rwlock_t session_lock; /**< mutex protecting netconf_sessions_list from multiple access errors */
Tomas Cejka6b886e02013-07-05 09:53:17 +0200106pthread_mutex_t ntf_history_lock; /**< mutex protecting notification history list */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100107pthread_mutex_t ntf_hist_clbc_mutex; /**< mutex protecting notification history list */
Tomas Cejka9a23f6e2014-03-27 14:57:00 +0100108pthread_mutex_t json_lock; /**< mutex for protecting json-c calls */
109
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100110unsigned int session_key_generator = 1;
Michal Vaskoc3146782015-11-04 14:46:41 +0100111struct session_with_mutex *netconf_sessions_list = NULL;
Michal Vaskoc3146782015-11-04 14:46:41 +0100112static const char *sockname;
Tomas Cejkad016f9c2013-07-10 09:16:16 +0200113static pthread_key_t notif_history_key;
Tomas Cejka442258e2014-04-01 18:17:18 +0200114pthread_key_t err_reply_key;
Radek Krejci469aab82012-07-22 18:42:20 +0200115volatile int isterminated = 0;
Radek Krejci469aab82012-07-22 18:42:20 +0200116static char* password;
Michal Vaskoefdd49f2016-04-06 11:13:27 +0200117int daemonize;
Radek Krejci469aab82012-07-22 18:42:20 +0200118
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100119json_object *create_ok_reply(void);
120json_object *create_data_reply(const char *data);
121static char *netconf_getschema(unsigned int session_key, const char *identifier, const char *version,
122 const char *format, json_object **err);
Michal Vaskof35ea502016-02-24 10:44:54 +0100123static void node_add_metadata_recursive(struct lyd_node *data_tree, const struct lys_module *module,
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100124 json_object *data_json_parent);
Michal Vasko3fda9a92015-11-23 10:10:57 +0100125static void node_metadata_typedef(struct lys_tpdf *tpdf, json_object *parent);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100126
127static void
128signal_handler(int sign)
Radek Krejci469aab82012-07-22 18:42:20 +0200129{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100130 switch (sign) {
131 case SIGINT:
132 case SIGTERM:
133 isterminated = 1;
134 break;
135 }
Radek Krejci469aab82012-07-22 18:42:20 +0200136}
137
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100138int
139netconf_callback_ssh_hostkey_check(const char* UNUSED(hostname), ssh_session UNUSED(session))
Radek Krejci469aab82012-07-22 18:42:20 +0200140{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100141 /* always approve */
142 return (EXIT_SUCCESS);
Radek Krejci469aab82012-07-22 18:42:20 +0200143}
144
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100145char *
Michal Vaskof35ea502016-02-24 10:44:54 +0100146netconf_callback_sshauth_passphrase(const char *UNUSED(priv_key_file))
Radek Krejci469aab82012-07-22 18:42:20 +0200147{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100148 char *buf;
149 buf = strdup(password);
150 return (buf);
Radek Krejci469aab82012-07-22 18:42:20 +0200151}
152
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100153char *
154netconf_callback_sshauth_password(const char *UNUSED(username), const char *UNUSED(hostname))
Radek Krejci469aab82012-07-22 18:42:20 +0200155{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100156 char *buf;
157 buf = strdup(password);
158 return (buf);
Radek Krejci469aab82012-07-22 18:42:20 +0200159}
160
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100161char *
162netconf_callback_sshauth_interactive(const char *UNUSED(name), const char *UNUSED(instruction),
163 const char *UNUSED(prompt), int UNUSED(echo))
Tomas Cejkab34b7b12015-06-21 22:54:11 +0200164{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100165 char *buf;
166 buf = strdup(password);
167 return (buf);
Tomas Cejkab34b7b12015-06-21 22:54:11 +0200168}
169
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100170void
Michal Vasko56c02b22016-04-06 09:59:09 +0200171netconf_callback_error_process(const char *message)
Radek Krejcic11fd862012-07-26 12:41:21 +0200172{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100173 json_object **err_reply_p = (json_object **) pthread_getspecific(err_reply_key);
174 if (err_reply_p == NULL) {
175 ERROR("Error message was not allocated. %s", __func__);
176 return;
177 }
178 json_object *err_reply = *err_reply_p;
Tomas Cejkaedb3ab42014-03-27 15:04:00 +0100179
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100180 json_object *array = NULL;
181 if (err_reply == NULL) {
182 ERROR("error calback: empty error list");
183 pthread_mutex_lock(&json_lock);
184 err_reply = json_object_new_object();
185 array = json_object_new_array();
186 json_object_object_add(err_reply, "type", json_object_new_int(REPLY_ERROR));
187 json_object_object_add(err_reply, "errors", array);
188 if (message != NULL) {
189 json_object_array_add(array, json_object_new_string(message));
190 }
191 pthread_mutex_unlock(&json_lock);
192 (*err_reply_p) = err_reply;
193 } else {
194 ERROR("error calback: nonempty error list");
195 pthread_mutex_lock(&json_lock);
196 if (json_object_object_get_ex(err_reply, "errors", &array) == TRUE) {
197 if (message != NULL) {
198 json_object_array_add(array, json_object_new_string(message));
199 }
200 }
201 pthread_mutex_unlock(&json_lock);
202 }
203 pthread_setspecific(err_reply_key, err_reply_p);
204 return;
Radek Krejcic11fd862012-07-26 12:41:21 +0200205}
206
Tomas Cejka47387fd2013-06-10 20:37:46 +0200207/**
208 * should be used in locked area
209 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100210void
211prepare_status_message(struct session_with_mutex *s, struct nc_session *session)
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200212{
Michal Vaskof35ea502016-02-24 10:44:54 +0100213 int i;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100214 json_object *json_obj = NULL;
215 json_object *js_tmp = NULL;
216 char *old_sid = NULL;
217 const char *j_old_sid = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +0100218 char str_port[6];
219 const char **cpblts;
220 struct lyd_node *yanglib, *module, *node;
Tomas Cejkaf38a54c2013-05-27 21:57:35 +0200221
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100222 if (s == NULL) {
223 ERROR("No session given.");
224 return;
225 }
Tomas Cejka8a82dab2013-05-30 23:37:23 +0200226
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100227 pthread_mutex_lock(&json_lock);
228 if (s->hello_message != NULL) {
229 ERROR("clean previous hello message");
230 if (json_object_object_get_ex(s->hello_message, "sid", &js_tmp) == TRUE) {
231 j_old_sid = json_object_get_string(js_tmp);
232 if (j_old_sid != NULL) {
233 old_sid = strdup(j_old_sid);
234 }
235 }
236 json_object_put(s->hello_message);
237 s->hello_message = NULL;
238 }
239 s->hello_message = json_object_new_object();
240 if (session != NULL) {
Michal Vaskof35ea502016-02-24 10:44:54 +0100241 if (!old_sid) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100242 /* we don't have old sid */
Michal Vaskof35ea502016-02-24 10:44:54 +0100243 asprintf(&old_sid, "%u", nc_session_get_id(session));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100244 }
Michal Vaskof35ea502016-02-24 10:44:54 +0100245 json_object_object_add(s->hello_message, "sid", json_object_new_string(old_sid));
246 free(old_sid);
247 old_sid = NULL;
248
249 json_object_object_add(s->hello_message, "version", json_object_new_string((nc_session_get_version(session) ? "1.1":"1.0")));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100250 json_object_object_add(s->hello_message, "host", json_object_new_string(nc_session_get_host(session)));
Michal Vaskof35ea502016-02-24 10:44:54 +0100251 sprintf(str_port, "%u", nc_session_get_port(session));
252 json_object_object_add(s->hello_message, "port", json_object_new_string(str_port));
253 json_object_object_add(s->hello_message, "user", json_object_new_string(nc_session_get_username(session)));
254 cpblts = nc_session_get_cpblts(session);
255 if (cpblts) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100256 json_obj = json_object_new_array();
Michal Vaskof35ea502016-02-24 10:44:54 +0100257 for (i = 0; cpblts[i]; ++i) {
258 json_object_array_add(json_obj, json_object_new_string(cpblts[i]));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100259 }
260 json_object_object_add(s->hello_message, "capabilities", json_obj);
261 }
Michal Vaskof35ea502016-02-24 10:44:54 +0100262
263 yanglib = ly_ctx_info(nc_session_get_ctx(session));
264 if (yanglib) {
265 json_obj = json_object_new_array();
266 LY_TREE_FOR(yanglib->child, module) {
267 if (!strcmp(module->schema->name, "module")) {
268 LY_TREE_FOR(module->child, node) {
269 if (!strcmp(node->schema->name, "name")) {
270 json_object_array_add(json_obj, json_object_new_string(((struct lyd_node_leaf_list *)node)->value_str));
271 break;
272 }
273 }
274 }
275 }
276 json_object_object_add(s->hello_message, "models", json_obj);
277
Michal Vaskoc04900a2016-03-15 16:20:24 +0100278 lyd_free(yanglib);
Michal Vaskof35ea502016-02-24 10:44:54 +0100279 }
280
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100281 DEBUG("%s", json_object_to_json_string(s->hello_message));
282 } else {
283 ERROR("Session was not given.");
284 json_object_object_add(s->hello_message, "type", json_object_new_int(REPLY_ERROR));
285 json_object_object_add(s->hello_message, "error-message", json_object_new_string("Invalid session identifier."));
286 }
287 DEBUG("Status info from hello message prepared");
288 pthread_mutex_unlock(&json_lock);
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200289}
290
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100291void
292create_err_reply_p()
Tomas Cejka442258e2014-04-01 18:17:18 +0200293{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100294 json_object **err_reply = calloc(1, sizeof(json_object **));
295 if (err_reply == NULL) {
296 ERROR("Allocation of err_reply storage failed!");
297 return;
298 }
299 if (pthread_setspecific(err_reply_key, err_reply) != 0) {
300 ERROR("cannot set thread-specific value.");
301 }
Tomas Cejka442258e2014-04-01 18:17:18 +0200302}
303
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100304void
305clean_err_reply()
Tomas Cejka442258e2014-04-01 18:17:18 +0200306{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100307 json_object **err_reply = (json_object **) pthread_getspecific(err_reply_key);
308 if (err_reply != NULL) {
309 if (*err_reply != NULL) {
310 pthread_mutex_lock(&json_lock);
311 json_object_put(*err_reply);
312 pthread_mutex_unlock(&json_lock);
Michal Vasko59a43052016-04-13 10:23:12 +0200313 *err_reply = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100314 }
315 if (pthread_setspecific(err_reply_key, err_reply) != 0) {
316 ERROR("Cannot set thread-specific hash value.");
317 }
318 }
Tomas Cejka442258e2014-04-01 18:17:18 +0200319}
320
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100321void
322free_err_reply()
Tomas Cejka442258e2014-04-01 18:17:18 +0200323{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100324 json_object **err_reply = (json_object **) pthread_getspecific(err_reply_key);
325 if (err_reply != NULL) {
326 if (*err_reply != NULL) {
327 pthread_mutex_lock(&json_lock);
328 json_object_put(*err_reply);
329 pthread_mutex_unlock(&json_lock);
330 }
331 free(err_reply);
332 err_reply = NULL;
333 if (pthread_setspecific(err_reply_key, err_reply) != 0) {
334 ERROR("Cannot set thread-specific hash value.");
335 }
336 }
337}
338
339static struct session_with_mutex *
340session_get_locked(unsigned int session_key, json_object **err)
341{
342 struct session_with_mutex *locked_session;
343
344 /* get non-exclusive (read) access to sessions_list (conns) */
345 DEBUG("LOCK wrlock %s", __func__);
346 if (pthread_rwlock_rdlock(&session_lock) != 0) {
347 if (*err) {
348 *err = create_error_reply("Locking failed.");
349 }
350 return NULL;
351 }
352 /* get session where send the RPC */
353 for (locked_session = netconf_sessions_list;
354 locked_session && (locked_session->session_key != session_key);
355 locked_session = locked_session->next);
356 if (!locked_session) {
357 if (*err) {
358 *err = create_error_reply("Session not found.");
359 }
360 return NULL;
361 }
362
363 /* get exclusive access to session */
364 DEBUG("LOCK mutex %s", __func__);
365 if (pthread_mutex_lock(&locked_session->lock) != 0) {
366 if (*err) {
367 *err = create_error_reply("Locking failed.");
368 }
369 goto wrlock_fail;
370 }
371 return locked_session;
372
373wrlock_fail:
374 DEBUG("UNLOCK wrlock %s", __func__);
375 pthread_rwlock_unlock(&session_lock);
376 return NULL;
377}
378
379static void
Michal Vaskoe32bcba2015-11-24 09:05:51 +0100380session_user_activity(const char *username)
381{
382 struct session_with_mutex *sess;
383
384 for (sess = netconf_sessions_list; sess; sess = sess->next) {
Michal Vaskof35ea502016-02-24 10:44:54 +0100385 if (!strcmp(nc_session_get_username(sess->session), username)) {
Michal Vaskoe32bcba2015-11-24 09:05:51 +0100386 sess->last_activity = time(NULL);
387 }
388 }
389}
390
391static void
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100392session_unlock(struct session_with_mutex *locked_session)
393{
394 DEBUG("UNLOCK mutex %s", __func__);
395 pthread_mutex_unlock(&locked_session->lock);
396 DEBUG("UNLOCK wrlock %s", __func__);
397 pthread_rwlock_unlock(&session_lock);
Tomas Cejka442258e2014-04-01 18:17:18 +0200398}
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200399
Michal Vasko3fda9a92015-11-23 10:10:57 +0100400static void
401node_metadata_text(const char *text, const char *name, json_object *parent)
402{
403 json_object *obj;
404
405 if (!text) {
406 return;
407 }
408
409 obj = json_object_new_string(text);
410 json_object_object_add(parent, name, obj);
411}
412
413static void
414node_metadata_restr(struct lys_restr *restr, const char *name, json_object *parent)
415{
416 json_object *obj;
417
418 if (!restr) {
419 return;
420 }
421
422 obj = json_object_new_string(restr->expr);
423 json_object_object_add(parent, name, obj);
424}
425
426static void
427node_metadata_must(uint8_t must_size, struct lys_restr *must, json_object *parent)
428{
429 uint8_t i;
430 json_object *array, *obj;
431
432 if (!must_size || !must) {
433 return;
434 }
435
436 array = json_object_new_array();
437
438 for (i = 0; i < must_size; ++i) {
439 obj = json_object_new_string(must[i].expr);
440 json_object_array_add(array, obj);
441 }
442
443 json_object_object_add(parent, "must", array);
444}
445
446static void
447node_metadata_basic(struct lys_node *node, json_object *parent)
448{
449 json_object *obj;
450
451 /* description */
452 node_metadata_text(node->dsc, "description", parent);
453
454 /* reference */
455 node_metadata_text(node->ref, "reference", parent);
456
457 /* config */
458 if (node->flags & LYS_CONFIG_R) {
459 obj = json_object_new_boolean(0);
460 } else {
461 obj = json_object_new_boolean(1);
462 }
463 json_object_object_add(parent, "config", obj);
464
465 /* status */
466 if (node->flags & LYS_STATUS_DEPRC) {
467 obj = json_object_new_string("deprecated");
468 } else if (node->flags & LYS_STATUS_OBSLT) {
469 obj = json_object_new_string("obsolete");
470 } else {
471 obj = json_object_new_string("current");
472 }
473 json_object_object_add(parent, "status", obj);
474
475 /* mandatory */
476 if (node->flags & LYS_MAND_TRUE) {
477 obj = json_object_new_boolean(1);
478 } else {
479 obj = json_object_new_boolean(0);
480 }
481 json_object_object_add(parent, "mandatory", obj);
482
483 /* NACM extensions */
484 if (node->nacm) {
485 if (node->nacm & LYS_NACM_DENYW) {
486 obj = json_object_new_string("default-deny-write");
487 } else {
488 obj = json_object_new_string("default-deny-all");
489 }
490 json_object_object_add(parent, "ext", obj);
491 }
492}
493
494static void
495node_metadata_when(struct lys_when *when, json_object *parent)
496{
497 json_object *obj;
498
499 if (!when) {
500 return;
501 }
502
503 obj = json_object_new_string(when->cond);
504 json_object_object_add(parent, "when", obj);
505}
506
507static void
Michal Vaskoa45770b2015-11-23 15:49:41 +0100508node_metadata_children_recursive(struct lys_node *node, json_object **child_array, json_object **choice_array)
Michal Vasko3fda9a92015-11-23 10:10:57 +0100509{
Michal Vaskoa45770b2015-11-23 15:49:41 +0100510 json_object *obj;
Michal Vasko3fda9a92015-11-23 10:10:57 +0100511 struct lys_node *child;
512
513 if (!node->child) {
514 return;
515 }
516
517 LY_TREE_FOR(node->child, child) {
Michal Vaskoa45770b2015-11-23 15:49:41 +0100518 if (child->nodetype == LYS_USES) {
519 node_metadata_children_recursive(child, child_array, choice_array);
520 } else if (child->nodetype & (LYS_CONTAINER | LYS_LEAF | LYS_LEAFLIST | LYS_LIST | LYS_ANYXML)) {
Michal Vasko3fda9a92015-11-23 10:10:57 +0100521 obj = json_object_new_string(child->name);
Michal Vaskoa45770b2015-11-23 15:49:41 +0100522 if (!*child_array) {
523 *child_array = json_object_new_array();
Michal Vasko3fda9a92015-11-23 10:10:57 +0100524 }
Michal Vaskoa45770b2015-11-23 15:49:41 +0100525 json_object_array_add(*child_array, obj);
Michal Vasko3fda9a92015-11-23 10:10:57 +0100526 } else if (child->nodetype == LYS_CHOICE) {
527 obj = json_object_new_string(child->name);
Michal Vaskoa45770b2015-11-23 15:49:41 +0100528 if (!*choice_array) {
529 *choice_array = json_object_new_array();
Michal Vasko3fda9a92015-11-23 10:10:57 +0100530 }
Michal Vaskoa45770b2015-11-23 15:49:41 +0100531 json_object_array_add(*choice_array, obj);
Michal Vasko3fda9a92015-11-23 10:10:57 +0100532 }
533 }
Michal Vasko3fda9a92015-11-23 10:10:57 +0100534}
535
536static void
Michal Vaskoa45770b2015-11-23 15:49:41 +0100537node_metadata_cases_recursive(struct lys_node_choice *choice, json_object *array)
Michal Vasko3fda9a92015-11-23 10:10:57 +0100538{
Michal Vaskoa45770b2015-11-23 15:49:41 +0100539 json_object *obj;
Michal Vasko3fda9a92015-11-23 10:10:57 +0100540 struct lys_node *child;
541
542 if (!choice->child) {
543 return;
544 }
545
Michal Vasko3fda9a92015-11-23 10:10:57 +0100546 LY_TREE_FOR(choice->child, child) {
Michal Vaskoa45770b2015-11-23 15:49:41 +0100547 if (child->nodetype == LYS_USES) {
548 node_metadata_cases_recursive((struct lys_node_choice *)child, array);
549 } else if (child->nodetype & (LYS_CONTAINER | LYS_LEAF | LYS_LEAFLIST | LYS_LIST | LYS_ANYXML | LYS_CASE)) {
Michal Vasko3fda9a92015-11-23 10:10:57 +0100550 obj = json_object_new_string(child->name);
551 json_object_array_add(array, obj);
552 }
553 }
Michal Vasko3fda9a92015-11-23 10:10:57 +0100554}
555
556static void
557node_metadata_min_max(uint32_t min, uint32_t max, json_object *parent)
558{
559 json_object *obj;
560
561 if (min) {
562 obj = json_object_new_int(min);
563 json_object_object_add(parent, "min-elements", obj);
564 }
565
566 if (max) {
567 obj = json_object_new_int(max);
568 json_object_object_add(parent, "max-elements", obj);
569 }
570}
571
572static void
573node_metadata_ident_recursive(struct lys_ident *ident, json_object *array)
574{
575 struct lys_ident_der *cur;
576 json_object *obj;
577
578 if (!ident) {
579 return;
580 }
581
582 obj = json_object_new_string(ident->name);
583 json_object_array_add(array, obj);
584
585 for (cur = ident->der; cur; cur = cur->next) {
586 node_metadata_ident_recursive(cur->ident, array);
587 }
588}
589
590static void
591node_metadata_type(struct lys_type *type, struct lys_module *module, json_object *parent)
592{
593 json_object *obj, *array, *item;
594 char *str;
595 int i;
596
597 /* built-in YANG type */
598 if (!type->der->module) {
599 switch (type->base) {
600 case LY_TYPE_BINARY:
601 node_metadata_text("binary", "type", parent);
602 node_metadata_restr(type->info.binary.length, "length", parent);
603 break;
604 case LY_TYPE_BITS:
605 node_metadata_text("bits", "type", parent);
606
607 array = json_object_new_array();
608 for (i = 0; i < type->info.bits.count; ++i) {
609 item = json_object_new_object();
610 obj = json_object_new_string(type->info.bits.bit[i].name);
611 json_object_object_add(item, "name", obj);
612 obj = json_object_new_int(type->info.bits.bit[i].pos);
613 json_object_object_add(item, "position", obj);
614 json_object_array_add(array, item);
615 }
616 json_object_object_add(parent, "bits", array);
617 break;
618 case LY_TYPE_BOOL:
619 node_metadata_text("bool", "type", parent);
620 break;
621 case LY_TYPE_DEC64:
622 node_metadata_text("decimal64", "type", parent);
623 node_metadata_restr(type->info.dec64.range, "range", parent);
624 obj = json_object_new_int(type->info.dec64.dig);
625 json_object_object_add(parent, "fraction-digits", obj);
626 break;
627 case LY_TYPE_EMPTY:
628 node_metadata_text("empty", "type", parent);
629 break;
630 case LY_TYPE_ENUM:
631 node_metadata_text("enumeration", "type", parent);
632
633 array = json_object_new_array();
634 for (i = 0; i < type->info.enums.count; ++i) {
635 obj = json_object_new_string(type->info.enums.enm[i].name);
636 json_object_array_add(array, obj);
637 }
638 json_object_object_add(parent, "enumval", array);
639 break;
640 case LY_TYPE_IDENT:
641 node_metadata_text("identityref", "type", parent);
642
643 array = json_object_new_array();
644 node_metadata_ident_recursive(type->info.ident.ref, array);
645 json_object_object_add(parent, "identityval", array);
646 break;
647 case LY_TYPE_INST:
648 node_metadata_text("instance-identifier", "type", parent);
649 if (type->info.inst.req == -1) {
650 obj = json_object_new_boolean(0);
651 } else {
652 obj = json_object_new_boolean(1);
653 }
654 json_object_object_add(parent, "require-instance", obj);
655 break;
656 case LY_TYPE_LEAFREF:
657 node_metadata_text("leafref", "type", parent);
658 node_metadata_text(type->info.lref.path, "path", parent);
659 break;
660 case LY_TYPE_STRING:
661 node_metadata_text("string", "type", parent);
662 node_metadata_restr(type->info.str.length, "length", parent);
663 if (type->info.str.pat_count) {
664 array = json_object_new_array();
665 for (i = 0; i < type->info.str.pat_count; ++i) {
666 obj = json_object_new_string(type->info.str.patterns[i].expr);
667 json_object_array_add(array, obj);
668 }
669 json_object_object_add(parent, "pattern", array);
670 }
671 break;
672 case LY_TYPE_UNION:
673 node_metadata_text("union", "type", parent);
674 array = json_object_new_array();
675 for (i = 0; i < type->info.uni.count; ++i) {
676 obj = json_object_new_object();
677 node_metadata_type(&type->info.uni.types[i], module, obj);
678 json_object_array_add(array, obj);
679 }
680 json_object_object_add(parent, "types", array);
681 break;
682 case LY_TYPE_INT8:
683 node_metadata_text("int8", "type", parent);
684 node_metadata_restr(type->info.num.range, "range", parent);
685 break;
686 case LY_TYPE_UINT8:
687 node_metadata_text("uint8", "type", parent);
688 node_metadata_restr(type->info.num.range, "range", parent);
689 break;
690 case LY_TYPE_INT16:
691 node_metadata_text("int16", "type", parent);
692 node_metadata_restr(type->info.num.range, "range", parent);
693 break;
694 case LY_TYPE_UINT16:
695 node_metadata_text("uint16", "type", parent);
696 node_metadata_restr(type->info.num.range, "range", parent);
697 break;
698 case LY_TYPE_INT32:
699 node_metadata_text("int32", "type", parent);
700 node_metadata_restr(type->info.num.range, "range", parent);
701 break;
702 case LY_TYPE_UINT32:
703 node_metadata_text("uint32", "type", parent);
704 node_metadata_restr(type->info.num.range, "range", parent);
705 break;
706 case LY_TYPE_INT64:
707 node_metadata_text("int64", "type", parent);
708 node_metadata_restr(type->info.num.range, "range", parent);
709 break;
710 case LY_TYPE_UINT64:
711 node_metadata_text("uint64", "type", parent);
712 node_metadata_restr(type->info.num.range, "range", parent);
713 break;
714 default:
715 ERROR("Internal: unknown type (%s:%d)", __FILE__, __LINE__);
716 break;
717 }
718
719 /* typedef */
720 } else {
721 if (!module || !type->module_name || !strcmp(type->module_name, module->name)) {
722 node_metadata_text(type->der->name, "type", parent);
723 } else {
724 asprintf(&str, "%s:%s", type->module_name, type->der->name);
725 node_metadata_text(str, "type", parent);
726 free(str);
727 }
728 obj = json_object_new_object();
729 node_metadata_typedef(type->der, obj);
730 json_object_object_add(parent, "typedef", obj);
731 }
732}
733
734static void
735node_metadata_typedef(struct lys_tpdf *tpdf, json_object *parent)
736{
737 json_object *obj;
738
739 /* description */
740 node_metadata_text(tpdf->dsc, "description", parent);
741
742 /* reference */
743 node_metadata_text(tpdf->ref, "reference", parent);
744
745 /* status */
746 if (tpdf->flags & LYS_STATUS_DEPRC) {
747 obj = json_object_new_string("deprecated");
748 } else if (tpdf->flags & LYS_STATUS_OBSLT) {
749 obj = json_object_new_string("obsolete");
750 } else {
751 obj = json_object_new_string("current");
752 }
753 json_object_object_add(parent, "status", obj);
754
755 /* type */
756 node_metadata_type(&tpdf->type, tpdf->module, parent);
757
758 /* units */
759 node_metadata_text(tpdf->units, "units", parent);
760
761 /* default */
762 node_metadata_text(tpdf->dflt, "default", parent);
763}
764
765static void
766node_metadata_container(struct lys_node_container *cont, json_object *parent)
767{
Michal Vaskoa45770b2015-11-23 15:49:41 +0100768 json_object *obj, *child_array = NULL, *choice_array = NULL;
Michal Vasko3fda9a92015-11-23 10:10:57 +0100769
770 /* element type */
771 obj = json_object_new_string("container");
772 json_object_object_add(parent, "eltype", obj);
773
774 /* shared info */
775 node_metadata_basic((struct lys_node *)cont, parent);
776
777 /* must */
778 node_metadata_must(cont->must_size, cont->must, parent);
779
780 /* presence */
781 node_metadata_text(cont->presence, "presence", parent);
782
783 /* when */
784 node_metadata_when(cont->when, parent);
785
786 /* children & choice */
Michal Vaskoa45770b2015-11-23 15:49:41 +0100787 node_metadata_children_recursive((struct lys_node *)cont, &child_array, &choice_array);
788 if (child_array) {
789 json_object_object_add(parent, "children", child_array);
790 }
791 if (choice_array) {
792 json_object_object_add(parent, "choice", choice_array);
793 }
Michal Vasko3fda9a92015-11-23 10:10:57 +0100794}
795
796static void
797node_metadata_choice(struct lys_node_choice *choice, json_object *parent)
798{
Michal Vaskoa45770b2015-11-23 15:49:41 +0100799 json_object *obj, *array;
Michal Vasko3fda9a92015-11-23 10:10:57 +0100800
801 /* element type */
802 obj = json_object_new_string("choice");
803 json_object_object_add(parent, "eltype", obj);
804
805 /* shared info */
806 node_metadata_basic((struct lys_node *)choice, parent);
807
808 /* default */
Michal Vasko5e1c6052016-03-17 15:43:33 +0100809 if (choice->dflt) {
810 node_metadata_text(choice->dflt->name, "default", parent);
811 }
Michal Vasko3fda9a92015-11-23 10:10:57 +0100812
813 /* when */
814 node_metadata_when(choice->when, parent);
815
816 /* cases */
Michal Vaskoa45770b2015-11-23 15:49:41 +0100817 if (choice->child) {
818 array = json_object_new_array();
819 node_metadata_cases_recursive(choice, array);
820 json_object_object_add(parent, "cases", array);
821 }
Michal Vasko3fda9a92015-11-23 10:10:57 +0100822}
823
824static void
825node_metadata_leaf(struct lys_node_leaf *leaf, json_object *parent)
826{
827 json_object *obj;
828 struct lys_node_list *list;
829 int is_key, i;
830
831 /* element type */
832 obj = json_object_new_string("leaf");
833 json_object_object_add(parent, "eltype", obj);
834
835 /* shared info */
836 node_metadata_basic((struct lys_node *)leaf, parent);
837
838 /* type */
839 node_metadata_type(&leaf->type, leaf->module, parent);
840
841 /* units */
842 node_metadata_text(leaf->units, "units", parent);
843
844 /* default */
845 node_metadata_text(leaf->dflt, "default", parent);
846
847 /* must */
848 node_metadata_must(leaf->must_size, leaf->must, parent);
849
850 /* when */
851 node_metadata_when(leaf->when, parent);
852
853 /* iskey */
854 is_key = 0;
855 list = (struct lys_node_list *)lys_parent((struct lys_node *)leaf);
856 if (list && (list->nodetype == LYS_LIST)) {
857 for (i = 0; i < list->keys_size; ++i) {
858 if (list->keys[i] == leaf) {
859 is_key = 1;
860 break;
861 }
862 }
863 }
864 obj = json_object_new_boolean(is_key);
865 json_object_object_add(parent, "iskey", obj);
866}
867
868static void
869node_metadata_leaflist(struct lys_node_leaflist *llist, json_object *parent)
870{
871 json_object *obj;
872
873 /* element type */
874 obj = json_object_new_string("leaf-list");
875 json_object_object_add(parent, "eltype", obj);
876
877 /* shared info */
878 node_metadata_basic((struct lys_node *)llist, parent);
879
880 /* type */
881 node_metadata_type(&llist->type, llist->module, parent);
882
883 /* units */
884 node_metadata_text(llist->units, "units", parent);
885
886 /* must */
887 node_metadata_must(llist->must_size, llist->must, parent);
888
889 /* when */
890 node_metadata_when(llist->when, parent);
891
892 /* min/max-elements */
893 node_metadata_min_max(llist->min, llist->max, parent);
894}
895
896static void
897node_metadata_list(struct lys_node_list *list, json_object *parent)
898{
Michal Vaskoa45770b2015-11-23 15:49:41 +0100899 json_object *obj, *array, *child_array = NULL, *choice_array = NULL;;
Michal Vasko3fda9a92015-11-23 10:10:57 +0100900 int i;
901 unsigned int j;
902
903 /* element type */
904 obj = json_object_new_string("list");
905 json_object_object_add(parent, "eltype", obj);
906
907 /* shared info */
908 node_metadata_basic((struct lys_node *)list, parent);
909
910 /* must */
911 node_metadata_must(list->must_size, list->must, parent);
912
913 /* when */
914 node_metadata_when(list->when, parent);
915
916 /* min/max-elements */
917 node_metadata_min_max(list->min, list->max, parent);
918
919 /* keys */
920 if (list->keys_size) {
921 array = json_object_new_array();
922 for (i = 0; i < list->keys_size; ++i) {
923 obj = json_object_new_string(list->keys[i]->name);
924 json_object_array_add(array, obj);
925 }
926 json_object_object_add(parent, "keys", array);
927 }
928
929 /* unique */
930 if (list->unique_size) {
931 array = json_object_new_array();
932 for (i = 0; i < list->unique_size; ++i) {
933 for (j = 0; j < list->unique[i].expr_size; ++j) {
934 obj = json_object_new_string(list->unique[i].expr[j]);
935 json_object_array_add(array, obj);
936 }
937 }
938 json_object_object_add(parent, "unique", array);
939 }
Michal Vaskoa45770b2015-11-23 15:49:41 +0100940
941 /* children & choice */
942 node_metadata_children_recursive((struct lys_node *)list, &child_array, &choice_array);
943 if (child_array) {
944 json_object_object_add(parent, "children", child_array);
945 }
946 if (choice_array) {
947 json_object_object_add(parent, "choice", choice_array);
948 }
Michal Vasko3fda9a92015-11-23 10:10:57 +0100949}
950
951static void
952node_metadata_anyxml(struct lys_node_anyxml *anyxml, json_object *parent)
953{
954 json_object *obj;
955
956 /* element type */
957 obj = json_object_new_string("anyxml");
958 json_object_object_add(parent, "eltype", obj);
959
960 /* shared info */
961 node_metadata_basic((struct lys_node *)anyxml, parent);
962
963 /* must */
964 node_metadata_must(anyxml->must_size, anyxml->must, parent);
965
966 /* when */
967 node_metadata_when(anyxml->when, parent);
968
969}
970
971static void
972node_metadata_case(struct lys_node_case *cas, json_object *parent)
973{
974 json_object *obj;
975
976 /* element type */
977 obj = json_object_new_string("case");
978 json_object_object_add(parent, "eltype", obj);
979
980 /* shared info */
981 node_metadata_basic((struct lys_node *)cas, parent);
982
983 /* when */
984 node_metadata_when(cas->when, parent);
985}
986
Michal Vaskoa45770b2015-11-23 15:49:41 +0100987static void
988node_metadata_rpc(struct lys_node_rpc *rpc, json_object *parent)
989{
990 json_object *obj;
991
992 /* element type */
993 obj = json_object_new_string("rpc");
994 json_object_object_add(parent, "eltype", obj);
995
996 /* description */
997 node_metadata_text(rpc->dsc, "description", parent);
998
999 /* reference */
1000 node_metadata_text(rpc->ref, "reference", parent);
1001
1002 /* status */
1003 if (rpc->flags & LYS_STATUS_DEPRC) {
1004 obj = json_object_new_string("deprecated");
1005 } else if (rpc->flags & LYS_STATUS_OBSLT) {
1006 obj = json_object_new_string("obsolete");
1007 } else {
1008 obj = json_object_new_string("current");
1009 }
1010 json_object_object_add(parent, "status", obj);
1011}
1012
1013static void
Michal Vaskof35ea502016-02-24 10:44:54 +01001014node_metadata_model(const struct lys_module *module, json_object *parent)
Michal Vaskoa45770b2015-11-23 15:49:41 +01001015{
1016 json_object *obj, *array, *item;
Michal Vaskoa4b8cdb2016-03-17 15:44:45 +01001017 const struct lys_node *node;
Michal Vaskoa45770b2015-11-23 15:49:41 +01001018 int i;
1019
1020 /* yang-version */
1021 if (module->version == 2) {
1022 obj = json_object_new_string("1.1");
1023 } else {
1024 obj = json_object_new_string("1.0");
1025 }
1026 json_object_object_add(parent, "yang-version", obj);
1027
1028 /* namespace */
1029 node_metadata_text(module->ns, "namespace", parent);
1030
1031 /* prefix */
1032 node_metadata_text(module->prefix, "prefix", parent);
1033
1034 /* contact */
1035 node_metadata_text(module->contact, "contact", parent);
1036
1037 /* organization */
1038 node_metadata_text(module->org, "organization", parent);
1039
1040 /* revision */
1041 if (module->rev_size) {
1042 node_metadata_text(module->rev[0].date, "revision", parent);
1043 }
1044
1045 /* description */
1046 node_metadata_text(module->dsc, "description", parent);
1047
1048 /* import */
1049 if (module->imp_size) {
1050 array = json_object_new_array();
1051 for (i = 0; i < module->imp_size; ++i) {
1052 item = json_object_new_object();
1053
1054 node_metadata_text(module->imp[i].module->name, "name", item);
1055 node_metadata_text(module->imp[i].prefix, "prefix", item);
1056 if (module->imp[i].rev && module->imp[i].rev[0]) {
1057 node_metadata_text(module->imp[i].rev, "revision", item);
1058 }
1059
1060 json_object_array_add(array, item);
1061 }
1062 json_object_object_add(parent, "imports", array);
1063 }
1064
1065 /* include */
1066 if (module->inc_size) {
1067 array = json_object_new_array();
1068 for (i = 0; i < module->inc_size; ++i) {
1069 item = json_object_new_object();
1070
1071 node_metadata_text(module->inc[i].submodule->name, "name", item);
1072 if (module->inc[i].rev && module->inc[i].rev[0]) {
1073 node_metadata_text(module->inc[i].rev, "revision", item);
1074 }
1075
1076 json_object_array_add(array, item);
1077 }
1078 json_object_object_add(parent, "includes", array);
1079 }
Michal Vaskoa4b8cdb2016-03-17 15:44:45 +01001080
1081 /* top-nodes */
1082 node = NULL;
1083 array = NULL;
1084 while ((node = lys_getnext(node, NULL, module, LYS_GETNEXT_WITHCHOICE))) {
1085 if (node->nodetype & (LYS_RPC | LYS_NOTIF)) {
1086 continue;
1087 }
1088 if (!array) {
1089 array = json_object_new_array();
1090 }
1091 item = json_object_new_string(node->name);
1092 json_object_array_add(array, item);
1093 }
1094 if (array) {
1095 json_object_object_add(parent, "top-nodes", array);
1096 }
Michal Vaskoa45770b2015-11-23 15:49:41 +01001097}
1098
Tomas Cejka0a4bba82013-04-19 11:51:28 +02001099/**
1100 * \defgroup netconf_operations NETCONF operations
1101 * The list of NETCONF operations that mod_netconf supports.
1102 * @{
1103 */
1104
1105/**
Tomas Cejka8ce138c2015-04-27 23:25:25 +02001106 * \brief Send RPC and wait for reply with timeout.
1107 *
1108 * \param[in] session libnetconf session
1109 * \param[in] rpc prepared RPC message
1110 * \param[in] timeout timeout in miliseconds, -1 for blocking, 0 for non-blocking
1111 * \param[out] reply reply from the server
Michal Vaskof35ea502016-02-24 10:44:54 +01001112 * \return NC_MSG_WOULDBLOCK or NC_MSG_ERROR.
Tomas Cejka8ce138c2015-04-27 23:25:25 +02001113 * On success, it returns NC_MSG_REPLY.
1114 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001115NC_MSG_TYPE
Michal Vaskof35ea502016-02-24 10:44:54 +01001116netconf_send_recv_timed(struct nc_session *session, struct nc_rpc *rpc, int timeout, int strict, struct nc_reply **reply)
Tomas Cejka8ce138c2015-04-27 23:25:25 +02001117{
Michal Vaskof35ea502016-02-24 10:44:54 +01001118 uint64_t msgid;
1119 NC_MSG_TYPE ret;
1120 ret = nc_send_rpc(session, rpc, timeout, &msgid);
1121 if (ret != NC_MSG_RPC) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001122 return ret;
1123 }
Michal Vaskof35ea502016-02-24 10:44:54 +01001124
1125 while ((ret = nc_recv_reply(session, rpc, msgid, timeout, (strict ? LYD_OPT_STRICT : 0), reply)) == NC_MSG_NOTIF);
1126
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001127 return ret;
1128}
1129
Tomas Cejka8ce138c2015-04-27 23:25:25 +02001130/**
Tomas Cejka0a4bba82013-04-19 11:51:28 +02001131 * \brief Connect to NETCONF server
1132 *
1133 * \warning Session_key hash is not bound with caller identification. This could be potential security risk.
1134 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001135static unsigned int
Michal Vaskof35ea502016-02-24 10:44:54 +01001136netconf_connect(const char *host, const char *port, const char *user, const char *pass, const char *privkey)
Radek Krejci469aab82012-07-22 18:42:20 +02001137{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001138 struct nc_session* session = NULL;
1139 struct session_with_mutex *locked_session, *last_session;
Michal Vaskoda5ccc82015-11-25 10:42:49 +01001140 char *pubkey;
Radek Krejci469aab82012-07-22 18:42:20 +02001141
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001142 /* connect to the requested NETCONF server */
1143 password = (char*)pass;
Michal Vaskoda5ccc82015-11-25 10:42:49 +01001144 if (privkey) {
Michal Vaskof35ea502016-02-24 10:44:54 +01001145 nc_client_ssh_set_auth_pref(NC_SSH_AUTH_PUBLICKEY, 3);
Michal Vaskoda5ccc82015-11-25 10:42:49 +01001146 asprintf(&pubkey, "%s.pub", privkey);
Michal Vaskof35ea502016-02-24 10:44:54 +01001147 nc_client_ssh_add_keypair(pubkey, privkey);
Michal Vaskoda5ccc82015-11-25 10:42:49 +01001148 free(pubkey);
1149 }
Michal Vaskof35ea502016-02-24 10:44:54 +01001150 nc_client_ssh_set_username(user);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001151 DEBUG("prepare to connect %s@%s:%s", user, host, port);
Michal Vaskof35ea502016-02-24 10:44:54 +01001152 session = nc_connect_ssh(host, (unsigned short)atoi(port), NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001153 DEBUG("nc_session_connect done");
David Kupka8e60a372012-09-04 09:15:20 +02001154
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001155 /* if connected successful, add session to the list */
1156 if (session != NULL) {
1157 if ((locked_session = calloc(1, sizeof(struct session_with_mutex))) == NULL || pthread_mutex_init (&locked_session->lock, NULL) != 0) {
Michal Vaskoa9590052016-03-08 10:12:24 +01001158 nc_session_free(session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001159 session = NULL;
1160 free(locked_session);
1161 locked_session = NULL;
1162 ERROR("Creating structure session_with_mutex failed %d (%s)", errno, strerror(errno));
1163 return 0;
1164 }
1165 locked_session->session = session;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001166 locked_session->hello_message = NULL;
1167 locked_session->closed = 0;
1168 pthread_mutex_init(&locked_session->lock, NULL);
1169 DEBUG("Before session_lock");
1170 /* get exclusive access to sessions_list (conns) */
1171 DEBUG("LOCK wrlock %s", __func__);
1172 if (pthread_rwlock_wrlock(&session_lock) != 0) {
Michal Vaskoa9590052016-03-08 10:12:24 +01001173 nc_session_free(session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001174 free(locked_session);
1175 ERROR("Error while locking rwlock: %d (%s)", errno, strerror(errno));
1176 return 0;
1177 }
1178 locked_session->ntfc_subscribed = 0;
1179 DEBUG("Add connection to the list");
1180 if (!netconf_sessions_list) {
Michal Vaskoc3146782015-11-04 14:46:41 +01001181 netconf_sessions_list = locked_session;
1182 } else {
1183 for (last_session = netconf_sessions_list; last_session->next; last_session = last_session->next);
1184 last_session->next = locked_session;
1185 locked_session->prev = last_session;
1186 }
Michal Vaskof35ea502016-02-24 10:44:54 +01001187 session_user_activity(nc_session_get_username(locked_session->session));
Tomas Cejka45ab59f2013-05-15 00:10:49 +02001188
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001189 /* no need to lock session, noone can read it while we have wrlock */
Tomas Cejka47387fd2013-06-10 20:37:46 +02001190
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001191 /* store information about session from hello message for future usage */
1192 prepare_status_message(locked_session, session);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001193
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001194 DEBUG("NETCONF session established");
1195 locked_session->session_key = session_key_generator;
1196 ++session_key_generator;
1197 if (session_key_generator == UINT_MAX) {
1198 session_key_generator = 1;
1199 }
Tomas Cejka47387fd2013-06-10 20:37:46 +02001200
Michal Vaskoe32bcba2015-11-24 09:05:51 +01001201 DEBUG("Before session_unlock");
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001202 /* unlock session list */
1203 DEBUG("UNLOCK wrlock %s", __func__);
1204 if (pthread_rwlock_unlock(&session_lock) != 0) {
1205 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
1206 }
Radek Krejci469aab82012-07-22 18:42:20 +02001207
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001208 return locked_session->session_key;
1209 }
1210
1211 ERROR("Connection could not be established");
1212 return 0;
Radek Krejci469aab82012-07-22 18:42:20 +02001213}
1214
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001215static int
1216close_and_free_session(struct session_with_mutex *locked_session)
Radek Krejci469aab82012-07-22 18:42:20 +02001217{
Michal Vaskoa53ef882015-11-24 11:02:01 +01001218 int i;
1219
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001220 DEBUG("LOCK mutex %s", __func__);
1221 if (pthread_mutex_lock(&locked_session->lock) != 0) {
1222 ERROR("Error while locking rwlock");
1223 }
1224 locked_session->ntfc_subscribed = 0;
1225 locked_session->closed = 1;
1226 if (locked_session->session != NULL) {
Michal Vaskoa9590052016-03-08 10:12:24 +01001227 nc_session_free(locked_session->session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001228 locked_session->session = NULL;
1229 }
1230 DEBUG("session closed.");
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001231 DEBUG("UNLOCK mutex %s", __func__);
1232 if (pthread_mutex_unlock(&locked_session->lock) != 0) {
1233 ERROR("Error while locking rwlock");
1234 }
Tomas Cejka47387fd2013-06-10 20:37:46 +02001235
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001236 DEBUG("closed session, disabled notif(?), wait 0.5s");
1237 usleep(500000); /* let notification thread stop */
Tomas Cejka47387fd2013-06-10 20:37:46 +02001238
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001239 /* session shouldn't be used by now */
Michal Vaskoa53ef882015-11-24 11:02:01 +01001240 for (i = 0; i < locked_session->notif_count; ++i) {
1241 free(locked_session->notifications[i].content);
1242 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001243 free(locked_session->notifications);
1244 pthread_mutex_destroy(&locked_session->lock);
1245 if (locked_session->hello_message != NULL) {
1246 json_object_put(locked_session->hello_message);
1247 locked_session->hello_message = NULL;
1248 }
1249 locked_session->session = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001250 free(locked_session);
1251 locked_session = NULL;
1252 DEBUG("NETCONF session closed, everything cleared.");
1253 return (EXIT_SUCCESS);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001254}
1255
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001256static int
1257netconf_close(unsigned int session_key, json_object **reply)
Tomas Cejka47387fd2013-06-10 20:37:46 +02001258{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001259 struct session_with_mutex *locked_session;
Radek Krejci469aab82012-07-22 18:42:20 +02001260
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001261 DEBUG("Session to close: %u", session_key);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001262
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001263 /* get exclusive (write) access to sessions_list (conns) */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001264 DEBUG("LOCK wrlock %s", __func__);
Michal Vaskodc40b3a2016-04-11 14:36:16 +02001265 if (pthread_rwlock_wrlock(&session_lock) != 0) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001266 ERROR("Error while locking rwlock");
1267 (*reply) = create_error_reply("Internal: Error while locking.");
1268 return EXIT_FAILURE;
1269 }
1270 /* remove session from the active sessions list -> nobody new can now work with session */
1271 for (locked_session = netconf_sessions_list;
1272 locked_session && (locked_session->session_key != session_key);
Michal Vaskoc3146782015-11-04 14:46:41 +01001273 locked_session = locked_session->next);
1274
1275 if (!locked_session) {
Michal Vaskodc40b3a2016-04-11 14:36:16 +02001276 DEBUG("UNLOCK wrlock %s", __func__);
Michal Vasko642cad02016-03-17 12:31:18 +01001277 pthread_rwlock_unlock(&session_lock);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001278 ERROR("Could not find the session %u to close.", session_key);
1279 (*reply) = create_error_reply("Internal: Error while finding a session.");
Michal Vaskoc3146782015-11-04 14:46:41 +01001280 return EXIT_FAILURE;
1281 }
1282
1283 if (!locked_session->prev) {
1284 netconf_sessions_list = netconf_sessions_list->next;
Michal Vaskof0b6fbb2016-03-08 12:04:34 +01001285 if (netconf_sessions_list) {
1286 netconf_sessions_list->prev = NULL;
1287 }
Michal Vaskoc3146782015-11-04 14:46:41 +01001288 } else {
1289 locked_session->prev->next = locked_session->next;
1290 if (locked_session->next) {
1291 locked_session->next->prev = locked_session->prev;
1292 }
1293 }
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001294
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001295 DEBUG("UNLOCK wrlock %s", __func__);
1296 if (pthread_rwlock_unlock (&session_lock) != 0) {
1297 ERROR("Error while unlocking rwlock");
1298 (*reply) = create_error_reply("Internal: Error while unlocking.");
1299 }
Tomas Cejka47387fd2013-06-10 20:37:46 +02001300
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001301 if ((locked_session != NULL) && (locked_session->session != NULL)) {
1302 return close_and_free_session(locked_session);
1303 } else {
1304 ERROR("Unknown session to close");
1305 (*reply) = create_error_reply("Internal: Unkown session to close.");
1306 return (EXIT_FAILURE);
1307 }
1308 (*reply) = NULL;
Radek Krejci469aab82012-07-22 18:42:20 +02001309}
1310
Tomas Cejkac7929632013-10-24 19:25:15 +02001311/**
1312 * Test reply message type and return error message.
1313 *
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001314 * \param[in] session nc_session internal struct
Michal Vaskoc3146782015-11-04 14:46:41 +01001315 * \param[in] session_key session ID, 0 to disable disconnect on error
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001316 * \param[in] msgt RPC-REPLY message type
Tomas Cejkac7929632013-10-24 19:25:15 +02001317 * \param[out] data
1318 * \return NULL on success
1319 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001320json_object *
Michal Vaskof35ea502016-02-24 10:44:54 +01001321netconf_test_reply(struct nc_session *session, unsigned int session_key, NC_MSG_TYPE msgt, struct nc_reply *reply, struct lyd_node **data)
Tomas Cejkac7929632013-10-24 19:25:15 +02001322{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001323 json_object *err = NULL;
Tomas Cejkac7929632013-10-24 19:25:15 +02001324
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001325 /* process the result of the operation */
1326 switch (msgt) {
Michal Vaskof35ea502016-02-24 10:44:54 +01001327 case NC_MSG_ERROR:
1328 if (nc_session_get_status(session) != NC_STATUS_RUNNING) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001329 ERROR("mod_netconf: receiving rpc-reply failed");
1330 if (session_key) {
1331 netconf_close(session_key, &err);
1332 }
1333 if (err != NULL) {
1334 return err;
1335 }
1336 return create_error_reply("Internal: Receiving RPC-REPLY failed.");
1337 }
1338 case NC_MSG_NONE:
1339 /* there is error handled by callback */
1340 if (data != NULL) {
1341 free(*data);
1342 (*data) = NULL;
1343 }
1344 return NULL;
1345 case NC_MSG_REPLY:
Michal Vaskof35ea502016-02-24 10:44:54 +01001346 switch (reply->type) {
1347 case NC_RPL_OK:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001348 if ((data != NULL) && (*data != NULL)) {
1349 free(*data);
1350 (*data) = NULL;
1351 }
1352 return create_ok_reply();
Michal Vaskof35ea502016-02-24 10:44:54 +01001353 case NC_RPL_DATA:
1354 if (((*data) = ((struct nc_reply_data *)reply)->data) == NULL) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001355 ERROR("mod_netconf: no data from reply");
1356 return create_error_reply("Internal: No data from reply received.");
1357 } else {
Michal Vaskof35ea502016-02-24 10:44:54 +01001358 ((struct nc_reply_data *)reply)->data = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001359 return NULL;
1360 }
1361 break;
Michal Vaskof35ea502016-02-24 10:44:54 +01001362 case NC_RPL_ERROR:
1363 ERROR("mod_netconf: unexpected rpc-reply (%d)", reply->type);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001364 if (data != NULL) {
1365 free(*data);
1366 (*data) = NULL;
1367 }
Michal Vaskof35ea502016-02-24 10:44:54 +01001368 return create_error_reply(((struct nc_reply_error *)reply)->err[0].message);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001369 default:
Michal Vaskof35ea502016-02-24 10:44:54 +01001370 ERROR("mod_netconf: unexpected rpc-reply (%d)", reply->type);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001371 if (data != NULL) {
1372 free(*data);
1373 (*data) = NULL;
1374 }
1375 return create_error_reply("Unknown type of NETCONF reply.");
1376 }
1377 break;
1378 default:
1379 ERROR("mod_netconf: unexpected reply message received (%d)", msgt);
1380 if (data != NULL) {
1381 free(*data);
1382 (*data) = NULL;
1383 }
1384 return create_error_reply("Internal: Unexpected RPC-REPLY message type.");
1385 }
Tomas Cejkac7929632013-10-24 19:25:15 +02001386}
1387
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001388json_object *
Michal Vaskof35ea502016-02-24 10:44:54 +01001389netconf_unlocked_op(struct nc_session *session, struct nc_rpc *rpc)
Tomas Cejka6b886e02013-07-05 09:53:17 +02001390{
Michal Vaskof35ea502016-02-24 10:44:54 +01001391 struct nc_reply* reply = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001392 NC_MSG_TYPE msgt;
Tomas Cejka6b886e02013-07-05 09:53:17 +02001393
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001394 /* check requests */
1395 if (rpc == NULL) {
1396 ERROR("mod_netconf: rpc is not created");
1397 return create_error_reply("Internal error: RPC is not created");
1398 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02001399
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001400 if (session != NULL) {
1401 /* send the request and get the reply */
Michal Vaskof35ea502016-02-24 10:44:54 +01001402 msgt = netconf_send_recv_timed(session, rpc, 50000, 0, &reply);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001403 /* process the result of the operation */
1404 return netconf_test_reply(session, 0, msgt, reply, NULL);
1405 } else {
1406 ERROR("Unknown session to process.");
1407 return create_error_reply("Internal error: Unknown session to process.");
1408 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02001409}
1410
Tomas Cejkac7929632013-10-24 19:25:15 +02001411/**
1412 * Perform RPC method that returns data.
1413 *
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001414 * \param[in] session_id session identifier
1415 * \param[in] rpc RPC message to perform
1416 * \param[out] received_data received data string, can be NULL when no data expected, value can be set to NULL if no data received
Tomas Cejkac7929632013-10-24 19:25:15 +02001417 * \return NULL on success, json object with error otherwise
1418 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001419static json_object *
Michal Vaskof35ea502016-02-24 10:44:54 +01001420netconf_op(unsigned int session_key, struct nc_rpc *rpc, int strict, struct lyd_node **received_data)
Radek Krejci469aab82012-07-22 18:42:20 +02001421{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001422 struct session_with_mutex * locked_session;
Michal Vaskof35ea502016-02-24 10:44:54 +01001423 struct nc_reply* reply = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001424 json_object *res = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01001425 struct lyd_node *data = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001426 NC_MSG_TYPE msgt;
Radek Krejci035bf4e2012-07-25 10:59:09 +02001427
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001428 /* check requests */
1429 if (rpc == NULL) {
1430 ERROR("mod_netconf: rpc is not created");
1431 res = create_error_reply("Internal: RPC could not be created.");
1432 data = NULL;
1433 goto finished;
1434 }
Radek Krejci8e4632a2012-07-26 13:40:34 +02001435
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001436 locked_session = session_get_locked(session_key, &res);
1437 if (!locked_session) {
1438 ERROR("Unknown session or locking failed.");
1439 goto finished;
1440 }
Tomas Cejkac7929632013-10-24 19:25:15 +02001441
Michal Vaskof35ea502016-02-24 10:44:54 +01001442 session_user_activity(nc_session_get_username(locked_session->session));
Tomas Cejkac7929632013-10-24 19:25:15 +02001443
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001444 /* send the request and get the reply */
Michal Vaskof35ea502016-02-24 10:44:54 +01001445 msgt = netconf_send_recv_timed(locked_session->session, rpc, 2000000, strict, &reply);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001446
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001447 session_unlock(locked_session);
Tomas Cejkac7929632013-10-24 19:25:15 +02001448
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001449 res = netconf_test_reply(locked_session->session, session_key, msgt, reply, &data);
Radek Krejcia332b692012-11-12 16:15:54 +01001450
Tomas Cejkac7929632013-10-24 19:25:15 +02001451finished:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001452 nc_reply_free(reply);
1453 if (received_data != NULL) {
1454 (*received_data) = data;
1455 } else {
1456 if (data != NULL) {
1457 free(data);
1458 data = NULL;
1459 }
1460 }
1461 return res;
Radek Krejci8e4632a2012-07-26 13:40:34 +02001462}
1463
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001464static char *
1465netconf_getconfig(unsigned int session_key, NC_DATASTORE source, const char *filter, int strict, json_object **err)
Radek Krejci8e4632a2012-07-26 13:40:34 +02001466{
Michal Vaskof35ea502016-02-24 10:44:54 +01001467 struct nc_rpc* rpc;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001468 struct session_with_mutex *locked_session;
Michal Vasko04245ee2016-03-16 09:32:59 +01001469 json_object *res = NULL, *data_cjson;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001470 enum json_tokener_error tok_err;
Michal Vasko04245ee2016-03-16 09:32:59 +01001471 char *data_json = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01001472 struct lyd_node *data, *sibling, *next;
Radek Krejci8e4632a2012-07-26 13:40:34 +02001473
Michal Vaskof35ea502016-02-24 10:44:54 +01001474 /* tell server to show all elements even if they have default values */
1475#ifdef HAVE_WITHDEFAULTS_TAGGED
1476 rpc = nc_rpc_getconfig(source, filter, NC_WD_MODE_ALL_TAG, NC_PARAMTYPE_CONST);
1477#else
1478 rpc = nc_rpc_getconfig(source, filter, 0, NC_PARAMTYPE_CONST);
1479#endif
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001480 if (rpc == NULL) {
1481 ERROR("mod_netconf: creating rpc request failed");
1482 return (NULL);
1483 }
Radek Krejci8e4632a2012-07-26 13:40:34 +02001484
Michal Vaskof35ea502016-02-24 10:44:54 +01001485 res = netconf_op(session_key, rpc, strict, &data);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001486 nc_rpc_free(rpc);
1487 if (res != NULL) {
1488 (*err) = res;
1489 } else {
1490 (*err) = NULL;
1491 }
Tomas Cejkac7929632013-10-24 19:25:15 +02001492
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001493 if (data) {
1494 for (locked_session = netconf_sessions_list;
1495 locked_session && (locked_session->session_key != session_key);
1496 locked_session = locked_session->next);
1497 /* won't fail */
1498
Michal Vaskof35ea502016-02-24 10:44:54 +01001499 /* print data into JSON */
1500 if (lyd_print_mem(&data_json, data, LYD_JSON, LYP_WITHSIBLINGS)) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001501 ERROR("Printing JSON <get-config> data failed.");
Michal Vaskof35ea502016-02-24 10:44:54 +01001502 lyd_free_withsiblings(data);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001503 return NULL;
1504 }
1505
1506 /* parse JSON data into cjson */
1507 pthread_mutex_lock(&json_lock);
Michal Vaskof35ea502016-02-24 10:44:54 +01001508 data_cjson = json_tokener_parse_verbose(data_json, &tok_err);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001509 if (!data_cjson) {
1510 ERROR("Parsing JSON config failed (%s).", json_tokener_error_desc(tok_err));
1511 pthread_mutex_unlock(&json_lock);
Michal Vaskof35ea502016-02-24 10:44:54 +01001512 lyd_free_withsiblings(data);
1513 free(data_json);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001514 return NULL;
1515 }
Michal Vaskof35ea502016-02-24 10:44:54 +01001516 free(data_json);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001517
1518 /* go simultaneously through both trees and add metadata */
Michal Vaskof35ea502016-02-24 10:44:54 +01001519 LY_TREE_FOR_SAFE(data, next, sibling) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001520 node_add_metadata_recursive(sibling, NULL, data_cjson);
1521 lyd_free(sibling);
1522 }
1523
Michal Vaskof35ea502016-02-24 10:44:54 +01001524 data_json = strdup(json_object_to_json_string_ext(data_cjson, 0));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001525 json_object_put(data_cjson);
1526 pthread_mutex_unlock(&json_lock);
1527 }
1528
Michal Vaskof35ea502016-02-24 10:44:54 +01001529 return (data_json);
Radek Krejci8e4632a2012-07-26 13:40:34 +02001530}
1531
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001532static char *
1533netconf_getschema(unsigned int session_key, const char *identifier, const char *version, const char *format, json_object **err)
Tomas Cejka0aeca8b2012-12-22 19:56:03 +01001534{
Michal Vaskof35ea502016-02-24 10:44:54 +01001535 struct nc_rpc *rpc;
1536 struct lyd_node *data = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001537 json_object *res = NULL;
Michal Vasko56ec5952016-04-05 14:30:23 +02001538 char *model_data = NULL;
Tomas Cejka0aeca8b2012-12-22 19:56:03 +01001539
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001540 /* create requests */
Michal Vaskof35ea502016-02-24 10:44:54 +01001541 rpc = nc_rpc_getschema(identifier, version, format, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001542 if (rpc == NULL) {
1543 ERROR("mod_netconf: creating rpc request failed");
1544 return (NULL);
1545 }
Tomas Cejka0aeca8b2012-12-22 19:56:03 +01001546
Michal Vaskof35ea502016-02-24 10:44:54 +01001547 res = netconf_op(session_key, rpc, 0, &data);
1548 nc_rpc_free(rpc);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001549 if (res != NULL) {
1550 (*err) = res;
1551 } else {
1552 (*err) = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01001553
1554 if (data) {
Michal Vasko56ec5952016-04-05 14:30:23 +02001555 if (((struct lyd_node_anyxml *)data)->xml_struct) {
1556 lyxml_print_mem(&model_data, ((struct lyd_node_anyxml *)data)->value.xml, 0);
1557 } else {
1558 model_data = strdup(((struct lyd_node_anyxml *)data)->value.str);
1559 }
1560 if (!model_data) {
1561 ERROR("memory allocation fail (%s:%d)", __FILE__, __LINE__);
Michal Vaskof35ea502016-02-24 10:44:54 +01001562 }
1563 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001564 }
Tomas Cejkac7929632013-10-24 19:25:15 +02001565
Michal Vaskof35ea502016-02-24 10:44:54 +01001566 return (model_data);
Tomas Cejka0aeca8b2012-12-22 19:56:03 +01001567}
1568
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001569static char *
1570netconf_get(unsigned int session_key, const char* filter, int strict, json_object **err)
Radek Krejci8e4632a2012-07-26 13:40:34 +02001571{
Michal Vaskof35ea502016-02-24 10:44:54 +01001572 struct nc_rpc* rpc;
1573 char* data_json = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001574 json_object *res = NULL, *data_cjson;
1575 enum json_tokener_error tok_err;
1576 struct session_with_mutex *locked_session;
Michal Vaskof35ea502016-02-24 10:44:54 +01001577 struct lyd_node *data, *sibling, *next;
Radek Krejci8e4632a2012-07-26 13:40:34 +02001578
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001579 /* create requests */
Michal Vaskof35ea502016-02-24 10:44:54 +01001580 rpc = nc_rpc_get(filter, 0, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001581 if (rpc == NULL) {
1582 ERROR("mod_netconf: creating rpc request failed");
1583 return (NULL);
1584 }
Radek Krejci8e4632a2012-07-26 13:40:34 +02001585
Michal Vaskof35ea502016-02-24 10:44:54 +01001586 res = netconf_op(session_key, rpc, strict, &data);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001587 nc_rpc_free(rpc);
1588 if (res != NULL) {
1589 (*err) = res;
1590 } else {
1591 (*err) = NULL;
1592 }
Tomas Cejkac7929632013-10-24 19:25:15 +02001593
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001594 if (data) {
1595 for (locked_session = netconf_sessions_list;
1596 locked_session && (locked_session->session_key != session_key);
1597 locked_session = locked_session->next);
1598 /* won't fail */
1599
Michal Vaskof35ea502016-02-24 10:44:54 +01001600 /* print JSON data */
1601 if (lyd_print_mem(&data_json, data, LYD_JSON, LYP_WITHSIBLINGS)) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001602 ERROR("Printing JSON <get> data failed.");
Michal Vaskof35ea502016-02-24 10:44:54 +01001603 lyd_free_withsiblings(data);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001604 return NULL;
1605 }
1606
1607 /* parse JSON data into cjson */
1608 pthread_mutex_lock(&json_lock);
Michal Vaskof35ea502016-02-24 10:44:54 +01001609 data_cjson = json_tokener_parse_verbose(data_json, &tok_err);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001610 if (!data_cjson) {
1611 ERROR("Parsing JSON config failed (%s).", json_tokener_error_desc(tok_err));
1612 pthread_mutex_unlock(&json_lock);
Michal Vaskof35ea502016-02-24 10:44:54 +01001613 lyd_free_withsiblings(data);
1614 free(data_json);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001615 return NULL;
1616 }
Michal Vaskof35ea502016-02-24 10:44:54 +01001617 free(data_json);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001618
1619 /* go simultaneously through both trees and add metadata */
Michal Vaskof35ea502016-02-24 10:44:54 +01001620 LY_TREE_FOR_SAFE(data, next, sibling) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001621 node_add_metadata_recursive(sibling, NULL, data_cjson);
1622 lyd_free(sibling);
1623 }
1624
Michal Vaskof35ea502016-02-24 10:44:54 +01001625 data_json = strdup(json_object_to_json_string_ext(data_cjson, 0));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001626 json_object_put(data_cjson);
1627 pthread_mutex_unlock(&json_lock);
1628 }
1629
Michal Vaskof35ea502016-02-24 10:44:54 +01001630 return data_json;
Radek Krejci8e4632a2012-07-26 13:40:34 +02001631}
1632
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001633static json_object *
1634netconf_copyconfig(unsigned int session_key, NC_DATASTORE source, NC_DATASTORE target, const char *config,
1635 const char *uri_src, const char *uri_trg)
Radek Krejci8e4632a2012-07-26 13:40:34 +02001636{
Michal Vaskof35ea502016-02-24 10:44:54 +01001637 struct nc_rpc* rpc;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001638 json_object *res = NULL;
Radek Krejci8e4632a2012-07-26 13:40:34 +02001639
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001640 /* create requests */
Michal Vaskof35ea502016-02-24 10:44:54 +01001641 rpc = nc_rpc_copy(target, uri_trg, source, (config ? config : uri_src), 0, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001642 if (rpc == NULL) {
1643 ERROR("mod_netconf: creating rpc request failed");
1644 return create_error_reply("Internal: Creating rpc request failed");
1645 }
Radek Krejci8e4632a2012-07-26 13:40:34 +02001646
Michal Vaskof35ea502016-02-24 10:44:54 +01001647 res = netconf_op(session_key, rpc, 0, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001648 nc_rpc_free(rpc);
Tomas Cejkac7929632013-10-24 19:25:15 +02001649
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001650 return res;
Radek Krejci8e4632a2012-07-26 13:40:34 +02001651}
Radek Krejci035bf4e2012-07-25 10:59:09 +02001652
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001653static json_object *
Michal Vaskof35ea502016-02-24 10:44:54 +01001654netconf_editconfig(unsigned int session_key, NC_DATASTORE target, NC_RPC_EDIT_DFLTOP defop,
1655 NC_RPC_EDIT_ERROPT erropt, NC_RPC_EDIT_TESTOPT testopt, const char *config_or_url)
Radek Krejci62ab34b2012-07-26 13:42:05 +02001656{
Michal Vaskof35ea502016-02-24 10:44:54 +01001657 struct nc_rpc* rpc;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001658 json_object *res = NULL;
Radek Krejci62ab34b2012-07-26 13:42:05 +02001659
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001660 /* create requests */
Michal Vaskof35ea502016-02-24 10:44:54 +01001661 rpc = nc_rpc_edit(target, defop, testopt, erropt, config_or_url, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001662 if (rpc == NULL) {
1663 ERROR("mod_netconf: creating rpc request failed");
1664 return create_error_reply("Internal: Creating rpc request failed");
1665 }
Radek Krejci62ab34b2012-07-26 13:42:05 +02001666
Michal Vaskof35ea502016-02-24 10:44:54 +01001667 res = netconf_op(session_key, rpc, 0, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001668 nc_rpc_free (rpc);
Tomas Cejkac7929632013-10-24 19:25:15 +02001669
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001670 return res;
Radek Krejci62ab34b2012-07-26 13:42:05 +02001671}
1672
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001673static json_object *
1674netconf_killsession(unsigned int session_key, const char *sid)
Radek Krejcie34d3eb2012-07-26 15:05:53 +02001675{
Michal Vaskof35ea502016-02-24 10:44:54 +01001676 struct nc_rpc *rpc;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001677 json_object *res = NULL;
Radek Krejcie34d3eb2012-07-26 15:05:53 +02001678
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001679 /* create requests */
Michal Vaskof35ea502016-02-24 10:44:54 +01001680 rpc = nc_rpc_kill(atoi(sid));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001681 if (rpc == NULL) {
1682 ERROR("mod_netconf: creating rpc request failed");
1683 return create_error_reply("Internal: Creating rpc request failed");
1684 }
Radek Krejcie34d3eb2012-07-26 15:05:53 +02001685
Michal Vaskof35ea502016-02-24 10:44:54 +01001686 res = netconf_op(session_key, rpc, 0, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001687 nc_rpc_free(rpc);
1688 return res;
Radek Krejcie34d3eb2012-07-26 15:05:53 +02001689}
1690
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001691static json_object *
Michal Vaskof35ea502016-02-24 10:44:54 +01001692netconf_onlytargetop(unsigned int session_key, NC_DATASTORE target, struct nc_rpc *(*op_func)(NC_DATASTORE))
Radek Krejci2f318372012-07-26 14:22:35 +02001693{
Michal Vaskof35ea502016-02-24 10:44:54 +01001694 struct nc_rpc* rpc;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001695 json_object *res = NULL;
Radek Krejci2f318372012-07-26 14:22:35 +02001696
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001697 /* create requests */
1698 rpc = op_func(target);
1699 if (rpc == NULL) {
1700 ERROR("mod_netconf: creating rpc request failed");
1701 return create_error_reply("Internal: Creating rpc request failed");
1702 }
Radek Krejci2f318372012-07-26 14:22:35 +02001703
Michal Vaskof35ea502016-02-24 10:44:54 +01001704 res = netconf_op(session_key, rpc, 0, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001705 nc_rpc_free (rpc);
1706 return res;
Radek Krejci2f318372012-07-26 14:22:35 +02001707}
1708
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001709static json_object *
1710netconf_deleteconfig(unsigned int session_key, NC_DATASTORE target, const char *url)
Radek Krejci5cd7d422012-07-26 14:50:29 +02001711{
Michal Vaskof35ea502016-02-24 10:44:54 +01001712 struct nc_rpc *rpc = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001713 json_object *res = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01001714 rpc = nc_rpc_delete(target, url, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001715 if (rpc == NULL) {
1716 ERROR("mod_netconf: creating rpc request failed");
1717 return create_error_reply("Internal: Creating rpc request failed");
1718 }
Tomas Cejka404d37e2013-04-13 02:31:35 +02001719
Michal Vaskof35ea502016-02-24 10:44:54 +01001720 res = netconf_op(session_key, rpc, 0, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001721 nc_rpc_free (rpc);
1722 return res;
Radek Krejci5cd7d422012-07-26 14:50:29 +02001723}
1724
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001725static json_object *
1726netconf_lock(unsigned int session_key, NC_DATASTORE target)
Radek Krejci5cd7d422012-07-26 14:50:29 +02001727{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001728 return (netconf_onlytargetop(session_key, target, nc_rpc_lock));
Radek Krejci5cd7d422012-07-26 14:50:29 +02001729}
1730
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001731static json_object *
1732netconf_unlock(unsigned int session_key, NC_DATASTORE target)
Radek Krejci5cd7d422012-07-26 14:50:29 +02001733{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001734 return (netconf_onlytargetop(session_key, target, nc_rpc_unlock));
Radek Krejci5cd7d422012-07-26 14:50:29 +02001735}
1736
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001737static json_object *
Michal Vaskof35ea502016-02-24 10:44:54 +01001738netconf_generic(unsigned int session_key, const char *xml_content, struct lyd_node **data)
Radek Krejci80c10d92012-07-30 08:38:50 +02001739{
Michal Vaskof35ea502016-02-24 10:44:54 +01001740 struct nc_rpc* rpc = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001741 json_object *res = NULL;
Radek Krejci80c10d92012-07-30 08:38:50 +02001742
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001743 /* create requests */
Michal Vaskof35ea502016-02-24 10:44:54 +01001744 rpc = nc_rpc_generic_xml(xml_content, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001745 if (rpc == NULL) {
1746 ERROR("mod_netconf: creating rpc request failed");
1747 return create_error_reply("Internal: Creating rpc request failed");
1748 }
Radek Krejci80c10d92012-07-30 08:38:50 +02001749
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001750 /* get session where send the RPC */
Michal Vaskof35ea502016-02-24 10:44:54 +01001751 res = netconf_op(session_key, rpc, 0, data);
1752 nc_rpc_free(rpc);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001753 return res;
1754}
1755
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001756static int
Michal Vaskof35ea502016-02-24 10:44:54 +01001757node_add_metadata(const struct lys_node *node, const struct lys_module *module, json_object *parent)
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001758{
1759 struct lys_module *cur_module;
1760 json_object *meta_obj;
1761 char *obj_name;
1762
Michal Vaskoa45770b2015-11-23 15:49:41 +01001763 if (node->nodetype == LYS_INPUT) {
1764 /* silently skipped */
1765 return 0;
1766 }
1767
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001768 cur_module = node->module;
1769 if (cur_module->type) {
1770 cur_module = ((struct lys_submodule *)cur_module)->belongsto;
1771 }
1772 if (cur_module == module) {
1773 asprintf(&obj_name, "$@%s", node->name);
1774 } else {
1775 asprintf(&obj_name, "$@%s:%s", cur_module->name, node->name);
1776 }
1777
1778 /* in (leaf-)lists the metadata could have already been added */
Michal Vaskoa45770b2015-11-23 15:49:41 +01001779 if ((node->nodetype & (LYS_LEAFLIST | LYS_LIST)) && (json_object_object_get_ex(parent, obj_name, NULL) == TRUE)) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001780 free(obj_name);
1781 return 1;
1782 }
1783
1784 meta_obj = json_object_new_object();
1785
1786 switch (node->nodetype) {
1787 case LYS_CONTAINER:
1788 node_metadata_container((struct lys_node_container *)node, meta_obj);
1789 break;
Michal Vasko3fda9a92015-11-23 10:10:57 +01001790 case LYS_CHOICE:
1791 node_metadata_choice((struct lys_node_choice *)node, meta_obj);
1792 break;
1793 case LYS_LEAF:
1794 node_metadata_leaf((struct lys_node_leaf *)node, meta_obj);
1795 break;
1796 case LYS_LEAFLIST:
1797 node_metadata_leaflist((struct lys_node_leaflist *)node, meta_obj);
1798 break;
1799 case LYS_LIST:
1800 node_metadata_list((struct lys_node_list *)node, meta_obj);
1801 break;
1802 case LYS_ANYXML:
1803 node_metadata_anyxml((struct lys_node_anyxml *)node, meta_obj);
1804 break;
1805 case LYS_CASE:
1806 node_metadata_case((struct lys_node_case *)node, meta_obj);
1807 break;
Michal Vaskoa45770b2015-11-23 15:49:41 +01001808 case LYS_RPC:
1809 node_metadata_rpc((struct lys_node_rpc *)node, meta_obj);
1810 break;
1811 default: /* LYS_OUTPUT */
Michal Vasko3fda9a92015-11-23 10:10:57 +01001812 ERROR("Internal: unuxpected nodetype (%s:%d)", __FILE__, __LINE__);
1813 break;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001814 }
1815
1816 /* just a precaution */
1817 if (json_object_get_type(parent) != json_type_object) {
1818 ERROR("Internal: wrong JSON type (%s:%d)", __FILE__, __LINE__);
1819 free(obj_name);
1820 return 1;
1821 }
1822
1823 json_object_object_add(parent, obj_name, meta_obj);
1824 free(obj_name);
1825 return 0;
1826}
1827
1828static void
Michal Vaskof35ea502016-02-24 10:44:54 +01001829node_add_metadata_recursive(struct lyd_node *data_tree, const struct lys_module *module, json_object *data_json_parent)
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001830{
1831 struct lys_module *cur_module;
1832 struct lys_node *list_schema;
1833 struct lyd_node *child, *list_item;
1834 json_object *child_json, *list_child_json;
1835 char *child_name;
1836 int list_idx;
1837
Michal Vaskoa45770b2015-11-23 15:49:41 +01001838 if (data_tree->schema->nodetype & (LYS_OUTPUT | LYS_GROUPING)) {
1839 return;
1840 }
1841
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001842 /* add data_tree metadata */
1843 if (node_add_metadata(data_tree->schema, module, data_json_parent)) {
1844 return;
1845 }
1846
1847 /* get data_tree module */
1848 cur_module = data_tree->schema->module;
1849 if (cur_module->type) {
1850 cur_module = ((struct lys_submodule *)cur_module)->belongsto;
1851 }
1852
1853 if (!(data_tree->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST | LYS_ANYXML))) {
1854 /* print correct data_tree JSON name */
1855 if (cur_module == module) {
1856 asprintf(&child_name, "%s", data_tree->schema->name);
1857 } else {
1858 asprintf(&child_name, "%s:%s", cur_module->name, data_tree->schema->name);
1859 }
1860
1861 /* go down in JSON object */
1862 if (json_object_object_get_ex(data_json_parent, child_name, &child_json) == FALSE) {
1863 ERROR("Internal: failed to get JSON object \"%s\".", child_name);
1864 free(child_name);
1865 return;
1866 }
1867 free(child_name);
1868
1869 if (data_tree->schema->nodetype == LYS_LIST) {
1870 if (json_object_get_type(child_json) != json_type_array) {
1871 ERROR("Internal: type mismatch (%s:%d)", __FILE__, __LINE__);
1872 return;
1873 }
1874 /* go down in data tree for every item, we process them all now, skip later
1875 * (metadata duplicate will be detected at the beginning of this function) */
1876 list_idx = 0;
1877 list_schema = data_tree->schema;
1878
1879 LY_TREE_FOR(data_tree, list_item) {
1880 /* another list member */
1881 if (list_item->schema == list_schema) {
1882 list_child_json = json_object_array_get_idx(child_json, list_idx);
1883 if (!list_child_json) {
1884 ERROR("Internal: list \"%s\" idx out-of-bounds", list_schema->name);
1885 return;
1886 }
1887 LY_TREE_FOR(list_item->child, child) {
1888 node_add_metadata_recursive(child, cur_module, list_child_json);
1889 }
1890
1891 ++list_idx;
1892 }
1893 }
1894 } else {
1895 if (json_object_get_type(child_json) != json_type_object) {
1896 ERROR("Internal: type mismatch (%s:%d)", __FILE__, __LINE__);
1897 return;
1898 }
1899 /* go down in data tree */
1900 LY_TREE_FOR(data_tree->child, child) {
1901 node_add_metadata_recursive(child, cur_module, child_json);
1902 }
1903 }
1904 }
1905}
1906
1907static void
Michal Vaskof35ea502016-02-24 10:44:54 +01001908node_add_model_metadata(const struct lys_module *module, json_object *parent)
Michal Vaskoa45770b2015-11-23 15:49:41 +01001909{
1910 json_object *obj;
1911 char *str;
1912
1913 obj = json_object_new_object();
1914 node_metadata_model(module, obj);
1915 asprintf(&str, "$@@%s", module->name);
1916 json_object_object_add(parent, str, obj);
1917 free(str);
1918}
1919
1920static void
Michal Vaskof35ea502016-02-24 10:44:54 +01001921node_add_children_with_metadata_recursive(const struct lys_node *node, const struct lys_module *module, json_object *parent)
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001922{
Michal Vaskof35ea502016-02-24 10:44:54 +01001923 const struct lys_module *cur_module;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001924 struct lys_node *child;
1925 json_object *node_json;
1926 char *json_name;
1927
Michal Vaskoa45770b2015-11-23 15:49:41 +01001928 if (node->nodetype & (LYS_OUTPUT | LYS_GROUPING)) {
1929 return;
1930 }
1931
1932 if (node->nodetype & LYS_USES) {
1933 cur_module = module;
1934 node_json = parent;
1935 goto children;
1936 }
1937
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001938 /* add node metadata */
1939 if (node_add_metadata(node, module, parent)) {
1940 ERROR("Internal: metadata duplicate for \"%s\".", node->name);
1941 return;
1942 }
1943
Michal Vaskoa45770b2015-11-23 15:49:41 +01001944 /* no other metadata */
1945 if (!node->child) {
1946 return;
1947 }
1948
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001949 /* get node module */
1950 cur_module = node->module;
1951 if (cur_module->type) {
1952 cur_module = ((struct lys_submodule *)cur_module)->belongsto;
1953 }
1954
1955 /* create JSON object for child metadata */
1956 node_json = json_object_new_object();
1957 if (cur_module == module) {
1958 json_object_object_add(parent, node->name, node_json);
1959 } else {
1960 asprintf(&json_name, "%s:%s", cur_module->name, node->name);
1961 json_object_object_add(parent, json_name, node_json);
1962 free(json_name);
1963 }
1964
Michal Vaskoa45770b2015-11-23 15:49:41 +01001965children:
Michal Vaskoea2ddd92016-03-17 15:43:58 +01001966 if (!(node->nodetype & (LYS_LEAF | LYS_LEAFLIST | LYS_ANYXML))) {
1967 LY_TREE_FOR(node->child, child) {
1968 node_add_children_with_metadata_recursive(child, cur_module, node_json);
1969 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001970 }
1971}
1972
1973static json_object *
1974libyang_query(unsigned int session_key, const char *filter, int load_children)
1975{
Michal Vaskof35ea502016-02-24 10:44:54 +01001976 const struct lys_node *node;
1977 const struct lys_module *module = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001978 struct session_with_mutex *locked_session;
1979 json_object *ret = NULL, *data;
1980
1981 locked_session = session_get_locked(session_key, &ret);
1982 if (!locked_session) {
1983 ERROR("Locking failed or session not found.");
1984 goto finish;
1985 }
1986
Michal Vaskof35ea502016-02-24 10:44:54 +01001987 session_user_activity(nc_session_get_username(locked_session->session));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001988
Michal Vaskoa45770b2015-11-23 15:49:41 +01001989 if (filter[0] == '/') {
Michal Vasko56ec5952016-04-05 14:30:23 +02001990 node = ly_ctx_get_node(nc_session_get_ctx(locked_session->session), NULL, filter);
Michal Vaskoa45770b2015-11-23 15:49:41 +01001991 if (!node) {
1992 ret = create_error_reply("Failed to resolve XPath filter node.");
1993 goto finish;
1994 }
1995 } else {
Michal Vaskof35ea502016-02-24 10:44:54 +01001996 module = ly_ctx_get_module(nc_session_get_ctx(locked_session->session), filter, NULL);
Michal Vaskoa45770b2015-11-23 15:49:41 +01001997 if (!module) {
1998 ret = create_error_reply("Failed to find model.");
1999 goto finish;
2000 }
2001 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002002
Michal Vaskoa45770b2015-11-23 15:49:41 +01002003 pthread_mutex_lock(&json_lock);
2004 data = json_object_new_object();
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002005
Michal Vaskoa45770b2015-11-23 15:49:41 +01002006 if (module) {
2007 node_add_model_metadata(module, data);
2008 if (load_children) {
2009 LY_TREE_FOR(module->data, node) {
2010 node_add_children_with_metadata_recursive(node, NULL, data);
2011 }
2012 }
2013 } else {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002014 if (load_children) {
2015 node_add_children_with_metadata_recursive(node, NULL, data);
2016 } else {
2017 node_add_metadata(node, NULL, data);
2018 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002019 }
2020
Michal Vaskoa45770b2015-11-23 15:49:41 +01002021 pthread_mutex_unlock(&json_lock);
2022 ret = create_data_reply(json_object_to_json_string(data));
2023 json_object_put(data);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002024
2025finish:
Michal Vaskoa45770b2015-11-23 15:49:41 +01002026 session_unlock(locked_session);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002027 return ret;
2028}
2029
2030static json_object *
2031libyang_merge(unsigned int session_key, const char *config)
2032{
2033 struct lyd_node *data_tree = NULL, *sibling;
2034 struct session_with_mutex *locked_session;
2035 json_object *ret = NULL, *data_json = NULL;
2036 enum json_tokener_error err = 0;
2037
2038 locked_session = session_get_locked(session_key, &ret);
2039 if (!locked_session) {
2040 ERROR("Locking failed or session not found.");
2041 goto finish;
2042 }
2043
Michal Vaskof35ea502016-02-24 10:44:54 +01002044 session_user_activity(nc_session_get_username(locked_session->session));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002045
Michal Vaskof35ea502016-02-24 10:44:54 +01002046 data_tree = lyd_parse_mem(nc_session_get_ctx(locked_session->session), config, LYD_JSON, LYD_OPT_STRICT);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002047 if (!data_tree) {
2048 ERROR("Creating data tree failed.");
2049 ret = create_error_reply("Failed to create data tree from JSON config.");
2050 session_unlock(locked_session);
2051 goto finish;
2052 }
2053
2054 session_unlock(locked_session);
2055
2056 pthread_mutex_lock(&json_lock);
2057 data_json = json_tokener_parse_verbose(config, &err);
2058 if (!data_json) {
2059 ERROR("Parsing JSON config failed (%s).", json_tokener_error_desc(err));
2060 pthread_mutex_unlock(&json_lock);
2061 ret = create_error_reply(json_tokener_error_desc(err));
2062 goto finish;
2063 }
2064
2065 /* go simultaneously through both trees and add metadata */
2066 LY_TREE_FOR(data_tree, sibling) {
2067 node_add_metadata_recursive(sibling, NULL, data_json);
2068 }
2069 pthread_mutex_unlock(&json_lock);
2070 ret = create_data_reply(json_object_to_json_string(data_json));
2071
2072finish:
2073 LY_TREE_FOR(data_tree, sibling) {
2074 lyd_free(sibling);
2075 }
2076 json_object_put(data_json);
2077 return ret;
Radek Krejci80c10d92012-07-30 08:38:50 +02002078}
2079
Tomas Cejka0a4bba82013-04-19 11:51:28 +02002080/**
2081 * @}
2082 *//* netconf_operations */
2083
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002084void
2085clb_print(NC_VERB_LEVEL level, const char *msg)
Radek Krejci469aab82012-07-22 18:42:20 +02002086{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002087 switch (level) {
Michal Vasko56c02b22016-04-06 09:59:09 +02002088 case NC_VERB_ERROR:
Michal Vaskoefdd49f2016-04-06 11:13:27 +02002089 ERROR("lib ERROR: %s", msg);
Michal Vasko56c02b22016-04-06 09:59:09 +02002090 break;
2091 case NC_VERB_WARNING:
Michal Vaskoefdd49f2016-04-06 11:13:27 +02002092 ERROR("lib WARNING: %s", msg);
Michal Vasko56c02b22016-04-06 09:59:09 +02002093 break;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002094 case NC_VERB_VERBOSE:
Michal Vaskoefdd49f2016-04-06 11:13:27 +02002095 ERROR("lib VERBOSE: %s", msg);
Michal Vasko56c02b22016-04-06 09:59:09 +02002096 break;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002097 case NC_VERB_DEBUG:
Michal Vaskoefdd49f2016-04-06 11:13:27 +02002098 DEBUG("lib DEBUG: %s", msg);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002099 break;
2100 }
Michal Vasko56c02b22016-04-06 09:59:09 +02002101
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002102 if (level == NC_VERB_ERROR) {
2103 /* return global error */
Michal Vasko56c02b22016-04-06 09:59:09 +02002104 netconf_callback_error_process(msg);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002105 }
Radek Krejci469aab82012-07-22 18:42:20 +02002106}
2107
Tomas Cejka64b87482013-06-03 16:30:53 +02002108/**
Tomas Cejka6e8f4262013-07-10 09:20:19 +02002109 * Receive message from client over UNIX socket and return pointer to it.
Tomas Cejka64b87482013-06-03 16:30:53 +02002110 * Caller should free message memory.
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002111 * \param[in] client socket descriptor of client
Tomas Cejka64b87482013-06-03 16:30:53 +02002112 * \return pointer to message
2113 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002114char *
2115get_framed_message(int client)
Tomas Cejka64b87482013-06-03 16:30:53 +02002116{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002117 /* read json in chunked framing */
2118 unsigned int buffer_size = 0;
2119 ssize_t buffer_len = 0;
2120 char *buffer = NULL;
2121 char c;
2122 ssize_t ret;
2123 int i, chunk_len;
2124 char chunk_len_str[12];
Tomas Cejka64b87482013-06-03 16:30:53 +02002125
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002126 while (1) {
2127 /* read chunk length */
2128 if ((ret = recv (client, &c, 1, 0)) != 1 || c != '\n') {
2129 if (buffer != NULL) {
2130 free (buffer);
2131 buffer = NULL;
2132 }
2133 break;
2134 }
2135 if ((ret = recv (client, &c, 1, 0)) != 1 || c != '#') {
2136 if (buffer != NULL) {
2137 free (buffer);
2138 buffer = NULL;
2139 }
2140 break;
2141 }
2142 i=0;
2143 memset (chunk_len_str, 0, 12);
2144 while ((ret = recv (client, &c, 1, 0) == 1 && (isdigit(c) || c == '#'))) {
2145 if (i==0 && c == '#') {
2146 if (recv (client, &c, 1, 0) != 1 || c != '\n') {
2147 /* end but invalid */
2148 if (buffer != NULL) {
2149 free (buffer);
2150 buffer = NULL;
2151 }
2152 }
2153 /* end of message, double-loop break */
2154 goto msg_complete;
2155 }
2156 chunk_len_str[i++] = c;
2157 if (i==11) {
2158 ERROR("Message is too long, buffer for length is not big enought!!!!");
2159 break;
2160 }
2161 }
2162 if (c != '\n') {
2163 if (buffer != NULL) {
2164 free (buffer);
2165 buffer = NULL;
2166 }
2167 break;
2168 }
2169 chunk_len_str[i] = 0;
2170 if ((chunk_len = atoi (chunk_len_str)) == 0) {
2171 if (buffer != NULL) {
2172 free (buffer);
2173 buffer = NULL;
2174 }
2175 break;
2176 }
2177 buffer_size += chunk_len+1;
2178 buffer = realloc (buffer, sizeof(char)*buffer_size);
2179 memset(buffer + (buffer_size-chunk_len-1), 0, chunk_len+1);
2180 if ((ret = recv (client, buffer+buffer_len, chunk_len, 0)) == -1 || ret != chunk_len) {
2181 if (buffer != NULL) {
2182 free (buffer);
2183 buffer = NULL;
2184 }
2185 break;
2186 }
2187 buffer_len += ret;
2188 }
Tomas Cejka64b87482013-06-03 16:30:53 +02002189msg_complete:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002190 return buffer;
Tomas Cejka64b87482013-06-03 16:30:53 +02002191}
2192
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002193NC_DATASTORE
2194parse_datastore(const char *ds)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002195{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002196 if (strcmp(ds, "running") == 0) {
2197 return NC_DATASTORE_RUNNING;
2198 } else if (strcmp(ds, "startup") == 0) {
2199 return NC_DATASTORE_STARTUP;
2200 } else if (strcmp(ds, "candidate") == 0) {
2201 return NC_DATASTORE_CANDIDATE;
2202 } else if (strcmp(ds, "url") == 0) {
2203 return NC_DATASTORE_URL;
2204 } else if (strcmp(ds, "config") == 0) {
2205 return NC_DATASTORE_CONFIG;
2206 }
2207 return -1;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002208}
2209
Michal Vaskof35ea502016-02-24 10:44:54 +01002210NC_RPC_EDIT_TESTOPT
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002211parse_testopt(const char *t)
Tomas Cejka5ae8dfb2014-02-14 23:42:17 +01002212{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002213 if (strcmp(t, "notset") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002214 return NC_RPC_EDIT_TESTOPT_UNKNOWN;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002215 } else if (strcmp(t, "testset") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002216 return NC_RPC_EDIT_TESTOPT_TESTSET;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002217 } else if (strcmp(t, "set") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002218 return NC_RPC_EDIT_TESTOPT_SET;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002219 } else if (strcmp(t, "test") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002220 return NC_RPC_EDIT_TESTOPT_TEST;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002221 }
Michal Vaskof35ea502016-02-24 10:44:54 +01002222 return NC_RPC_EDIT_TESTOPT_UNKNOWN;
Tomas Cejka5ae8dfb2014-02-14 23:42:17 +01002223}
2224
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002225json_object *
2226create_error_reply(const char *errmess)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002227{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002228 json_object *reply, *array;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002229
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002230 pthread_mutex_lock(&json_lock);
2231 reply = json_object_new_object();
2232 array = json_object_new_array();
2233 json_object_object_add(reply, "type", json_object_new_int(REPLY_ERROR));
2234 json_object_array_add(array, json_object_new_string(errmess));
2235 json_object_object_add(reply, "errors", array);
2236 pthread_mutex_unlock(&json_lock);
2237
2238 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002239}
2240
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002241json_object *
2242create_data_reply(const char *data)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002243{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002244 pthread_mutex_lock(&json_lock);
2245 json_object *reply = json_object_new_object();
2246 json_object_object_add(reply, "type", json_object_new_int(REPLY_DATA));
2247 json_object_object_add(reply, "data", json_object_new_string(data));
2248 pthread_mutex_unlock(&json_lock);
2249 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002250}
2251
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002252json_object *
2253create_ok_reply(void)
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002254{
Michal Vasko365dc4c2016-03-17 10:03:58 +01002255 json_object *reply;
2256
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002257 pthread_mutex_lock(&json_lock);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002258 reply = json_object_new_object();
2259 json_object_object_add(reply, "type", json_object_new_int(REPLY_OK));
2260 pthread_mutex_unlock(&json_lock);
2261 return reply;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002262}
2263
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002264json_object *
2265create_replies(void)
Tomas Cejka09629492014-07-10 15:58:06 +02002266{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002267 json_object *replies;
2268
2269 pthread_mutex_lock(&json_lock);
2270 replies = json_object_new_object();
2271 pthread_mutex_unlock(&json_lock);
2272
2273 return replies;
Tomas Cejka09629492014-07-10 15:58:06 +02002274}
2275
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002276void
2277add_reply(json_object *replies, json_object *reply, unsigned int session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002278{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002279 char *str;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002280
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002281 asprintf(&str, "%u", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002282
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002283 pthread_mutex_lock(&json_lock);
2284 json_object_object_add(replies, str, reply);
2285 pthread_mutex_unlock(&json_lock);
Tomas Cejka09629492014-07-10 15:58:06 +02002286
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002287 free(str);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002288}
2289
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002290char *
2291get_param_string(json_object *data, const char *name)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002292{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002293 json_object *js_tmp = NULL;
2294 char *res = NULL;
2295 if (json_object_object_get_ex(data, name, &js_tmp) == TRUE) {
2296 res = strdup(json_object_get_string(js_tmp));
2297 }
2298 return res;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002299}
2300
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002301json_object *
2302handle_op_connect(json_object *request)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002303{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002304 char *host = NULL;
2305 char *port = NULL;
2306 char *user = NULL;
2307 char *pass = NULL;
Michal Vaskoda5ccc82015-11-25 10:42:49 +01002308 char *privkey = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002309 json_object *reply = NULL;
2310 unsigned int session_key = 0;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002311
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002312 DEBUG("Request: connect");
2313 pthread_mutex_lock(&json_lock);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002314
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002315 host = get_param_string(request, "host");
2316 port = get_param_string(request, "port");
2317 user = get_param_string(request, "user");
2318 pass = get_param_string(request, "pass");
Michal Vaskoda5ccc82015-11-25 10:42:49 +01002319 privkey = get_param_string(request, "privatekey");
Tomas Cejkad5b53772013-06-08 23:01:07 +02002320
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002321 pthread_mutex_unlock(&json_lock);
Tomas Cejka09629492014-07-10 15:58:06 +02002322
Michal Vaskoda5ccc82015-11-25 10:42:49 +01002323 if (host == NULL) {
2324 host = "localhost";
2325 }
2326
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002327 DEBUG("host: %s, port: %s, user: %s", host, port, user);
Michal Vaskoda5ccc82015-11-25 10:42:49 +01002328 if (user == NULL) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002329 ERROR("Cannot connect - insufficient input.");
2330 session_key = 0;
2331 } else {
Michal Vaskof35ea502016-02-24 10:44:54 +01002332 session_key = netconf_connect(host, port, user, pass, privkey);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002333 DEBUG("Session key: %u", session_key);
2334 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002335
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002336 GETSPEC_ERR_REPLY
2337
2338 pthread_mutex_lock(&json_lock);
2339 if (session_key == 0) {
2340 /* negative reply */
2341 if (err_reply == NULL) {
2342 reply = json_object_new_object();
2343 json_object_object_add(reply, "type", json_object_new_int(REPLY_ERROR));
2344 json_object_object_add(reply, "error-message", json_object_new_string("Connecting NETCONF server failed."));
2345 ERROR("Connection failed.");
2346 } else {
2347 /* use filled err_reply from libnetconf's callback */
2348 reply = err_reply;
2349 ERROR("Connect - error from libnetconf's callback.");
2350 }
2351 } else {
2352 /* positive reply */
2353 reply = json_object_new_object();
2354 json_object_object_add(reply, "type", json_object_new_int(REPLY_OK));
2355 json_object_object_add(reply, "session", json_object_new_int(session_key));
2356 }
2357 memset(pass, 0, strlen(pass));
2358 pthread_mutex_unlock(&json_lock);
2359 CHECK_AND_FREE(host);
2360 CHECK_AND_FREE(user);
2361 CHECK_AND_FREE(port);
2362 CHECK_AND_FREE(pass);
Michal Vaskoda5ccc82015-11-25 10:42:49 +01002363 CHECK_AND_FREE(privkey);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002364 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002365}
2366
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002367json_object *
2368handle_op_disconnect(json_object *UNUSED(request), unsigned int session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002369{
Michal Vasko53260242016-04-06 11:18:18 +02002370 json_object *reply = NULL;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002371
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002372 DEBUG("Request: disconnect (session %u)", session_key);
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01002373
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002374 if (netconf_close(session_key, &reply) != EXIT_SUCCESS) {
2375 CHECK_ERR_SET_REPLY_ERR("Get configuration information from device failed.")
2376 } else {
2377 reply = create_ok_reply();
2378 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002379
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002380 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002381}
2382
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002383json_object *
2384handle_op_get(json_object *request, unsigned int session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002385{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002386 char *filter = NULL;
2387 char *data = NULL;
2388 json_object *reply = NULL, *obj;
2389 int strict;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002390
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002391 DEBUG("Request: get (session %u)", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002392
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002393 pthread_mutex_lock(&json_lock);
2394 filter = get_param_string(request, "filter");
2395 if (json_object_object_get_ex(request, "strict", &obj) == FALSE) {
2396 pthread_mutex_unlock(&json_lock);
2397 reply = create_error_reply("Missing strict parameter.");
Michal Vaskoedab4df2016-04-13 11:33:58 +02002398 goto finalize;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002399 }
2400 strict = json_object_get_boolean(obj);
2401 pthread_mutex_unlock(&json_lock);
Tomas Cejka09629492014-07-10 15:58:06 +02002402
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002403 if ((data = netconf_get(session_key, filter, strict, &reply)) == NULL) {
2404 CHECK_ERR_SET_REPLY_ERR("Get information failed.")
2405 } else {
2406 reply = create_data_reply(data);
2407 free(data);
2408 }
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01002409
Michal Vaskoedab4df2016-04-13 11:33:58 +02002410finalize:
2411 CHECK_AND_FREE(filter);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002412 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002413}
2414
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002415json_object *
2416handle_op_getconfig(json_object *request, unsigned int session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002417{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002418 NC_DATASTORE ds_type_s = -1;
2419 char *filter = NULL;
2420 char *data = NULL;
2421 char *source = NULL;
2422 json_object *reply = NULL, *obj;
2423 int strict;
Tomas Cejkab4d05872014-02-14 22:44:38 +01002424
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002425 DEBUG("Request: get-config (session %u)", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002426
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002427 pthread_mutex_lock(&json_lock);
2428 filter = get_param_string(request, "filter");
2429 source = get_param_string(request, "source");
2430 if (source != NULL) {
2431 ds_type_s = parse_datastore(source);
2432 }
2433 if (json_object_object_get_ex(request, "strict", &obj) == FALSE) {
2434 pthread_mutex_unlock(&json_lock);
2435 reply = create_error_reply("Missing strict parameter.");
Michal Vaskoedab4df2016-04-13 11:33:58 +02002436 goto finalize;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002437 }
2438 strict = json_object_get_boolean(obj);
2439 pthread_mutex_unlock(&json_lock);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002440
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002441 if ((int)ds_type_s == -1) {
2442 reply = create_error_reply("Invalid source repository type requested.");
2443 goto finalize;
2444 }
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01002445
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002446 if ((data = netconf_getconfig(session_key, ds_type_s, filter, strict, &reply)) == NULL) {
2447 CHECK_ERR_SET_REPLY_ERR("Get configuration operation failed.")
2448 } else {
2449 reply = create_data_reply(data);
2450 free(data);
2451 }
Tomas Cejkaedb3ab42014-03-27 15:04:00 +01002452
Tomas Cejka09629492014-07-10 15:58:06 +02002453finalize:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002454 CHECK_AND_FREE(filter);
2455 CHECK_AND_FREE(source);
2456 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002457}
2458
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002459json_object *
2460handle_op_editconfig(json_object *request, unsigned int session_key, int idx)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002461{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002462 NC_DATASTORE ds_type_t = -1;
Michal Vaskof35ea502016-02-24 10:44:54 +01002463 NC_RPC_EDIT_DFLTOP defop_type = 0;
2464 NC_RPC_EDIT_ERROPT erropt_type = 0;
2465 NC_RPC_EDIT_TESTOPT testopt_type = NC_RPC_EDIT_TESTOPT_TESTSET;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002466 char *defop = NULL;
2467 char *erropt = NULL;
2468 char *config = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002469 char *target = NULL;
2470 char *testopt = NULL;
2471 char *urisource = NULL;
2472 json_object *reply = NULL, *configs, *obj;
Michal Vaskof35ea502016-02-24 10:44:54 +01002473 struct lyd_node *content;
2474 struct session_with_mutex *locked_session;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002475
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002476 DEBUG("Request: edit-config (session %u)", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002477
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002478 pthread_mutex_lock(&json_lock);
2479 /* get parameters */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002480 if (json_object_object_get_ex(request, "configs", &configs) == FALSE) {
2481 pthread_mutex_unlock(&json_lock);
2482 reply = create_error_reply("Missing configs parameter.");
2483 goto finalize;
2484 }
2485 obj = json_object_array_get_idx(configs, idx);
2486 config = strdup(json_object_get_string(obj));
Tomas Cejkad5b53772013-06-08 23:01:07 +02002487
Michal Vaskof35ea502016-02-24 10:44:54 +01002488 target = get_param_string(request, "target");
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002489 defop = get_param_string(request, "default-operation");
2490 erropt = get_param_string(request, "error-option");
2491 urisource = get_param_string(request, "uri-source");
2492 testopt = get_param_string(request, "test-option");
2493 pthread_mutex_unlock(&json_lock);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002494
Michal Vaskob8f5d442016-04-05 14:48:37 +02002495 if (!target) {
2496 ERROR("Missing the target parameter.");
2497 goto finalize;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002498 }
Michal Vaskob8f5d442016-04-05 14:48:37 +02002499 ds_type_t = parse_datastore(target);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002500
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002501 if (defop != NULL) {
2502 if (strcmp(defop, "merge") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002503 defop_type = NC_RPC_EDIT_DFLTOP_MERGE;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002504 } else if (strcmp(defop, "replace") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002505 defop_type = NC_RPC_EDIT_DFLTOP_REPLACE;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002506 } else if (strcmp(defop, "none") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002507 defop_type = NC_RPC_EDIT_DFLTOP_NONE;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002508 } else {
2509 reply = create_error_reply("Invalid default-operation parameter.");
2510 goto finalize;
2511 }
2512 } else {
Michal Vaskof35ea502016-02-24 10:44:54 +01002513 defop_type = NC_RPC_EDIT_DFLTOP_UNKNOWN;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002514 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002515
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002516 if (erropt != NULL) {
2517 if (strcmp(erropt, "continue-on-error") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002518 erropt_type = NC_RPC_EDIT_ERROPT_CONTINUE;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002519 } else if (strcmp(erropt, "stop-on-error") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002520 erropt_type = NC_RPC_EDIT_ERROPT_STOP;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002521 } else if (strcmp(erropt, "rollback-on-error") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002522 erropt_type = NC_RPC_EDIT_ERROPT_ROLLBACK;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002523 } else {
2524 reply = create_error_reply("Invalid error-option parameter.");
2525 goto finalize;
2526 }
2527 } else {
2528 erropt_type = 0;
2529 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002530
Michal Vaskof35ea502016-02-24 10:44:54 +01002531 if ((config && urisource) || (!config && !urisource)) {
2532 reply = create_error_reply("Invalid config and uri-source data parameters.");
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002533 goto finalize;
2534 }
Michal Vaskof35ea502016-02-24 10:44:54 +01002535
2536 if (config) {
2537 locked_session = session_get_locked(session_key, NULL);
2538 if (!locked_session) {
2539 ERROR("Unknown session or locking failed.");
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002540 goto finalize;
2541 }
Michal Vaskof35ea502016-02-24 10:44:54 +01002542
2543 content = lyd_parse_mem(nc_session_get_ctx(locked_session->session), config, LYD_JSON, LYD_OPT_EDIT);
2544 session_unlock(locked_session);
2545
Michal Vaskoc7a8f3c2016-04-05 14:53:33 +02002546 if (!content) {
2547 ERROR("Failed to parse edit-config content.");
2548 goto finalize;
2549 }
2550
Michal Vaskof35ea502016-02-24 10:44:54 +01002551 free(config);
Michal Vaskoc7a8f3c2016-04-05 14:53:33 +02002552 config = NULL;
2553
Michal Vaskof35ea502016-02-24 10:44:54 +01002554 lyd_print_mem(&config, content, LYD_XML, LYP_WITHSIBLINGS);
2555 lyd_free_withsiblings(content);
Michal Vaskoc7a8f3c2016-04-05 14:53:33 +02002556 if (!config) {
2557 ERROR("Failed to print edit-config content.");
2558 goto finalize;
2559 }
Michal Vaskof35ea502016-02-24 10:44:54 +01002560 } else {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002561 config = urisource;
2562 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002563
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002564 if (testopt != NULL) {
2565 testopt_type = parse_testopt(testopt);
2566 } else {
Michal Vaskof35ea502016-02-24 10:44:54 +01002567 testopt_type = NC_RPC_EDIT_TESTOPT_TESTSET;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002568 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002569
Michal Vaskof35ea502016-02-24 10:44:54 +01002570 reply = netconf_editconfig(session_key, ds_type_t, defop_type, erropt_type, testopt_type, config);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002571
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002572 CHECK_ERR_SET_REPLY
Tomas Cejkaedb3ab42014-03-27 15:04:00 +01002573
Tomas Cejka09629492014-07-10 15:58:06 +02002574finalize:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002575 CHECK_AND_FREE(defop);
2576 CHECK_AND_FREE(erropt);
2577 CHECK_AND_FREE(config);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002578 CHECK_AND_FREE(urisource);
2579 CHECK_AND_FREE(target);
2580 CHECK_AND_FREE(testopt);
2581
2582 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002583}
2584
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002585json_object *
2586handle_op_copyconfig(json_object *request, unsigned int session_key, int idx)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002587{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002588 NC_DATASTORE ds_type_s = -1;
2589 NC_DATASTORE ds_type_t = -1;
2590 char *config = NULL;
2591 char *target = NULL;
2592 char *source = NULL;
2593 char *uri_src = NULL;
2594 char *uri_trg = NULL;
2595 json_object *reply = NULL, *configs, *obj;
Michal Vaskof35ea502016-02-24 10:44:54 +01002596 struct lyd_node *content;
2597 struct session_with_mutex *locked_session;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002598
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002599 DEBUG("Request: copy-config (session %u)", session_key);
Tomas Cejka47387fd2013-06-10 20:37:46 +02002600
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002601 /* get parameters */
2602 pthread_mutex_lock(&json_lock);
2603 target = get_param_string(request, "target");
2604 source = get_param_string(request, "source");
2605 uri_src = get_param_string(request, "uri-source");
2606 uri_trg = get_param_string(request, "uri-target");
2607 if (!strcmp(source, "config")) {
2608 if (json_object_object_get_ex(request, "configs", &configs) == FALSE) {
2609 pthread_mutex_unlock(&json_lock);
2610 reply = create_error_reply("Missing configs parameter.");
2611 goto finalize;
2612 }
2613 obj = json_object_array_get_idx(configs, idx);
2614 if (!obj) {
2615 pthread_mutex_unlock(&json_lock);
2616 reply = create_error_reply("Configs array parameter shorter than sessions.");
2617 goto finalize;
2618 }
2619 config = strdup(json_object_get_string(obj));
2620 }
2621 pthread_mutex_unlock(&json_lock);
2622
2623 if (target != NULL) {
2624 ds_type_t = parse_datastore(target);
2625 }
2626 if (source != NULL) {
2627 ds_type_s = parse_datastore(source);
2628 }
2629
2630 if ((int)ds_type_s == -1) {
2631 /* invalid source datastore specified */
2632 reply = create_error_reply("Invalid source repository type requested.");
2633 goto finalize;
2634 }
2635
2636 if ((int)ds_type_t == -1) {
2637 /* invalid target datastore specified */
2638 reply = create_error_reply("Invalid target repository type requested.");
2639 goto finalize;
2640 }
2641
2642 if (ds_type_s == NC_DATASTORE_URL) {
2643 if (uri_src == NULL) {
2644 uri_src = "";
2645 }
2646 }
2647 if (ds_type_t == NC_DATASTORE_URL) {
2648 if (uri_trg == NULL) {
2649 uri_trg = "";
2650 }
2651 }
Michal Vaskof35ea502016-02-24 10:44:54 +01002652
2653 if (config) {
2654 locked_session = session_get_locked(session_key, NULL);
2655 if (!locked_session) {
2656 ERROR("Unknown session or locking failed.");
2657 goto finalize;
2658 }
2659
2660 content = lyd_parse_mem(nc_session_get_ctx(locked_session->session), config, LYD_JSON, LYD_OPT_CONFIG);
2661 session_unlock(locked_session);
2662
2663 free(config);
2664 lyd_print_mem(&config, content, LYD_XML, LYP_WITHSIBLINGS);
2665 lyd_free_withsiblings(content);
2666 }
2667
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002668 reply = netconf_copyconfig(session_key, ds_type_s, ds_type_t, config, uri_src, uri_trg);
2669
2670 CHECK_ERR_SET_REPLY
2671
2672finalize:
2673 CHECK_AND_FREE(config);
2674 CHECK_AND_FREE(target);
2675 CHECK_AND_FREE(source);
2676 CHECK_AND_FREE(uri_src);
2677 CHECK_AND_FREE(uri_trg);
2678
2679 return reply;
2680}
2681
2682json_object *
2683handle_op_deleteconfig(json_object *request, unsigned int session_key)
2684{
2685 json_object *reply;
2686 NC_DATASTORE ds_type = -1;
2687 char *target, *url;
2688
2689 DEBUG("Request: delete-config (session %u)", session_key);
2690
2691 pthread_mutex_lock(&json_lock);
2692 target = get_param_string(request, "target");
2693 url = get_param_string(request, "url");
2694 pthread_mutex_unlock(&json_lock);
2695
2696 if (target != NULL) {
2697 ds_type = parse_datastore(target);
2698 }
2699 if ((int)ds_type == -1) {
2700 reply = create_error_reply("Invalid target repository type requested.");
2701 goto finalize;
2702 }
2703 if (ds_type == NC_DATASTORE_URL) {
2704 if (!url) {
2705 url = "";
2706 }
2707 }
2708
2709 reply = netconf_deleteconfig(session_key, ds_type, url);
2710
2711 CHECK_ERR_SET_REPLY
2712 if (reply == NULL) {
2713 reply = create_ok_reply();
2714 }
2715
2716finalize:
2717 CHECK_AND_FREE(target);
2718 CHECK_AND_FREE(url);
2719 return reply;
2720}
2721
2722json_object *
2723handle_op_lock(json_object *request, unsigned int session_key)
2724{
2725 json_object *reply;
2726 NC_DATASTORE ds_type = -1;
2727 char *target;
2728
2729 DEBUG("Request: lock (session %u)", session_key);
2730
2731 pthread_mutex_lock(&json_lock);
2732 target = get_param_string(request, "target");
2733 pthread_mutex_unlock(&json_lock);
2734
2735 if (target != NULL) {
2736 ds_type = parse_datastore(target);
2737 }
2738 if ((int)ds_type == -1) {
2739 reply = create_error_reply("Invalid target repository type requested.");
2740 goto finalize;
2741 }
2742
2743 reply = netconf_lock(session_key, ds_type);
2744
2745 CHECK_ERR_SET_REPLY
2746 if (reply == NULL) {
2747 reply = create_ok_reply();
2748 }
2749
2750finalize:
2751 CHECK_AND_FREE(target);
2752 return reply;
2753}
2754
2755json_object *
2756handle_op_unlock(json_object *request, unsigned int session_key)
2757{
2758 json_object *reply;
2759 NC_DATASTORE ds_type = -1;
2760 char *target;
2761
2762 DEBUG("Request: unlock (session %u)", session_key);
2763
2764 pthread_mutex_lock(&json_lock);
2765 target = get_param_string(request, "target");
2766 pthread_mutex_unlock(&json_lock);
2767
2768 if (target != NULL) {
2769 ds_type = parse_datastore(target);
2770 }
2771 if ((int)ds_type == -1) {
2772 reply = create_error_reply("Invalid target repository type requested.");
2773 goto finalize;
2774 }
2775
2776 reply = netconf_unlock(session_key, ds_type);
2777
2778 CHECK_ERR_SET_REPLY
2779 if (reply == NULL) {
2780 reply = create_ok_reply();
2781 }
2782
2783finalize:
2784 CHECK_AND_FREE(target);
2785 return reply;
2786}
2787
2788json_object *
2789handle_op_kill(json_object *request, unsigned int session_key)
2790{
2791 json_object *reply = NULL;
2792 char *sid = NULL;
2793
2794 DEBUG("Request: kill-session (session %u)", session_key);
2795
2796 pthread_mutex_lock(&json_lock);
2797 sid = get_param_string(request, "session-id");
2798 pthread_mutex_unlock(&json_lock);
2799
2800 if (sid == NULL) {
2801 reply = create_error_reply("Missing session-id parameter.");
2802 goto finalize;
2803 }
2804
2805 reply = netconf_killsession(session_key, sid);
2806
2807 CHECK_ERR_SET_REPLY
2808
2809finalize:
2810 CHECK_AND_FREE(sid);
2811 return reply;
2812}
2813
2814json_object *
2815handle_op_info(json_object *UNUSED(request), unsigned int session_key)
2816{
2817 json_object *reply = NULL;
2818 struct session_with_mutex *locked_session = NULL;
2819 DEBUG("Request: get info about session %u", session_key);
2820
2821 DEBUG("LOCK wrlock %s", __func__);
2822 if (pthread_rwlock_rdlock(&session_lock) != 0) {
2823 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
2824 }
2825
2826 for (locked_session = netconf_sessions_list;
2827 locked_session && (locked_session->session_key != session_key);
Michal Vaskoc3146782015-11-04 14:46:41 +01002828 locked_session = locked_session->next);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002829 if (locked_session != NULL) {
2830 DEBUG("LOCK mutex %s", __func__);
2831 pthread_mutex_lock(&locked_session->lock);
2832 DEBUG("UNLOCK wrlock %s", __func__);
2833 if (pthread_rwlock_unlock(&session_lock) != 0) {
2834 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
2835 }
2836 if (locked_session->hello_message != NULL) {
Michal Vaskoa266afd2016-04-13 10:33:53 +02002837 reply = json_object_get(locked_session->hello_message);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002838 } else {
2839 reply = create_error_reply("Invalid session identifier.");
2840 }
2841 DEBUG("UNLOCK mutex %s", __func__);
2842 pthread_mutex_unlock(&locked_session->lock);
2843 } else {
2844 DEBUG("UNLOCK wrlock %s", __func__);
2845 if (pthread_rwlock_unlock(&session_lock) != 0) {
2846 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
2847 }
2848 reply = create_error_reply("Invalid session identifier.");
2849 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002850
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002851 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002852}
2853
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002854json_object *
2855handle_op_generic(json_object *request, unsigned int session_key, int idx)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002856{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002857 json_object *reply = NULL, *contents, *obj;
Michal Vaskof35ea502016-02-24 10:44:54 +01002858 char *content = NULL, *str;
2859 struct lyd_node *data = NULL, *node_content;
2860 struct session_with_mutex *locked_session;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002861
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002862 DEBUG("Request: generic request (session %u)", session_key);
Tomas Cejka47387fd2013-06-10 20:37:46 +02002863
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002864 pthread_mutex_lock(&json_lock);
2865 if (json_object_object_get_ex(request, "contents", &contents) == FALSE) {
2866 pthread_mutex_unlock(&json_lock);
2867 reply = create_error_reply("Missing contents parameter.");
2868 goto finalize;
2869 }
2870 obj = json_object_array_get_idx(contents, idx);
2871 if (!obj) {
2872 pthread_mutex_unlock(&json_lock);
2873 reply = create_error_reply("Contents array parameter shorter than sessions.");
2874 goto finalize;
2875 }
Michal Vaskof35ea502016-02-24 10:44:54 +01002876 content = strdup(json_object_get_string(obj));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002877 pthread_mutex_unlock(&json_lock);
2878
Michal Vaskof35ea502016-02-24 10:44:54 +01002879 locked_session = session_get_locked(session_key, NULL);
2880 if (!locked_session) {
2881 ERROR("Unknown session or locking failed.");
2882 goto finalize;
2883 }
2884
2885 node_content = lyd_parse_mem(nc_session_get_ctx(locked_session->session), content, LYD_JSON, LYD_OPT_RPC);
2886 session_unlock(locked_session);
2887
2888 free(content);
2889 lyd_print_mem(&content, node_content, LYD_XML, LYP_WITHSIBLINGS);
2890 lyd_free_withsiblings(node_content);
2891
2892 reply = netconf_generic(session_key, content, &data);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002893 if (reply == NULL) {
2894 GETSPEC_ERR_REPLY
2895 if (err_reply != NULL) {
2896 /* use filled err_reply from libnetconf's callback */
2897 reply = err_reply;
2898 }
2899 } else {
2900 if (data == NULL) {
2901 pthread_mutex_lock(&json_lock);
2902 reply = json_object_new_object();
2903 json_object_object_add(reply, "type", json_object_new_int(REPLY_OK));
2904 pthread_mutex_unlock(&json_lock);
2905 } else {
Michal Vaskof35ea502016-02-24 10:44:54 +01002906 lyd_print_mem(&str, data, LYD_JSON, LYP_WITHSIBLINGS);
2907 lyd_free_withsiblings(data);
2908 reply = create_data_reply(str);
2909 free(str);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002910 }
2911 }
2912
2913finalize:
Michal Vaskof35ea502016-02-24 10:44:54 +01002914 CHECK_AND_FREE(content);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002915 return reply;
2916}
2917
2918json_object *
2919handle_op_getschema(json_object *request, unsigned int session_key)
2920{
2921 char *data = NULL;
2922 char *identifier = NULL;
2923 char *version = NULL;
2924 char *format = NULL;
2925 json_object *reply = NULL;
2926
2927 DEBUG("Request: get-schema (session %u)", session_key);
2928
2929 pthread_mutex_lock(&json_lock);
2930 identifier = get_param_string(request, "identifier");
2931 version = get_param_string(request, "version");
2932 format = get_param_string(request, "format");
2933 pthread_mutex_unlock(&json_lock);
2934
2935 if (identifier == NULL) {
2936 reply = create_error_reply("No identifier for get-schema supplied.");
2937 goto finalize;
2938 }
2939
2940 DEBUG("get-schema(version: %s, format: %s)", version, format);
2941 if ((data = netconf_getschema(session_key, identifier, version, format, &reply)) == NULL) {
2942 CHECK_ERR_SET_REPLY_ERR("Get models operation failed.")
2943 } else {
2944 reply = create_data_reply(data);
2945 free(data);
2946 }
2947
2948finalize:
2949 CHECK_AND_FREE(identifier);
2950 CHECK_AND_FREE(version);
2951 CHECK_AND_FREE(format);
2952 return reply;
2953}
2954
2955json_object *
2956handle_op_reloadhello(json_object *UNUSED(request), unsigned int session_key)
2957{
2958 struct nc_session *temp_session = NULL;
2959 struct session_with_mutex * locked_session = NULL;
2960 json_object *reply = NULL;
2961
2962 DEBUG("Request: reload hello (session %u)", session_key);
2963
2964 DEBUG("LOCK wrlock %s", __func__);
2965 if (pthread_rwlock_wrlock(&session_lock) != 0) {
2966 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
2967 return NULL;
2968 }
2969
2970 for (locked_session = netconf_sessions_list;
2971 locked_session && (locked_session->session_key != session_key);
Michal Vaskoc3146782015-11-04 14:46:41 +01002972 locked_session = locked_session->next);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002973 if ((locked_session != NULL) && (locked_session->hello_message != NULL)) {
2974 DEBUG("LOCK mutex %s", __func__);
2975 pthread_mutex_lock(&locked_session->lock);
2976 DEBUG("creating temporary NC session.");
Michal Vaskof35ea502016-02-24 10:44:54 +01002977 temp_session = nc_connect_ssh_channel(locked_session->session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002978 if (temp_session != NULL) {
2979 prepare_status_message(locked_session, temp_session);
2980 DEBUG("closing temporal NC session.");
Michal Vaskoa9590052016-03-08 10:12:24 +01002981 nc_session_free(temp_session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002982 temp_session = NULL;
2983 } else {
2984 DEBUG("Reload hello failed due to channel establishment");
2985 reply = create_error_reply("Reload was unsuccessful, connection failed.");
2986 }
2987 DEBUG("UNLOCK mutex %s", __func__);
2988 pthread_mutex_unlock(&locked_session->lock);
2989 DEBUG("UNLOCK wrlock %s", __func__);
2990 if (pthread_rwlock_unlock(&session_lock) != 0) {
2991 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
2992 }
2993 } else {
2994 DEBUG("UNLOCK wrlock %s", __func__);
2995 if (pthread_rwlock_unlock(&session_lock) != 0) {
2996 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
2997 }
2998 reply = create_error_reply("Invalid session identifier.");
2999 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02003000
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003001 if ((reply == NULL) && (locked_session->hello_message != NULL)) {
Michal Vaskoa266afd2016-04-13 10:33:53 +02003002 reply = json_object_get(locked_session->hello_message);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003003 }
Tomas Cejka47387fd2013-06-10 20:37:46 +02003004
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003005 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02003006}
3007
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003008void
Michal Vaskof35ea502016-02-24 10:44:54 +01003009notification_history(struct nc_session *session, const struct nc_notif *notif)
Tomas Cejka6b886e02013-07-05 09:53:17 +02003010{
Michal Vaskof35ea502016-02-24 10:44:54 +01003011 time_t eventtime;
3012 char *content;
3013 (void)session;
3014
3015 eventtime = nc_datetime2time(notif->datetime);
3016
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003017 json_object *notif_history_array = (json_object *)pthread_getspecific(notif_history_key);
3018 if (notif_history_array == NULL) {
3019 ERROR("No list of notification history found.");
3020 return;
3021 }
3022 DEBUG("Got notification from history %lu.", (long unsigned)eventtime);
3023 pthread_mutex_lock(&json_lock);
Michal Vaskof35ea502016-02-24 10:44:54 +01003024 json_object *notif_obj = json_object_new_object();
3025 if (notif_obj == NULL) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003026 ERROR("Could not allocate memory for notification (json).");
3027 goto failed;
3028 }
Michal Vaskof35ea502016-02-24 10:44:54 +01003029 lyd_print_mem(&content, notif->tree, LYD_JSON, 0);
3030
3031 json_object_object_add(notif_obj, "eventtime", json_object_new_int64(eventtime));
3032 json_object_object_add(notif_obj, "content", json_object_new_string(content));
3033
3034 free(content);
3035
3036 json_object_array_add(notif_history_array, notif_obj);
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01003037failed:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003038 pthread_mutex_unlock(&json_lock);
Tomas Cejka6b886e02013-07-05 09:53:17 +02003039}
3040
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003041json_object *
3042handle_op_ntfgethistory(json_object *request, unsigned int session_key)
Tomas Cejka6b886e02013-07-05 09:53:17 +02003043{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003044 json_object *reply = NULL;
3045 json_object *js_tmp = NULL;
3046 struct session_with_mutex *locked_session = NULL;
3047 struct nc_session *temp_session = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01003048 struct nc_rpc *rpc = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003049 time_t start = 0;
3050 time_t stop = 0;
3051 int64_t from = 0, to = 0;
Tomas Cejka6b886e02013-07-05 09:53:17 +02003052
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003053 DEBUG("Request: get notification history (session %u)", session_key);
Tomas Cejka6b886e02013-07-05 09:53:17 +02003054
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003055 pthread_mutex_lock(&json_lock);
3056 if (json_object_object_get_ex(request, "from", &js_tmp) == TRUE) {
3057 from = json_object_get_int64(js_tmp);
3058 }
3059 if (json_object_object_get_ex(request, "to", &js_tmp) == TRUE) {
3060 to = json_object_get_int64(js_tmp);
3061 }
3062 pthread_mutex_unlock(&json_lock);
Tomas Cejka09629492014-07-10 15:58:06 +02003063
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003064 start = time(NULL) + from;
3065 stop = time(NULL) + to;
Tomas Cejka6b886e02013-07-05 09:53:17 +02003066
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003067 DEBUG("notification history interval %li %li", (long int)from, (long int)to);
Tomas Cejka6b886e02013-07-05 09:53:17 +02003068
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003069 DEBUG("LOCK wrlock %s", __func__);
3070 if (pthread_rwlock_rdlock(&session_lock) != 0) {
3071 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
3072 reply = create_error_reply("Internal lock failed.");
3073 goto finalize;
3074 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02003075
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003076 for (locked_session = netconf_sessions_list;
3077 locked_session && (locked_session->session_key != session_key);
Michal Vaskoc3146782015-11-04 14:46:41 +01003078 locked_session = locked_session->next);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003079 if (locked_session != NULL) {
3080 DEBUG("LOCK mutex %s", __func__);
3081 pthread_mutex_lock(&locked_session->lock);
3082 DEBUG("UNLOCK wrlock %s", __func__);
3083 if (pthread_rwlock_unlock(&session_lock) != 0) {
3084 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
3085 }
3086 DEBUG("creating temporal NC session.");
Michal Vaskof35ea502016-02-24 10:44:54 +01003087 temp_session = nc_connect_ssh_channel(locked_session->session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003088 if (temp_session != NULL) {
Michal Vaskof35ea502016-02-24 10:44:54 +01003089 rpc = nc_rpc_subscribe(NULL, NULL, nc_time2datetime(start, NULL), nc_time2datetime(stop, NULL), NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003090 if (rpc == NULL) {
3091 DEBUG("UNLOCK mutex %s", __func__);
3092 pthread_mutex_unlock(&locked_session->lock);
3093 DEBUG("notifications: creating an rpc request failed.");
3094 reply = create_error_reply("notifications: creating an rpc request failed.");
3095 goto finalize;
3096 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02003097
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003098 DEBUG("Send NC subscribe.");
3099 /** \todo replace with sth like netconf_op(http_server, session_hash, rpc) */
3100 json_object *res = netconf_unlocked_op(temp_session, rpc);
3101 if (res != NULL) {
3102 DEBUG("UNLOCK mutex %s", __func__);
3103 pthread_mutex_unlock(&locked_session->lock);
3104 DEBUG("Subscription RPC failed.");
3105 reply = res;
3106 goto finalize;
3107 }
3108 rpc = NULL; /* just note that rpc is already freed by send_recv_process() */
Tomas Cejka6b886e02013-07-05 09:53:17 +02003109
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003110 DEBUG("UNLOCK mutex %s", __func__);
3111 pthread_mutex_unlock(&locked_session->lock);
Michal Vaskodc40b3a2016-04-11 14:36:16 +02003112 DEBUG("LOCK ntf mutex %s", __func__);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003113 pthread_mutex_lock(&ntf_history_lock);
3114 pthread_mutex_lock(&json_lock);
3115 json_object *notif_history_array = json_object_new_array();
3116 pthread_mutex_unlock(&json_lock);
3117 if (pthread_setspecific(notif_history_key, notif_history_array) != 0) {
3118 ERROR("notif_history: cannot set thread-specific hash value.");
3119 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02003120
Michal Vaskof35ea502016-02-24 10:44:54 +01003121 nc_recv_notif_dispatch(temp_session, notification_history);
Tomas Cejka6b886e02013-07-05 09:53:17 +02003122
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003123 pthread_mutex_lock(&json_lock);
3124 reply = json_object_new_object();
3125 json_object_object_add(reply, "notifications", notif_history_array);
3126 //json_object_put(notif_history_array);
3127 pthread_mutex_unlock(&json_lock);
Tomas Cejka6b886e02013-07-05 09:53:17 +02003128
Michal Vaskodc40b3a2016-04-11 14:36:16 +02003129 DEBUG("UNLOCK ntf mutex %s", __func__);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003130 pthread_mutex_unlock(&ntf_history_lock);
3131 DEBUG("closing temporal NC session.");
Michal Vaskoa9590052016-03-08 10:12:24 +01003132 nc_session_free(temp_session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003133 temp_session = NULL;
3134 } else {
3135 DEBUG("UNLOCK mutex %s", __func__);
3136 pthread_mutex_unlock(&locked_session->lock);
3137 DEBUG("Get history of notification failed due to channel establishment");
3138 reply = create_error_reply("Get history of notification was unsuccessful, connection failed.");
3139 }
3140 } else {
3141 DEBUG("UNLOCK wrlock %s", __func__);
3142 if (pthread_rwlock_unlock(&session_lock) != 0) {
3143 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
3144 }
3145 reply = create_error_reply("Invalid session identifier.");
3146 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02003147
Tomas Cejka09629492014-07-10 15:58:06 +02003148finalize:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003149 return reply;
Tomas Cejka4003a702013-10-01 00:02:45 +02003150}
3151
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003152json_object *
3153handle_op_validate(json_object *request, unsigned int session_key)
Tomas Cejka4003a702013-10-01 00:02:45 +02003154{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003155 json_object *reply = NULL;
3156 char *target = NULL;
3157 char *url = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01003158 struct nc_rpc *rpc = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003159 NC_DATASTORE target_ds;
Tomas Cejka4003a702013-10-01 00:02:45 +02003160
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003161 DEBUG("Request: validate datastore (session %u)", session_key);
Tomas Cejka4003a702013-10-01 00:02:45 +02003162
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003163 pthread_mutex_lock(&json_lock);
3164 target = get_param_string(request, "target");
3165 url = get_param_string(request, "url");
3166 pthread_mutex_unlock(&json_lock);
Tomas Cejka4003a702013-10-01 00:02:45 +02003167
3168
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003169 if (target == NULL) {
3170 reply = create_error_reply("Missing target parameter.");
3171 goto finalize;
3172 }
Tomas Cejka4003a702013-10-01 00:02:45 +02003173
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003174 /* validation */
3175 target_ds = parse_datastore(target);
Michal Vaskof35ea502016-02-24 10:44:54 +01003176 rpc = nc_rpc_validate(target_ds, url, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003177 if (rpc == NULL) {
3178 DEBUG("mod_netconf: creating rpc request failed");
3179 reply = create_error_reply("Creation of RPC request failed.");
3180 goto finalize;
3181 }
Tomas Cejka4003a702013-10-01 00:02:45 +02003182
Michal Vaskof35ea502016-02-24 10:44:54 +01003183 if ((reply = netconf_op(session_key, rpc, 0, NULL)) == NULL) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003184 CHECK_ERR_SET_REPLY
Tomas Cejkaedb3ab42014-03-27 15:04:00 +01003185
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003186 if (reply == NULL) {
3187 DEBUG("Request: validation ok.");
3188 reply = create_ok_reply();
3189 }
3190 }
3191 nc_rpc_free (rpc);
Tomas Cejkaedb3ab42014-03-27 15:04:00 +01003192
Tomas Cejka09629492014-07-10 15:58:06 +02003193finalize:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003194 CHECK_AND_FREE(target);
3195 CHECK_AND_FREE(url);
3196 return reply;
Tomas Cejka6b886e02013-07-05 09:53:17 +02003197}
3198
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003199json_object *
3200handle_op_query(json_object *request, unsigned int session_key, int idx)
David Kupka8e60a372012-09-04 09:15:20 +02003201{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003202 json_object *reply = NULL, *filters, *obj;
3203 char *filter = NULL;
3204 int load_children = 0;
David Kupka8e60a372012-09-04 09:15:20 +02003205
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003206 DEBUG("Request: query (session %u)", session_key);
David Kupka8e60a372012-09-04 09:15:20 +02003207
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003208 pthread_mutex_lock(&json_lock);
3209 if (json_object_object_get_ex(request, "filters", &filters) == FALSE) {
3210 pthread_mutex_unlock(&json_lock);
3211 reply = create_error_reply("Missing filters parameter.");
3212 goto finalize;
3213 }
3214 obj = json_object_array_get_idx(filters, idx);
3215 if (!obj) {
3216 pthread_mutex_unlock(&json_lock);
3217 reply = create_error_reply("Filters array parameter shorter than sessions.");
3218 goto finalize;
3219 }
3220 filter = strdup(json_object_get_string(obj));
3221 if (json_object_object_get_ex(request, "load_children", &obj) == TRUE) {
3222 load_children = json_object_get_boolean(obj);
3223 }
3224 pthread_mutex_unlock(&json_lock);
Tomas Cejka442258e2014-04-01 18:17:18 +02003225
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003226 reply = libyang_query(session_key, filter, load_children);
David Kupka8e60a372012-09-04 09:15:20 +02003227
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003228 CHECK_ERR_SET_REPLY
3229 if (!reply) {
3230 reply = create_error_reply("Query failed.");
3231 }
David Kupka8e60a372012-09-04 09:15:20 +02003232
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003233finalize:
3234 CHECK_AND_FREE(filter);
3235 return reply;
3236}
David Kupka8e60a372012-09-04 09:15:20 +02003237
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003238json_object *
3239handle_op_merge(json_object *request, unsigned int session_key, int idx)
3240{
3241 json_object *reply = NULL, *configs, *obj;
3242 char *config = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01003243 struct lyd_node *content;
3244 struct session_with_mutex *locked_session;
David Kupka8e60a372012-09-04 09:15:20 +02003245
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003246 DEBUG("Request: merge (session %u)", session_key);
David Kupka8e60a372012-09-04 09:15:20 +02003247
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003248 pthread_mutex_lock(&json_lock);
3249 if (json_object_object_get_ex(request, "configurations", &configs) == FALSE) {
3250 pthread_mutex_unlock(&json_lock);
3251 reply = create_error_reply("Missing configurations parameter.");
3252 goto finalize;
3253 }
3254 obj = json_object_array_get_idx(configs, idx);
3255 if (!obj) {
3256 pthread_mutex_unlock(&json_lock);
3257 reply = create_error_reply("Filters array parameter shorter than sessions.");
3258 goto finalize;
3259 }
3260 config = strdup(json_object_get_string(obj));
3261 pthread_mutex_unlock(&json_lock);
David Kupka8e60a372012-09-04 09:15:20 +02003262
Michal Vaskof35ea502016-02-24 10:44:54 +01003263 locked_session = session_get_locked(session_key, NULL);
3264 if (!locked_session) {
3265 ERROR("Unknown session or locking failed.");
3266 goto finalize;
3267 }
3268
3269 content = lyd_parse_mem(nc_session_get_ctx(locked_session->session), config, LYD_JSON, LYD_OPT_DATA);
3270 session_unlock(locked_session);
3271
3272 free(config);
3273 lyd_print_mem(&config, content, LYD_XML, LYP_WITHSIBLINGS);
3274 lyd_free_withsiblings(content);
3275
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003276 reply = libyang_merge(session_key, config);
David Kupka8e60a372012-09-04 09:15:20 +02003277
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003278 CHECK_ERR_SET_REPLY
3279 if (!reply) {
3280 reply = create_error_reply("Merge failed.");
3281 }
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01003282
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003283finalize:
3284 CHECK_AND_FREE(config);
3285 return reply;
3286}
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01003287
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003288void *
3289thread_routine(void *arg)
3290{
3291 void *retval = NULL;
3292 struct pollfd fds;
3293 json_object *request = NULL, *replies = NULL, *reply, *sessions = NULL;
3294 json_object *js_tmp = NULL;
Michal Vaskodf280a22016-03-17 09:19:53 +01003295 int operation = (-1), count, i, sent;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003296 int status = 0;
3297 const char *msgtext;
3298 unsigned int session_key = 0;
3299 char *chunked_out_msg = NULL;
3300 int client = ((struct pass_to_thread *)arg)->client;
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01003301
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003302 char *buffer = NULL;
David Kupka8e60a372012-09-04 09:15:20 +02003303
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003304 /* init thread specific err_reply memory */
3305 create_err_reply_p();
David Kupka8e60a372012-09-04 09:15:20 +02003306
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003307 while (!isterminated) {
3308 fds.fd = client;
3309 fds.events = POLLIN;
3310 fds.revents = 0;
David Kupka8e60a372012-09-04 09:15:20 +02003311
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003312 status = poll(&fds, 1, 1000);
Tomas Cejkad5b53772013-06-08 23:01:07 +02003313
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003314 if (status == 0 || (status == -1 && (errno == EAGAIN || (errno == EINTR && isterminated == 0)))) {
3315 /* poll was interrupted - check if the isterminated is set and if not, try poll again */
3316 continue;
3317 } else if (status < 0) {
3318 /* 0: poll time outed
3319 * close socket and ignore this request from the client, it can try it again
3320 * -1: poll failed
3321 * something wrong happend, close this socket and wait for another request
3322 */
3323 close(client);
3324 break;
3325 }
3326 /* status > 0 */
David Kupka8e60a372012-09-04 09:15:20 +02003327
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003328 /* check the status of the socket */
David Kupka8e60a372012-09-04 09:15:20 +02003329
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003330 /* if nothing to read and POLLHUP (EOF) or POLLERR set */
3331 if ((fds.revents & POLLHUP) || (fds.revents & POLLERR)) {
3332 /* close client's socket (it's probably already closed by client */
3333 close(client);
3334 break;
3335 }
Tomas Cejka09629492014-07-10 15:58:06 +02003336
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003337 buffer = get_framed_message(client);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003338 if (buffer != NULL) {
Michal Vaskoda384162016-04-12 15:33:23 +02003339 DEBUG("Received message:\n%.*s\n", 1024, buffer);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003340 enum json_tokener_error jerr;
3341 pthread_mutex_lock(&json_lock);
3342 request = json_tokener_parse_verbose(buffer, &jerr);
3343 if (jerr != json_tokener_success) {
3344 ERROR("JSON parsing error");
3345 pthread_mutex_unlock(&json_lock);
3346 continue;
3347 }
3348
3349 if (json_object_object_get_ex(request, "type", &js_tmp) == TRUE) {
3350 operation = json_object_get_int(js_tmp);
3351 }
3352 pthread_mutex_unlock(&json_lock);
3353 if (operation == -1) {
3354 replies = create_replies();
3355 add_reply(replies, create_error_reply("Missing operation type from frontend."), 0);
3356 goto send_reply;
3357 }
3358
3359 if ((operation < 4) || ((operation > 19) && (operation < 100)) || (operation > 101)) {
3360 DEBUG("Unknown mod_netconf operation requested (%d)", operation);
3361 replies = create_replies();
3362 add_reply(replies, create_error_reply("Operation not supported."), 0);
3363 goto send_reply;
3364 }
3365
3366 DEBUG("operation %d", operation);
3367
3368 /* null global JSON error-reply */
3369 clean_err_reply();
3370
3371 /* clean replies envelope */
3372 if (replies != NULL) {
3373 pthread_mutex_lock(&json_lock);
3374 json_object_put(replies);
3375 pthread_mutex_unlock(&json_lock);
3376 }
3377 replies = create_replies();
3378
3379 if (operation == MSG_CONNECT) {
3380 count = 1;
3381 } else {
3382 pthread_mutex_lock(&json_lock);
3383 if (json_object_object_get_ex(request, "sessions", &sessions) == FALSE) {
Michal Vasko642cad02016-03-17 12:31:18 +01003384 pthread_mutex_unlock(&json_lock);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003385 add_reply(replies, create_error_reply("Operation missing \"sessions\" arg"), 0);
3386 goto send_reply;
3387 }
3388 count = json_object_array_length(sessions);
3389 pthread_mutex_unlock(&json_lock);
3390 }
3391
3392 for (i = 0; i < count; ++i) {
3393 if (operation != MSG_CONNECT) {
3394 js_tmp = json_object_array_get_idx(sessions, i);
3395 session_key = json_object_get_int(js_tmp);
3396 }
3397
3398 /* process required operation */
Michal Vasko977bad92016-03-15 16:20:51 +01003399 reply = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003400 switch (operation) {
3401 case MSG_CONNECT:
3402 reply = handle_op_connect(request);
3403 break;
3404 case MSG_DISCONNECT:
3405 reply = handle_op_disconnect(request, session_key);
3406 break;
3407 case MSG_GET:
3408 reply = handle_op_get(request, session_key);
3409 break;
3410 case MSG_GETCONFIG:
3411 reply = handle_op_getconfig(request, session_key);
3412 break;
3413 case MSG_EDITCONFIG:
3414 reply = handle_op_editconfig(request, session_key, i);
3415 break;
3416 case MSG_COPYCONFIG:
3417 reply = handle_op_copyconfig(request, session_key, i);
3418 break;
3419 case MSG_DELETECONFIG:
3420 reply = handle_op_deleteconfig(request, session_key);
3421 break;
3422 case MSG_LOCK:
3423 reply = handle_op_lock(request, session_key);
3424 break;
3425 case MSG_UNLOCK:
3426 reply = handle_op_unlock(request, session_key);
3427 break;
3428 case MSG_KILL:
3429 reply = handle_op_kill(request, session_key);
3430 break;
3431 case MSG_INFO:
3432 reply = handle_op_info(request, session_key);
3433 break;
3434 case MSG_GENERIC:
3435 reply = handle_op_generic(request, session_key, i);
3436 break;
3437 case MSG_GETSCHEMA:
3438 reply = handle_op_getschema(request, session_key);
3439 break;
3440 case MSG_RELOADHELLO:
3441 reply = handle_op_reloadhello(request, session_key);
3442 break;
3443 case MSG_NTF_GETHISTORY:
3444 reply = handle_op_ntfgethistory(request, session_key);
3445 break;
3446 case MSG_VALIDATE:
3447 reply = handle_op_validate(request, session_key);
3448 break;
3449 case SCH_QUERY:
3450 reply = handle_op_query(request, session_key, i);
3451 break;
3452 case SCH_MERGE:
3453 reply = handle_op_merge(request, session_key, i);
3454 break;
3455 }
3456
3457 add_reply(replies, reply, session_key);
3458 }
3459
3460 /* free parameters */
3461 operation = (-1);
3462
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003463 if (request != NULL) {
3464 pthread_mutex_lock(&json_lock);
3465 json_object_put(request);
3466 pthread_mutex_unlock(&json_lock);
Michal Vasko365dc4c2016-03-17 10:03:58 +01003467 request = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003468 }
Tomas Cejka09629492014-07-10 15:58:06 +02003469
3470send_reply:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003471 /* send reply to caller */
3472 if (replies) {
3473 pthread_mutex_lock(&json_lock);
3474 msgtext = json_object_to_json_string(replies);
Michal Vasko52c91772016-03-17 10:04:12 +01003475 pthread_mutex_unlock(&json_lock);
Michal Vaskoda384162016-04-12 15:33:23 +02003476 DEBUG("Sending message:\n%.*s\n", 1024, msgtext);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003477 if (asprintf(&chunked_out_msg, "\n#%d\n%s\n##\n", (int)strlen(msgtext), msgtext) == -1) {
3478 if (buffer != NULL) {
3479 free(buffer);
3480 buffer = NULL;
3481 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003482 break;
3483 }
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01003484
Michal Vaskodf280a22016-03-17 09:19:53 +01003485 i = 0;
3486 sent = 0;
3487 count = strlen(chunked_out_msg) + 1;
3488 while (count && ((i = send(client, chunked_out_msg + sent, count, 0)) != -1)) {
3489 sent += i;
3490 count -= i;
3491 }
3492 if (i == -1) {
3493 ERROR("Sending message failed (%s).", strerror(errno));
3494 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003495 pthread_mutex_lock(&json_lock);
3496 json_object_put(replies);
Michal Vasko52c91772016-03-17 10:04:12 +01003497 pthread_mutex_unlock(&json_lock);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003498 replies = NULL;
Michal Vasko2314d402016-04-06 13:24:06 +02003499
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003500 CHECK_AND_FREE(chunked_out_msg);
3501 chunked_out_msg = NULL;
3502 if (buffer) {
3503 free(buffer);
3504 buffer = NULL;
3505 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003506 clean_err_reply();
3507 } else {
3508 ERROR("Reply is NULL, shouldn't be...");
3509 continue;
3510 }
3511 }
3512 }
3513 free(arg);
3514 free_err_reply();
Michal Vaskod0205992016-03-17 10:04:49 +01003515 nc_thread_destroy();
David Kupka8e60a372012-09-04 09:15:20 +02003516
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003517 return retval;
David Kupka8e60a372012-09-04 09:15:20 +02003518}
3519
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003520/**
3521 * \brief Close all open NETCONF sessions.
3522 *
3523 * During termination of mod_netconf, it is useful to close all remaining
3524 * sessions. This function iterates over the list of sessions and close them
3525 * all.
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003526 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003527static void
3528close_all_nc_sessions(void)
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003529{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003530 struct session_with_mutex *locked_session, *next_session;
3531 int ret;
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003532
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003533 /* get exclusive access to sessions_list (conns) */
3534 DEBUG("LOCK wrlock %s", __func__);
Michal Vaskodc40b3a2016-04-11 14:36:16 +02003535 if ((ret = pthread_rwlock_wrlock(&session_lock)) != 0) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003536 ERROR("Error while locking rwlock: %d (%s)", ret, strerror(ret));
3537 return;
3538 }
3539 for (next_session = netconf_sessions_list; next_session;) {
3540 locked_session = next_session;
3541 next_session = locked_session->next;
Tomas Cejka47387fd2013-06-10 20:37:46 +02003542
Michal Vaskoc3146782015-11-04 14:46:41 +01003543 /* close_and_free_session handles locking on its own */
Michal Vaskof35ea502016-02-24 10:44:54 +01003544 DEBUG("Closing NETCONF session %u (SID %u).", locked_session->session_key, nc_session_get_id(locked_session->session));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003545 close_and_free_session(locked_session);
3546 }
3547 netconf_sessions_list = NULL;
3548
3549 /* get exclusive access to sessions_list (conns) */
3550 DEBUG("UNLOCK wrlock %s", __func__);
Michal Vaskodc40b3a2016-04-11 14:36:16 +02003551 if (pthread_rwlock_unlock(&session_lock) != 0) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003552 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
3553 }
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003554}
3555
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003556static void
3557check_timeout_and_close(void)
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003558{
Michal Vaskoda384162016-04-12 15:33:23 +02003559 struct session_with_mutex *locked_session = NULL, *next_session;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003560 time_t current_time = time(NULL);
3561 int ret;
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003562
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003563 /* get exclusive access to sessions_list (conns) */
Michal Vaskoe41fb6e2016-04-12 08:53:23 +02003564 //DEBUG("LOCK wrlock %s", __func__);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003565 if ((ret = pthread_rwlock_wrlock(&session_lock)) != 0) {
3566 DEBUG("Error while locking rwlock: %d (%s)", ret, strerror(ret));
3567 return;
3568 }
Michal Vaskoda384162016-04-12 15:33:23 +02003569
3570 locked_session = netconf_sessions_list;
3571 while (locked_session) {
3572 next_session = locked_session->next;
3573
3574 if (!locked_session->session) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003575 continue;
3576 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003577 if ((current_time - locked_session->last_activity) > ACTIVITY_TIMEOUT) {
Michal Vaskof35ea502016-02-24 10:44:54 +01003578 DEBUG("Closing NETCONF session %u (SID %u).", locked_session->session_key, nc_session_get_id(locked_session->session));
Tomas Cejka47387fd2013-06-10 20:37:46 +02003579
Michal Vaskoda384162016-04-12 15:33:23 +02003580 /* remove it from the list */
3581 if (!locked_session->prev) {
3582 netconf_sessions_list = netconf_sessions_list->next;
3583 if (netconf_sessions_list) {
3584 netconf_sessions_list->prev = NULL;
3585 }
3586 } else {
3587 locked_session->prev->next = locked_session->next;
3588 if (locked_session->next) {
3589 locked_session->next->prev = locked_session->prev;
3590 }
3591 }
3592
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003593 /* close_and_free_session handles locking on its own */
3594 close_and_free_session(locked_session);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003595 }
Michal Vaskoda384162016-04-12 15:33:23 +02003596
3597 locked_session = next_session;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003598 }
Michal Vaskoe41fb6e2016-04-12 08:53:23 +02003599 //DEBUG("UNLOCK wrlock %s", __func__);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003600 if (pthread_rwlock_unlock(&session_lock) != 0) {
3601 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
3602 }
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003603}
3604
3605
3606/**
Radek Krejcif23850c2012-07-23 16:14:17 +02003607 * This is actually implementation of NETCONF client
3608 * - requests are received from UNIX socket in the predefined format
3609 * - results are replied through the same way
Michal Vaskoc3146782015-11-04 14:46:41 +01003610 * - the daemon run as a separate process
Radek Krejcif23850c2012-07-23 16:14:17 +02003611 *
3612 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003613static void
3614forked_proc(void)
Radek Krejci469aab82012-07-22 18:42:20 +02003615{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003616 struct timeval tv;
3617 struct sockaddr_un local, remote;
3618 int lsock, client, ret, i, pthread_count = 0;
3619 unsigned int olds = 0, timediff = 0;
3620 socklen_t len;
3621 struct pass_to_thread *arg;
3622 pthread_t *ptids = calloc(1, sizeof(pthread_t));
3623 struct timespec maxtime;
3624 pthread_rwlockattr_t lock_attrs;
3625 #ifdef WITH_NOTIFICATIONS
3626 char use_notifications = 0;
3627 #endif
David Kupka8e60a372012-09-04 09:15:20 +02003628
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003629 /* wait at most 5 seconds for every thread to terminate */
3630 maxtime.tv_sec = 5;
3631 maxtime.tv_nsec = 0;
Radek Krejci469aab82012-07-22 18:42:20 +02003632
Tomas Cejka04e08f42014-03-27 19:52:34 +01003633#ifdef HAVE_UNIXD_SETUP_CHILD
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003634 /* change uid and gid of process for security reasons */
3635 unixd_setup_child();
Tomas Cejka04e08f42014-03-27 19:52:34 +01003636#else
3637# ifdef SU_GROUP
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003638 if (strlen(SU_GROUP) > 0) {
3639 struct group *g = getgrnam(SU_GROUP);
3640 if (g == NULL) {
3641 ERROR("GID (%s) was not found.", SU_GROUP);
3642 return;
3643 }
3644 if (setgid(g->gr_gid) != 0) {
3645 ERROR("Switching to %s GID failed. (%s)", SU_GROUP, strerror(errno));
3646 return;
3647 }
3648 }
Tomas Cejka04e08f42014-03-27 19:52:34 +01003649# else
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003650 DEBUG("no SU_GROUP");
Tomas Cejka04e08f42014-03-27 19:52:34 +01003651# endif
3652# ifdef SU_USER
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003653 if (strlen(SU_USER) > 0) {
3654 struct passwd *p = getpwnam(SU_USER);
3655 if (p == NULL) {
3656 ERROR("UID (%s) was not found.", SU_USER);
3657 return;
3658 }
3659 if (setuid(p->pw_uid) != 0) {
3660 ERROR("Switching to UID %s failed. (%s)", SU_USER, strerror(errno));
3661 return;
3662 }
3663 }
Tomas Cejka04e08f42014-03-27 19:52:34 +01003664# else
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003665 DEBUG("no SU_USER");
Tomas Cejka04e08f42014-03-27 19:52:34 +01003666# endif
3667#endif
Radek Krejci469aab82012-07-22 18:42:20 +02003668
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003669 /* try to remove if exists */
3670 unlink(sockname);
Tomas Cejka04e08f42014-03-27 19:52:34 +01003671
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003672 /* create listening UNIX socket to accept incoming connections */
3673 if ((lsock = socket(PF_UNIX, SOCK_STREAM, 0)) == -1) {
3674 ERROR("Creating socket failed (%s)", strerror(errno));
3675 goto error_exit;
3676 }
Radek Krejci469aab82012-07-22 18:42:20 +02003677
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003678 local.sun_family = AF_UNIX;
3679 strncpy(local.sun_path, sockname, sizeof(local.sun_path));
3680 len = offsetof(struct sockaddr_un, sun_path) + strlen(local.sun_path);
Radek Krejci469aab82012-07-22 18:42:20 +02003681
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003682 if (bind(lsock, (struct sockaddr *)&local, len) == -1) {
3683 if (errno == EADDRINUSE) {
3684 ERROR("mod_netconf socket address already in use");
3685 goto error_exit;
3686 }
3687 ERROR("Binding socket failed (%s)", strerror(errno));
3688 goto error_exit;
3689 }
Radek Krejci469aab82012-07-22 18:42:20 +02003690
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003691 if (listen(lsock, MAX_SOCKET_CL) == -1) {
3692 ERROR("Setting up listen socket failed (%s)", strerror(errno));
3693 goto error_exit;
3694 }
3695 chmod(sockname, S_IWUSR | S_IWGRP | S_IWOTH | S_IRUSR | S_IRGRP | S_IROTH);
Radek Krejci469aab82012-07-22 18:42:20 +02003696
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003697 uid_t user = -1;
3698 if (strlen(CHOWN_USER) > 0) {
3699 struct passwd *p = getpwnam(CHOWN_USER);
3700 if (p != NULL) {
3701 user = p->pw_uid;
3702 }
3703 }
3704 gid_t group = -1;
3705 if (strlen(CHOWN_GROUP) > 0) {
3706 struct group *g = getgrnam(CHOWN_GROUP);
3707 if (g != NULL) {
3708 group = g->gr_gid;
3709 }
3710 }
3711 if (chown(sockname, user, group) == -1) {
3712 ERROR("Chown on socket file failed (%s).", strerror(errno));
3713 }
Tomas Cejka04e08f42014-03-27 19:52:34 +01003714
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003715 /* prepare internal lists */
Tomas Cejkaba21b382013-04-13 02:37:32 +02003716
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003717 #ifdef WITH_NOTIFICATIONS
3718 if (notification_init() == -1) {
3719 ERROR("libwebsockets initialization failed");
3720 use_notifications = 0;
3721 } else {
3722 use_notifications = 1;
3723 }
3724 #endif
Tomas Cejkad340dbf2013-03-24 20:36:57 +01003725
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003726 /* setup libnetconf's callbacks */
Michal Vaskod0205992016-03-17 10:04:49 +01003727 nc_client_init();
Michal Vaskodedf91b2016-04-06 10:00:31 +02003728 nc_verbosity(NC_VERB_VERBOSE);
Michal Vaskof35ea502016-02-24 10:44:54 +01003729 nc_set_print_clb(clb_print);
3730 nc_client_ssh_set_auth_hostkey_check_clb(netconf_callback_ssh_hostkey_check);
3731 nc_client_ssh_set_auth_interactive_clb(netconf_callback_sshauth_interactive);
3732 nc_client_ssh_set_auth_password_clb(netconf_callback_sshauth_password);
3733 nc_client_ssh_set_auth_privkey_passphrase_clb(netconf_callback_sshauth_passphrase);
Radek Krejci469aab82012-07-22 18:42:20 +02003734
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003735 /* disable publickey authentication */
Michal Vaskof35ea502016-02-24 10:44:54 +01003736 nc_client_ssh_set_auth_pref(NC_SSH_AUTH_PUBLICKEY, -1);
Radek Krejci469aab82012-07-22 18:42:20 +02003737
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003738 /* create mutex protecting session list */
3739 pthread_rwlockattr_init(&lock_attrs);
3740 /* rwlock is shared only with threads in this process */
3741 pthread_rwlockattr_setpshared(&lock_attrs, PTHREAD_PROCESS_PRIVATE);
3742 /* create rw lock */
3743 if (pthread_rwlock_init(&session_lock, &lock_attrs) != 0) {
3744 ERROR("Initialization of mutex failed: %d (%s)", errno, strerror(errno));
3745 goto error_exit;
3746 }
3747 pthread_mutex_init(&ntf_history_lock, NULL);
3748 pthread_mutex_init(&json_lock, NULL);
3749 DEBUG("Initialization of notification history.");
3750 if (pthread_key_create(&notif_history_key, NULL) != 0) {
3751 ERROR("Initialization of notification history failed.");
3752 }
3753 if (pthread_key_create(&err_reply_key, NULL) != 0) {
3754 ERROR("Initialization of reply key failed.");
3755 }
Tomas Cejka8a82dab2013-05-30 23:37:23 +02003756
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003757 fcntl(lsock, F_SETFL, fcntl(lsock, F_GETFL, 0) | O_NONBLOCK);
3758 while (isterminated == 0) {
3759 gettimeofday(&tv, NULL);
3760 timediff = (unsigned int)tv.tv_sec - olds;
3761 #ifdef WITH_NOTIFICATIONS
3762 if (use_notifications == 1) {
3763 notification_handle();
3764 }
3765 #endif
3766 if (timediff > ACTIVITY_CHECK_INTERVAL) {
3767 check_timeout_and_close();
3768 }
Radek Krejci469aab82012-07-22 18:42:20 +02003769
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003770 /* open incoming connection if any */
3771 len = sizeof(remote);
3772 client = accept(lsock, (struct sockaddr *) &remote, &len);
3773 if (client == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
3774 usleep(SLEEP_TIME * 1000);
3775 continue;
3776 } else if (client == -1 && (errno == EINTR)) {
3777 continue;
3778 } else if (client == -1) {
3779 ERROR("Accepting mod_netconf client connection failed (%s)", strerror(errno));
3780 continue;
3781 }
Radek Krejci469aab82012-07-22 18:42:20 +02003782
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003783 /* set client's socket as non-blocking */
3784 //fcntl(client, F_SETFL, fcntl(client, F_GETFL, 0) | O_NONBLOCK);
Radek Krejci469aab82012-07-22 18:42:20 +02003785
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003786 arg = malloc(sizeof(struct pass_to_thread));
3787 arg->client = client;
3788 arg->netconf_sessions_list = netconf_sessions_list;
Radek Krejci469aab82012-07-22 18:42:20 +02003789
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003790 /* start new thread. It will serve this particular request and then terminate */
3791 if ((ret = pthread_create (&ptids[pthread_count], NULL, thread_routine, (void *)arg)) != 0) {
3792 ERROR("Creating POSIX thread failed: %d\n", ret);
3793 } else {
3794 DEBUG("Thread %lu created", ptids[pthread_count]);
3795 pthread_count++;
3796 ptids = realloc (ptids, sizeof(pthread_t) * (pthread_count+1));
3797 ptids[pthread_count] = 0;
3798 }
Radek Krejci469aab82012-07-22 18:42:20 +02003799
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003800 /* check if some thread already terminated, free some resources by joining it */
3801 for (i = 0; i < pthread_count; i++) {
3802 if (pthread_tryjoin_np(ptids[i], (void **)&arg) == 0) {
3803 DEBUG("Thread %lu joined with retval %p", ptids[i], arg);
3804 pthread_count--;
3805 if (pthread_count > 0) {
3806 /* place last Thread ID on the place of joined one */
3807 ptids[i] = ptids[pthread_count];
3808 }
3809 }
3810 }
3811 DEBUG("Running %d threads", pthread_count);
3812 }
Radek Krejci469aab82012-07-22 18:42:20 +02003813
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003814 DEBUG("mod_netconf terminating...");
3815 /* join all threads */
3816 for (i = 0; i < pthread_count; i++) {
3817 pthread_timedjoin_np(ptids[i], (void **)&arg, &maxtime);
3818 }
Radek Krejci469aab82012-07-22 18:42:20 +02003819
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003820 #ifdef WITH_NOTIFICATIONS
3821 notification_close();
3822 #endif
Tomas Cejkad340dbf2013-03-24 20:36:57 +01003823
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003824 /* close all NETCONF sessions */
3825 close_all_nc_sessions();
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003826
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003827 /* destroy rwlock */
3828 pthread_rwlock_destroy(&session_lock);
3829 pthread_rwlockattr_destroy(&lock_attrs);
David Kupka8e60a372012-09-04 09:15:20 +02003830
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003831 DEBUG("Exiting from the mod_netconf daemon");
Radek Krejci469aab82012-07-22 18:42:20 +02003832
Michal Vaskod0205992016-03-17 10:04:49 +01003833 nc_client_destroy();
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003834 free(ptids);
3835 close(lsock);
3836 exit(0);
3837 return;
3838
Tomas Cejkaef531ee2013-11-12 16:07:00 +01003839error_exit:
Michal Vaskod0205992016-03-17 10:04:49 +01003840 nc_client_destroy();
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003841 close(lsock);
3842 free(ptids);
3843 return;
Radek Krejci469aab82012-07-22 18:42:20 +02003844}
3845
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003846int
3847main(int argc, char **argv)
Tomas Cejkaef531ee2013-11-12 16:07:00 +01003848{
Michal Vaskoc3146782015-11-04 14:46:41 +01003849 struct sigaction action;
3850 sigset_t block_mask;
Michal Vaskoefdd49f2016-04-06 11:13:27 +02003851 int i;
Michal Vaskoc3146782015-11-04 14:46:41 +01003852
Michal Vaskoa53ef882015-11-24 11:02:01 +01003853 if (argc > 3) {
3854 printf("Usage: [--(h)elp] [--(d)aemon] [socket-path]\n");
3855 return 1;
3856 }
3857
3858 sockname = SOCKET_FILENAME;
3859 for (i = 1; i < argc; ++i) {
3860 if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
3861 printf("Usage: [--(h)elp] [--(d)aemon] [socket-path]\n");
3862 return 0;
3863 } else if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--daemon")) {
3864 daemonize = 1;
3865 } else {
3866 sockname = argv[i];
3867 }
3868 }
3869
Michal Vaskoefdd49f2016-04-06 11:13:27 +02003870 if (daemonize) {
3871 if (daemon(0, 0) == -1) {
3872 ERROR("daemon() failed (%s)", strerror(errno));
3873 return 1;
3874 }
3875 openlog("netopeerguid", LOG_PID, LOG_DAEMON);
Michal Vaskoc3146782015-11-04 14:46:41 +01003876 }
3877
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003878 sigfillset(&block_mask);
Michal Vaskoc3146782015-11-04 14:46:41 +01003879 action.sa_handler = signal_handler;
3880 action.sa_mask = block_mask;
3881 action.sa_flags = 0;
3882 sigaction(SIGINT, &action, NULL);
3883 sigaction(SIGTERM, &action, NULL);
3884
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003885 forked_proc();
3886 DEBUG("Terminated");
Michal Vaskoefdd49f2016-04-06 11:13:27 +02003887 if (daemonize) {
3888 closelog();
3889 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003890 return 0;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01003891}