blob: 0698e4d3685fa70a3d238a0d1169e4189ff0dd80 [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>
Radek Krejci469aab82012-07-22 18:42:20 +020053#include <sys/types.h>
54#include <sys/socket.h>
55#include <sys/un.h>
Tomas Cejkad340dbf2013-03-24 20:36:57 +010056#include <sys/fcntl.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 Vaskoc3146782015-11-04 14:46:41 +010059#include <errno.h>
Michal Vaskoda0ab5c2015-11-13 13:24:51 +010060#include <limits.h>
Tomas Cejka04e08f42014-03-27 19:52:34 +010061#include <grp.h>
Michal Vaskoc3146782015-11-04 14:46:41 +010062#include <signal.h>
David Kupka8e60a372012-09-04 09:15:20 +020063#include <pthread.h>
64#include <ctype.h>
Radek Krejci7b4ddd02012-07-30 08:09:58 +020065
Michal Vaskof35ea502016-02-24 10:44:54 +010066#include <nc_client.h>
Radek Krejci7b4ddd02012-07-30 08:09:58 +020067
Tomas Cejka04e08f42014-03-27 19:52:34 +010068#include "../config.h"
69
Tomas Cejkad340dbf2013-03-24 20:36:57 +010070#ifdef WITH_NOTIFICATIONS
Michal Vaskoa53ef882015-11-24 11:02:01 +010071#include "notification_server.h"
Tomas Cejkad340dbf2013-03-24 20:36:57 +010072#endif
73
Tomas Cejka94da2c52013-01-08 18:20:30 +010074#include "message_type.h"
Michal Vaskoa53ef882015-11-24 11:02:01 +010075#include "netopeerguid.h"
Radek Krejci469aab82012-07-22 18:42:20 +020076
Michal Vaskoda0ab5c2015-11-13 13:24:51 +010077#define SCHEMA_DIR "/tmp/yang_models"
Radek Krejci469aab82012-07-22 18:42:20 +020078#define MAX_PROCS 5
Michal Vaskoa53ef882015-11-24 11:02:01 +010079#define SOCKET_FILENAME "/var/run/netopeerguid.sock"
Radek Krejci469aab82012-07-22 18:42:20 +020080#define MAX_SOCKET_CL 10
81#define BUFFER_SIZE 4096
Michal Vaskoda0ab5c2015-11-13 13:24:51 +010082#define ACTIVITY_CHECK_INTERVAL 10 /**< timeout in seconds, how often activity is checked */
83#define ACTIVITY_TIMEOUT (60*60) /**< timeout in seconds, after this time, session is automaticaly closed. */
Radek Krejci469aab82012-07-22 18:42:20 +020084
Michal Vasko7732dee2015-11-05 10:22:15 +010085/* sleep in master process for non-blocking socket reading, in msec */
Radek Krejci469aab82012-07-22 18:42:20 +020086#define SLEEP_TIME 200
87
88#ifndef offsetof
89#define offsetof(type, member) ((size_t) ((type *) 0)->member)
90#endif
91
Tomas Cejka027f3bc2012-11-10 20:28:36 +010092/* timeout in msec */
Radek Krejci469aab82012-07-22 18:42:20 +020093struct timeval timeout = { 1, 0 };
94
Michal Vaskoda0ab5c2015-11-13 13:24:51 +010095#define NCWITHDEFAULTS NCWD_MODE_NOTSET
Tomas Cejka5064c232013-01-17 09:30:58 +010096
Radek Krejci469aab82012-07-22 18:42:20 +020097#define MSG_OK 0
98#define MSG_OPEN 1
99#define MSG_DATA 2
100#define MSG_CLOSE 3
101#define MSG_ERROR 4
102#define MSG_UNKNOWN 5
103
Tomas Cejka47387fd2013-06-10 20:37:46 +0200104pthread_rwlock_t session_lock; /**< mutex protecting netconf_sessions_list from multiple access errors */
Tomas Cejka6b886e02013-07-05 09:53:17 +0200105pthread_mutex_t ntf_history_lock; /**< mutex protecting notification history list */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100106pthread_mutex_t ntf_hist_clbc_mutex; /**< mutex protecting notification history list */
Tomas Cejka9a23f6e2014-03-27 14:57:00 +0100107pthread_mutex_t json_lock; /**< mutex for protecting json-c calls */
108
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100109unsigned int session_key_generator = 1;
Michal Vaskoc3146782015-11-04 14:46:41 +0100110struct session_with_mutex *netconf_sessions_list = NULL;
Michal Vaskoc3146782015-11-04 14:46:41 +0100111static const char *sockname;
Tomas Cejkad016f9c2013-07-10 09:16:16 +0200112static pthread_key_t notif_history_key;
Tomas Cejka442258e2014-04-01 18:17:18 +0200113pthread_key_t err_reply_key;
Radek Krejci469aab82012-07-22 18:42:20 +0200114volatile int isterminated = 0;
Radek Krejci469aab82012-07-22 18:42:20 +0200115static char* password;
116
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100117json_object *create_ok_reply(void);
118json_object *create_data_reply(const char *data);
119static char *netconf_getschema(unsigned int session_key, const char *identifier, const char *version,
120 const char *format, json_object **err);
Michal Vaskof35ea502016-02-24 10:44:54 +0100121static void node_add_metadata_recursive(struct lyd_node *data_tree, const struct lys_module *module,
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100122 json_object *data_json_parent);
Michal Vasko3fda9a92015-11-23 10:10:57 +0100123static void node_metadata_typedef(struct lys_tpdf *tpdf, json_object *parent);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100124
125static void
126signal_handler(int sign)
Radek Krejci469aab82012-07-22 18:42:20 +0200127{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100128 switch (sign) {
129 case SIGINT:
130 case SIGTERM:
131 isterminated = 1;
132 break;
133 }
Radek Krejci469aab82012-07-22 18:42:20 +0200134}
135
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100136int
137netconf_callback_ssh_hostkey_check(const char* UNUSED(hostname), ssh_session UNUSED(session))
Radek Krejci469aab82012-07-22 18:42:20 +0200138{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100139 /* always approve */
140 return (EXIT_SUCCESS);
Radek Krejci469aab82012-07-22 18:42:20 +0200141}
142
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100143char *
Michal Vaskof35ea502016-02-24 10:44:54 +0100144netconf_callback_sshauth_passphrase(const char *UNUSED(priv_key_file))
Radek Krejci469aab82012-07-22 18:42:20 +0200145{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100146 char *buf;
147 buf = strdup(password);
148 return (buf);
Radek Krejci469aab82012-07-22 18:42:20 +0200149}
150
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100151char *
152netconf_callback_sshauth_password(const char *UNUSED(username), const char *UNUSED(hostname))
Radek Krejci469aab82012-07-22 18:42:20 +0200153{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100154 char *buf;
155 buf = strdup(password);
156 return (buf);
Radek Krejci469aab82012-07-22 18:42:20 +0200157}
158
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100159char *
160netconf_callback_sshauth_interactive(const char *UNUSED(name), const char *UNUSED(instruction),
161 const char *UNUSED(prompt), int UNUSED(echo))
Tomas Cejkab34b7b12015-06-21 22:54:11 +0200162{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100163 char *buf;
164 buf = strdup(password);
165 return (buf);
Tomas Cejkab34b7b12015-06-21 22:54:11 +0200166}
167
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100168void
169netconf_callback_error_process(const char *UNUSED(tag),
170 const char *UNUSED(type),
171 const char *UNUSED(severity),
172 const char *UNUSED(apptag),
173 const char *UNUSED(path),
174 const char *message,
175 const char *UNUSED(attribute),
176 const char *UNUSED(element),
177 const char *UNUSED(ns),
178 const char *UNUSED(sid))
Radek Krejcic11fd862012-07-26 12:41:21 +0200179{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100180 json_object **err_reply_p = (json_object **) pthread_getspecific(err_reply_key);
181 if (err_reply_p == NULL) {
182 ERROR("Error message was not allocated. %s", __func__);
183 return;
184 }
185 json_object *err_reply = *err_reply_p;
Tomas Cejkaedb3ab42014-03-27 15:04:00 +0100186
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100187 json_object *array = NULL;
188 if (err_reply == NULL) {
189 ERROR("error calback: empty error list");
190 pthread_mutex_lock(&json_lock);
191 err_reply = json_object_new_object();
192 array = json_object_new_array();
193 json_object_object_add(err_reply, "type", json_object_new_int(REPLY_ERROR));
194 json_object_object_add(err_reply, "errors", array);
195 if (message != NULL) {
196 json_object_array_add(array, json_object_new_string(message));
197 }
198 pthread_mutex_unlock(&json_lock);
199 (*err_reply_p) = err_reply;
200 } else {
201 ERROR("error calback: nonempty error list");
202 pthread_mutex_lock(&json_lock);
203 if (json_object_object_get_ex(err_reply, "errors", &array) == TRUE) {
204 if (message != NULL) {
205 json_object_array_add(array, json_object_new_string(message));
206 }
207 }
208 pthread_mutex_unlock(&json_lock);
209 }
210 pthread_setspecific(err_reply_key, err_reply_p);
211 return;
Radek Krejcic11fd862012-07-26 12:41:21 +0200212}
213
Tomas Cejka47387fd2013-06-10 20:37:46 +0200214/**
215 * should be used in locked area
216 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100217void
218prepare_status_message(struct session_with_mutex *s, struct nc_session *session)
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200219{
Michal Vaskof35ea502016-02-24 10:44:54 +0100220 int i;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100221 json_object *json_obj = NULL;
222 json_object *js_tmp = NULL;
223 char *old_sid = NULL;
224 const char *j_old_sid = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +0100225 char str_port[6];
226 const char **cpblts;
227 struct lyd_node *yanglib, *module, *node;
Tomas Cejkaf38a54c2013-05-27 21:57:35 +0200228
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100229 if (s == NULL) {
230 ERROR("No session given.");
231 return;
232 }
Tomas Cejka8a82dab2013-05-30 23:37:23 +0200233
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100234 pthread_mutex_lock(&json_lock);
235 if (s->hello_message != NULL) {
236 ERROR("clean previous hello message");
237 if (json_object_object_get_ex(s->hello_message, "sid", &js_tmp) == TRUE) {
238 j_old_sid = json_object_get_string(js_tmp);
239 if (j_old_sid != NULL) {
240 old_sid = strdup(j_old_sid);
241 }
242 }
243 json_object_put(s->hello_message);
244 s->hello_message = NULL;
245 }
246 s->hello_message = json_object_new_object();
247 if (session != NULL) {
Michal Vaskof35ea502016-02-24 10:44:54 +0100248 if (!old_sid) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100249 /* we don't have old sid */
Michal Vaskof35ea502016-02-24 10:44:54 +0100250 asprintf(&old_sid, "%u", nc_session_get_id(session));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100251 }
Michal Vaskof35ea502016-02-24 10:44:54 +0100252 json_object_object_add(s->hello_message, "sid", json_object_new_string(old_sid));
253 free(old_sid);
254 old_sid = NULL;
255
256 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 +0100257 json_object_object_add(s->hello_message, "host", json_object_new_string(nc_session_get_host(session)));
Michal Vaskof35ea502016-02-24 10:44:54 +0100258 sprintf(str_port, "%u", nc_session_get_port(session));
259 json_object_object_add(s->hello_message, "port", json_object_new_string(str_port));
260 json_object_object_add(s->hello_message, "user", json_object_new_string(nc_session_get_username(session)));
261 cpblts = nc_session_get_cpblts(session);
262 if (cpblts) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100263 json_obj = json_object_new_array();
Michal Vaskof35ea502016-02-24 10:44:54 +0100264 for (i = 0; cpblts[i]; ++i) {
265 json_object_array_add(json_obj, json_object_new_string(cpblts[i]));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100266 }
267 json_object_object_add(s->hello_message, "capabilities", json_obj);
268 }
Michal Vaskof35ea502016-02-24 10:44:54 +0100269
270 yanglib = ly_ctx_info(nc_session_get_ctx(session));
271 if (yanglib) {
272 json_obj = json_object_new_array();
273 LY_TREE_FOR(yanglib->child, module) {
274 if (!strcmp(module->schema->name, "module")) {
275 LY_TREE_FOR(module->child, node) {
276 if (!strcmp(node->schema->name, "name")) {
277 json_object_array_add(json_obj, json_object_new_string(((struct lyd_node_leaf_list *)node)->value_str));
278 break;
279 }
280 }
281 }
282 }
283 json_object_object_add(s->hello_message, "models", json_obj);
284
285 lyd_free(node);
286 }
287
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100288 DEBUG("%s", json_object_to_json_string(s->hello_message));
289 } else {
290 ERROR("Session was not given.");
291 json_object_object_add(s->hello_message, "type", json_object_new_int(REPLY_ERROR));
292 json_object_object_add(s->hello_message, "error-message", json_object_new_string("Invalid session identifier."));
293 }
294 DEBUG("Status info from hello message prepared");
295 pthread_mutex_unlock(&json_lock);
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200296}
297
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100298void
299create_err_reply_p()
Tomas Cejka442258e2014-04-01 18:17:18 +0200300{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100301 json_object **err_reply = calloc(1, sizeof(json_object **));
302 if (err_reply == NULL) {
303 ERROR("Allocation of err_reply storage failed!");
304 return;
305 }
306 if (pthread_setspecific(err_reply_key, err_reply) != 0) {
307 ERROR("cannot set thread-specific value.");
308 }
Tomas Cejka442258e2014-04-01 18:17:18 +0200309}
310
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100311void
312clean_err_reply()
Tomas Cejka442258e2014-04-01 18:17:18 +0200313{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100314 json_object **err_reply = (json_object **) pthread_getspecific(err_reply_key);
315 if (err_reply != NULL) {
316 if (*err_reply != NULL) {
317 pthread_mutex_lock(&json_lock);
318 json_object_put(*err_reply);
319 pthread_mutex_unlock(&json_lock);
320 }
321 if (pthread_setspecific(err_reply_key, err_reply) != 0) {
322 ERROR("Cannot set thread-specific hash value.");
323 }
324 }
Tomas Cejka442258e2014-04-01 18:17:18 +0200325}
326
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100327void
328free_err_reply()
Tomas Cejka442258e2014-04-01 18:17:18 +0200329{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100330 json_object **err_reply = (json_object **) pthread_getspecific(err_reply_key);
331 if (err_reply != NULL) {
332 if (*err_reply != NULL) {
333 pthread_mutex_lock(&json_lock);
334 json_object_put(*err_reply);
335 pthread_mutex_unlock(&json_lock);
336 }
337 free(err_reply);
338 err_reply = NULL;
339 if (pthread_setspecific(err_reply_key, err_reply) != 0) {
340 ERROR("Cannot set thread-specific hash value.");
341 }
342 }
343}
344
345static struct session_with_mutex *
346session_get_locked(unsigned int session_key, json_object **err)
347{
348 struct session_with_mutex *locked_session;
349
350 /* get non-exclusive (read) access to sessions_list (conns) */
351 DEBUG("LOCK wrlock %s", __func__);
352 if (pthread_rwlock_rdlock(&session_lock) != 0) {
353 if (*err) {
354 *err = create_error_reply("Locking failed.");
355 }
356 return NULL;
357 }
358 /* get session where send the RPC */
359 for (locked_session = netconf_sessions_list;
360 locked_session && (locked_session->session_key != session_key);
361 locked_session = locked_session->next);
362 if (!locked_session) {
363 if (*err) {
364 *err = create_error_reply("Session not found.");
365 }
366 return NULL;
367 }
368
369 /* get exclusive access to session */
370 DEBUG("LOCK mutex %s", __func__);
371 if (pthread_mutex_lock(&locked_session->lock) != 0) {
372 if (*err) {
373 *err = create_error_reply("Locking failed.");
374 }
375 goto wrlock_fail;
376 }
377 return locked_session;
378
379wrlock_fail:
380 DEBUG("UNLOCK wrlock %s", __func__);
381 pthread_rwlock_unlock(&session_lock);
382 return NULL;
383}
384
385static void
Michal Vaskoe32bcba2015-11-24 09:05:51 +0100386session_user_activity(const char *username)
387{
388 struct session_with_mutex *sess;
389
390 for (sess = netconf_sessions_list; sess; sess = sess->next) {
Michal Vaskof35ea502016-02-24 10:44:54 +0100391 if (!strcmp(nc_session_get_username(sess->session), username)) {
Michal Vaskoe32bcba2015-11-24 09:05:51 +0100392 sess->last_activity = time(NULL);
393 }
394 }
395}
396
397static void
Michal Vaskoda0ab5c2015-11-13 13:24:51 +0100398session_unlock(struct session_with_mutex *locked_session)
399{
400 DEBUG("UNLOCK mutex %s", __func__);
401 pthread_mutex_unlock(&locked_session->lock);
402 DEBUG("UNLOCK wrlock %s", __func__);
403 pthread_rwlock_unlock(&session_lock);
Tomas Cejka442258e2014-04-01 18:17:18 +0200404}
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200405
Michal Vasko3fda9a92015-11-23 10:10:57 +0100406static void
407node_metadata_text(const char *text, const char *name, json_object *parent)
408{
409 json_object *obj;
410
411 if (!text) {
412 return;
413 }
414
415 obj = json_object_new_string(text);
416 json_object_object_add(parent, name, obj);
417}
418
419static void
420node_metadata_restr(struct lys_restr *restr, const char *name, json_object *parent)
421{
422 json_object *obj;
423
424 if (!restr) {
425 return;
426 }
427
428 obj = json_object_new_string(restr->expr);
429 json_object_object_add(parent, name, obj);
430}
431
432static void
433node_metadata_must(uint8_t must_size, struct lys_restr *must, json_object *parent)
434{
435 uint8_t i;
436 json_object *array, *obj;
437
438 if (!must_size || !must) {
439 return;
440 }
441
442 array = json_object_new_array();
443
444 for (i = 0; i < must_size; ++i) {
445 obj = json_object_new_string(must[i].expr);
446 json_object_array_add(array, obj);
447 }
448
449 json_object_object_add(parent, "must", array);
450}
451
452static void
453node_metadata_basic(struct lys_node *node, json_object *parent)
454{
455 json_object *obj;
456
457 /* description */
458 node_metadata_text(node->dsc, "description", parent);
459
460 /* reference */
461 node_metadata_text(node->ref, "reference", parent);
462
463 /* config */
464 if (node->flags & LYS_CONFIG_R) {
465 obj = json_object_new_boolean(0);
466 } else {
467 obj = json_object_new_boolean(1);
468 }
469 json_object_object_add(parent, "config", obj);
470
471 /* status */
472 if (node->flags & LYS_STATUS_DEPRC) {
473 obj = json_object_new_string("deprecated");
474 } else if (node->flags & LYS_STATUS_OBSLT) {
475 obj = json_object_new_string("obsolete");
476 } else {
477 obj = json_object_new_string("current");
478 }
479 json_object_object_add(parent, "status", obj);
480
481 /* mandatory */
482 if (node->flags & LYS_MAND_TRUE) {
483 obj = json_object_new_boolean(1);
484 } else {
485 obj = json_object_new_boolean(0);
486 }
487 json_object_object_add(parent, "mandatory", obj);
488
489 /* NACM extensions */
490 if (node->nacm) {
491 if (node->nacm & LYS_NACM_DENYW) {
492 obj = json_object_new_string("default-deny-write");
493 } else {
494 obj = json_object_new_string("default-deny-all");
495 }
496 json_object_object_add(parent, "ext", obj);
497 }
498}
499
500static void
501node_metadata_when(struct lys_when *when, json_object *parent)
502{
503 json_object *obj;
504
505 if (!when) {
506 return;
507 }
508
509 obj = json_object_new_string(when->cond);
510 json_object_object_add(parent, "when", obj);
511}
512
513static void
Michal Vaskoa45770b2015-11-23 15:49:41 +0100514node_metadata_children_recursive(struct lys_node *node, json_object **child_array, json_object **choice_array)
Michal Vasko3fda9a92015-11-23 10:10:57 +0100515{
Michal Vaskoa45770b2015-11-23 15:49:41 +0100516 json_object *obj;
Michal Vasko3fda9a92015-11-23 10:10:57 +0100517 struct lys_node *child;
518
519 if (!node->child) {
520 return;
521 }
522
523 LY_TREE_FOR(node->child, child) {
Michal Vaskoa45770b2015-11-23 15:49:41 +0100524 if (child->nodetype == LYS_USES) {
525 node_metadata_children_recursive(child, child_array, choice_array);
526 } else if (child->nodetype & (LYS_CONTAINER | LYS_LEAF | LYS_LEAFLIST | LYS_LIST | LYS_ANYXML)) {
Michal Vasko3fda9a92015-11-23 10:10:57 +0100527 obj = json_object_new_string(child->name);
Michal Vaskoa45770b2015-11-23 15:49:41 +0100528 if (!*child_array) {
529 *child_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(*child_array, obj);
Michal Vasko3fda9a92015-11-23 10:10:57 +0100532 } else if (child->nodetype == LYS_CHOICE) {
533 obj = json_object_new_string(child->name);
Michal Vaskoa45770b2015-11-23 15:49:41 +0100534 if (!*choice_array) {
535 *choice_array = json_object_new_array();
Michal Vasko3fda9a92015-11-23 10:10:57 +0100536 }
Michal Vaskoa45770b2015-11-23 15:49:41 +0100537 json_object_array_add(*choice_array, obj);
Michal Vasko3fda9a92015-11-23 10:10:57 +0100538 }
539 }
Michal Vasko3fda9a92015-11-23 10:10:57 +0100540}
541
542static void
Michal Vaskoa45770b2015-11-23 15:49:41 +0100543node_metadata_cases_recursive(struct lys_node_choice *choice, json_object *array)
Michal Vasko3fda9a92015-11-23 10:10:57 +0100544{
Michal Vaskoa45770b2015-11-23 15:49:41 +0100545 json_object *obj;
Michal Vasko3fda9a92015-11-23 10:10:57 +0100546 struct lys_node *child;
547
548 if (!choice->child) {
549 return;
550 }
551
Michal Vasko3fda9a92015-11-23 10:10:57 +0100552 LY_TREE_FOR(choice->child, child) {
Michal Vaskoa45770b2015-11-23 15:49:41 +0100553 if (child->nodetype == LYS_USES) {
554 node_metadata_cases_recursive((struct lys_node_choice *)child, array);
555 } else if (child->nodetype & (LYS_CONTAINER | LYS_LEAF | LYS_LEAFLIST | LYS_LIST | LYS_ANYXML | LYS_CASE)) {
Michal Vasko3fda9a92015-11-23 10:10:57 +0100556 obj = json_object_new_string(child->name);
557 json_object_array_add(array, obj);
558 }
559 }
Michal Vasko3fda9a92015-11-23 10:10:57 +0100560}
561
562static void
563node_metadata_min_max(uint32_t min, uint32_t max, json_object *parent)
564{
565 json_object *obj;
566
567 if (min) {
568 obj = json_object_new_int(min);
569 json_object_object_add(parent, "min-elements", obj);
570 }
571
572 if (max) {
573 obj = json_object_new_int(max);
574 json_object_object_add(parent, "max-elements", obj);
575 }
576}
577
578static void
579node_metadata_ident_recursive(struct lys_ident *ident, json_object *array)
580{
581 struct lys_ident_der *cur;
582 json_object *obj;
583
584 if (!ident) {
585 return;
586 }
587
588 obj = json_object_new_string(ident->name);
589 json_object_array_add(array, obj);
590
591 for (cur = ident->der; cur; cur = cur->next) {
592 node_metadata_ident_recursive(cur->ident, array);
593 }
594}
595
596static void
597node_metadata_type(struct lys_type *type, struct lys_module *module, json_object *parent)
598{
599 json_object *obj, *array, *item;
600 char *str;
601 int i;
602
603 /* built-in YANG type */
604 if (!type->der->module) {
605 switch (type->base) {
606 case LY_TYPE_BINARY:
607 node_metadata_text("binary", "type", parent);
608 node_metadata_restr(type->info.binary.length, "length", parent);
609 break;
610 case LY_TYPE_BITS:
611 node_metadata_text("bits", "type", parent);
612
613 array = json_object_new_array();
614 for (i = 0; i < type->info.bits.count; ++i) {
615 item = json_object_new_object();
616 obj = json_object_new_string(type->info.bits.bit[i].name);
617 json_object_object_add(item, "name", obj);
618 obj = json_object_new_int(type->info.bits.bit[i].pos);
619 json_object_object_add(item, "position", obj);
620 json_object_array_add(array, item);
621 }
622 json_object_object_add(parent, "bits", array);
623 break;
624 case LY_TYPE_BOOL:
625 node_metadata_text("bool", "type", parent);
626 break;
627 case LY_TYPE_DEC64:
628 node_metadata_text("decimal64", "type", parent);
629 node_metadata_restr(type->info.dec64.range, "range", parent);
630 obj = json_object_new_int(type->info.dec64.dig);
631 json_object_object_add(parent, "fraction-digits", obj);
632 break;
633 case LY_TYPE_EMPTY:
634 node_metadata_text("empty", "type", parent);
635 break;
636 case LY_TYPE_ENUM:
637 node_metadata_text("enumeration", "type", parent);
638
639 array = json_object_new_array();
640 for (i = 0; i < type->info.enums.count; ++i) {
641 obj = json_object_new_string(type->info.enums.enm[i].name);
642 json_object_array_add(array, obj);
643 }
644 json_object_object_add(parent, "enumval", array);
645 break;
646 case LY_TYPE_IDENT:
647 node_metadata_text("identityref", "type", parent);
648
649 array = json_object_new_array();
650 node_metadata_ident_recursive(type->info.ident.ref, array);
651 json_object_object_add(parent, "identityval", array);
652 break;
653 case LY_TYPE_INST:
654 node_metadata_text("instance-identifier", "type", parent);
655 if (type->info.inst.req == -1) {
656 obj = json_object_new_boolean(0);
657 } else {
658 obj = json_object_new_boolean(1);
659 }
660 json_object_object_add(parent, "require-instance", obj);
661 break;
662 case LY_TYPE_LEAFREF:
663 node_metadata_text("leafref", "type", parent);
664 node_metadata_text(type->info.lref.path, "path", parent);
665 break;
666 case LY_TYPE_STRING:
667 node_metadata_text("string", "type", parent);
668 node_metadata_restr(type->info.str.length, "length", parent);
669 if (type->info.str.pat_count) {
670 array = json_object_new_array();
671 for (i = 0; i < type->info.str.pat_count; ++i) {
672 obj = json_object_new_string(type->info.str.patterns[i].expr);
673 json_object_array_add(array, obj);
674 }
675 json_object_object_add(parent, "pattern", array);
676 }
677 break;
678 case LY_TYPE_UNION:
679 node_metadata_text("union", "type", parent);
680 array = json_object_new_array();
681 for (i = 0; i < type->info.uni.count; ++i) {
682 obj = json_object_new_object();
683 node_metadata_type(&type->info.uni.types[i], module, obj);
684 json_object_array_add(array, obj);
685 }
686 json_object_object_add(parent, "types", array);
687 break;
688 case LY_TYPE_INT8:
689 node_metadata_text("int8", "type", parent);
690 node_metadata_restr(type->info.num.range, "range", parent);
691 break;
692 case LY_TYPE_UINT8:
693 node_metadata_text("uint8", "type", parent);
694 node_metadata_restr(type->info.num.range, "range", parent);
695 break;
696 case LY_TYPE_INT16:
697 node_metadata_text("int16", "type", parent);
698 node_metadata_restr(type->info.num.range, "range", parent);
699 break;
700 case LY_TYPE_UINT16:
701 node_metadata_text("uint16", "type", parent);
702 node_metadata_restr(type->info.num.range, "range", parent);
703 break;
704 case LY_TYPE_INT32:
705 node_metadata_text("int32", "type", parent);
706 node_metadata_restr(type->info.num.range, "range", parent);
707 break;
708 case LY_TYPE_UINT32:
709 node_metadata_text("uint32", "type", parent);
710 node_metadata_restr(type->info.num.range, "range", parent);
711 break;
712 case LY_TYPE_INT64:
713 node_metadata_text("int64", "type", parent);
714 node_metadata_restr(type->info.num.range, "range", parent);
715 break;
716 case LY_TYPE_UINT64:
717 node_metadata_text("uint64", "type", parent);
718 node_metadata_restr(type->info.num.range, "range", parent);
719 break;
720 default:
721 ERROR("Internal: unknown type (%s:%d)", __FILE__, __LINE__);
722 break;
723 }
724
725 /* typedef */
726 } else {
727 if (!module || !type->module_name || !strcmp(type->module_name, module->name)) {
728 node_metadata_text(type->der->name, "type", parent);
729 } else {
730 asprintf(&str, "%s:%s", type->module_name, type->der->name);
731 node_metadata_text(str, "type", parent);
732 free(str);
733 }
734 obj = json_object_new_object();
735 node_metadata_typedef(type->der, obj);
736 json_object_object_add(parent, "typedef", obj);
737 }
738}
739
740static void
741node_metadata_typedef(struct lys_tpdf *tpdf, json_object *parent)
742{
743 json_object *obj;
744
745 /* description */
746 node_metadata_text(tpdf->dsc, "description", parent);
747
748 /* reference */
749 node_metadata_text(tpdf->ref, "reference", parent);
750
751 /* status */
752 if (tpdf->flags & LYS_STATUS_DEPRC) {
753 obj = json_object_new_string("deprecated");
754 } else if (tpdf->flags & LYS_STATUS_OBSLT) {
755 obj = json_object_new_string("obsolete");
756 } else {
757 obj = json_object_new_string("current");
758 }
759 json_object_object_add(parent, "status", obj);
760
761 /* type */
762 node_metadata_type(&tpdf->type, tpdf->module, parent);
763
764 /* units */
765 node_metadata_text(tpdf->units, "units", parent);
766
767 /* default */
768 node_metadata_text(tpdf->dflt, "default", parent);
769}
770
771static void
772node_metadata_container(struct lys_node_container *cont, json_object *parent)
773{
Michal Vaskoa45770b2015-11-23 15:49:41 +0100774 json_object *obj, *child_array = NULL, *choice_array = NULL;
Michal Vasko3fda9a92015-11-23 10:10:57 +0100775
776 /* element type */
777 obj = json_object_new_string("container");
778 json_object_object_add(parent, "eltype", obj);
779
780 /* shared info */
781 node_metadata_basic((struct lys_node *)cont, parent);
782
783 /* must */
784 node_metadata_must(cont->must_size, cont->must, parent);
785
786 /* presence */
787 node_metadata_text(cont->presence, "presence", parent);
788
789 /* when */
790 node_metadata_when(cont->when, parent);
791
792 /* children & choice */
Michal Vaskoa45770b2015-11-23 15:49:41 +0100793 node_metadata_children_recursive((struct lys_node *)cont, &child_array, &choice_array);
794 if (child_array) {
795 json_object_object_add(parent, "children", child_array);
796 }
797 if (choice_array) {
798 json_object_object_add(parent, "choice", choice_array);
799 }
Michal Vasko3fda9a92015-11-23 10:10:57 +0100800}
801
802static void
803node_metadata_choice(struct lys_node_choice *choice, json_object *parent)
804{
Michal Vaskoa45770b2015-11-23 15:49:41 +0100805 json_object *obj, *array;
Michal Vasko3fda9a92015-11-23 10:10:57 +0100806
807 /* element type */
808 obj = json_object_new_string("choice");
809 json_object_object_add(parent, "eltype", obj);
810
811 /* shared info */
812 node_metadata_basic((struct lys_node *)choice, parent);
813
814 /* default */
815 node_metadata_text(choice->dflt->name, "default", parent);
816
817 /* when */
818 node_metadata_when(choice->when, parent);
819
820 /* cases */
Michal Vaskoa45770b2015-11-23 15:49:41 +0100821 if (choice->child) {
822 array = json_object_new_array();
823 node_metadata_cases_recursive(choice, array);
824 json_object_object_add(parent, "cases", array);
825 }
Michal Vasko3fda9a92015-11-23 10:10:57 +0100826}
827
828static void
829node_metadata_leaf(struct lys_node_leaf *leaf, json_object *parent)
830{
831 json_object *obj;
832 struct lys_node_list *list;
833 int is_key, i;
834
835 /* element type */
836 obj = json_object_new_string("leaf");
837 json_object_object_add(parent, "eltype", obj);
838
839 /* shared info */
840 node_metadata_basic((struct lys_node *)leaf, parent);
841
842 /* type */
843 node_metadata_type(&leaf->type, leaf->module, parent);
844
845 /* units */
846 node_metadata_text(leaf->units, "units", parent);
847
848 /* default */
849 node_metadata_text(leaf->dflt, "default", parent);
850
851 /* must */
852 node_metadata_must(leaf->must_size, leaf->must, parent);
853
854 /* when */
855 node_metadata_when(leaf->when, parent);
856
857 /* iskey */
858 is_key = 0;
859 list = (struct lys_node_list *)lys_parent((struct lys_node *)leaf);
860 if (list && (list->nodetype == LYS_LIST)) {
861 for (i = 0; i < list->keys_size; ++i) {
862 if (list->keys[i] == leaf) {
863 is_key = 1;
864 break;
865 }
866 }
867 }
868 obj = json_object_new_boolean(is_key);
869 json_object_object_add(parent, "iskey", obj);
870}
871
872static void
873node_metadata_leaflist(struct lys_node_leaflist *llist, json_object *parent)
874{
875 json_object *obj;
876
877 /* element type */
878 obj = json_object_new_string("leaf-list");
879 json_object_object_add(parent, "eltype", obj);
880
881 /* shared info */
882 node_metadata_basic((struct lys_node *)llist, parent);
883
884 /* type */
885 node_metadata_type(&llist->type, llist->module, parent);
886
887 /* units */
888 node_metadata_text(llist->units, "units", parent);
889
890 /* must */
891 node_metadata_must(llist->must_size, llist->must, parent);
892
893 /* when */
894 node_metadata_when(llist->when, parent);
895
896 /* min/max-elements */
897 node_metadata_min_max(llist->min, llist->max, parent);
898}
899
900static void
901node_metadata_list(struct lys_node_list *list, json_object *parent)
902{
Michal Vaskoa45770b2015-11-23 15:49:41 +0100903 json_object *obj, *array, *child_array = NULL, *choice_array = NULL;;
Michal Vasko3fda9a92015-11-23 10:10:57 +0100904 int i;
905 unsigned int j;
906
907 /* element type */
908 obj = json_object_new_string("list");
909 json_object_object_add(parent, "eltype", obj);
910
911 /* shared info */
912 node_metadata_basic((struct lys_node *)list, parent);
913
914 /* must */
915 node_metadata_must(list->must_size, list->must, parent);
916
917 /* when */
918 node_metadata_when(list->when, parent);
919
920 /* min/max-elements */
921 node_metadata_min_max(list->min, list->max, parent);
922
923 /* keys */
924 if (list->keys_size) {
925 array = json_object_new_array();
926 for (i = 0; i < list->keys_size; ++i) {
927 obj = json_object_new_string(list->keys[i]->name);
928 json_object_array_add(array, obj);
929 }
930 json_object_object_add(parent, "keys", array);
931 }
932
933 /* unique */
934 if (list->unique_size) {
935 array = json_object_new_array();
936 for (i = 0; i < list->unique_size; ++i) {
937 for (j = 0; j < list->unique[i].expr_size; ++j) {
938 obj = json_object_new_string(list->unique[i].expr[j]);
939 json_object_array_add(array, obj);
940 }
941 }
942 json_object_object_add(parent, "unique", array);
943 }
Michal Vaskoa45770b2015-11-23 15:49:41 +0100944
945 /* children & choice */
946 node_metadata_children_recursive((struct lys_node *)list, &child_array, &choice_array);
947 if (child_array) {
948 json_object_object_add(parent, "children", child_array);
949 }
950 if (choice_array) {
951 json_object_object_add(parent, "choice", choice_array);
952 }
Michal Vasko3fda9a92015-11-23 10:10:57 +0100953}
954
955static void
956node_metadata_anyxml(struct lys_node_anyxml *anyxml, json_object *parent)
957{
958 json_object *obj;
959
960 /* element type */
961 obj = json_object_new_string("anyxml");
962 json_object_object_add(parent, "eltype", obj);
963
964 /* shared info */
965 node_metadata_basic((struct lys_node *)anyxml, parent);
966
967 /* must */
968 node_metadata_must(anyxml->must_size, anyxml->must, parent);
969
970 /* when */
971 node_metadata_when(anyxml->when, parent);
972
973}
974
975static void
976node_metadata_case(struct lys_node_case *cas, json_object *parent)
977{
978 json_object *obj;
979
980 /* element type */
981 obj = json_object_new_string("case");
982 json_object_object_add(parent, "eltype", obj);
983
984 /* shared info */
985 node_metadata_basic((struct lys_node *)cas, parent);
986
987 /* when */
988 node_metadata_when(cas->when, parent);
989}
990
Michal Vaskoa45770b2015-11-23 15:49:41 +0100991static void
992node_metadata_rpc(struct lys_node_rpc *rpc, json_object *parent)
993{
994 json_object *obj;
995
996 /* element type */
997 obj = json_object_new_string("rpc");
998 json_object_object_add(parent, "eltype", obj);
999
1000 /* description */
1001 node_metadata_text(rpc->dsc, "description", parent);
1002
1003 /* reference */
1004 node_metadata_text(rpc->ref, "reference", parent);
1005
1006 /* status */
1007 if (rpc->flags & LYS_STATUS_DEPRC) {
1008 obj = json_object_new_string("deprecated");
1009 } else if (rpc->flags & LYS_STATUS_OBSLT) {
1010 obj = json_object_new_string("obsolete");
1011 } else {
1012 obj = json_object_new_string("current");
1013 }
1014 json_object_object_add(parent, "status", obj);
1015}
1016
1017static void
Michal Vaskof35ea502016-02-24 10:44:54 +01001018node_metadata_model(const struct lys_module *module, json_object *parent)
Michal Vaskoa45770b2015-11-23 15:49:41 +01001019{
1020 json_object *obj, *array, *item;
1021 int i;
1022
1023 /* yang-version */
1024 if (module->version == 2) {
1025 obj = json_object_new_string("1.1");
1026 } else {
1027 obj = json_object_new_string("1.0");
1028 }
1029 json_object_object_add(parent, "yang-version", obj);
1030
1031 /* namespace */
1032 node_metadata_text(module->ns, "namespace", parent);
1033
1034 /* prefix */
1035 node_metadata_text(module->prefix, "prefix", parent);
1036
1037 /* contact */
1038 node_metadata_text(module->contact, "contact", parent);
1039
1040 /* organization */
1041 node_metadata_text(module->org, "organization", parent);
1042
1043 /* revision */
1044 if (module->rev_size) {
1045 node_metadata_text(module->rev[0].date, "revision", parent);
1046 }
1047
1048 /* description */
1049 node_metadata_text(module->dsc, "description", parent);
1050
1051 /* import */
1052 if (module->imp_size) {
1053 array = json_object_new_array();
1054 for (i = 0; i < module->imp_size; ++i) {
1055 item = json_object_new_object();
1056
1057 node_metadata_text(module->imp[i].module->name, "name", item);
1058 node_metadata_text(module->imp[i].prefix, "prefix", item);
1059 if (module->imp[i].rev && module->imp[i].rev[0]) {
1060 node_metadata_text(module->imp[i].rev, "revision", item);
1061 }
1062
1063 json_object_array_add(array, item);
1064 }
1065 json_object_object_add(parent, "imports", array);
1066 }
1067
1068 /* include */
1069 if (module->inc_size) {
1070 array = json_object_new_array();
1071 for (i = 0; i < module->inc_size; ++i) {
1072 item = json_object_new_object();
1073
1074 node_metadata_text(module->inc[i].submodule->name, "name", item);
1075 if (module->inc[i].rev && module->inc[i].rev[0]) {
1076 node_metadata_text(module->inc[i].rev, "revision", item);
1077 }
1078
1079 json_object_array_add(array, item);
1080 }
1081 json_object_object_add(parent, "includes", array);
1082 }
1083}
1084
Tomas Cejka0a4bba82013-04-19 11:51:28 +02001085/**
1086 * \defgroup netconf_operations NETCONF operations
1087 * The list of NETCONF operations that mod_netconf supports.
1088 * @{
1089 */
1090
1091/**
Tomas Cejka8ce138c2015-04-27 23:25:25 +02001092 * \brief Send RPC and wait for reply with timeout.
1093 *
1094 * \param[in] session libnetconf session
1095 * \param[in] rpc prepared RPC message
1096 * \param[in] timeout timeout in miliseconds, -1 for blocking, 0 for non-blocking
1097 * \param[out] reply reply from the server
Michal Vaskof35ea502016-02-24 10:44:54 +01001098 * \return NC_MSG_WOULDBLOCK or NC_MSG_ERROR.
Tomas Cejka8ce138c2015-04-27 23:25:25 +02001099 * On success, it returns NC_MSG_REPLY.
1100 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001101NC_MSG_TYPE
Michal Vaskof35ea502016-02-24 10:44:54 +01001102netconf_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 +02001103{
Michal Vaskof35ea502016-02-24 10:44:54 +01001104 uint64_t msgid;
1105 NC_MSG_TYPE ret;
1106 ret = nc_send_rpc(session, rpc, timeout, &msgid);
1107 if (ret != NC_MSG_RPC) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001108 return ret;
1109 }
Michal Vaskof35ea502016-02-24 10:44:54 +01001110
1111 while ((ret = nc_recv_reply(session, rpc, msgid, timeout, (strict ? LYD_OPT_STRICT : 0), reply)) == NC_MSG_NOTIF);
1112
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001113 return ret;
1114}
1115
Tomas Cejka8ce138c2015-04-27 23:25:25 +02001116/**
Tomas Cejka0a4bba82013-04-19 11:51:28 +02001117 * \brief Connect to NETCONF server
1118 *
1119 * \warning Session_key hash is not bound with caller identification. This could be potential security risk.
1120 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001121static unsigned int
Michal Vaskof35ea502016-02-24 10:44:54 +01001122netconf_connect(const char *host, const char *port, const char *user, const char *pass, const char *privkey)
Radek Krejci469aab82012-07-22 18:42:20 +02001123{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001124 struct nc_session* session = NULL;
1125 struct session_with_mutex *locked_session, *last_session;
Michal Vaskoda5ccc82015-11-25 10:42:49 +01001126 char *pubkey;
Radek Krejci469aab82012-07-22 18:42:20 +02001127
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001128 /* connect to the requested NETCONF server */
1129 password = (char*)pass;
Michal Vaskoda5ccc82015-11-25 10:42:49 +01001130 if (privkey) {
Michal Vaskof35ea502016-02-24 10:44:54 +01001131 nc_client_ssh_set_auth_pref(NC_SSH_AUTH_PUBLICKEY, 3);
Michal Vaskoda5ccc82015-11-25 10:42:49 +01001132 asprintf(&pubkey, "%s.pub", privkey);
Michal Vaskof35ea502016-02-24 10:44:54 +01001133 nc_client_ssh_add_keypair(pubkey, privkey);
Michal Vaskoda5ccc82015-11-25 10:42:49 +01001134 free(pubkey);
1135 }
Michal Vaskof35ea502016-02-24 10:44:54 +01001136 nc_client_ssh_set_username(user);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001137 DEBUG("prepare to connect %s@%s:%s", user, host, port);
Michal Vaskof35ea502016-02-24 10:44:54 +01001138 session = nc_connect_ssh(host, (unsigned short)atoi(port), NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001139 DEBUG("nc_session_connect done");
David Kupka8e60a372012-09-04 09:15:20 +02001140
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001141 /* if connected successful, add session to the list */
1142 if (session != NULL) {
1143 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 +01001144 nc_session_free(session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001145 session = NULL;
1146 free(locked_session);
1147 locked_session = NULL;
1148 ERROR("Creating structure session_with_mutex failed %d (%s)", errno, strerror(errno));
1149 return 0;
1150 }
1151 locked_session->session = session;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001152 locked_session->hello_message = NULL;
1153 locked_session->closed = 0;
1154 pthread_mutex_init(&locked_session->lock, NULL);
1155 DEBUG("Before session_lock");
1156 /* get exclusive access to sessions_list (conns) */
1157 DEBUG("LOCK wrlock %s", __func__);
1158 if (pthread_rwlock_wrlock(&session_lock) != 0) {
Michal Vaskoa9590052016-03-08 10:12:24 +01001159 nc_session_free(session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001160 free(locked_session);
1161 ERROR("Error while locking rwlock: %d (%s)", errno, strerror(errno));
1162 return 0;
1163 }
1164 locked_session->ntfc_subscribed = 0;
1165 DEBUG("Add connection to the list");
1166 if (!netconf_sessions_list) {
Michal Vaskoc3146782015-11-04 14:46:41 +01001167 netconf_sessions_list = locked_session;
1168 } else {
1169 for (last_session = netconf_sessions_list; last_session->next; last_session = last_session->next);
1170 last_session->next = locked_session;
1171 locked_session->prev = last_session;
1172 }
Michal Vaskof35ea502016-02-24 10:44:54 +01001173 session_user_activity(nc_session_get_username(locked_session->session));
Tomas Cejka45ab59f2013-05-15 00:10:49 +02001174
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001175 /* no need to lock session, noone can read it while we have wrlock */
Tomas Cejka47387fd2013-06-10 20:37:46 +02001176
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001177 /* store information about session from hello message for future usage */
1178 prepare_status_message(locked_session, session);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001179
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001180 DEBUG("NETCONF session established");
1181 locked_session->session_key = session_key_generator;
1182 ++session_key_generator;
1183 if (session_key_generator == UINT_MAX) {
1184 session_key_generator = 1;
1185 }
Tomas Cejka47387fd2013-06-10 20:37:46 +02001186
Michal Vaskoe32bcba2015-11-24 09:05:51 +01001187 DEBUG("Before session_unlock");
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001188 /* unlock session list */
1189 DEBUG("UNLOCK wrlock %s", __func__);
1190 if (pthread_rwlock_unlock(&session_lock) != 0) {
1191 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
1192 }
Radek Krejci469aab82012-07-22 18:42:20 +02001193
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001194 return locked_session->session_key;
1195 }
1196
1197 ERROR("Connection could not be established");
1198 return 0;
Radek Krejci469aab82012-07-22 18:42:20 +02001199}
1200
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001201static int
1202close_and_free_session(struct session_with_mutex *locked_session)
Radek Krejci469aab82012-07-22 18:42:20 +02001203{
Michal Vaskoa53ef882015-11-24 11:02:01 +01001204 int i;
1205
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001206 DEBUG("lock private lock.");
1207 DEBUG("LOCK mutex %s", __func__);
1208 if (pthread_mutex_lock(&locked_session->lock) != 0) {
1209 ERROR("Error while locking rwlock");
1210 }
1211 locked_session->ntfc_subscribed = 0;
1212 locked_session->closed = 1;
1213 if (locked_session->session != NULL) {
Michal Vaskoa9590052016-03-08 10:12:24 +01001214 nc_session_free(locked_session->session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001215 locked_session->session = NULL;
1216 }
1217 DEBUG("session closed.");
1218 DEBUG("unlock private lock.");
1219 DEBUG("UNLOCK mutex %s", __func__);
1220 if (pthread_mutex_unlock(&locked_session->lock) != 0) {
1221 ERROR("Error while locking rwlock");
1222 }
Tomas Cejka47387fd2013-06-10 20:37:46 +02001223
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001224 DEBUG("unlock session lock.");
1225 DEBUG("closed session, disabled notif(?), wait 0.5s");
1226 usleep(500000); /* let notification thread stop */
Tomas Cejka47387fd2013-06-10 20:37:46 +02001227
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001228 /* session shouldn't be used by now */
Michal Vaskoa53ef882015-11-24 11:02:01 +01001229 for (i = 0; i < locked_session->notif_count; ++i) {
1230 free(locked_session->notifications[i].content);
1231 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001232 free(locked_session->notifications);
1233 pthread_mutex_destroy(&locked_session->lock);
1234 if (locked_session->hello_message != NULL) {
1235 json_object_put(locked_session->hello_message);
1236 locked_session->hello_message = NULL;
1237 }
1238 locked_session->session = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001239 free(locked_session);
1240 locked_session = NULL;
1241 DEBUG("NETCONF session closed, everything cleared.");
1242 return (EXIT_SUCCESS);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001243}
1244
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001245static int
1246netconf_close(unsigned int session_key, json_object **reply)
Tomas Cejka47387fd2013-06-10 20:37:46 +02001247{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001248 struct session_with_mutex *locked_session;
Radek Krejci469aab82012-07-22 18:42:20 +02001249
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001250 DEBUG("Session to close: %u", session_key);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001251
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001252 /* get exclusive (write) access to sessions_list (conns) */
1253 DEBUG("lock session lock.");
1254 DEBUG("LOCK wrlock %s", __func__);
1255 if (pthread_rwlock_wrlock (&session_lock) != 0) {
1256 ERROR("Error while locking rwlock");
1257 (*reply) = create_error_reply("Internal: Error while locking.");
1258 return EXIT_FAILURE;
1259 }
1260 /* remove session from the active sessions list -> nobody new can now work with session */
1261 for (locked_session = netconf_sessions_list;
1262 locked_session && (locked_session->session_key != session_key);
Michal Vaskoc3146782015-11-04 14:46:41 +01001263 locked_session = locked_session->next);
1264
1265 if (!locked_session) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001266 ERROR("Could not find the session %u to close.", session_key);
1267 (*reply) = create_error_reply("Internal: Error while finding a session.");
Michal Vaskoc3146782015-11-04 14:46:41 +01001268 return EXIT_FAILURE;
1269 }
1270
1271 if (!locked_session->prev) {
1272 netconf_sessions_list = netconf_sessions_list->next;
Michal Vaskof0b6fbb2016-03-08 12:04:34 +01001273 if (netconf_sessions_list) {
1274 netconf_sessions_list->prev = NULL;
1275 }
Michal Vaskoc3146782015-11-04 14:46:41 +01001276 } else {
1277 locked_session->prev->next = locked_session->next;
1278 if (locked_session->next) {
1279 locked_session->next->prev = locked_session->prev;
1280 }
1281 }
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001282
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001283 DEBUG("UNLOCK wrlock %s", __func__);
1284 if (pthread_rwlock_unlock (&session_lock) != 0) {
1285 ERROR("Error while unlocking rwlock");
1286 (*reply) = create_error_reply("Internal: Error while unlocking.");
1287 }
Tomas Cejka47387fd2013-06-10 20:37:46 +02001288
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001289 if ((locked_session != NULL) && (locked_session->session != NULL)) {
1290 return close_and_free_session(locked_session);
1291 } else {
1292 ERROR("Unknown session to close");
1293 (*reply) = create_error_reply("Internal: Unkown session to close.");
1294 return (EXIT_FAILURE);
1295 }
1296 (*reply) = NULL;
Radek Krejci469aab82012-07-22 18:42:20 +02001297}
1298
Tomas Cejkac7929632013-10-24 19:25:15 +02001299/**
1300 * Test reply message type and return error message.
1301 *
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001302 * \param[in] session nc_session internal struct
Michal Vaskoc3146782015-11-04 14:46:41 +01001303 * \param[in] session_key session ID, 0 to disable disconnect on error
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001304 * \param[in] msgt RPC-REPLY message type
Tomas Cejkac7929632013-10-24 19:25:15 +02001305 * \param[out] data
1306 * \return NULL on success
1307 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001308json_object *
Michal Vaskof35ea502016-02-24 10:44:54 +01001309netconf_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 +02001310{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001311 json_object *err = NULL;
Tomas Cejkac7929632013-10-24 19:25:15 +02001312
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001313 /* process the result of the operation */
1314 switch (msgt) {
Michal Vaskof35ea502016-02-24 10:44:54 +01001315 case NC_MSG_ERROR:
1316 if (nc_session_get_status(session) != NC_STATUS_RUNNING) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001317 ERROR("mod_netconf: receiving rpc-reply failed");
1318 if (session_key) {
1319 netconf_close(session_key, &err);
1320 }
1321 if (err != NULL) {
1322 return err;
1323 }
1324 return create_error_reply("Internal: Receiving RPC-REPLY failed.");
1325 }
1326 case NC_MSG_NONE:
1327 /* there is error handled by callback */
1328 if (data != NULL) {
1329 free(*data);
1330 (*data) = NULL;
1331 }
1332 return NULL;
1333 case NC_MSG_REPLY:
Michal Vaskof35ea502016-02-24 10:44:54 +01001334 switch (reply->type) {
1335 case NC_RPL_OK:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001336 if ((data != NULL) && (*data != NULL)) {
1337 free(*data);
1338 (*data) = NULL;
1339 }
1340 return create_ok_reply();
Michal Vaskof35ea502016-02-24 10:44:54 +01001341 case NC_RPL_DATA:
1342 if (((*data) = ((struct nc_reply_data *)reply)->data) == NULL) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001343 ERROR("mod_netconf: no data from reply");
1344 return create_error_reply("Internal: No data from reply received.");
1345 } else {
Michal Vaskof35ea502016-02-24 10:44:54 +01001346 ((struct nc_reply_data *)reply)->data = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001347 return NULL;
1348 }
1349 break;
Michal Vaskof35ea502016-02-24 10:44:54 +01001350 case NC_RPL_ERROR:
1351 ERROR("mod_netconf: unexpected rpc-reply (%d)", reply->type);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001352 if (data != NULL) {
1353 free(*data);
1354 (*data) = NULL;
1355 }
Michal Vaskof35ea502016-02-24 10:44:54 +01001356 return create_error_reply(((struct nc_reply_error *)reply)->err[0].message);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001357 default:
Michal Vaskof35ea502016-02-24 10:44:54 +01001358 ERROR("mod_netconf: unexpected rpc-reply (%d)", reply->type);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001359 if (data != NULL) {
1360 free(*data);
1361 (*data) = NULL;
1362 }
1363 return create_error_reply("Unknown type of NETCONF reply.");
1364 }
1365 break;
1366 default:
1367 ERROR("mod_netconf: unexpected reply message received (%d)", msgt);
1368 if (data != NULL) {
1369 free(*data);
1370 (*data) = NULL;
1371 }
1372 return create_error_reply("Internal: Unexpected RPC-REPLY message type.");
1373 }
Tomas Cejkac7929632013-10-24 19:25:15 +02001374}
1375
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001376json_object *
Michal Vaskof35ea502016-02-24 10:44:54 +01001377netconf_unlocked_op(struct nc_session *session, struct nc_rpc *rpc)
Tomas Cejka6b886e02013-07-05 09:53:17 +02001378{
Michal Vaskof35ea502016-02-24 10:44:54 +01001379 struct nc_reply* reply = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001380 NC_MSG_TYPE msgt;
Tomas Cejka6b886e02013-07-05 09:53:17 +02001381
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001382 /* check requests */
1383 if (rpc == NULL) {
1384 ERROR("mod_netconf: rpc is not created");
1385 return create_error_reply("Internal error: RPC is not created");
1386 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02001387
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001388 if (session != NULL) {
1389 /* send the request and get the reply */
Michal Vaskof35ea502016-02-24 10:44:54 +01001390 msgt = netconf_send_recv_timed(session, rpc, 50000, 0, &reply);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001391 /* process the result of the operation */
1392 return netconf_test_reply(session, 0, msgt, reply, NULL);
1393 } else {
1394 ERROR("Unknown session to process.");
1395 return create_error_reply("Internal error: Unknown session to process.");
1396 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02001397}
1398
Tomas Cejkac7929632013-10-24 19:25:15 +02001399/**
1400 * Perform RPC method that returns data.
1401 *
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001402 * \param[in] session_id session identifier
1403 * \param[in] rpc RPC message to perform
1404 * \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 +02001405 * \return NULL on success, json object with error otherwise
1406 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001407static json_object *
Michal Vaskof35ea502016-02-24 10:44:54 +01001408netconf_op(unsigned int session_key, struct nc_rpc *rpc, int strict, struct lyd_node **received_data)
Radek Krejci469aab82012-07-22 18:42:20 +02001409{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001410 struct session_with_mutex * locked_session;
Michal Vaskof35ea502016-02-24 10:44:54 +01001411 struct nc_reply* reply = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001412 json_object *res = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01001413 struct lyd_node *data = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001414 NC_MSG_TYPE msgt;
Radek Krejci035bf4e2012-07-25 10:59:09 +02001415
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001416 /* check requests */
1417 if (rpc == NULL) {
1418 ERROR("mod_netconf: rpc is not created");
1419 res = create_error_reply("Internal: RPC could not be created.");
1420 data = NULL;
1421 goto finished;
1422 }
Radek Krejci8e4632a2012-07-26 13:40:34 +02001423
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001424 locked_session = session_get_locked(session_key, &res);
1425 if (!locked_session) {
1426 ERROR("Unknown session or locking failed.");
1427 goto finished;
1428 }
Tomas Cejkac7929632013-10-24 19:25:15 +02001429
Michal Vaskof35ea502016-02-24 10:44:54 +01001430 session_user_activity(nc_session_get_username(locked_session->session));
Tomas Cejkac7929632013-10-24 19:25:15 +02001431
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001432 /* send the request and get the reply */
Michal Vaskof35ea502016-02-24 10:44:54 +01001433 msgt = netconf_send_recv_timed(locked_session->session, rpc, 2000000, strict, &reply);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001434
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001435 session_unlock(locked_session);
Tomas Cejkac7929632013-10-24 19:25:15 +02001436
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001437 res = netconf_test_reply(locked_session->session, session_key, msgt, reply, &data);
Radek Krejcia332b692012-11-12 16:15:54 +01001438
Tomas Cejkac7929632013-10-24 19:25:15 +02001439finished:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001440 nc_reply_free(reply);
1441 if (received_data != NULL) {
1442 (*received_data) = data;
1443 } else {
1444 if (data != NULL) {
1445 free(data);
1446 data = NULL;
1447 }
1448 }
1449 return res;
Radek Krejci8e4632a2012-07-26 13:40:34 +02001450}
1451
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001452static char *
1453netconf_getconfig(unsigned int session_key, NC_DATASTORE source, const char *filter, int strict, json_object **err)
Radek Krejci8e4632a2012-07-26 13:40:34 +02001454{
Michal Vaskof35ea502016-02-24 10:44:54 +01001455 struct nc_rpc* rpc;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001456 struct session_with_mutex *locked_session;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001457 json_object *res = NULL, *data_cjson;
1458 enum json_tokener_error tok_err;
Michal Vaskof35ea502016-02-24 10:44:54 +01001459 char *data_json;
1460 struct lyd_node *data, *sibling, *next;
Radek Krejci8e4632a2012-07-26 13:40:34 +02001461
Michal Vaskof35ea502016-02-24 10:44:54 +01001462 /* tell server to show all elements even if they have default values */
1463#ifdef HAVE_WITHDEFAULTS_TAGGED
1464 rpc = nc_rpc_getconfig(source, filter, NC_WD_MODE_ALL_TAG, NC_PARAMTYPE_CONST);
1465#else
1466 rpc = nc_rpc_getconfig(source, filter, 0, NC_PARAMTYPE_CONST);
1467#endif
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001468 if (rpc == NULL) {
1469 ERROR("mod_netconf: creating rpc request failed");
1470 return (NULL);
1471 }
Radek Krejci8e4632a2012-07-26 13:40:34 +02001472
Michal Vaskof35ea502016-02-24 10:44:54 +01001473 res = netconf_op(session_key, rpc, strict, &data);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001474 nc_rpc_free(rpc);
1475 if (res != NULL) {
1476 (*err) = res;
1477 } else {
1478 (*err) = NULL;
1479 }
Tomas Cejkac7929632013-10-24 19:25:15 +02001480
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001481 if (data) {
1482 for (locked_session = netconf_sessions_list;
1483 locked_session && (locked_session->session_key != session_key);
1484 locked_session = locked_session->next);
1485 /* won't fail */
1486
Michal Vaskof35ea502016-02-24 10:44:54 +01001487 /* print data into JSON */
1488 if (lyd_print_mem(&data_json, data, LYD_JSON, LYP_WITHSIBLINGS)) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001489 ERROR("Printing JSON <get-config> data failed.");
Michal Vaskof35ea502016-02-24 10:44:54 +01001490 lyd_free_withsiblings(data);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001491 return NULL;
1492 }
1493
1494 /* parse JSON data into cjson */
1495 pthread_mutex_lock(&json_lock);
Michal Vaskof35ea502016-02-24 10:44:54 +01001496 data_cjson = json_tokener_parse_verbose(data_json, &tok_err);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001497 if (!data_cjson) {
1498 ERROR("Parsing JSON config failed (%s).", json_tokener_error_desc(tok_err));
1499 pthread_mutex_unlock(&json_lock);
Michal Vaskof35ea502016-02-24 10:44:54 +01001500 lyd_free_withsiblings(data);
1501 free(data_json);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001502 return NULL;
1503 }
Michal Vaskof35ea502016-02-24 10:44:54 +01001504 free(data_json);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001505
1506 /* go simultaneously through both trees and add metadata */
Michal Vaskof35ea502016-02-24 10:44:54 +01001507 LY_TREE_FOR_SAFE(data, next, sibling) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001508 node_add_metadata_recursive(sibling, NULL, data_cjson);
1509 lyd_free(sibling);
1510 }
1511
Michal Vaskof35ea502016-02-24 10:44:54 +01001512 data_json = strdup(json_object_to_json_string_ext(data_cjson, 0));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001513 json_object_put(data_cjson);
1514 pthread_mutex_unlock(&json_lock);
1515 }
1516
Michal Vaskof35ea502016-02-24 10:44:54 +01001517 return (data_json);
Radek Krejci8e4632a2012-07-26 13:40:34 +02001518}
1519
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001520static char *
1521netconf_getschema(unsigned int session_key, const char *identifier, const char *version, const char *format, json_object **err)
Tomas Cejka0aeca8b2012-12-22 19:56:03 +01001522{
Michal Vaskof35ea502016-02-24 10:44:54 +01001523 struct nc_rpc *rpc;
1524 struct lyd_node *data = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001525 json_object *res = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01001526 char *model_data = NULL, *anyxml, *ptr, *ptr2;
Tomas Cejka0aeca8b2012-12-22 19:56:03 +01001527
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001528 /* create requests */
Michal Vaskof35ea502016-02-24 10:44:54 +01001529 rpc = nc_rpc_getschema(identifier, version, format, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001530 if (rpc == NULL) {
1531 ERROR("mod_netconf: creating rpc request failed");
1532 return (NULL);
1533 }
Tomas Cejka0aeca8b2012-12-22 19:56:03 +01001534
Michal Vaskof35ea502016-02-24 10:44:54 +01001535 res = netconf_op(session_key, rpc, 0, &data);
1536 nc_rpc_free(rpc);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001537 if (res != NULL) {
1538 (*err) = res;
1539 } else {
1540 (*err) = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01001541
1542 if (data) {
1543 lyxml_print_mem(&anyxml, ((struct lyd_node_anyxml *)data)->value, 0);
1544
1545 /* it's with the data root node, remove it */
1546 if (anyxml) {
1547 ptr = strchr(anyxml, '>');
1548 ++ptr;
1549
1550 ptr2 = strrchr(anyxml, '<');
1551
1552 model_data = strndup(ptr, strlen(ptr) - strlen(ptr2));
1553 free(anyxml);
1554 }
1555 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001556 }
Tomas Cejkac7929632013-10-24 19:25:15 +02001557
Michal Vaskof35ea502016-02-24 10:44:54 +01001558 return (model_data);
Tomas Cejka0aeca8b2012-12-22 19:56:03 +01001559}
1560
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001561static char *
1562netconf_get(unsigned int session_key, const char* filter, int strict, json_object **err)
Radek Krejci8e4632a2012-07-26 13:40:34 +02001563{
Michal Vaskof35ea502016-02-24 10:44:54 +01001564 struct nc_rpc* rpc;
1565 char* data_json = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001566 json_object *res = NULL, *data_cjson;
1567 enum json_tokener_error tok_err;
1568 struct session_with_mutex *locked_session;
Michal Vaskof35ea502016-02-24 10:44:54 +01001569 struct lyd_node *data, *sibling, *next;
Radek Krejci8e4632a2012-07-26 13:40:34 +02001570
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001571 /* create requests */
Michal Vaskof35ea502016-02-24 10:44:54 +01001572 rpc = nc_rpc_get(filter, 0, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001573 if (rpc == NULL) {
1574 ERROR("mod_netconf: creating rpc request failed");
1575 return (NULL);
1576 }
Radek Krejci8e4632a2012-07-26 13:40:34 +02001577
Michal Vaskof35ea502016-02-24 10:44:54 +01001578 res = netconf_op(session_key, rpc, strict, &data);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001579 nc_rpc_free(rpc);
1580 if (res != NULL) {
1581 (*err) = res;
1582 } else {
1583 (*err) = NULL;
1584 }
Tomas Cejkac7929632013-10-24 19:25:15 +02001585
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001586 if (data) {
1587 for (locked_session = netconf_sessions_list;
1588 locked_session && (locked_session->session_key != session_key);
1589 locked_session = locked_session->next);
1590 /* won't fail */
1591
Michal Vaskof35ea502016-02-24 10:44:54 +01001592 /* print JSON data */
1593 if (lyd_print_mem(&data_json, data, LYD_JSON, LYP_WITHSIBLINGS)) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001594 ERROR("Printing JSON <get> data failed.");
Michal Vaskof35ea502016-02-24 10:44:54 +01001595 lyd_free_withsiblings(data);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001596 return NULL;
1597 }
1598
1599 /* parse JSON data into cjson */
1600 pthread_mutex_lock(&json_lock);
Michal Vaskof35ea502016-02-24 10:44:54 +01001601 data_cjson = json_tokener_parse_verbose(data_json, &tok_err);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001602 if (!data_cjson) {
1603 ERROR("Parsing JSON config failed (%s).", json_tokener_error_desc(tok_err));
1604 pthread_mutex_unlock(&json_lock);
Michal Vaskof35ea502016-02-24 10:44:54 +01001605 lyd_free_withsiblings(data);
1606 free(data_json);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001607 return NULL;
1608 }
Michal Vaskof35ea502016-02-24 10:44:54 +01001609 free(data_json);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001610
1611 /* go simultaneously through both trees and add metadata */
Michal Vaskof35ea502016-02-24 10:44:54 +01001612 LY_TREE_FOR_SAFE(data, next, sibling) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001613 node_add_metadata_recursive(sibling, NULL, data_cjson);
1614 lyd_free(sibling);
1615 }
1616
Michal Vaskof35ea502016-02-24 10:44:54 +01001617 data_json = strdup(json_object_to_json_string_ext(data_cjson, 0));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001618 json_object_put(data_cjson);
1619 pthread_mutex_unlock(&json_lock);
1620 }
1621
Michal Vaskof35ea502016-02-24 10:44:54 +01001622 return data_json;
Radek Krejci8e4632a2012-07-26 13:40:34 +02001623}
1624
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001625static json_object *
1626netconf_copyconfig(unsigned int session_key, NC_DATASTORE source, NC_DATASTORE target, const char *config,
1627 const char *uri_src, const char *uri_trg)
Radek Krejci8e4632a2012-07-26 13:40:34 +02001628{
Michal Vaskof35ea502016-02-24 10:44:54 +01001629 struct nc_rpc* rpc;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001630 json_object *res = NULL;
Radek Krejci8e4632a2012-07-26 13:40:34 +02001631
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001632 /* create requests */
Michal Vaskof35ea502016-02-24 10:44:54 +01001633 rpc = nc_rpc_copy(target, uri_trg, source, (config ? config : uri_src), 0, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001634 if (rpc == NULL) {
1635 ERROR("mod_netconf: creating rpc request failed");
1636 return create_error_reply("Internal: Creating rpc request failed");
1637 }
Radek Krejci8e4632a2012-07-26 13:40:34 +02001638
Michal Vaskof35ea502016-02-24 10:44:54 +01001639 res = netconf_op(session_key, rpc, 0, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001640 nc_rpc_free(rpc);
Tomas Cejkac7929632013-10-24 19:25:15 +02001641
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001642 return res;
Radek Krejci8e4632a2012-07-26 13:40:34 +02001643}
Radek Krejci035bf4e2012-07-25 10:59:09 +02001644
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001645static json_object *
Michal Vaskof35ea502016-02-24 10:44:54 +01001646netconf_editconfig(unsigned int session_key, NC_DATASTORE target, NC_RPC_EDIT_DFLTOP defop,
1647 NC_RPC_EDIT_ERROPT erropt, NC_RPC_EDIT_TESTOPT testopt, const char *config_or_url)
Radek Krejci62ab34b2012-07-26 13:42:05 +02001648{
Michal Vaskof35ea502016-02-24 10:44:54 +01001649 struct nc_rpc* rpc;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001650 json_object *res = NULL;
Radek Krejci62ab34b2012-07-26 13:42:05 +02001651
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001652 /* create requests */
Michal Vaskof35ea502016-02-24 10:44:54 +01001653 rpc = nc_rpc_edit(target, defop, testopt, erropt, config_or_url, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001654 if (rpc == NULL) {
1655 ERROR("mod_netconf: creating rpc request failed");
1656 return create_error_reply("Internal: Creating rpc request failed");
1657 }
Radek Krejci62ab34b2012-07-26 13:42:05 +02001658
Michal Vaskof35ea502016-02-24 10:44:54 +01001659 res = netconf_op(session_key, rpc, 0, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001660 nc_rpc_free (rpc);
Tomas Cejkac7929632013-10-24 19:25:15 +02001661
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001662 return res;
Radek Krejci62ab34b2012-07-26 13:42:05 +02001663}
1664
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001665static json_object *
1666netconf_killsession(unsigned int session_key, const char *sid)
Radek Krejcie34d3eb2012-07-26 15:05:53 +02001667{
Michal Vaskof35ea502016-02-24 10:44:54 +01001668 struct nc_rpc *rpc;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001669 json_object *res = NULL;
Radek Krejcie34d3eb2012-07-26 15:05:53 +02001670
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001671 /* create requests */
Michal Vaskof35ea502016-02-24 10:44:54 +01001672 rpc = nc_rpc_kill(atoi(sid));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001673 if (rpc == NULL) {
1674 ERROR("mod_netconf: creating rpc request failed");
1675 return create_error_reply("Internal: Creating rpc request failed");
1676 }
Radek Krejcie34d3eb2012-07-26 15:05:53 +02001677
Michal Vaskof35ea502016-02-24 10:44:54 +01001678 res = netconf_op(session_key, rpc, 0, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001679 nc_rpc_free(rpc);
1680 return res;
Radek Krejcie34d3eb2012-07-26 15:05:53 +02001681}
1682
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001683static json_object *
Michal Vaskof35ea502016-02-24 10:44:54 +01001684netconf_onlytargetop(unsigned int session_key, NC_DATASTORE target, struct nc_rpc *(*op_func)(NC_DATASTORE))
Radek Krejci2f318372012-07-26 14:22:35 +02001685{
Michal Vaskof35ea502016-02-24 10:44:54 +01001686 struct nc_rpc* rpc;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001687 json_object *res = NULL;
Radek Krejci2f318372012-07-26 14:22:35 +02001688
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001689 /* create requests */
1690 rpc = op_func(target);
1691 if (rpc == NULL) {
1692 ERROR("mod_netconf: creating rpc request failed");
1693 return create_error_reply("Internal: Creating rpc request failed");
1694 }
Radek Krejci2f318372012-07-26 14:22:35 +02001695
Michal Vaskof35ea502016-02-24 10:44:54 +01001696 res = netconf_op(session_key, rpc, 0, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001697 nc_rpc_free (rpc);
1698 return res;
Radek Krejci2f318372012-07-26 14:22:35 +02001699}
1700
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001701static json_object *
1702netconf_deleteconfig(unsigned int session_key, NC_DATASTORE target, const char *url)
Radek Krejci5cd7d422012-07-26 14:50:29 +02001703{
Michal Vaskof35ea502016-02-24 10:44:54 +01001704 struct nc_rpc *rpc = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001705 json_object *res = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01001706 rpc = nc_rpc_delete(target, url, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001707 if (rpc == NULL) {
1708 ERROR("mod_netconf: creating rpc request failed");
1709 return create_error_reply("Internal: Creating rpc request failed");
1710 }
Tomas Cejka404d37e2013-04-13 02:31:35 +02001711
Michal Vaskof35ea502016-02-24 10:44:54 +01001712 res = netconf_op(session_key, rpc, 0, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001713 nc_rpc_free (rpc);
1714 return res;
Radek Krejci5cd7d422012-07-26 14:50:29 +02001715}
1716
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001717static json_object *
1718netconf_lock(unsigned int session_key, NC_DATASTORE target)
Radek Krejci5cd7d422012-07-26 14:50:29 +02001719{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001720 return (netconf_onlytargetop(session_key, target, nc_rpc_lock));
Radek Krejci5cd7d422012-07-26 14:50:29 +02001721}
1722
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001723static json_object *
1724netconf_unlock(unsigned int session_key, NC_DATASTORE target)
Radek Krejci5cd7d422012-07-26 14:50:29 +02001725{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001726 return (netconf_onlytargetop(session_key, target, nc_rpc_unlock));
Radek Krejci5cd7d422012-07-26 14:50:29 +02001727}
1728
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001729static json_object *
Michal Vaskof35ea502016-02-24 10:44:54 +01001730netconf_generic(unsigned int session_key, const char *xml_content, struct lyd_node **data)
Radek Krejci80c10d92012-07-30 08:38:50 +02001731{
Michal Vaskof35ea502016-02-24 10:44:54 +01001732 struct nc_rpc* rpc = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001733 json_object *res = NULL;
Radek Krejci80c10d92012-07-30 08:38:50 +02001734
Michal Vaskoa53ef882015-11-24 11:02:01 +01001735 assert(!data || !*data);
1736
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001737 /* create requests */
Michal Vaskof35ea502016-02-24 10:44:54 +01001738 rpc = nc_rpc_generic_xml(xml_content, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001739 if (rpc == NULL) {
1740 ERROR("mod_netconf: creating rpc request failed");
1741 return create_error_reply("Internal: Creating rpc request failed");
1742 }
Radek Krejci80c10d92012-07-30 08:38:50 +02001743
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001744 /* get session where send the RPC */
Michal Vaskof35ea502016-02-24 10:44:54 +01001745 res = netconf_op(session_key, rpc, 0, data);
1746 nc_rpc_free(rpc);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001747 return res;
1748}
1749
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001750static int
Michal Vaskof35ea502016-02-24 10:44:54 +01001751node_add_metadata(const struct lys_node *node, const struct lys_module *module, json_object *parent)
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001752{
1753 struct lys_module *cur_module;
1754 json_object *meta_obj;
1755 char *obj_name;
1756
Michal Vaskoa45770b2015-11-23 15:49:41 +01001757 if (node->nodetype == LYS_INPUT) {
1758 /* silently skipped */
1759 return 0;
1760 }
1761
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001762 cur_module = node->module;
1763 if (cur_module->type) {
1764 cur_module = ((struct lys_submodule *)cur_module)->belongsto;
1765 }
1766 if (cur_module == module) {
1767 asprintf(&obj_name, "$@%s", node->name);
1768 } else {
1769 asprintf(&obj_name, "$@%s:%s", cur_module->name, node->name);
1770 }
1771
1772 /* in (leaf-)lists the metadata could have already been added */
Michal Vaskoa45770b2015-11-23 15:49:41 +01001773 if ((node->nodetype & (LYS_LEAFLIST | LYS_LIST)) && (json_object_object_get_ex(parent, obj_name, NULL) == TRUE)) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001774 free(obj_name);
1775 return 1;
1776 }
1777
1778 meta_obj = json_object_new_object();
1779
1780 switch (node->nodetype) {
1781 case LYS_CONTAINER:
1782 node_metadata_container((struct lys_node_container *)node, meta_obj);
1783 break;
Michal Vasko3fda9a92015-11-23 10:10:57 +01001784 case LYS_CHOICE:
1785 node_metadata_choice((struct lys_node_choice *)node, meta_obj);
1786 break;
1787 case LYS_LEAF:
1788 node_metadata_leaf((struct lys_node_leaf *)node, meta_obj);
1789 break;
1790 case LYS_LEAFLIST:
1791 node_metadata_leaflist((struct lys_node_leaflist *)node, meta_obj);
1792 break;
1793 case LYS_LIST:
1794 node_metadata_list((struct lys_node_list *)node, meta_obj);
1795 break;
1796 case LYS_ANYXML:
1797 node_metadata_anyxml((struct lys_node_anyxml *)node, meta_obj);
1798 break;
1799 case LYS_CASE:
1800 node_metadata_case((struct lys_node_case *)node, meta_obj);
1801 break;
Michal Vaskoa45770b2015-11-23 15:49:41 +01001802 case LYS_RPC:
1803 node_metadata_rpc((struct lys_node_rpc *)node, meta_obj);
1804 break;
1805 default: /* LYS_OUTPUT */
Michal Vasko3fda9a92015-11-23 10:10:57 +01001806 ERROR("Internal: unuxpected nodetype (%s:%d)", __FILE__, __LINE__);
1807 break;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001808 }
1809
1810 /* just a precaution */
1811 if (json_object_get_type(parent) != json_type_object) {
1812 ERROR("Internal: wrong JSON type (%s:%d)", __FILE__, __LINE__);
1813 free(obj_name);
1814 return 1;
1815 }
1816
1817 json_object_object_add(parent, obj_name, meta_obj);
1818 free(obj_name);
1819 return 0;
1820}
1821
1822static void
Michal Vaskof35ea502016-02-24 10:44:54 +01001823node_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 +01001824{
1825 struct lys_module *cur_module;
1826 struct lys_node *list_schema;
1827 struct lyd_node *child, *list_item;
1828 json_object *child_json, *list_child_json;
1829 char *child_name;
1830 int list_idx;
1831
Michal Vaskoa45770b2015-11-23 15:49:41 +01001832 if (data_tree->schema->nodetype & (LYS_OUTPUT | LYS_GROUPING)) {
1833 return;
1834 }
1835
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001836 /* add data_tree metadata */
1837 if (node_add_metadata(data_tree->schema, module, data_json_parent)) {
1838 return;
1839 }
1840
1841 /* get data_tree module */
1842 cur_module = data_tree->schema->module;
1843 if (cur_module->type) {
1844 cur_module = ((struct lys_submodule *)cur_module)->belongsto;
1845 }
1846
1847 if (!(data_tree->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST | LYS_ANYXML))) {
1848 /* print correct data_tree JSON name */
1849 if (cur_module == module) {
1850 asprintf(&child_name, "%s", data_tree->schema->name);
1851 } else {
1852 asprintf(&child_name, "%s:%s", cur_module->name, data_tree->schema->name);
1853 }
1854
1855 /* go down in JSON object */
1856 if (json_object_object_get_ex(data_json_parent, child_name, &child_json) == FALSE) {
1857 ERROR("Internal: failed to get JSON object \"%s\".", child_name);
1858 free(child_name);
1859 return;
1860 }
1861 free(child_name);
1862
1863 if (data_tree->schema->nodetype == LYS_LIST) {
1864 if (json_object_get_type(child_json) != json_type_array) {
1865 ERROR("Internal: type mismatch (%s:%d)", __FILE__, __LINE__);
1866 return;
1867 }
1868 /* go down in data tree for every item, we process them all now, skip later
1869 * (metadata duplicate will be detected at the beginning of this function) */
1870 list_idx = 0;
1871 list_schema = data_tree->schema;
1872
1873 LY_TREE_FOR(data_tree, list_item) {
1874 /* another list member */
1875 if (list_item->schema == list_schema) {
1876 list_child_json = json_object_array_get_idx(child_json, list_idx);
1877 if (!list_child_json) {
1878 ERROR("Internal: list \"%s\" idx out-of-bounds", list_schema->name);
1879 return;
1880 }
1881 LY_TREE_FOR(list_item->child, child) {
1882 node_add_metadata_recursive(child, cur_module, list_child_json);
1883 }
1884
1885 ++list_idx;
1886 }
1887 }
1888 } else {
1889 if (json_object_get_type(child_json) != json_type_object) {
1890 ERROR("Internal: type mismatch (%s:%d)", __FILE__, __LINE__);
1891 return;
1892 }
1893 /* go down in data tree */
1894 LY_TREE_FOR(data_tree->child, child) {
1895 node_add_metadata_recursive(child, cur_module, child_json);
1896 }
1897 }
1898 }
1899}
1900
1901static void
Michal Vaskof35ea502016-02-24 10:44:54 +01001902node_add_model_metadata(const struct lys_module *module, json_object *parent)
Michal Vaskoa45770b2015-11-23 15:49:41 +01001903{
1904 json_object *obj;
1905 char *str;
1906
1907 obj = json_object_new_object();
1908 node_metadata_model(module, obj);
1909 asprintf(&str, "$@@%s", module->name);
1910 json_object_object_add(parent, str, obj);
1911 free(str);
1912}
1913
1914static void
Michal Vaskof35ea502016-02-24 10:44:54 +01001915node_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 +01001916{
Michal Vaskof35ea502016-02-24 10:44:54 +01001917 const struct lys_module *cur_module;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001918 struct lys_node *child;
1919 json_object *node_json;
1920 char *json_name;
1921
Michal Vaskoa45770b2015-11-23 15:49:41 +01001922 if (node->nodetype & (LYS_OUTPUT | LYS_GROUPING)) {
1923 return;
1924 }
1925
1926 if (node->nodetype & LYS_USES) {
1927 cur_module = module;
1928 node_json = parent;
1929 goto children;
1930 }
1931
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001932 /* add node metadata */
1933 if (node_add_metadata(node, module, parent)) {
1934 ERROR("Internal: metadata duplicate for \"%s\".", node->name);
1935 return;
1936 }
1937
Michal Vaskoa45770b2015-11-23 15:49:41 +01001938 /* no other metadata */
1939 if (!node->child) {
1940 return;
1941 }
1942
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001943 /* get node module */
1944 cur_module = node->module;
1945 if (cur_module->type) {
1946 cur_module = ((struct lys_submodule *)cur_module)->belongsto;
1947 }
1948
1949 /* create JSON object for child metadata */
1950 node_json = json_object_new_object();
1951 if (cur_module == module) {
1952 json_object_object_add(parent, node->name, node_json);
1953 } else {
1954 asprintf(&json_name, "%s:%s", cur_module->name, node->name);
1955 json_object_object_add(parent, json_name, node_json);
1956 free(json_name);
1957 }
1958
Michal Vaskoa45770b2015-11-23 15:49:41 +01001959children:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001960 LY_TREE_FOR(node->child, child) {
1961 node_add_children_with_metadata_recursive(child, cur_module, node_json);
1962 }
1963}
1964
1965static json_object *
1966libyang_query(unsigned int session_key, const char *filter, int load_children)
1967{
Michal Vaskof35ea502016-02-24 10:44:54 +01001968 const struct lys_node *node;
1969 const struct lys_module *module = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001970 struct session_with_mutex *locked_session;
1971 json_object *ret = NULL, *data;
1972
1973 locked_session = session_get_locked(session_key, &ret);
1974 if (!locked_session) {
1975 ERROR("Locking failed or session not found.");
1976 goto finish;
1977 }
1978
Michal Vaskof35ea502016-02-24 10:44:54 +01001979 session_user_activity(nc_session_get_username(locked_session->session));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001980
Michal Vaskoa45770b2015-11-23 15:49:41 +01001981 if (filter[0] == '/') {
Michal Vaskof35ea502016-02-24 10:44:54 +01001982 node = ly_ctx_get_node(nc_session_get_ctx(locked_session->session), filter);
Michal Vaskoa45770b2015-11-23 15:49:41 +01001983 if (!node) {
1984 ret = create_error_reply("Failed to resolve XPath filter node.");
1985 goto finish;
1986 }
1987 } else {
Michal Vaskof35ea502016-02-24 10:44:54 +01001988 module = ly_ctx_get_module(nc_session_get_ctx(locked_session->session), filter, NULL);
Michal Vaskoa45770b2015-11-23 15:49:41 +01001989 if (!module) {
1990 ret = create_error_reply("Failed to find model.");
1991 goto finish;
1992 }
1993 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001994
Michal Vaskoa45770b2015-11-23 15:49:41 +01001995 pthread_mutex_lock(&json_lock);
1996 data = json_object_new_object();
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01001997
Michal Vaskoa45770b2015-11-23 15:49:41 +01001998 if (module) {
1999 node_add_model_metadata(module, data);
2000 if (load_children) {
2001 LY_TREE_FOR(module->data, node) {
2002 node_add_children_with_metadata_recursive(node, NULL, data);
2003 }
2004 }
2005 } else {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002006 if (load_children) {
2007 node_add_children_with_metadata_recursive(node, NULL, data);
2008 } else {
2009 node_add_metadata(node, NULL, data);
2010 }
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002011 }
2012
Michal Vaskoa45770b2015-11-23 15:49:41 +01002013 pthread_mutex_unlock(&json_lock);
2014 ret = create_data_reply(json_object_to_json_string(data));
2015 json_object_put(data);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002016
2017finish:
Michal Vaskoa45770b2015-11-23 15:49:41 +01002018 session_unlock(locked_session);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002019 return ret;
2020}
2021
2022static json_object *
2023libyang_merge(unsigned int session_key, const char *config)
2024{
2025 struct lyd_node *data_tree = NULL, *sibling;
2026 struct session_with_mutex *locked_session;
2027 json_object *ret = NULL, *data_json = NULL;
2028 enum json_tokener_error err = 0;
2029
2030 locked_session = session_get_locked(session_key, &ret);
2031 if (!locked_session) {
2032 ERROR("Locking failed or session not found.");
2033 goto finish;
2034 }
2035
Michal Vaskof35ea502016-02-24 10:44:54 +01002036 session_user_activity(nc_session_get_username(locked_session->session));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002037
Michal Vaskof35ea502016-02-24 10:44:54 +01002038 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 +01002039 if (!data_tree) {
2040 ERROR("Creating data tree failed.");
2041 ret = create_error_reply("Failed to create data tree from JSON config.");
2042 session_unlock(locked_session);
2043 goto finish;
2044 }
2045
2046 session_unlock(locked_session);
2047
2048 pthread_mutex_lock(&json_lock);
2049 data_json = json_tokener_parse_verbose(config, &err);
2050 if (!data_json) {
2051 ERROR("Parsing JSON config failed (%s).", json_tokener_error_desc(err));
2052 pthread_mutex_unlock(&json_lock);
2053 ret = create_error_reply(json_tokener_error_desc(err));
2054 goto finish;
2055 }
2056
2057 /* go simultaneously through both trees and add metadata */
2058 LY_TREE_FOR(data_tree, sibling) {
2059 node_add_metadata_recursive(sibling, NULL, data_json);
2060 }
2061 pthread_mutex_unlock(&json_lock);
2062 ret = create_data_reply(json_object_to_json_string(data_json));
2063
2064finish:
2065 LY_TREE_FOR(data_tree, sibling) {
2066 lyd_free(sibling);
2067 }
2068 json_object_put(data_json);
2069 return ret;
Radek Krejci80c10d92012-07-30 08:38:50 +02002070}
2071
Tomas Cejka0a4bba82013-04-19 11:51:28 +02002072/**
2073 * @}
2074 *//* netconf_operations */
2075
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002076void
2077clb_print(NC_VERB_LEVEL level, const char *msg)
Radek Krejci469aab82012-07-22 18:42:20 +02002078{
Tomas Cejka8a86cc22014-09-18 15:35:07 +02002079#define FOREACH(I) \
Tomas Cejkacf44e522015-04-24 17:29:21 +02002080 I(NC_VERB_ERROR) I(NC_VERB_WARNING)
2081
2082#define CASE(VAL) case VAL: ERROR("%s: %s", #VAL, msg); \
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002083 break;
Tomas Cejka8a86cc22014-09-18 15:35:07 +02002084
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002085 switch (level) {
2086 FOREACH(CASE);
2087 case NC_VERB_VERBOSE:
2088 case NC_VERB_DEBUG:
2089 DEBUG("DEBUG: %s", msg);
2090 break;
2091 }
2092 if (level == NC_VERB_ERROR) {
2093 /* return global error */
2094 netconf_callback_error_process(NULL /* tag */, NULL /* type */,
2095 NULL /* severity */, NULL /* apptag */,
2096 NULL /* path */, msg, NULL /* attribute */,
2097 NULL /* element */, NULL /* ns */, NULL /* sid */);
2098 }
Radek Krejci469aab82012-07-22 18:42:20 +02002099}
2100
Tomas Cejka64b87482013-06-03 16:30:53 +02002101/**
Tomas Cejka6e8f4262013-07-10 09:20:19 +02002102 * Receive message from client over UNIX socket and return pointer to it.
Tomas Cejka64b87482013-06-03 16:30:53 +02002103 * Caller should free message memory.
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002104 * \param[in] client socket descriptor of client
Tomas Cejka64b87482013-06-03 16:30:53 +02002105 * \return pointer to message
2106 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002107char *
2108get_framed_message(int client)
Tomas Cejka64b87482013-06-03 16:30:53 +02002109{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002110 /* read json in chunked framing */
2111 unsigned int buffer_size = 0;
2112 ssize_t buffer_len = 0;
2113 char *buffer = NULL;
2114 char c;
2115 ssize_t ret;
2116 int i, chunk_len;
2117 char chunk_len_str[12];
Tomas Cejka64b87482013-06-03 16:30:53 +02002118
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002119 while (1) {
2120 /* read chunk length */
2121 if ((ret = recv (client, &c, 1, 0)) != 1 || c != '\n') {
2122 if (buffer != NULL) {
2123 free (buffer);
2124 buffer = NULL;
2125 }
2126 break;
2127 }
2128 if ((ret = recv (client, &c, 1, 0)) != 1 || c != '#') {
2129 if (buffer != NULL) {
2130 free (buffer);
2131 buffer = NULL;
2132 }
2133 break;
2134 }
2135 i=0;
2136 memset (chunk_len_str, 0, 12);
2137 while ((ret = recv (client, &c, 1, 0) == 1 && (isdigit(c) || c == '#'))) {
2138 if (i==0 && c == '#') {
2139 if (recv (client, &c, 1, 0) != 1 || c != '\n') {
2140 /* end but invalid */
2141 if (buffer != NULL) {
2142 free (buffer);
2143 buffer = NULL;
2144 }
2145 }
2146 /* end of message, double-loop break */
2147 goto msg_complete;
2148 }
2149 chunk_len_str[i++] = c;
2150 if (i==11) {
2151 ERROR("Message is too long, buffer for length is not big enought!!!!");
2152 break;
2153 }
2154 }
2155 if (c != '\n') {
2156 if (buffer != NULL) {
2157 free (buffer);
2158 buffer = NULL;
2159 }
2160 break;
2161 }
2162 chunk_len_str[i] = 0;
2163 if ((chunk_len = atoi (chunk_len_str)) == 0) {
2164 if (buffer != NULL) {
2165 free (buffer);
2166 buffer = NULL;
2167 }
2168 break;
2169 }
2170 buffer_size += chunk_len+1;
2171 buffer = realloc (buffer, sizeof(char)*buffer_size);
2172 memset(buffer + (buffer_size-chunk_len-1), 0, chunk_len+1);
2173 if ((ret = recv (client, buffer+buffer_len, chunk_len, 0)) == -1 || ret != chunk_len) {
2174 if (buffer != NULL) {
2175 free (buffer);
2176 buffer = NULL;
2177 }
2178 break;
2179 }
2180 buffer_len += ret;
2181 }
Tomas Cejka64b87482013-06-03 16:30:53 +02002182msg_complete:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002183 return buffer;
Tomas Cejka64b87482013-06-03 16:30:53 +02002184}
2185
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002186NC_DATASTORE
2187parse_datastore(const char *ds)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002188{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002189 if (strcmp(ds, "running") == 0) {
2190 return NC_DATASTORE_RUNNING;
2191 } else if (strcmp(ds, "startup") == 0) {
2192 return NC_DATASTORE_STARTUP;
2193 } else if (strcmp(ds, "candidate") == 0) {
2194 return NC_DATASTORE_CANDIDATE;
2195 } else if (strcmp(ds, "url") == 0) {
2196 return NC_DATASTORE_URL;
2197 } else if (strcmp(ds, "config") == 0) {
2198 return NC_DATASTORE_CONFIG;
2199 }
2200 return -1;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002201}
2202
Michal Vaskof35ea502016-02-24 10:44:54 +01002203NC_RPC_EDIT_TESTOPT
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002204parse_testopt(const char *t)
Tomas Cejka5ae8dfb2014-02-14 23:42:17 +01002205{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002206 if (strcmp(t, "notset") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002207 return NC_RPC_EDIT_TESTOPT_UNKNOWN;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002208 } else if (strcmp(t, "testset") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002209 return NC_RPC_EDIT_TESTOPT_TESTSET;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002210 } else if (strcmp(t, "set") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002211 return NC_RPC_EDIT_TESTOPT_SET;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002212 } else if (strcmp(t, "test") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002213 return NC_RPC_EDIT_TESTOPT_TEST;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002214 }
Michal Vaskof35ea502016-02-24 10:44:54 +01002215 return NC_RPC_EDIT_TESTOPT_UNKNOWN;
Tomas Cejka5ae8dfb2014-02-14 23:42:17 +01002216}
2217
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002218json_object *
2219create_error_reply(const char *errmess)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002220{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002221 json_object *reply, *array;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002222
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002223 pthread_mutex_lock(&json_lock);
2224 reply = json_object_new_object();
2225 array = json_object_new_array();
2226 json_object_object_add(reply, "type", json_object_new_int(REPLY_ERROR));
2227 json_object_array_add(array, json_object_new_string(errmess));
2228 json_object_object_add(reply, "errors", array);
2229 pthread_mutex_unlock(&json_lock);
2230
2231 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002232}
2233
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002234json_object *
2235create_data_reply(const char *data)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002236{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002237 pthread_mutex_lock(&json_lock);
2238 json_object *reply = json_object_new_object();
2239 json_object_object_add(reply, "type", json_object_new_int(REPLY_DATA));
2240 json_object_object_add(reply, "data", json_object_new_string(data));
2241 pthread_mutex_unlock(&json_lock);
2242 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002243}
2244
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002245json_object *
2246create_ok_reply(void)
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002247{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002248 pthread_mutex_lock(&json_lock);
2249 json_object *reply = json_object_new_object();
2250 reply = json_object_new_object();
2251 json_object_object_add(reply, "type", json_object_new_int(REPLY_OK));
2252 pthread_mutex_unlock(&json_lock);
2253 return reply;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002254}
2255
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002256json_object *
2257create_replies(void)
Tomas Cejka09629492014-07-10 15:58:06 +02002258{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002259 json_object *replies;
2260
2261 pthread_mutex_lock(&json_lock);
2262 replies = json_object_new_object();
2263 pthread_mutex_unlock(&json_lock);
2264
2265 return replies;
Tomas Cejka09629492014-07-10 15:58:06 +02002266}
2267
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002268void
2269add_reply(json_object *replies, json_object *reply, unsigned int session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002270{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002271 char *str;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002272
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002273 asprintf(&str, "%u", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002274
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002275 pthread_mutex_lock(&json_lock);
2276 json_object_object_add(replies, str, reply);
2277 pthread_mutex_unlock(&json_lock);
Tomas Cejka09629492014-07-10 15:58:06 +02002278
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002279 free(str);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002280}
2281
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002282char *
2283get_param_string(json_object *data, const char *name)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002284{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002285 json_object *js_tmp = NULL;
2286 char *res = NULL;
2287 if (json_object_object_get_ex(data, name, &js_tmp) == TRUE) {
2288 res = strdup(json_object_get_string(js_tmp));
2289 }
2290 return res;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002291}
2292
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002293json_object *
2294handle_op_connect(json_object *request)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002295{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002296 char *host = NULL;
2297 char *port = NULL;
2298 char *user = NULL;
2299 char *pass = NULL;
Michal Vaskoda5ccc82015-11-25 10:42:49 +01002300 char *privkey = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002301 json_object *reply = NULL;
2302 unsigned int session_key = 0;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002303
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002304 DEBUG("Request: connect");
2305 pthread_mutex_lock(&json_lock);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002306
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002307 host = get_param_string(request, "host");
2308 port = get_param_string(request, "port");
2309 user = get_param_string(request, "user");
2310 pass = get_param_string(request, "pass");
Michal Vaskoda5ccc82015-11-25 10:42:49 +01002311 privkey = get_param_string(request, "privatekey");
Tomas Cejkad5b53772013-06-08 23:01:07 +02002312
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002313 pthread_mutex_unlock(&json_lock);
Tomas Cejka09629492014-07-10 15:58:06 +02002314
Michal Vaskoda5ccc82015-11-25 10:42:49 +01002315 if (host == NULL) {
2316 host = "localhost";
2317 }
2318
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002319 DEBUG("host: %s, port: %s, user: %s", host, port, user);
Michal Vaskoda5ccc82015-11-25 10:42:49 +01002320 if (user == NULL) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002321 ERROR("Cannot connect - insufficient input.");
2322 session_key = 0;
2323 } else {
Michal Vaskof35ea502016-02-24 10:44:54 +01002324 session_key = netconf_connect(host, port, user, pass, privkey);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002325 DEBUG("Session key: %u", session_key);
2326 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002327
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002328 GETSPEC_ERR_REPLY
2329
2330 pthread_mutex_lock(&json_lock);
2331 if (session_key == 0) {
2332 /* negative reply */
2333 if (err_reply == NULL) {
2334 reply = json_object_new_object();
2335 json_object_object_add(reply, "type", json_object_new_int(REPLY_ERROR));
2336 json_object_object_add(reply, "error-message", json_object_new_string("Connecting NETCONF server failed."));
2337 ERROR("Connection failed.");
2338 } else {
2339 /* use filled err_reply from libnetconf's callback */
2340 reply = err_reply;
2341 ERROR("Connect - error from libnetconf's callback.");
2342 }
2343 } else {
2344 /* positive reply */
2345 reply = json_object_new_object();
2346 json_object_object_add(reply, "type", json_object_new_int(REPLY_OK));
2347 json_object_object_add(reply, "session", json_object_new_int(session_key));
2348 }
2349 memset(pass, 0, strlen(pass));
2350 pthread_mutex_unlock(&json_lock);
2351 CHECK_AND_FREE(host);
2352 CHECK_AND_FREE(user);
2353 CHECK_AND_FREE(port);
2354 CHECK_AND_FREE(pass);
Michal Vaskoda5ccc82015-11-25 10:42:49 +01002355 CHECK_AND_FREE(privkey);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002356 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002357}
2358
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002359json_object *
2360handle_op_disconnect(json_object *UNUSED(request), unsigned int session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002361{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002362 json_object *reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002363
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002364 DEBUG("Request: disconnect (session %u)", session_key);
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01002365
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002366 if (netconf_close(session_key, &reply) != EXIT_SUCCESS) {
2367 CHECK_ERR_SET_REPLY_ERR("Get configuration information from device failed.")
2368 } else {
2369 reply = create_ok_reply();
2370 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002371
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002372 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002373}
2374
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002375json_object *
2376handle_op_get(json_object *request, unsigned int session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002377{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002378 char *filter = NULL;
2379 char *data = NULL;
2380 json_object *reply = NULL, *obj;
2381 int strict;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002382
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002383 DEBUG("Request: get (session %u)", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002384
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002385 pthread_mutex_lock(&json_lock);
2386 filter = get_param_string(request, "filter");
2387 if (json_object_object_get_ex(request, "strict", &obj) == FALSE) {
2388 pthread_mutex_unlock(&json_lock);
2389 reply = create_error_reply("Missing strict parameter.");
2390 return reply;
2391 }
2392 strict = json_object_get_boolean(obj);
2393 pthread_mutex_unlock(&json_lock);
Tomas Cejka09629492014-07-10 15:58:06 +02002394
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002395 if ((data = netconf_get(session_key, filter, strict, &reply)) == NULL) {
2396 CHECK_ERR_SET_REPLY_ERR("Get information failed.")
2397 } else {
2398 reply = create_data_reply(data);
2399 free(data);
2400 }
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01002401
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002402 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002403}
2404
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002405json_object *
2406handle_op_getconfig(json_object *request, unsigned int session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002407{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002408 NC_DATASTORE ds_type_s = -1;
2409 char *filter = NULL;
2410 char *data = NULL;
2411 char *source = NULL;
2412 json_object *reply = NULL, *obj;
2413 int strict;
Tomas Cejkab4d05872014-02-14 22:44:38 +01002414
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002415 DEBUG("Request: get-config (session %u)", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002416
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002417 pthread_mutex_lock(&json_lock);
2418 filter = get_param_string(request, "filter");
2419 source = get_param_string(request, "source");
2420 if (source != NULL) {
2421 ds_type_s = parse_datastore(source);
2422 }
2423 if (json_object_object_get_ex(request, "strict", &obj) == FALSE) {
2424 pthread_mutex_unlock(&json_lock);
2425 reply = create_error_reply("Missing strict parameter.");
2426 return reply;
2427 }
2428 strict = json_object_get_boolean(obj);
2429 pthread_mutex_unlock(&json_lock);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002430
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002431 if ((int)ds_type_s == -1) {
2432 reply = create_error_reply("Invalid source repository type requested.");
2433 goto finalize;
2434 }
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01002435
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002436 if ((data = netconf_getconfig(session_key, ds_type_s, filter, strict, &reply)) == NULL) {
2437 CHECK_ERR_SET_REPLY_ERR("Get configuration operation failed.")
2438 } else {
2439 reply = create_data_reply(data);
2440 free(data);
2441 }
Tomas Cejkaedb3ab42014-03-27 15:04:00 +01002442
Tomas Cejka09629492014-07-10 15:58:06 +02002443finalize:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002444 CHECK_AND_FREE(filter);
2445 CHECK_AND_FREE(source);
2446 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002447}
2448
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002449json_object *
2450handle_op_editconfig(json_object *request, unsigned int session_key, int idx)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002451{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002452 NC_DATASTORE ds_type_t = -1;
Michal Vaskof35ea502016-02-24 10:44:54 +01002453 NC_RPC_EDIT_DFLTOP defop_type = 0;
2454 NC_RPC_EDIT_ERROPT erropt_type = 0;
2455 NC_RPC_EDIT_TESTOPT testopt_type = NC_RPC_EDIT_TESTOPT_TESTSET;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002456 char *defop = NULL;
2457 char *erropt = NULL;
2458 char *config = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002459 char *target = NULL;
2460 char *testopt = NULL;
2461 char *urisource = NULL;
2462 json_object *reply = NULL, *configs, *obj;
Michal Vaskof35ea502016-02-24 10:44:54 +01002463 struct lyd_node *content;
2464 struct session_with_mutex *locked_session;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002465
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002466 DEBUG("Request: edit-config (session %u)", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002467
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002468 pthread_mutex_lock(&json_lock);
2469 /* get parameters */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002470 if (json_object_object_get_ex(request, "configs", &configs) == FALSE) {
2471 pthread_mutex_unlock(&json_lock);
2472 reply = create_error_reply("Missing configs parameter.");
2473 goto finalize;
2474 }
2475 obj = json_object_array_get_idx(configs, idx);
2476 config = strdup(json_object_get_string(obj));
Tomas Cejkad5b53772013-06-08 23:01:07 +02002477
Michal Vaskof35ea502016-02-24 10:44:54 +01002478 target = get_param_string(request, "target");
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002479 defop = get_param_string(request, "default-operation");
2480 erropt = get_param_string(request, "error-option");
2481 urisource = get_param_string(request, "uri-source");
2482 testopt = get_param_string(request, "test-option");
2483 pthread_mutex_unlock(&json_lock);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002484
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002485 if (target != NULL) {
2486 ds_type_t = parse_datastore(target);
2487 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002488
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002489 if (defop != NULL) {
2490 if (strcmp(defop, "merge") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002491 defop_type = NC_RPC_EDIT_DFLTOP_MERGE;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002492 } else if (strcmp(defop, "replace") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002493 defop_type = NC_RPC_EDIT_DFLTOP_REPLACE;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002494 } else if (strcmp(defop, "none") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002495 defop_type = NC_RPC_EDIT_DFLTOP_NONE;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002496 } else {
2497 reply = create_error_reply("Invalid default-operation parameter.");
2498 goto finalize;
2499 }
2500 } else {
Michal Vaskof35ea502016-02-24 10:44:54 +01002501 defop_type = NC_RPC_EDIT_DFLTOP_UNKNOWN;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002502 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002503
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002504 if (erropt != NULL) {
2505 if (strcmp(erropt, "continue-on-error") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002506 erropt_type = NC_RPC_EDIT_ERROPT_CONTINUE;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002507 } else if (strcmp(erropt, "stop-on-error") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002508 erropt_type = NC_RPC_EDIT_ERROPT_STOP;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002509 } else if (strcmp(erropt, "rollback-on-error") == 0) {
Michal Vaskof35ea502016-02-24 10:44:54 +01002510 erropt_type = NC_RPC_EDIT_ERROPT_ROLLBACK;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002511 } else {
2512 reply = create_error_reply("Invalid error-option parameter.");
2513 goto finalize;
2514 }
2515 } else {
2516 erropt_type = 0;
2517 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002518
Michal Vaskof35ea502016-02-24 10:44:54 +01002519 if ((config && urisource) || (!config && !urisource)) {
2520 reply = create_error_reply("Invalid config and uri-source data parameters.");
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002521 goto finalize;
2522 }
Michal Vaskof35ea502016-02-24 10:44:54 +01002523
2524 if (config) {
2525 locked_session = session_get_locked(session_key, NULL);
2526 if (!locked_session) {
2527 ERROR("Unknown session or locking failed.");
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002528 goto finalize;
2529 }
Michal Vaskof35ea502016-02-24 10:44:54 +01002530
2531 content = lyd_parse_mem(nc_session_get_ctx(locked_session->session), config, LYD_JSON, LYD_OPT_EDIT);
2532 session_unlock(locked_session);
2533
2534 free(config);
2535 lyd_print_mem(&config, content, LYD_XML, LYP_WITHSIBLINGS);
2536 lyd_free_withsiblings(content);
2537 } else {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002538 config = urisource;
2539 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002540
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002541 if (testopt != NULL) {
2542 testopt_type = parse_testopt(testopt);
2543 } else {
Michal Vaskof35ea502016-02-24 10:44:54 +01002544 testopt_type = NC_RPC_EDIT_TESTOPT_TESTSET;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002545 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002546
Michal Vaskof35ea502016-02-24 10:44:54 +01002547 reply = netconf_editconfig(session_key, ds_type_t, defop_type, erropt_type, testopt_type, config);
Tomas Cejkad5b53772013-06-08 23:01:07 +02002548
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002549 CHECK_ERR_SET_REPLY
Tomas Cejkaedb3ab42014-03-27 15:04:00 +01002550
Tomas Cejka09629492014-07-10 15:58:06 +02002551finalize:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002552 CHECK_AND_FREE(defop);
2553 CHECK_AND_FREE(erropt);
2554 CHECK_AND_FREE(config);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002555 CHECK_AND_FREE(urisource);
2556 CHECK_AND_FREE(target);
2557 CHECK_AND_FREE(testopt);
2558
2559 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002560}
2561
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002562json_object *
2563handle_op_copyconfig(json_object *request, unsigned int session_key, int idx)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002564{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002565 NC_DATASTORE ds_type_s = -1;
2566 NC_DATASTORE ds_type_t = -1;
2567 char *config = NULL;
2568 char *target = NULL;
2569 char *source = NULL;
2570 char *uri_src = NULL;
2571 char *uri_trg = NULL;
2572 json_object *reply = NULL, *configs, *obj;
Michal Vaskof35ea502016-02-24 10:44:54 +01002573 struct lyd_node *content;
2574 struct session_with_mutex *locked_session;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002575
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002576 DEBUG("Request: copy-config (session %u)", session_key);
Tomas Cejka47387fd2013-06-10 20:37:46 +02002577
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002578 /* get parameters */
2579 pthread_mutex_lock(&json_lock);
2580 target = get_param_string(request, "target");
2581 source = get_param_string(request, "source");
2582 uri_src = get_param_string(request, "uri-source");
2583 uri_trg = get_param_string(request, "uri-target");
2584 if (!strcmp(source, "config")) {
2585 if (json_object_object_get_ex(request, "configs", &configs) == FALSE) {
2586 pthread_mutex_unlock(&json_lock);
2587 reply = create_error_reply("Missing configs parameter.");
2588 goto finalize;
2589 }
2590 obj = json_object_array_get_idx(configs, idx);
2591 if (!obj) {
2592 pthread_mutex_unlock(&json_lock);
2593 reply = create_error_reply("Configs array parameter shorter than sessions.");
2594 goto finalize;
2595 }
2596 config = strdup(json_object_get_string(obj));
2597 }
2598 pthread_mutex_unlock(&json_lock);
2599
2600 if (target != NULL) {
2601 ds_type_t = parse_datastore(target);
2602 }
2603 if (source != NULL) {
2604 ds_type_s = parse_datastore(source);
2605 }
2606
2607 if ((int)ds_type_s == -1) {
2608 /* invalid source datastore specified */
2609 reply = create_error_reply("Invalid source repository type requested.");
2610 goto finalize;
2611 }
2612
2613 if ((int)ds_type_t == -1) {
2614 /* invalid target datastore specified */
2615 reply = create_error_reply("Invalid target repository type requested.");
2616 goto finalize;
2617 }
2618
2619 if (ds_type_s == NC_DATASTORE_URL) {
2620 if (uri_src == NULL) {
2621 uri_src = "";
2622 }
2623 }
2624 if (ds_type_t == NC_DATASTORE_URL) {
2625 if (uri_trg == NULL) {
2626 uri_trg = "";
2627 }
2628 }
Michal Vaskof35ea502016-02-24 10:44:54 +01002629
2630 if (config) {
2631 locked_session = session_get_locked(session_key, NULL);
2632 if (!locked_session) {
2633 ERROR("Unknown session or locking failed.");
2634 goto finalize;
2635 }
2636
2637 content = lyd_parse_mem(nc_session_get_ctx(locked_session->session), config, LYD_JSON, LYD_OPT_CONFIG);
2638 session_unlock(locked_session);
2639
2640 free(config);
2641 lyd_print_mem(&config, content, LYD_XML, LYP_WITHSIBLINGS);
2642 lyd_free_withsiblings(content);
2643 }
2644
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002645 reply = netconf_copyconfig(session_key, ds_type_s, ds_type_t, config, uri_src, uri_trg);
2646
2647 CHECK_ERR_SET_REPLY
2648
2649finalize:
2650 CHECK_AND_FREE(config);
2651 CHECK_AND_FREE(target);
2652 CHECK_AND_FREE(source);
2653 CHECK_AND_FREE(uri_src);
2654 CHECK_AND_FREE(uri_trg);
2655
2656 return reply;
2657}
2658
2659json_object *
2660handle_op_deleteconfig(json_object *request, unsigned int session_key)
2661{
2662 json_object *reply;
2663 NC_DATASTORE ds_type = -1;
2664 char *target, *url;
2665
2666 DEBUG("Request: delete-config (session %u)", session_key);
2667
2668 pthread_mutex_lock(&json_lock);
2669 target = get_param_string(request, "target");
2670 url = get_param_string(request, "url");
2671 pthread_mutex_unlock(&json_lock);
2672
2673 if (target != NULL) {
2674 ds_type = parse_datastore(target);
2675 }
2676 if ((int)ds_type == -1) {
2677 reply = create_error_reply("Invalid target repository type requested.");
2678 goto finalize;
2679 }
2680 if (ds_type == NC_DATASTORE_URL) {
2681 if (!url) {
2682 url = "";
2683 }
2684 }
2685
2686 reply = netconf_deleteconfig(session_key, ds_type, url);
2687
2688 CHECK_ERR_SET_REPLY
2689 if (reply == NULL) {
2690 reply = create_ok_reply();
2691 }
2692
2693finalize:
2694 CHECK_AND_FREE(target);
2695 CHECK_AND_FREE(url);
2696 return reply;
2697}
2698
2699json_object *
2700handle_op_lock(json_object *request, unsigned int session_key)
2701{
2702 json_object *reply;
2703 NC_DATASTORE ds_type = -1;
2704 char *target;
2705
2706 DEBUG("Request: lock (session %u)", session_key);
2707
2708 pthread_mutex_lock(&json_lock);
2709 target = get_param_string(request, "target");
2710 pthread_mutex_unlock(&json_lock);
2711
2712 if (target != NULL) {
2713 ds_type = parse_datastore(target);
2714 }
2715 if ((int)ds_type == -1) {
2716 reply = create_error_reply("Invalid target repository type requested.");
2717 goto finalize;
2718 }
2719
2720 reply = netconf_lock(session_key, ds_type);
2721
2722 CHECK_ERR_SET_REPLY
2723 if (reply == NULL) {
2724 reply = create_ok_reply();
2725 }
2726
2727finalize:
2728 CHECK_AND_FREE(target);
2729 return reply;
2730}
2731
2732json_object *
2733handle_op_unlock(json_object *request, unsigned int session_key)
2734{
2735 json_object *reply;
2736 NC_DATASTORE ds_type = -1;
2737 char *target;
2738
2739 DEBUG("Request: unlock (session %u)", session_key);
2740
2741 pthread_mutex_lock(&json_lock);
2742 target = get_param_string(request, "target");
2743 pthread_mutex_unlock(&json_lock);
2744
2745 if (target != NULL) {
2746 ds_type = parse_datastore(target);
2747 }
2748 if ((int)ds_type == -1) {
2749 reply = create_error_reply("Invalid target repository type requested.");
2750 goto finalize;
2751 }
2752
2753 reply = netconf_unlock(session_key, ds_type);
2754
2755 CHECK_ERR_SET_REPLY
2756 if (reply == NULL) {
2757 reply = create_ok_reply();
2758 }
2759
2760finalize:
2761 CHECK_AND_FREE(target);
2762 return reply;
2763}
2764
2765json_object *
2766handle_op_kill(json_object *request, unsigned int session_key)
2767{
2768 json_object *reply = NULL;
2769 char *sid = NULL;
2770
2771 DEBUG("Request: kill-session (session %u)", session_key);
2772
2773 pthread_mutex_lock(&json_lock);
2774 sid = get_param_string(request, "session-id");
2775 pthread_mutex_unlock(&json_lock);
2776
2777 if (sid == NULL) {
2778 reply = create_error_reply("Missing session-id parameter.");
2779 goto finalize;
2780 }
2781
2782 reply = netconf_killsession(session_key, sid);
2783
2784 CHECK_ERR_SET_REPLY
2785
2786finalize:
2787 CHECK_AND_FREE(sid);
2788 return reply;
2789}
2790
2791json_object *
2792handle_op_info(json_object *UNUSED(request), unsigned int session_key)
2793{
2794 json_object *reply = NULL;
2795 struct session_with_mutex *locked_session = NULL;
2796 DEBUG("Request: get info about session %u", session_key);
2797
2798 DEBUG("LOCK wrlock %s", __func__);
2799 if (pthread_rwlock_rdlock(&session_lock) != 0) {
2800 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
2801 }
2802
2803 for (locked_session = netconf_sessions_list;
2804 locked_session && (locked_session->session_key != session_key);
Michal Vaskoc3146782015-11-04 14:46:41 +01002805 locked_session = locked_session->next);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002806 if (locked_session != NULL) {
2807 DEBUG("LOCK mutex %s", __func__);
2808 pthread_mutex_lock(&locked_session->lock);
2809 DEBUG("UNLOCK wrlock %s", __func__);
2810 if (pthread_rwlock_unlock(&session_lock) != 0) {
2811 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
2812 }
2813 if (locked_session->hello_message != NULL) {
2814 reply = locked_session->hello_message;
2815 } else {
2816 reply = create_error_reply("Invalid session identifier.");
2817 }
2818 DEBUG("UNLOCK mutex %s", __func__);
2819 pthread_mutex_unlock(&locked_session->lock);
2820 } else {
2821 DEBUG("UNLOCK wrlock %s", __func__);
2822 if (pthread_rwlock_unlock(&session_lock) != 0) {
2823 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
2824 }
2825 reply = create_error_reply("Invalid session identifier.");
2826 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002827
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002828 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002829}
2830
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002831json_object *
2832handle_op_generic(json_object *request, unsigned int session_key, int idx)
Tomas Cejkad5b53772013-06-08 23:01:07 +02002833{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002834 json_object *reply = NULL, *contents, *obj;
Michal Vaskof35ea502016-02-24 10:44:54 +01002835 char *content = NULL, *str;
2836 struct lyd_node *data = NULL, *node_content;
2837 struct session_with_mutex *locked_session;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002838
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002839 DEBUG("Request: generic request (session %u)", session_key);
Tomas Cejka47387fd2013-06-10 20:37:46 +02002840
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002841 pthread_mutex_lock(&json_lock);
2842 if (json_object_object_get_ex(request, "contents", &contents) == FALSE) {
2843 pthread_mutex_unlock(&json_lock);
2844 reply = create_error_reply("Missing contents parameter.");
2845 goto finalize;
2846 }
2847 obj = json_object_array_get_idx(contents, idx);
2848 if (!obj) {
2849 pthread_mutex_unlock(&json_lock);
2850 reply = create_error_reply("Contents array parameter shorter than sessions.");
2851 goto finalize;
2852 }
Michal Vaskof35ea502016-02-24 10:44:54 +01002853 content = strdup(json_object_get_string(obj));
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002854 pthread_mutex_unlock(&json_lock);
2855
Michal Vaskof35ea502016-02-24 10:44:54 +01002856 locked_session = session_get_locked(session_key, NULL);
2857 if (!locked_session) {
2858 ERROR("Unknown session or locking failed.");
2859 goto finalize;
2860 }
2861
2862 node_content = lyd_parse_mem(nc_session_get_ctx(locked_session->session), content, LYD_JSON, LYD_OPT_RPC);
2863 session_unlock(locked_session);
2864
2865 free(content);
2866 lyd_print_mem(&content, node_content, LYD_XML, LYP_WITHSIBLINGS);
2867 lyd_free_withsiblings(node_content);
2868
2869 reply = netconf_generic(session_key, content, &data);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002870 if (reply == NULL) {
2871 GETSPEC_ERR_REPLY
2872 if (err_reply != NULL) {
2873 /* use filled err_reply from libnetconf's callback */
2874 reply = err_reply;
2875 }
2876 } else {
2877 if (data == NULL) {
2878 pthread_mutex_lock(&json_lock);
2879 reply = json_object_new_object();
2880 json_object_object_add(reply, "type", json_object_new_int(REPLY_OK));
2881 pthread_mutex_unlock(&json_lock);
2882 } else {
Michal Vaskof35ea502016-02-24 10:44:54 +01002883 lyd_print_mem(&str, data, LYD_JSON, LYP_WITHSIBLINGS);
2884 lyd_free_withsiblings(data);
2885 reply = create_data_reply(str);
2886 free(str);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002887 }
2888 }
2889
2890finalize:
Michal Vaskof35ea502016-02-24 10:44:54 +01002891 CHECK_AND_FREE(content);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002892 return reply;
2893}
2894
2895json_object *
2896handle_op_getschema(json_object *request, unsigned int session_key)
2897{
2898 char *data = NULL;
2899 char *identifier = NULL;
2900 char *version = NULL;
2901 char *format = NULL;
2902 json_object *reply = NULL;
2903
2904 DEBUG("Request: get-schema (session %u)", session_key);
2905
2906 pthread_mutex_lock(&json_lock);
2907 identifier = get_param_string(request, "identifier");
2908 version = get_param_string(request, "version");
2909 format = get_param_string(request, "format");
2910 pthread_mutex_unlock(&json_lock);
2911
2912 if (identifier == NULL) {
2913 reply = create_error_reply("No identifier for get-schema supplied.");
2914 goto finalize;
2915 }
2916
2917 DEBUG("get-schema(version: %s, format: %s)", version, format);
2918 if ((data = netconf_getschema(session_key, identifier, version, format, &reply)) == NULL) {
2919 CHECK_ERR_SET_REPLY_ERR("Get models operation failed.")
2920 } else {
2921 reply = create_data_reply(data);
2922 free(data);
2923 }
2924
2925finalize:
2926 CHECK_AND_FREE(identifier);
2927 CHECK_AND_FREE(version);
2928 CHECK_AND_FREE(format);
2929 return reply;
2930}
2931
2932json_object *
2933handle_op_reloadhello(json_object *UNUSED(request), unsigned int session_key)
2934{
2935 struct nc_session *temp_session = NULL;
2936 struct session_with_mutex * locked_session = NULL;
2937 json_object *reply = NULL;
2938
2939 DEBUG("Request: reload hello (session %u)", session_key);
2940
2941 DEBUG("LOCK wrlock %s", __func__);
2942 if (pthread_rwlock_wrlock(&session_lock) != 0) {
2943 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
2944 return NULL;
2945 }
2946
2947 for (locked_session = netconf_sessions_list;
2948 locked_session && (locked_session->session_key != session_key);
Michal Vaskoc3146782015-11-04 14:46:41 +01002949 locked_session = locked_session->next);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002950 if ((locked_session != NULL) && (locked_session->hello_message != NULL)) {
2951 DEBUG("LOCK mutex %s", __func__);
2952 pthread_mutex_lock(&locked_session->lock);
2953 DEBUG("creating temporary NC session.");
Michal Vaskof35ea502016-02-24 10:44:54 +01002954 temp_session = nc_connect_ssh_channel(locked_session->session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002955 if (temp_session != NULL) {
2956 prepare_status_message(locked_session, temp_session);
2957 DEBUG("closing temporal NC session.");
Michal Vaskoa9590052016-03-08 10:12:24 +01002958 nc_session_free(temp_session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002959 temp_session = NULL;
2960 } else {
2961 DEBUG("Reload hello failed due to channel establishment");
2962 reply = create_error_reply("Reload was unsuccessful, connection failed.");
2963 }
2964 DEBUG("UNLOCK mutex %s", __func__);
2965 pthread_mutex_unlock(&locked_session->lock);
2966 DEBUG("UNLOCK wrlock %s", __func__);
2967 if (pthread_rwlock_unlock(&session_lock) != 0) {
2968 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
2969 }
2970 } else {
2971 DEBUG("UNLOCK wrlock %s", __func__);
2972 if (pthread_rwlock_unlock(&session_lock) != 0) {
2973 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
2974 }
2975 reply = create_error_reply("Invalid session identifier.");
2976 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02002977
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002978 if ((reply == NULL) && (locked_session->hello_message != NULL)) {
2979 reply = locked_session->hello_message;
2980 }
Tomas Cejka47387fd2013-06-10 20:37:46 +02002981
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002982 return reply;
Tomas Cejkad5b53772013-06-08 23:01:07 +02002983}
2984
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002985void
Michal Vaskof35ea502016-02-24 10:44:54 +01002986notification_history(struct nc_session *session, const struct nc_notif *notif)
Tomas Cejka6b886e02013-07-05 09:53:17 +02002987{
Michal Vaskof35ea502016-02-24 10:44:54 +01002988 time_t eventtime;
2989 char *content;
2990 (void)session;
2991
2992 eventtime = nc_datetime2time(notif->datetime);
2993
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01002994 json_object *notif_history_array = (json_object *)pthread_getspecific(notif_history_key);
2995 if (notif_history_array == NULL) {
2996 ERROR("No list of notification history found.");
2997 return;
2998 }
2999 DEBUG("Got notification from history %lu.", (long unsigned)eventtime);
3000 pthread_mutex_lock(&json_lock);
Michal Vaskof35ea502016-02-24 10:44:54 +01003001 json_object *notif_obj = json_object_new_object();
3002 if (notif_obj == NULL) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003003 ERROR("Could not allocate memory for notification (json).");
3004 goto failed;
3005 }
Michal Vaskof35ea502016-02-24 10:44:54 +01003006 lyd_print_mem(&content, notif->tree, LYD_JSON, 0);
3007
3008 json_object_object_add(notif_obj, "eventtime", json_object_new_int64(eventtime));
3009 json_object_object_add(notif_obj, "content", json_object_new_string(content));
3010
3011 free(content);
3012
3013 json_object_array_add(notif_history_array, notif_obj);
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01003014failed:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003015 pthread_mutex_unlock(&json_lock);
Tomas Cejka6b886e02013-07-05 09:53:17 +02003016}
3017
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003018json_object *
3019handle_op_ntfgethistory(json_object *request, unsigned int session_key)
Tomas Cejka6b886e02013-07-05 09:53:17 +02003020{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003021 json_object *reply = NULL;
3022 json_object *js_tmp = NULL;
3023 struct session_with_mutex *locked_session = NULL;
3024 struct nc_session *temp_session = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01003025 struct nc_rpc *rpc = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003026 time_t start = 0;
3027 time_t stop = 0;
3028 int64_t from = 0, to = 0;
Tomas Cejka6b886e02013-07-05 09:53:17 +02003029
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003030 DEBUG("Request: get notification history (session %u)", session_key);
Tomas Cejka6b886e02013-07-05 09:53:17 +02003031
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003032 pthread_mutex_lock(&json_lock);
3033 if (json_object_object_get_ex(request, "from", &js_tmp) == TRUE) {
3034 from = json_object_get_int64(js_tmp);
3035 }
3036 if (json_object_object_get_ex(request, "to", &js_tmp) == TRUE) {
3037 to = json_object_get_int64(js_tmp);
3038 }
3039 pthread_mutex_unlock(&json_lock);
Tomas Cejka09629492014-07-10 15:58:06 +02003040
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003041 start = time(NULL) + from;
3042 stop = time(NULL) + to;
Tomas Cejka6b886e02013-07-05 09:53:17 +02003043
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003044 DEBUG("notification history interval %li %li", (long int)from, (long int)to);
Tomas Cejka6b886e02013-07-05 09:53:17 +02003045
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003046 DEBUG("LOCK wrlock %s", __func__);
3047 if (pthread_rwlock_rdlock(&session_lock) != 0) {
3048 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
3049 reply = create_error_reply("Internal lock failed.");
3050 goto finalize;
3051 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02003052
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003053 for (locked_session = netconf_sessions_list;
3054 locked_session && (locked_session->session_key != session_key);
Michal Vaskoc3146782015-11-04 14:46:41 +01003055 locked_session = locked_session->next);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003056 if (locked_session != NULL) {
3057 DEBUG("LOCK mutex %s", __func__);
3058 pthread_mutex_lock(&locked_session->lock);
3059 DEBUG("UNLOCK wrlock %s", __func__);
3060 if (pthread_rwlock_unlock(&session_lock) != 0) {
3061 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
3062 }
3063 DEBUG("creating temporal NC session.");
Michal Vaskof35ea502016-02-24 10:44:54 +01003064 temp_session = nc_connect_ssh_channel(locked_session->session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003065 if (temp_session != NULL) {
Michal Vaskof35ea502016-02-24 10:44:54 +01003066 rpc = nc_rpc_subscribe(NULL, NULL, nc_time2datetime(start, NULL), nc_time2datetime(stop, NULL), NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003067 if (rpc == NULL) {
3068 DEBUG("UNLOCK mutex %s", __func__);
3069 pthread_mutex_unlock(&locked_session->lock);
3070 DEBUG("notifications: creating an rpc request failed.");
3071 reply = create_error_reply("notifications: creating an rpc request failed.");
3072 goto finalize;
3073 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02003074
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003075 DEBUG("Send NC subscribe.");
3076 /** \todo replace with sth like netconf_op(http_server, session_hash, rpc) */
3077 json_object *res = netconf_unlocked_op(temp_session, rpc);
3078 if (res != NULL) {
3079 DEBUG("UNLOCK mutex %s", __func__);
3080 pthread_mutex_unlock(&locked_session->lock);
3081 DEBUG("Subscription RPC failed.");
3082 reply = res;
3083 goto finalize;
3084 }
3085 rpc = NULL; /* just note that rpc is already freed by send_recv_process() */
Tomas Cejka6b886e02013-07-05 09:53:17 +02003086
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003087 DEBUG("UNLOCK mutex %s", __func__);
3088 pthread_mutex_unlock(&locked_session->lock);
3089 DEBUG("LOCK mutex %s", __func__);
3090 pthread_mutex_lock(&ntf_history_lock);
3091 pthread_mutex_lock(&json_lock);
3092 json_object *notif_history_array = json_object_new_array();
3093 pthread_mutex_unlock(&json_lock);
3094 if (pthread_setspecific(notif_history_key, notif_history_array) != 0) {
3095 ERROR("notif_history: cannot set thread-specific hash value.");
3096 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02003097
Michal Vaskof35ea502016-02-24 10:44:54 +01003098 nc_recv_notif_dispatch(temp_session, notification_history);
Tomas Cejka6b886e02013-07-05 09:53:17 +02003099
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003100 pthread_mutex_lock(&json_lock);
3101 reply = json_object_new_object();
3102 json_object_object_add(reply, "notifications", notif_history_array);
3103 //json_object_put(notif_history_array);
3104 pthread_mutex_unlock(&json_lock);
Tomas Cejka6b886e02013-07-05 09:53:17 +02003105
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003106 DEBUG("UNLOCK mutex %s", __func__);
3107 pthread_mutex_unlock(&ntf_history_lock);
3108 DEBUG("closing temporal NC session.");
Michal Vaskoa9590052016-03-08 10:12:24 +01003109 nc_session_free(temp_session, NULL);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003110 temp_session = NULL;
3111 } else {
3112 DEBUG("UNLOCK mutex %s", __func__);
3113 pthread_mutex_unlock(&locked_session->lock);
3114 DEBUG("Get history of notification failed due to channel establishment");
3115 reply = create_error_reply("Get history of notification was unsuccessful, connection failed.");
3116 }
3117 } else {
3118 DEBUG("UNLOCK wrlock %s", __func__);
3119 if (pthread_rwlock_unlock(&session_lock) != 0) {
3120 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
3121 }
3122 reply = create_error_reply("Invalid session identifier.");
3123 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02003124
Tomas Cejka09629492014-07-10 15:58:06 +02003125finalize:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003126 return reply;
Tomas Cejka4003a702013-10-01 00:02:45 +02003127}
3128
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003129json_object *
3130handle_op_validate(json_object *request, unsigned int session_key)
Tomas Cejka4003a702013-10-01 00:02:45 +02003131{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003132 json_object *reply = NULL;
3133 char *target = NULL;
3134 char *url = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01003135 struct nc_rpc *rpc = NULL;
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003136 NC_DATASTORE target_ds;
Tomas Cejka4003a702013-10-01 00:02:45 +02003137
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003138 DEBUG("Request: validate datastore (session %u)", session_key);
Tomas Cejka4003a702013-10-01 00:02:45 +02003139
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003140 pthread_mutex_lock(&json_lock);
3141 target = get_param_string(request, "target");
3142 url = get_param_string(request, "url");
3143 pthread_mutex_unlock(&json_lock);
Tomas Cejka4003a702013-10-01 00:02:45 +02003144
3145
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003146 if (target == NULL) {
3147 reply = create_error_reply("Missing target parameter.");
3148 goto finalize;
3149 }
Tomas Cejka4003a702013-10-01 00:02:45 +02003150
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003151 /* validation */
3152 target_ds = parse_datastore(target);
Michal Vaskof35ea502016-02-24 10:44:54 +01003153 rpc = nc_rpc_validate(target_ds, url, NC_PARAMTYPE_CONST);
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003154 if (rpc == NULL) {
3155 DEBUG("mod_netconf: creating rpc request failed");
3156 reply = create_error_reply("Creation of RPC request failed.");
3157 goto finalize;
3158 }
Tomas Cejka4003a702013-10-01 00:02:45 +02003159
Michal Vaskof35ea502016-02-24 10:44:54 +01003160 if ((reply = netconf_op(session_key, rpc, 0, NULL)) == NULL) {
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003161 CHECK_ERR_SET_REPLY
Tomas Cejkaedb3ab42014-03-27 15:04:00 +01003162
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003163 if (reply == NULL) {
3164 DEBUG("Request: validation ok.");
3165 reply = create_ok_reply();
3166 }
3167 }
3168 nc_rpc_free (rpc);
Tomas Cejkaedb3ab42014-03-27 15:04:00 +01003169
Tomas Cejka09629492014-07-10 15:58:06 +02003170finalize:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003171 CHECK_AND_FREE(target);
3172 CHECK_AND_FREE(url);
3173 return reply;
Tomas Cejka6b886e02013-07-05 09:53:17 +02003174}
3175
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003176json_object *
3177handle_op_query(json_object *request, unsigned int session_key, int idx)
David Kupka8e60a372012-09-04 09:15:20 +02003178{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003179 json_object *reply = NULL, *filters, *obj;
3180 char *filter = NULL;
3181 int load_children = 0;
David Kupka8e60a372012-09-04 09:15:20 +02003182
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003183 DEBUG("Request: query (session %u)", session_key);
David Kupka8e60a372012-09-04 09:15:20 +02003184
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003185 pthread_mutex_lock(&json_lock);
3186 if (json_object_object_get_ex(request, "filters", &filters) == FALSE) {
3187 pthread_mutex_unlock(&json_lock);
3188 reply = create_error_reply("Missing filters parameter.");
3189 goto finalize;
3190 }
3191 obj = json_object_array_get_idx(filters, idx);
3192 if (!obj) {
3193 pthread_mutex_unlock(&json_lock);
3194 reply = create_error_reply("Filters array parameter shorter than sessions.");
3195 goto finalize;
3196 }
3197 filter = strdup(json_object_get_string(obj));
3198 if (json_object_object_get_ex(request, "load_children", &obj) == TRUE) {
3199 load_children = json_object_get_boolean(obj);
3200 }
3201 pthread_mutex_unlock(&json_lock);
Tomas Cejka442258e2014-04-01 18:17:18 +02003202
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003203 reply = libyang_query(session_key, filter, load_children);
David Kupka8e60a372012-09-04 09:15:20 +02003204
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003205 CHECK_ERR_SET_REPLY
3206 if (!reply) {
3207 reply = create_error_reply("Query failed.");
3208 }
David Kupka8e60a372012-09-04 09:15:20 +02003209
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003210finalize:
3211 CHECK_AND_FREE(filter);
3212 return reply;
3213}
David Kupka8e60a372012-09-04 09:15:20 +02003214
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003215json_object *
3216handle_op_merge(json_object *request, unsigned int session_key, int idx)
3217{
3218 json_object *reply = NULL, *configs, *obj;
3219 char *config = NULL;
Michal Vaskof35ea502016-02-24 10:44:54 +01003220 struct lyd_node *content;
3221 struct session_with_mutex *locked_session;
David Kupka8e60a372012-09-04 09:15:20 +02003222
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003223 DEBUG("Request: merge (session %u)", session_key);
David Kupka8e60a372012-09-04 09:15:20 +02003224
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003225 pthread_mutex_lock(&json_lock);
3226 if (json_object_object_get_ex(request, "configurations", &configs) == FALSE) {
3227 pthread_mutex_unlock(&json_lock);
3228 reply = create_error_reply("Missing configurations parameter.");
3229 goto finalize;
3230 }
3231 obj = json_object_array_get_idx(configs, idx);
3232 if (!obj) {
3233 pthread_mutex_unlock(&json_lock);
3234 reply = create_error_reply("Filters array parameter shorter than sessions.");
3235 goto finalize;
3236 }
3237 config = strdup(json_object_get_string(obj));
3238 pthread_mutex_unlock(&json_lock);
David Kupka8e60a372012-09-04 09:15:20 +02003239
Michal Vaskof35ea502016-02-24 10:44:54 +01003240 locked_session = session_get_locked(session_key, NULL);
3241 if (!locked_session) {
3242 ERROR("Unknown session or locking failed.");
3243 goto finalize;
3244 }
3245
3246 content = lyd_parse_mem(nc_session_get_ctx(locked_session->session), config, LYD_JSON, LYD_OPT_DATA);
3247 session_unlock(locked_session);
3248
3249 free(config);
3250 lyd_print_mem(&config, content, LYD_XML, LYP_WITHSIBLINGS);
3251 lyd_free_withsiblings(content);
3252
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003253 reply = libyang_merge(session_key, config);
David Kupka8e60a372012-09-04 09:15:20 +02003254
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003255 CHECK_ERR_SET_REPLY
3256 if (!reply) {
3257 reply = create_error_reply("Merge failed.");
3258 }
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01003259
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003260finalize:
3261 CHECK_AND_FREE(config);
3262 return reply;
3263}
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01003264
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003265void *
3266thread_routine(void *arg)
3267{
3268 void *retval = NULL;
3269 struct pollfd fds;
3270 json_object *request = NULL, *replies = NULL, *reply, *sessions = NULL;
3271 json_object *js_tmp = NULL;
3272 int operation = (-1), count, i;
3273 int status = 0;
3274 const char *msgtext;
3275 unsigned int session_key = 0;
3276 char *chunked_out_msg = NULL;
3277 int client = ((struct pass_to_thread *)arg)->client;
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01003278
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003279 char *buffer = NULL;
David Kupka8e60a372012-09-04 09:15:20 +02003280
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003281 /* init thread specific err_reply memory */
3282 create_err_reply_p();
David Kupka8e60a372012-09-04 09:15:20 +02003283
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003284 while (!isterminated) {
3285 fds.fd = client;
3286 fds.events = POLLIN;
3287 fds.revents = 0;
David Kupka8e60a372012-09-04 09:15:20 +02003288
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003289 status = poll(&fds, 1, 1000);
Tomas Cejkad5b53772013-06-08 23:01:07 +02003290
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003291 if (status == 0 || (status == -1 && (errno == EAGAIN || (errno == EINTR && isterminated == 0)))) {
3292 /* poll was interrupted - check if the isterminated is set and if not, try poll again */
3293 continue;
3294 } else if (status < 0) {
3295 /* 0: poll time outed
3296 * close socket and ignore this request from the client, it can try it again
3297 * -1: poll failed
3298 * something wrong happend, close this socket and wait for another request
3299 */
3300 close(client);
3301 break;
3302 }
3303 /* status > 0 */
David Kupka8e60a372012-09-04 09:15:20 +02003304
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003305 /* check the status of the socket */
David Kupka8e60a372012-09-04 09:15:20 +02003306
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003307 /* if nothing to read and POLLHUP (EOF) or POLLERR set */
3308 if ((fds.revents & POLLHUP) || (fds.revents & POLLERR)) {
3309 /* close client's socket (it's probably already closed by client */
3310 close(client);
3311 break;
3312 }
Tomas Cejka09629492014-07-10 15:58:06 +02003313
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003314 DEBUG("Get framed message...");
3315 buffer = get_framed_message(client);
Tomas Cejka09629492014-07-10 15:58:06 +02003316
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003317 DEBUG("Check read buffer.");
3318 if (buffer != NULL) {
3319 enum json_tokener_error jerr;
3320 pthread_mutex_lock(&json_lock);
3321 request = json_tokener_parse_verbose(buffer, &jerr);
3322 if (jerr != json_tokener_success) {
3323 ERROR("JSON parsing error");
3324 pthread_mutex_unlock(&json_lock);
3325 continue;
3326 }
3327
3328 if (json_object_object_get_ex(request, "type", &js_tmp) == TRUE) {
3329 operation = json_object_get_int(js_tmp);
3330 }
3331 pthread_mutex_unlock(&json_lock);
3332 if (operation == -1) {
3333 replies = create_replies();
3334 add_reply(replies, create_error_reply("Missing operation type from frontend."), 0);
3335 goto send_reply;
3336 }
3337
3338 if ((operation < 4) || ((operation > 19) && (operation < 100)) || (operation > 101)) {
3339 DEBUG("Unknown mod_netconf operation requested (%d)", operation);
3340 replies = create_replies();
3341 add_reply(replies, create_error_reply("Operation not supported."), 0);
3342 goto send_reply;
3343 }
3344
3345 DEBUG("operation %d", operation);
3346
3347 /* null global JSON error-reply */
3348 clean_err_reply();
3349
3350 /* clean replies envelope */
3351 if (replies != NULL) {
3352 pthread_mutex_lock(&json_lock);
3353 json_object_put(replies);
3354 pthread_mutex_unlock(&json_lock);
3355 }
3356 replies = create_replies();
3357
3358 if (operation == MSG_CONNECT) {
3359 count = 1;
3360 } else {
3361 pthread_mutex_lock(&json_lock);
3362 if (json_object_object_get_ex(request, "sessions", &sessions) == FALSE) {
3363 add_reply(replies, create_error_reply("Operation missing \"sessions\" arg"), 0);
3364 goto send_reply;
3365 }
3366 count = json_object_array_length(sessions);
3367 pthread_mutex_unlock(&json_lock);
3368 }
3369
3370 for (i = 0; i < count; ++i) {
3371 if (operation != MSG_CONNECT) {
3372 js_tmp = json_object_array_get_idx(sessions, i);
3373 session_key = json_object_get_int(js_tmp);
3374 }
3375
3376 /* process required operation */
3377 switch (operation) {
3378 case MSG_CONNECT:
3379 reply = handle_op_connect(request);
3380 break;
3381 case MSG_DISCONNECT:
3382 reply = handle_op_disconnect(request, session_key);
3383 break;
3384 case MSG_GET:
3385 reply = handle_op_get(request, session_key);
3386 break;
3387 case MSG_GETCONFIG:
3388 reply = handle_op_getconfig(request, session_key);
3389 break;
3390 case MSG_EDITCONFIG:
3391 reply = handle_op_editconfig(request, session_key, i);
3392 break;
3393 case MSG_COPYCONFIG:
3394 reply = handle_op_copyconfig(request, session_key, i);
3395 break;
3396 case MSG_DELETECONFIG:
3397 reply = handle_op_deleteconfig(request, session_key);
3398 break;
3399 case MSG_LOCK:
3400 reply = handle_op_lock(request, session_key);
3401 break;
3402 case MSG_UNLOCK:
3403 reply = handle_op_unlock(request, session_key);
3404 break;
3405 case MSG_KILL:
3406 reply = handle_op_kill(request, session_key);
3407 break;
3408 case MSG_INFO:
3409 reply = handle_op_info(request, session_key);
3410 break;
3411 case MSG_GENERIC:
3412 reply = handle_op_generic(request, session_key, i);
3413 break;
3414 case MSG_GETSCHEMA:
3415 reply = handle_op_getschema(request, session_key);
3416 break;
3417 case MSG_RELOADHELLO:
3418 reply = handle_op_reloadhello(request, session_key);
3419 break;
3420 case MSG_NTF_GETHISTORY:
3421 reply = handle_op_ntfgethistory(request, session_key);
3422 break;
3423 case MSG_VALIDATE:
3424 reply = handle_op_validate(request, session_key);
3425 break;
3426 case SCH_QUERY:
3427 reply = handle_op_query(request, session_key, i);
3428 break;
3429 case SCH_MERGE:
3430 reply = handle_op_merge(request, session_key, i);
3431 break;
3432 }
3433
3434 add_reply(replies, reply, session_key);
3435 }
3436
3437 /* free parameters */
3438 operation = (-1);
3439
3440 DEBUG("Clean request json object.");
3441 if (request != NULL) {
3442 pthread_mutex_lock(&json_lock);
3443 json_object_put(request);
3444 pthread_mutex_unlock(&json_lock);
3445 }
3446 DEBUG("Send reply json object.");
Tomas Cejka09629492014-07-10 15:58:06 +02003447
3448send_reply:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003449 /* send reply to caller */
3450 if (replies) {
3451 pthread_mutex_lock(&json_lock);
3452 msgtext = json_object_to_json_string(replies);
3453 if (asprintf(&chunked_out_msg, "\n#%d\n%s\n##\n", (int)strlen(msgtext), msgtext) == -1) {
3454 if (buffer != NULL) {
3455 free(buffer);
3456 buffer = NULL;
3457 }
3458 pthread_mutex_unlock(&json_lock);
3459 break;
3460 }
3461 pthread_mutex_unlock(&json_lock);
Tomas Cejka9a23f6e2014-03-27 14:57:00 +01003462
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003463 DEBUG("Send framed reply json object.");
3464 send(client, chunked_out_msg, strlen(chunked_out_msg) + 1, 0);
3465 DEBUG("Clean reply json object.");
3466 pthread_mutex_lock(&json_lock);
3467 json_object_put(replies);
3468 replies = NULL;
3469 DEBUG("Clean message buffer.");
3470 CHECK_AND_FREE(chunked_out_msg);
3471 chunked_out_msg = NULL;
3472 if (buffer) {
3473 free(buffer);
3474 buffer = NULL;
3475 }
3476 pthread_mutex_unlock(&json_lock);
3477 clean_err_reply();
3478 } else {
3479 ERROR("Reply is NULL, shouldn't be...");
3480 continue;
3481 }
3482 }
3483 }
3484 free(arg);
3485 free_err_reply();
David Kupka8e60a372012-09-04 09:15:20 +02003486
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003487 return retval;
David Kupka8e60a372012-09-04 09:15:20 +02003488}
3489
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003490/**
3491 * \brief Close all open NETCONF sessions.
3492 *
3493 * During termination of mod_netconf, it is useful to close all remaining
3494 * sessions. This function iterates over the list of sessions and close them
3495 * all.
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003496 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003497static void
3498close_all_nc_sessions(void)
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003499{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003500 struct session_with_mutex *locked_session, *next_session;
3501 int ret;
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003502
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003503 /* get exclusive access to sessions_list (conns) */
3504 DEBUG("LOCK wrlock %s", __func__);
3505 if ((ret = pthread_rwlock_wrlock (&session_lock)) != 0) {
3506 ERROR("Error while locking rwlock: %d (%s)", ret, strerror(ret));
3507 return;
3508 }
3509 for (next_session = netconf_sessions_list; next_session;) {
3510 locked_session = next_session;
3511 next_session = locked_session->next;
Tomas Cejka47387fd2013-06-10 20:37:46 +02003512
Michal Vaskoc3146782015-11-04 14:46:41 +01003513 /* close_and_free_session handles locking on its own */
Michal Vaskof35ea502016-02-24 10:44:54 +01003514 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 +01003515 close_and_free_session(locked_session);
3516 }
3517 netconf_sessions_list = NULL;
3518
3519 /* get exclusive access to sessions_list (conns) */
3520 DEBUG("UNLOCK wrlock %s", __func__);
3521 if (pthread_rwlock_unlock (&session_lock) != 0) {
3522 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
3523 }
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003524}
3525
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003526static void
3527check_timeout_and_close(void)
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003528{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003529 struct nc_session *ns = NULL;
3530 struct session_with_mutex *locked_session = NULL;
3531 time_t current_time = time(NULL);
3532 int ret;
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003533
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003534 /* get exclusive access to sessions_list (conns) */
3535 if ((ret = pthread_rwlock_wrlock(&session_lock)) != 0) {
3536 DEBUG("Error while locking rwlock: %d (%s)", ret, strerror(ret));
3537 return;
3538 }
3539 for (locked_session = netconf_sessions_list; locked_session; locked_session = locked_session->next) {
3540 ns = locked_session->session;
3541 if (ns == NULL) {
3542 continue;
3543 }
3544 pthread_mutex_lock(&locked_session->lock);
3545 if ((current_time - locked_session->last_activity) > ACTIVITY_TIMEOUT) {
Michal Vaskof35ea502016-02-24 10:44:54 +01003546 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 +02003547
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003548 /* close_and_free_session handles locking on its own */
3549 close_and_free_session(locked_session);
3550 } else {
3551 pthread_mutex_unlock(&locked_session->lock);
3552 }
3553 }
3554 /* get exclusive access to sessions_list (conns) */
3555 if (pthread_rwlock_unlock(&session_lock) != 0) {
3556 ERROR("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
3557 }
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003558}
3559
3560
3561/**
Radek Krejcif23850c2012-07-23 16:14:17 +02003562 * This is actually implementation of NETCONF client
3563 * - requests are received from UNIX socket in the predefined format
3564 * - results are replied through the same way
Michal Vaskoc3146782015-11-04 14:46:41 +01003565 * - the daemon run as a separate process
Radek Krejcif23850c2012-07-23 16:14:17 +02003566 *
3567 */
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003568static void
3569forked_proc(void)
Radek Krejci469aab82012-07-22 18:42:20 +02003570{
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003571 struct timeval tv;
3572 struct sockaddr_un local, remote;
3573 int lsock, client, ret, i, pthread_count = 0;
3574 unsigned int olds = 0, timediff = 0;
3575 socklen_t len;
3576 struct pass_to_thread *arg;
3577 pthread_t *ptids = calloc(1, sizeof(pthread_t));
3578 struct timespec maxtime;
3579 pthread_rwlockattr_t lock_attrs;
3580 #ifdef WITH_NOTIFICATIONS
3581 char use_notifications = 0;
3582 #endif
David Kupka8e60a372012-09-04 09:15:20 +02003583
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003584 /* wait at most 5 seconds for every thread to terminate */
3585 maxtime.tv_sec = 5;
3586 maxtime.tv_nsec = 0;
Radek Krejci469aab82012-07-22 18:42:20 +02003587
Tomas Cejka04e08f42014-03-27 19:52:34 +01003588#ifdef HAVE_UNIXD_SETUP_CHILD
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003589 /* change uid and gid of process for security reasons */
3590 unixd_setup_child();
Tomas Cejka04e08f42014-03-27 19:52:34 +01003591#else
3592# ifdef SU_GROUP
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003593 if (strlen(SU_GROUP) > 0) {
3594 struct group *g = getgrnam(SU_GROUP);
3595 if (g == NULL) {
3596 ERROR("GID (%s) was not found.", SU_GROUP);
3597 return;
3598 }
3599 if (setgid(g->gr_gid) != 0) {
3600 ERROR("Switching to %s GID failed. (%s)", SU_GROUP, strerror(errno));
3601 return;
3602 }
3603 }
Tomas Cejka04e08f42014-03-27 19:52:34 +01003604# else
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003605 DEBUG("no SU_GROUP");
Tomas Cejka04e08f42014-03-27 19:52:34 +01003606# endif
3607# ifdef SU_USER
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003608 if (strlen(SU_USER) > 0) {
3609 struct passwd *p = getpwnam(SU_USER);
3610 if (p == NULL) {
3611 ERROR("UID (%s) was not found.", SU_USER);
3612 return;
3613 }
3614 if (setuid(p->pw_uid) != 0) {
3615 ERROR("Switching to UID %s failed. (%s)", SU_USER, strerror(errno));
3616 return;
3617 }
3618 }
Tomas Cejka04e08f42014-03-27 19:52:34 +01003619# else
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003620 DEBUG("no SU_USER");
Tomas Cejka04e08f42014-03-27 19:52:34 +01003621# endif
3622#endif
Radek Krejci469aab82012-07-22 18:42:20 +02003623
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003624 /* try to remove if exists */
3625 unlink(sockname);
Tomas Cejka04e08f42014-03-27 19:52:34 +01003626
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003627 /* create listening UNIX socket to accept incoming connections */
3628 if ((lsock = socket(PF_UNIX, SOCK_STREAM, 0)) == -1) {
3629 ERROR("Creating socket failed (%s)", strerror(errno));
3630 goto error_exit;
3631 }
Radek Krejci469aab82012-07-22 18:42:20 +02003632
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003633 local.sun_family = AF_UNIX;
3634 strncpy(local.sun_path, sockname, sizeof(local.sun_path));
3635 len = offsetof(struct sockaddr_un, sun_path) + strlen(local.sun_path);
Radek Krejci469aab82012-07-22 18:42:20 +02003636
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003637 if (bind(lsock, (struct sockaddr *)&local, len) == -1) {
3638 if (errno == EADDRINUSE) {
3639 ERROR("mod_netconf socket address already in use");
3640 goto error_exit;
3641 }
3642 ERROR("Binding socket failed (%s)", strerror(errno));
3643 goto error_exit;
3644 }
Radek Krejci469aab82012-07-22 18:42:20 +02003645
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003646 if (listen(lsock, MAX_SOCKET_CL) == -1) {
3647 ERROR("Setting up listen socket failed (%s)", strerror(errno));
3648 goto error_exit;
3649 }
3650 chmod(sockname, S_IWUSR | S_IWGRP | S_IWOTH | S_IRUSR | S_IRGRP | S_IROTH);
Radek Krejci469aab82012-07-22 18:42:20 +02003651
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003652 uid_t user = -1;
3653 if (strlen(CHOWN_USER) > 0) {
3654 struct passwd *p = getpwnam(CHOWN_USER);
3655 if (p != NULL) {
3656 user = p->pw_uid;
3657 }
3658 }
3659 gid_t group = -1;
3660 if (strlen(CHOWN_GROUP) > 0) {
3661 struct group *g = getgrnam(CHOWN_GROUP);
3662 if (g != NULL) {
3663 group = g->gr_gid;
3664 }
3665 }
3666 if (chown(sockname, user, group) == -1) {
3667 ERROR("Chown on socket file failed (%s).", strerror(errno));
3668 }
Tomas Cejka04e08f42014-03-27 19:52:34 +01003669
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003670 /* prepare internal lists */
Tomas Cejkaba21b382013-04-13 02:37:32 +02003671
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003672 #ifdef WITH_NOTIFICATIONS
3673 if (notification_init() == -1) {
3674 ERROR("libwebsockets initialization failed");
3675 use_notifications = 0;
3676 } else {
3677 use_notifications = 1;
3678 }
3679 #endif
Tomas Cejkad340dbf2013-03-24 20:36:57 +01003680
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003681 /* setup libnetconf's callbacks */
3682 nc_verbosity(NC_VERB_DEBUG);
Michal Vaskof35ea502016-02-24 10:44:54 +01003683 nc_set_print_clb(clb_print);
3684 nc_client_ssh_set_auth_hostkey_check_clb(netconf_callback_ssh_hostkey_check);
3685 nc_client_ssh_set_auth_interactive_clb(netconf_callback_sshauth_interactive);
3686 nc_client_ssh_set_auth_password_clb(netconf_callback_sshauth_password);
3687 nc_client_ssh_set_auth_privkey_passphrase_clb(netconf_callback_sshauth_passphrase);
Radek Krejci469aab82012-07-22 18:42:20 +02003688
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003689 /* disable publickey authentication */
Michal Vaskof35ea502016-02-24 10:44:54 +01003690 nc_client_ssh_set_auth_pref(NC_SSH_AUTH_PUBLICKEY, -1);
Radek Krejci469aab82012-07-22 18:42:20 +02003691
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003692 /* create mutex protecting session list */
3693 pthread_rwlockattr_init(&lock_attrs);
3694 /* rwlock is shared only with threads in this process */
3695 pthread_rwlockattr_setpshared(&lock_attrs, PTHREAD_PROCESS_PRIVATE);
3696 /* create rw lock */
3697 if (pthread_rwlock_init(&session_lock, &lock_attrs) != 0) {
3698 ERROR("Initialization of mutex failed: %d (%s)", errno, strerror(errno));
3699 goto error_exit;
3700 }
3701 pthread_mutex_init(&ntf_history_lock, NULL);
3702 pthread_mutex_init(&json_lock, NULL);
3703 DEBUG("Initialization of notification history.");
3704 if (pthread_key_create(&notif_history_key, NULL) != 0) {
3705 ERROR("Initialization of notification history failed.");
3706 }
3707 if (pthread_key_create(&err_reply_key, NULL) != 0) {
3708 ERROR("Initialization of reply key failed.");
3709 }
Tomas Cejka8a82dab2013-05-30 23:37:23 +02003710
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003711 fcntl(lsock, F_SETFL, fcntl(lsock, F_GETFL, 0) | O_NONBLOCK);
3712 while (isterminated == 0) {
3713 gettimeofday(&tv, NULL);
3714 timediff = (unsigned int)tv.tv_sec - olds;
3715 #ifdef WITH_NOTIFICATIONS
3716 if (use_notifications == 1) {
3717 notification_handle();
3718 }
3719 #endif
3720 if (timediff > ACTIVITY_CHECK_INTERVAL) {
3721 check_timeout_and_close();
3722 }
Radek Krejci469aab82012-07-22 18:42:20 +02003723
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003724 /* open incoming connection if any */
3725 len = sizeof(remote);
3726 client = accept(lsock, (struct sockaddr *) &remote, &len);
3727 if (client == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
3728 usleep(SLEEP_TIME * 1000);
3729 continue;
3730 } else if (client == -1 && (errno == EINTR)) {
3731 continue;
3732 } else if (client == -1) {
3733 ERROR("Accepting mod_netconf client connection failed (%s)", strerror(errno));
3734 continue;
3735 }
Radek Krejci469aab82012-07-22 18:42:20 +02003736
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003737 /* set client's socket as non-blocking */
3738 //fcntl(client, F_SETFL, fcntl(client, F_GETFL, 0) | O_NONBLOCK);
Radek Krejci469aab82012-07-22 18:42:20 +02003739
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003740 arg = malloc(sizeof(struct pass_to_thread));
3741 arg->client = client;
3742 arg->netconf_sessions_list = netconf_sessions_list;
Radek Krejci469aab82012-07-22 18:42:20 +02003743
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003744 /* start new thread. It will serve this particular request and then terminate */
3745 if ((ret = pthread_create (&ptids[pthread_count], NULL, thread_routine, (void *)arg)) != 0) {
3746 ERROR("Creating POSIX thread failed: %d\n", ret);
3747 } else {
3748 DEBUG("Thread %lu created", ptids[pthread_count]);
3749 pthread_count++;
3750 ptids = realloc (ptids, sizeof(pthread_t) * (pthread_count+1));
3751 ptids[pthread_count] = 0;
3752 }
Radek Krejci469aab82012-07-22 18:42:20 +02003753
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003754 /* check if some thread already terminated, free some resources by joining it */
3755 for (i = 0; i < pthread_count; i++) {
3756 if (pthread_tryjoin_np(ptids[i], (void **)&arg) == 0) {
3757 DEBUG("Thread %lu joined with retval %p", ptids[i], arg);
3758 pthread_count--;
3759 if (pthread_count > 0) {
3760 /* place last Thread ID on the place of joined one */
3761 ptids[i] = ptids[pthread_count];
3762 }
3763 }
3764 }
3765 DEBUG("Running %d threads", pthread_count);
3766 }
Radek Krejci469aab82012-07-22 18:42:20 +02003767
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003768 DEBUG("mod_netconf terminating...");
3769 /* join all threads */
3770 for (i = 0; i < pthread_count; i++) {
3771 pthread_timedjoin_np(ptids[i], (void **)&arg, &maxtime);
3772 }
Radek Krejci469aab82012-07-22 18:42:20 +02003773
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003774 #ifdef WITH_NOTIFICATIONS
3775 notification_close();
3776 #endif
Tomas Cejkad340dbf2013-03-24 20:36:57 +01003777
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003778 /* close all NETCONF sessions */
3779 close_all_nc_sessions();
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02003780
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003781 /* destroy rwlock */
3782 pthread_rwlock_destroy(&session_lock);
3783 pthread_rwlockattr_destroy(&lock_attrs);
David Kupka8e60a372012-09-04 09:15:20 +02003784
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003785 DEBUG("Exiting from the mod_netconf daemon");
Radek Krejci469aab82012-07-22 18:42:20 +02003786
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003787 free(ptids);
3788 close(lsock);
3789 exit(0);
3790 return;
3791
Tomas Cejkaef531ee2013-11-12 16:07:00 +01003792error_exit:
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003793 close(lsock);
3794 free(ptids);
3795 return;
Radek Krejci469aab82012-07-22 18:42:20 +02003796}
3797
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003798int
3799main(int argc, char **argv)
Tomas Cejkaef531ee2013-11-12 16:07:00 +01003800{
Michal Vaskoc3146782015-11-04 14:46:41 +01003801 struct sigaction action;
3802 sigset_t block_mask;
Michal Vaskoa53ef882015-11-24 11:02:01 +01003803 int daemonize = 0, i;
Michal Vaskoc3146782015-11-04 14:46:41 +01003804
Michal Vaskoa53ef882015-11-24 11:02:01 +01003805 if (argc > 3) {
3806 printf("Usage: [--(h)elp] [--(d)aemon] [socket-path]\n");
3807 return 1;
3808 }
3809
3810 sockname = SOCKET_FILENAME;
3811 for (i = 1; i < argc; ++i) {
3812 if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
3813 printf("Usage: [--(h)elp] [--(d)aemon] [socket-path]\n");
3814 return 0;
3815 } else if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--daemon")) {
3816 daemonize = 1;
3817 } else {
3818 sockname = argv[i];
3819 }
3820 }
3821
3822 if (daemonize && (daemon(0, 0) == -1)) {
3823 ERROR("daemon() failed (%s)", strerror(errno));
3824 return 1;
Michal Vaskoc3146782015-11-04 14:46:41 +01003825 }
3826
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003827 sigfillset(&block_mask);
Michal Vaskoc3146782015-11-04 14:46:41 +01003828 action.sa_handler = signal_handler;
3829 action.sa_mask = block_mask;
3830 action.sa_flags = 0;
3831 sigaction(SIGINT, &action, NULL);
3832 sigaction(SIGTERM, &action, NULL);
3833
Michal Vaskoda0ab5c2015-11-13 13:24:51 +01003834 forked_proc();
3835 DEBUG("Terminated");
3836 return 0;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01003837}