blob: f6218abe91fbe60d653229c5fffe571df5286658 [file] [log] [blame]
Radek Krejci469aab82012-07-22 18:42:20 +02001/*!
2 * \file mod_netconf.c
3 * \brief NETCONF Apache modul for Netopeer
4 * \author Tomas Cejka <cejkat@cesnet.cz>
5 * \author Radek Krejci <rkrejci@cesnet.cz>
6 * \date 2011
7 * \date 2012
Tomas Cejka94da2c52013-01-08 18:20:30 +01008 * \date 2013
Radek Krejci469aab82012-07-22 18:42:20 +02009 */
10/*
Tomas Cejkad340dbf2013-03-24 20:36:57 +010011 * Copyright (C) 2011-2013 CESNET
Radek Krejci469aab82012-07-22 18:42:20 +020012 *
13 * LICENSE TERMS
14 *
15 * Redistribution and use in source and binary forms, with or without
16 * modification, are permitted provided that the following conditions
17 * are met:
18 * 1. Redistributions of source code must retain the above copyright
19 * notice, this list of conditions and the following disclaimer.
20 * 2. Redistributions in binary form must reproduce the above copyright
21 * notice, this list of conditions and the following disclaimer in
22 * the documentation and/or other materials provided with the
23 * distribution.
24 * 3. Neither the name of the Company nor the names of its contributors
25 * may be used to endorse or promote products derived from this
26 * software without specific prior written permission.
27 *
28 * ALTERNATIVELY, provided that this notice is retained in full, this
29 * product may be distributed under the terms of the GNU General Public
30 * License (GPL) version 2 or later, in which case the provisions
31 * of the GPL apply INSTEAD OF those given above.
32 *
33 * This software is provided ``as is'', and any express or implied
34 * warranties, including, but not limited to, the implied warranties of
35 * merchantability and fitness for a particular purpose are disclaimed.
36 * In no event shall the company or contributors be liable for any
37 * direct, indirect, incidental, special, exemplary, or consequential
38 * damages (including, but not limited to, procurement of substitute
39 * goods or services; loss of use, data, or profits; or business
40 * interruption) however caused and on any theory of liability, whether
41 * in contract, strict liability, or tort (including negligence or
42 * otherwise) arising in any way out of the use of this software, even
43 * if advised of the possibility of such damage.
44 *
45 */
46
Radek Krejci7b4ddd02012-07-30 08:09:58 +020047#include <unistd.h>
48#include <poll.h>
Radek Krejci469aab82012-07-22 18:42:20 +020049#include <sys/types.h>
50#include <sys/socket.h>
51#include <sys/un.h>
Tomas Cejkad340dbf2013-03-24 20:36:57 +010052#include <sys/fcntl.h>
David Kupka8e60a372012-09-04 09:15:20 +020053#include <pthread.h>
54#include <ctype.h>
Radek Krejci7b4ddd02012-07-30 08:09:58 +020055
56#include <unixd.h>
57#include <httpd.h>
58#include <http_log.h>
59#include <http_config.h>
60
61#include <apr_sha1.h>
62#include <apr_hash.h>
63#include <apr_signal.h>
64#include <apr_strings.h>
Radek Krejci469aab82012-07-22 18:42:20 +020065
Radek Krejci8fd1f5e2012-07-24 17:33:36 +020066#include <json/json.h>
67
Radek Krejci469aab82012-07-22 18:42:20 +020068#include <libnetconf.h>
Tomas Cejkab3cc64f2013-05-03 19:44:54 +020069#include <libnetconf_ssh.h>
Radek Krejci7b4ddd02012-07-30 08:09:58 +020070
Tomas Cejkad340dbf2013-03-24 20:36:57 +010071#ifdef WITH_NOTIFICATIONS
72#include "notification_module.h"
73#endif
74
Tomas Cejka94da2c52013-01-08 18:20:30 +010075#include "message_type.h"
Tomas Cejkaaf7a1562013-04-13 02:27:43 +020076#include "mod_netconf.h"
Radek Krejci469aab82012-07-22 18:42:20 +020077
78#define MAX_PROCS 5
Radek Krejci6cb08982012-07-25 18:01:06 +020079#define SOCKET_FILENAME "/tmp/mod_netconf.sock"
Radek Krejci469aab82012-07-22 18:42:20 +020080#define MAX_SOCKET_CL 10
81#define BUFFER_SIZE 4096
Tomas Cejkaaf7a1562013-04-13 02:27:43 +020082#define NOTIFICATION_QUEUE_SIZE 10
83#define ACTIVITY_CHECK_INTERVAL 10 /**< timeout in seconds, how often activity is checked */
Tomas Cejka04e39952013-04-19 11:49:38 +020084#define ACTIVITY_TIMEOUT (60*60) /**< timeout in seconds, after this time, session is automaticaly closed. */
Radek Krejci469aab82012-07-22 18:42:20 +020085
86/* sleep in master process for non-blocking socket reading */
87#define SLEEP_TIME 200
88
89#ifndef offsetof
90#define offsetof(type, member) ((size_t) ((type *) 0)->member)
91#endif
92
Tomas Cejkaef531ee2013-11-12 16:07:00 +010093server_rec *http_server = NULL;
94
Tomas Cejka027f3bc2012-11-10 20:28:36 +010095/* timeout in msec */
Radek Krejci469aab82012-07-22 18:42:20 +020096struct timeval timeout = { 1, 0 };
97
Tomas Cejka5064c232013-01-17 09:30:58 +010098#define NCWITHDEFAULTS NCWD_MODE_NOTSET
99
100
Radek Krejci469aab82012-07-22 18:42:20 +0200101#define MSG_OK 0
102#define MSG_OPEN 1
103#define MSG_DATA 2
104#define MSG_CLOSE 3
105#define MSG_ERROR 4
106#define MSG_UNKNOWN 5
107
Radek Krejci469aab82012-07-22 18:42:20 +0200108module AP_MODULE_DECLARE_DATA netconf_module;
109
Tomas Cejka47387fd2013-06-10 20:37:46 +0200110pthread_rwlock_t session_lock; /**< mutex protecting netconf_sessions_list from multiple access errors */
Tomas Cejka6b886e02013-07-05 09:53:17 +0200111pthread_mutex_t ntf_history_lock; /**< mutex protecting notification history list */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100112pthread_mutex_t ntf_hist_clbc_mutex; /**< mutex protecting notification history list */
Tomas Cejka47387fd2013-06-10 20:37:46 +0200113apr_hash_t *netconf_sessions_list = NULL;
David Kupka8e60a372012-09-04 09:15:20 +0200114
Tomas Cejkad016f9c2013-07-10 09:16:16 +0200115static pthread_key_t notif_history_key;
Tomas Cejka6b886e02013-07-05 09:53:17 +0200116
Radek Krejci469aab82012-07-22 18:42:20 +0200117volatile int isterminated = 0;
118
119static char* password;
120
Radek Krejci469aab82012-07-22 18:42:20 +0200121static void signal_handler(int sign)
122{
123 switch (sign) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100124 case SIGINT:
Radek Krejci469aab82012-07-22 18:42:20 +0200125 case SIGTERM:
126 isterminated = 1;
Radek Krejci469aab82012-07-22 18:42:20 +0200127 break;
128 }
129}
130
Radek Krejci8fd1f5e2012-07-24 17:33:36 +0200131static char* gen_ncsession_hash( const char* hostname, const char* port, const char* sid)
Radek Krejci469aab82012-07-22 18:42:20 +0200132{
Radek Krejcif23850c2012-07-23 16:14:17 +0200133 unsigned char hash_raw[APR_SHA1_DIGESTSIZE];
134 int i;
Radek Krejci8fd1f5e2012-07-24 17:33:36 +0200135 char* hash;
Radek Krejcif23850c2012-07-23 16:14:17 +0200136
Radek Krejci469aab82012-07-22 18:42:20 +0200137 apr_sha1_ctx_t sha1_ctx;
138 apr_sha1_init(&sha1_ctx);
139 apr_sha1_update(&sha1_ctx, hostname, strlen(hostname));
140 apr_sha1_update(&sha1_ctx, port, strlen(port));
141 apr_sha1_update(&sha1_ctx, sid, strlen(sid));
Radek Krejcif23850c2012-07-23 16:14:17 +0200142 apr_sha1_final(hash_raw, &sha1_ctx);
Radek Krejci469aab82012-07-22 18:42:20 +0200143
Radek Krejcif23850c2012-07-23 16:14:17 +0200144 /* convert binary hash into hex string, which is printable */
Radek Krejci8fd1f5e2012-07-24 17:33:36 +0200145 hash = malloc(sizeof(char) * ((2*APR_SHA1_DIGESTSIZE)+1));
Radek Krejcif23850c2012-07-23 16:14:17 +0200146 for (i = 0; i < APR_SHA1_DIGESTSIZE; i++) {
Radek Krejci8fd1f5e2012-07-24 17:33:36 +0200147 snprintf(hash + (2*i), 3, "%02x", hash_raw[i]);
Radek Krejcif23850c2012-07-23 16:14:17 +0200148 }
149 //hash[2*APR_SHA1_DIGESTSIZE] = 0;
Radek Krejci469aab82012-07-22 18:42:20 +0200150
Radek Krejci8fd1f5e2012-07-24 17:33:36 +0200151 return (hash);
Radek Krejci469aab82012-07-22 18:42:20 +0200152}
153
154int netconf_callback_ssh_hostkey_check (const char* hostname, int keytype, const char* fingerprint)
155{
156 /* always approve */
157 return (EXIT_SUCCESS);
158}
159
160char* netconf_callback_sshauth_password (const char* username, const char* hostname)
161{
162 char* buf;
163
164 buf = malloc ((strlen(password) + 1) * sizeof(char));
165 apr_cpystrn(buf, password, strlen(password) + 1);
166
167 return (buf);
168}
169
170void netconf_callback_sshauth_interactive (const char* name,
171 int name_len,
172 const char* instruction,
173 int instruction_len,
174 int num_prompts,
175 const LIBSSH2_USERAUTH_KBDINT_PROMPT* prompts,
176 LIBSSH2_USERAUTH_KBDINT_RESPONSE* responses,
177 void** abstract)
178{
179 int i;
180
181 for (i=0; i<num_prompts; i++) {
182 responses[i].text = malloc ((strlen(password) + 1) * sizeof(char));
183 apr_cpystrn(responses[i].text, password, strlen(password) + 1);
184 responses[i].length = strlen(responses[i].text) + 1;
185 }
186
187 return;
188}
189
Radek Krejcic11fd862012-07-26 12:41:21 +0200190static json_object *err_reply = NULL;
191void netconf_callback_error_process(const char* tag,
192 const char* type,
193 const char* severity,
194 const char* apptag,
195 const char* path,
196 const char* message,
197 const char* attribute,
198 const char* element,
199 const char* ns,
200 const char* sid)
201{
Tomas Cejka0858dbb2013-11-19 15:11:00 +0100202 json_object *array = NULL;
203 if (err_reply == NULL) {
204 err_reply = json_object_new_object();
205 array = json_object_new_array();
206 json_object_object_add(err_reply, "type", json_object_new_int(REPLY_ERROR));
207 json_object_object_add(err_reply, "errors", array);
208 if (message != NULL) {
209 json_object_array_add(array, json_object_new_string(message));
210 }
211 return;
212 } else {
213 array = json_object_object_get(err_reply, "errors");
214 if (array != NULL) {
215 if (message != NULL) {
216 json_object_array_add(array, json_object_new_string(message));
217 }
218 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100219 }
Radek Krejcic11fd862012-07-26 12:41:21 +0200220}
221
Tomas Cejka47387fd2013-06-10 20:37:46 +0200222/**
223 * should be used in locked area
224 */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100225void prepare_status_message(struct session_with_mutex *s, struct nc_session *session)
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200226{
Tomas Cejka8a82dab2013-05-30 23:37:23 +0200227 json_object *json_obj = NULL;
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100228 char *old_sid = NULL;
229 const char *j_old_sid = NULL;
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200230 const char *cpbltstr;
231 struct nc_cpblts* cpblts = NULL;
Tomas Cejkaf38a54c2013-05-27 21:57:35 +0200232
Tomas Cejka8a82dab2013-05-30 23:37:23 +0200233 if (s == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100234 DEBUG("No session given.");
Tomas Cejka8a82dab2013-05-30 23:37:23 +0200235 return;
236 }
237
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200238 if (s->hello_message != NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100239 DEBUG("clean previous hello message");
Tomas Cejka8a82dab2013-05-30 23:37:23 +0200240 //json_object_put(s->hello_message);
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100241 j_old_sid = json_object_get_string(json_object_object_get(s->hello_message, "sid"));
242 if (j_old_sid != NULL) {
243 old_sid = strdup(j_old_sid);
244 }
Tomas Cejka8a82dab2013-05-30 23:37:23 +0200245 s->hello_message = NULL;
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200246 }
247 s->hello_message = json_object_new_object();
248 if (session != NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100249 if (old_sid != NULL) {
250 /* use previous sid */
251 json_object_object_add(s->hello_message, "sid", json_object_new_string(old_sid));
252 free(old_sid);
253 } else {
Tomas Cejkaf38a54c2013-05-27 21:57:35 +0200254 /* we don't have old sid */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100255 json_object_object_add(s->hello_message, "sid", json_object_new_string(nc_session_get_id(session)));
256 }
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200257 json_object_object_add(s->hello_message, "version", json_object_new_string((nc_session_get_version(session) == 0)?"1.0":"1.1"));
258 json_object_object_add(s->hello_message, "host", json_object_new_string(nc_session_get_host(session)));
259 json_object_object_add(s->hello_message, "port", json_object_new_string(nc_session_get_port(session)));
260 json_object_object_add(s->hello_message, "user", json_object_new_string(nc_session_get_user(session)));
261 cpblts = nc_session_get_cpblts (session);
262 if (cpblts != NULL) {
263 json_obj = json_object_new_array();
264 nc_cpblts_iter_start (cpblts);
265 while ((cpbltstr = nc_cpblts_iter_next (cpblts)) != NULL) {
266 json_object_array_add(json_obj, json_object_new_string(cpbltstr));
267 }
268 json_object_object_add(s->hello_message, "capabilities", json_obj);
269 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100270 DEBUG("%s", json_object_to_json_string(s->hello_message));
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200271 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100272 DEBUG("Session was not given.");
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200273 json_object_object_add(s->hello_message, "type", json_object_new_int(REPLY_ERROR));
274 json_object_object_add(s->hello_message, "error-message", json_object_new_string("Invalid session identifier."));
275 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100276 DEBUG("Status info from hello message prepared");
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200277
278}
279
280
Tomas Cejka0a4bba82013-04-19 11:51:28 +0200281/**
282 * \defgroup netconf_operations NETCONF operations
283 * The list of NETCONF operations that mod_netconf supports.
284 * @{
285 */
286
287/**
288 * \brief Connect to NETCONF server
289 *
290 * \warning Session_key hash is not bound with caller identification. This could be potential security risk.
291 */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100292static char* netconf_connect(apr_pool_t* pool, const char* host, const char* port, const char* user, const char* pass, struct nc_cpblts * cpblts)
Radek Krejci469aab82012-07-22 18:42:20 +0200293{
Tomas Cejkaae9efe52013-04-23 13:37:36 +0200294 struct nc_session* session = NULL;
David Kupka8e60a372012-09-04 09:15:20 +0200295 struct session_with_mutex * locked_session;
Radek Krejcif23850c2012-07-23 16:14:17 +0200296 char *session_key;
Radek Krejci469aab82012-07-22 18:42:20 +0200297
298 /* connect to the requested NETCONF server */
Radek Krejci8fd1f5e2012-07-24 17:33:36 +0200299 password = (char*)pass;
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100300 DEBUG("prepare to connect %s@%s:%s", user, host, port);
Tomas Cejkaae9efe52013-04-23 13:37:36 +0200301 nc_verbosity(NC_VERB_DEBUG);
David Kupka8e60a372012-09-04 09:15:20 +0200302 session = nc_session_connect(host, (unsigned short) atoi (port), user, cpblts);
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100303 DEBUG("nc_session_connect done");
David Kupka8e60a372012-09-04 09:15:20 +0200304
Radek Krejci469aab82012-07-22 18:42:20 +0200305 /* if connected successful, add session to the list */
306 if (session != NULL) {
307 /* generate hash for the session */
Radek Krejcic11fd862012-07-26 12:41:21 +0200308 session_key = gen_ncsession_hash(
309 (host==NULL) ? "localhost" : host,
310 (port==NULL) ? "830" : port,
Radek Krejcia282bed2012-07-27 14:43:45 +0200311 nc_session_get_id(session));
David Kupka8e60a372012-09-04 09:15:20 +0200312
Tomas Cejkaba21b382013-04-13 02:37:32 +0200313 /** \todo allocate from apr_pool */
David Kupka8e60a372012-09-04 09:15:20 +0200314 if ((locked_session = malloc (sizeof (struct session_with_mutex))) == NULL || pthread_mutex_init (&locked_session->lock, NULL) != 0) {
315 nc_session_free(session);
316 free (locked_session);
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100317 DEBUG("Creating structure session_with_mutex failed %d (%s)", errno, strerror(errno));
David Kupka8e60a372012-09-04 09:15:20 +0200318 return NULL;
319 }
320 locked_session->session = session;
Tomas Cejkaaf7a1562013-04-13 02:27:43 +0200321 locked_session->last_activity = apr_time_now();
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200322 locked_session->hello_message = NULL;
Tomas Cejkabdedcd32013-06-09 11:54:53 +0200323 locked_session->closed = 0;
David Kupka8e60a372012-09-04 09:15:20 +0200324 pthread_mutex_init (&locked_session->lock, NULL);
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100325 DEBUG("Before session_lock");
David Kupka8e60a372012-09-04 09:15:20 +0200326 /* get exclusive access to sessions_list (conns) */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100327 DEBUG("LOCK wrlock %s", __func__);
David Kupka8e60a372012-09-04 09:15:20 +0200328 if (pthread_rwlock_wrlock (&session_lock) != 0) {
329 nc_session_free(session);
330 free (locked_session);
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100331 DEBUG("Error while locking rwlock: %d (%s)", errno, strerror(errno));
David Kupka8e60a372012-09-04 09:15:20 +0200332 return NULL;
333 }
Tomas Cejkaba21b382013-04-13 02:37:32 +0200334 locked_session->notifications = apr_array_make(pool, NOTIFICATION_QUEUE_SIZE, sizeof(notification_t));
Tomas Cejka654f84e2013-04-19 11:55:01 +0200335 locked_session->ntfc_subscribed = 0;
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100336 DEBUG("Add connection to the list");
Tomas Cejka47387fd2013-06-10 20:37:46 +0200337 apr_hash_set(netconf_sessions_list, apr_pstrdup(pool, session_key), APR_HASH_KEY_STRING, (void *) locked_session);
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100338 DEBUG("Before session_unlock");
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200339
Tomas Cejka47387fd2013-06-10 20:37:46 +0200340 /* lock session */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100341 DEBUG("LOCK mutex %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +0200342 pthread_mutex_lock(&locked_session->lock);
343
344 /* unlock session list */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100345 DEBUG("UNLOCK wrlock %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +0200346 if (pthread_rwlock_unlock (&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100347 DEBUG("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejka47387fd2013-06-10 20:37:46 +0200348 }
349
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200350 /* store information about session from hello message for future usage */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100351 prepare_status_message(locked_session, session);
Tomas Cejka45ab59f2013-05-15 00:10:49 +0200352
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100353 DEBUG("UNLOCK mutex %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +0200354 pthread_mutex_unlock(&locked_session->lock);
355
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100356 DEBUG("NETCONF session established");
Radek Krejci8fd1f5e2012-07-24 17:33:36 +0200357 return (session_key);
Radek Krejci469aab82012-07-22 18:42:20 +0200358 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100359 DEBUG("Connection could not be established");
Radek Krejci8fd1f5e2012-07-24 17:33:36 +0200360 return (NULL);
Radek Krejci469aab82012-07-22 18:42:20 +0200361 }
362
Radek Krejci469aab82012-07-22 18:42:20 +0200363}
364
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100365static int close_and_free_session(struct session_with_mutex *locked_session)
Radek Krejci469aab82012-07-22 18:42:20 +0200366{
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100367 DEBUG("lock private lock.");
368 DEBUG("LOCK mutex %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +0200369 if (pthread_mutex_lock(&locked_session->lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100370 DEBUG("Error while locking rwlock");
Tomas Cejka47387fd2013-06-10 20:37:46 +0200371 }
372 locked_session->ntfc_subscribed = 0;
373 locked_session->closed = 1;
Tomas Cejkaaecc5f72013-10-01 00:03:50 +0200374 nc_session_free(locked_session->session);
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100375 DEBUG("session closed.");
376 DEBUG("unlock private lock.");
377 DEBUG("UNLOCK mutex %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +0200378 if (pthread_mutex_unlock(&locked_session->lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100379 DEBUG("Error while locking rwlock");
Tomas Cejka47387fd2013-06-10 20:37:46 +0200380 }
381
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100382 DEBUG("unlock session lock.");
383 DEBUG("closed session, disabled notif(?), wait 2s");
Tomas Cejka47387fd2013-06-10 20:37:46 +0200384 usleep(500000); /* let notification thread stop */
385
386 /* session shouldn't be used by now */
387 /** \todo free all notifications from queue */
388 apr_array_clear(locked_session->notifications);
389 pthread_mutex_destroy(&locked_session->lock);
390 if (locked_session->hello_message != NULL) {
391 /** \todo free hello_message */
392 //json_object_put(locked_session->hello_message);
393 locked_session->hello_message = NULL;
394 }
Tomas Cejka47387fd2013-06-10 20:37:46 +0200395 locked_session->session = NULL;
Tomas Cejkaaecc5f72013-10-01 00:03:50 +0200396 free(locked_session);
Tomas Cejka47387fd2013-06-10 20:37:46 +0200397 locked_session = NULL;
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100398 DEBUG("NETCONF session closed, everything cleared.");
Tomas Cejka47387fd2013-06-10 20:37:46 +0200399 return (EXIT_SUCCESS);
400}
401
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100402static int netconf_close(const char* session_key, json_object **reply)
Tomas Cejka47387fd2013-06-10 20:37:46 +0200403{
David Kupka8e60a372012-09-04 09:15:20 +0200404 struct session_with_mutex * locked_session;
Radek Krejci469aab82012-07-22 18:42:20 +0200405
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100406 DEBUG("Key in hash to close: %s", session_key);
Tomas Cejka47387fd2013-06-10 20:37:46 +0200407
David Kupka8e60a372012-09-04 09:15:20 +0200408 /* get exclusive (write) access to sessions_list (conns) */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100409 DEBUG("lock session lock.");
410 DEBUG("LOCK wrlock %s", __func__);
David Kupka8e60a372012-09-04 09:15:20 +0200411 if (pthread_rwlock_wrlock (&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100412 DEBUG("Error while locking rwlock");
413 (*reply) = create_error("Internal: Error while locking.");
David Kupka8e60a372012-09-04 09:15:20 +0200414 return EXIT_FAILURE;
415 }
Tomas Cejka47387fd2013-06-10 20:37:46 +0200416 /* get session to close */
417 locked_session = (struct session_with_mutex *)apr_hash_get(netconf_sessions_list, session_key, APR_HASH_KEY_STRING);
418 /* remove session from the active sessions list -> nobody new can now work with session */
419 apr_hash_set(netconf_sessions_list, session_key, APR_HASH_KEY_STRING, NULL);
Tomas Cejkabdedcd32013-06-09 11:54:53 +0200420
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100421 DEBUG("UNLOCK wrlock %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +0200422 if (pthread_rwlock_unlock (&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100423 DEBUG("Error while unlocking rwlock");
424 (*reply) = create_error("Internal: Error while unlocking.");
Tomas Cejka47387fd2013-06-10 20:37:46 +0200425 }
426
427 if ((locked_session != NULL) && (locked_session->session != NULL)) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100428 return close_and_free_session(locked_session);
Radek Krejci469aab82012-07-22 18:42:20 +0200429 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100430 DEBUG("Unknown session to close");
431 (*reply) = create_error("Internal: Unkown session to close.");
Radek Krejci8fd1f5e2012-07-24 17:33:36 +0200432 return (EXIT_FAILURE);
Radek Krejci469aab82012-07-22 18:42:20 +0200433 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100434 (*reply) = NULL;
Radek Krejci469aab82012-07-22 18:42:20 +0200435}
436
Tomas Cejkac7929632013-10-24 19:25:15 +0200437/**
438 * Test reply message type and return error message.
439 *
Tomas Cejkac7929632013-10-24 19:25:15 +0200440 * \param[in] session nc_session internal struct
441 * \param[in] session_key session key, NULL to disable disconnect on error
442 * \param[in] msgt RPC-REPLY message type
443 * \param[out] data
444 * \return NULL on success
445 */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100446json_object *netconf_test_reply(struct nc_session *session, const char *session_key, NC_MSG_TYPE msgt, nc_reply *reply, char **data)
Tomas Cejkac7929632013-10-24 19:25:15 +0200447{
448 NC_REPLY_TYPE replyt;
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100449 json_object *err = NULL;
Tomas Cejkac7929632013-10-24 19:25:15 +0200450
451 /* process the result of the operation */
452 switch (msgt) {
453 case NC_MSG_UNKNOWN:
454 if (nc_session_get_status(session) != NC_SESSION_STATUS_WORKING) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100455 DEBUG("mod_netconf: receiving rpc-reply failed");
Tomas Cejkac7929632013-10-24 19:25:15 +0200456 if (session_key != NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100457 netconf_close(session_key, &err);
458 }
459 if (err != NULL) {
460 return err;
Tomas Cejkac7929632013-10-24 19:25:15 +0200461 }
462 return create_error("Internal: Receiving RPC-REPLY failed.");
463 }
464 case NC_MSG_NONE:
465 /* there is error handled by callback */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100466 if (data != NULL) {
467 free(*data);
468 }
Tomas Cejkac7929632013-10-24 19:25:15 +0200469 (*data) = NULL;
470 return NULL;
471 case NC_MSG_REPLY:
472 switch (replyt = nc_reply_get_type(reply)) {
473 case NC_REPLY_OK:
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100474 if ((data != NULL) && (*data != NULL)) {
475 free(*data);
476 (*data) = NULL;
477 }
478 return create_ok();
Tomas Cejkac7929632013-10-24 19:25:15 +0200479 case NC_REPLY_DATA:
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100480 if (((*data) = nc_reply_get_data(reply)) == NULL) {
481 DEBUG("mod_netconf: no data from reply");
Tomas Cejkac7929632013-10-24 19:25:15 +0200482 return create_error("Internal: No data from reply received.");
483 } else {
484 return NULL;
485 }
486 break;
487 case NC_REPLY_ERROR:
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100488 DEBUG("mod_netconf: unexpected rpc-reply (%d)", replyt);
489 if (data != NULL) {
490 free(*data);
491 (*data) = NULL;
492 }
Tomas Cejkac7929632013-10-24 19:25:15 +0200493 return create_error(nc_reply_get_errormsg(reply));
494 default:
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100495 DEBUG("mod_netconf: unexpected rpc-reply (%d)", replyt);
496 if (data != NULL) {
497 free(*data);
498 (*data) = NULL;
499 }
Tomas Cejkac7929632013-10-24 19:25:15 +0200500 return create_error(nc_reply_get_errormsg(reply));
501 }
502 break;
503 default:
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100504 DEBUG("mod_netconf: unexpected reply message received (%d)", msgt);
505 if (data != NULL) {
506 free(*data);
507 (*data) = NULL;
508 }
Tomas Cejkac7929632013-10-24 19:25:15 +0200509 return create_error("Internal: Unexpected RPC-REPLY message type.");
510 }
511}
512
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100513json_object *netconf_unlocked_op(struct nc_session *session, nc_rpc* rpc)
Tomas Cejka6b886e02013-07-05 09:53:17 +0200514{
515 nc_reply* reply = NULL;
Tomas Cejka6b886e02013-07-05 09:53:17 +0200516 NC_MSG_TYPE msgt;
Tomas Cejka6b886e02013-07-05 09:53:17 +0200517
518 /* check requests */
519 if (rpc == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100520 DEBUG("mod_netconf: rpc is not created");
Tomas Cejkac7929632013-10-24 19:25:15 +0200521 return create_error("Internal error: RPC is not created");
Tomas Cejka6b886e02013-07-05 09:53:17 +0200522 }
523
524 if (session != NULL) {
525 /* send the request and get the reply */
526 msgt = nc_session_send_recv(session, rpc, &reply);
527 /* process the result of the operation */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100528 return netconf_test_reply(session, NULL, msgt, reply, NULL);
Tomas Cejka6b886e02013-07-05 09:53:17 +0200529 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100530 DEBUG("Unknown session to process.");
Tomas Cejkac7929632013-10-24 19:25:15 +0200531 return create_error("Internal error: Unknown session to process.");
Tomas Cejka6b886e02013-07-05 09:53:17 +0200532 }
533}
534
Tomas Cejkac7929632013-10-24 19:25:15 +0200535/**
536 * Perform RPC method that returns data.
537 *
Tomas Cejkac7929632013-10-24 19:25:15 +0200538 * \param[in] session_key session identifier
539 * \param[in] rpc RPC message to perform
540 * \param[out] received_data received data string, can be NULL when no data expected, value can be set to NULL if no data received
541 * \return NULL on success, json object with error otherwise
542 */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100543static json_object *netconf_op(const char* session_key, nc_rpc* rpc, char **received_data)
Radek Krejci469aab82012-07-22 18:42:20 +0200544{
545 struct nc_session *session = NULL;
David Kupka8e60a372012-09-04 09:15:20 +0200546 struct session_with_mutex * locked_session;
Tomas Cejka00635972013-06-03 15:10:52 +0200547 nc_reply* reply = NULL;
Tomas Cejkac7929632013-10-24 19:25:15 +0200548 json_object *res = NULL;
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100549 char *data = NULL;
Radek Krejcia332b692012-11-12 16:15:54 +0100550 NC_MSG_TYPE msgt;
Radek Krejci035bf4e2012-07-25 10:59:09 +0200551
Radek Krejci8e4632a2012-07-26 13:40:34 +0200552 /* check requests */
553 if (rpc == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100554 DEBUG("mod_netconf: rpc is not created");
Tomas Cejkac7929632013-10-24 19:25:15 +0200555 res = create_error("Internal: RPC could not be created.");
556 data = NULL;
557 goto finished;
Radek Krejci8e4632a2012-07-26 13:40:34 +0200558 }
559
David Kupka8e60a372012-09-04 09:15:20 +0200560 /* get non-exclusive (read) access to sessions_list (conns) */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100561 DEBUG("LOCK wrlock %s", __func__);
David Kupka8e60a372012-09-04 09:15:20 +0200562 if (pthread_rwlock_rdlock (&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100563 DEBUG("Error while locking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejkac7929632013-10-24 19:25:15 +0200564 res = create_error("Internal: Lock failed.");
565 data = NULL;
566 goto finished;
David Kupka8e60a372012-09-04 09:15:20 +0200567 }
Radek Krejci8e4632a2012-07-26 13:40:34 +0200568 /* get session where send the RPC */
Tomas Cejka47387fd2013-06-10 20:37:46 +0200569 locked_session = (struct session_with_mutex *)apr_hash_get(netconf_sessions_list, session_key, APR_HASH_KEY_STRING);
David Kupka8e60a372012-09-04 09:15:20 +0200570 if (locked_session != NULL) {
571 session = locked_session->session;
572 }
Radek Krejci035bf4e2012-07-25 10:59:09 +0200573 if (session != NULL) {
David Kupka8e60a372012-09-04 09:15:20 +0200574 /* get exclusive access to session */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100575 DEBUG("LOCK mutex %s", __func__);
David Kupka8e60a372012-09-04 09:15:20 +0200576 if (pthread_mutex_lock(&locked_session->lock) != 0) {
577 /* unlock before returning error */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100578 DEBUG("UNLOCK wrlock %s", __func__);
David Kupka8e60a372012-09-04 09:15:20 +0200579 if (pthread_rwlock_unlock (&session_lock) != 0) {
Tomas Cejkac7929632013-10-24 19:25:15 +0200580
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100581 DEBUG("Error while locking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejkac7929632013-10-24 19:25:15 +0200582 res = create_error("Internal: Could not unlock.");
583 goto finished;
David Kupka8e60a372012-09-04 09:15:20 +0200584 }
Tomas Cejkac7929632013-10-24 19:25:15 +0200585 res = create_error("Internal: Could not unlock.");
David Kupka8e60a372012-09-04 09:15:20 +0200586 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100587 DEBUG("UNLOCK wrlock %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +0200588 if (pthread_rwlock_unlock(&session_lock) != 0) {
Tomas Cejkac7929632013-10-24 19:25:15 +0200589
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100590 DEBUG("Error while locking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejkac7929632013-10-24 19:25:15 +0200591 res = create_error("Internal: Could not unlock.");
Tomas Cejka47387fd2013-06-10 20:37:46 +0200592 }
593
Tomas Cejkaaf7a1562013-04-13 02:27:43 +0200594 locked_session->last_activity = apr_time_now();
Tomas Cejkac7929632013-10-24 19:25:15 +0200595
Radek Krejci035bf4e2012-07-25 10:59:09 +0200596 /* send the request and get the reply */
Radek Krejcia332b692012-11-12 16:15:54 +0100597 msgt = nc_session_send_recv(session, rpc, &reply);
598
David Kupka8e60a372012-09-04 09:15:20 +0200599 /* first release exclusive lock for this session */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100600 DEBUG("UNLOCK mutex %s", __func__);
David Kupka8e60a372012-09-04 09:15:20 +0200601 pthread_mutex_unlock(&locked_session->lock);
602 /* end of critical section */
Radek Krejci035bf4e2012-07-25 10:59:09 +0200603
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100604 res = netconf_test_reply(session, session_key, msgt, reply, &data);
Radek Krejci035bf4e2012-07-25 10:59:09 +0200605 } else {
Tomas Cejkabcdc1142012-11-14 01:12:43 +0100606 /* release lock on failure */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100607 DEBUG("UNLOCK wrlock %s", __func__);
Tomas Cejkabcdc1142012-11-14 01:12:43 +0100608 if (pthread_rwlock_unlock (&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100609 DEBUG("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejkabcdc1142012-11-14 01:12:43 +0100610 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100611 DEBUG("Unknown session to process.");
Tomas Cejkac7929632013-10-24 19:25:15 +0200612 res = create_error("Unknown session to process.");
613 data = NULL;
Radek Krejci035bf4e2012-07-25 10:59:09 +0200614 }
Tomas Cejkac7929632013-10-24 19:25:15 +0200615finished:
616 nc_reply_free(reply);
617 if (received_data != NULL) {
618 (*received_data) = data;
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100619 } else {
620 if (data != NULL) {
621 free(data);
622 data = NULL;
623 }
Radek Krejci8e4632a2012-07-26 13:40:34 +0200624 }
Tomas Cejkac7929632013-10-24 19:25:15 +0200625 return res;
Radek Krejci8e4632a2012-07-26 13:40:34 +0200626}
627
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100628static char* netconf_getconfig(const char* session_key, NC_DATASTORE source, const char* filter, json_object **err)
Radek Krejci8e4632a2012-07-26 13:40:34 +0200629{
630 nc_rpc* rpc;
631 struct nc_filter *f = NULL;
632 char* data = NULL;
Tomas Cejkac7929632013-10-24 19:25:15 +0200633 json_object *res = NULL;
Radek Krejci8e4632a2012-07-26 13:40:34 +0200634
635 /* create filter if set */
636 if (filter != NULL) {
637 f = nc_filter_new(NC_FILTER_SUBTREE, filter);
638 }
639
640 /* create requests */
Tomas Cejka5064c232013-01-17 09:30:58 +0100641 rpc = nc_rpc_getconfig (source, f);
Radek Krejci8e4632a2012-07-26 13:40:34 +0200642 nc_filter_free(f);
643 if (rpc == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100644 DEBUG("mod_netconf: creating rpc request failed");
Radek Krejci8e4632a2012-07-26 13:40:34 +0200645 return (NULL);
646 }
647
Tomas Cejka94674662013-09-13 15:55:24 +0200648 /* tell server to show all elements even if they have default values */
649 if (nc_rpc_capability_attr(rpc, NC_CAP_ATTR_WITHDEFAULTS_MODE, NCWD_MODE_ALL)) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100650 DEBUG("mod_netconf: setting withdefaults failed");
Tomas Cejka94674662013-09-13 15:55:24 +0200651 }
652
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100653 res = netconf_op(session_key, rpc, &data);
Radek Krejci8e4632a2012-07-26 13:40:34 +0200654 nc_rpc_free (rpc);
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100655 if (res != NULL) {
656 (*err) = res;
657 } else {
658 (*err) = NULL;
Tomas Cejkac7929632013-10-24 19:25:15 +0200659 }
660
Radek Krejci8e4632a2012-07-26 13:40:34 +0200661 return (data);
662}
663
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100664static char* netconf_getschema(const char* session_key, const char* identifier, const char* version, const char* format, json_object **err)
Tomas Cejka0aeca8b2012-12-22 19:56:03 +0100665{
666 nc_rpc* rpc;
667 char* data = NULL;
Tomas Cejkac7929632013-10-24 19:25:15 +0200668 json_object *res = NULL;
Tomas Cejka0aeca8b2012-12-22 19:56:03 +0100669
670 /* create requests */
Tomas Cejka94da2c52013-01-08 18:20:30 +0100671 rpc = nc_rpc_getschema(identifier, version, format);
Tomas Cejka0aeca8b2012-12-22 19:56:03 +0100672 if (rpc == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100673 DEBUG("mod_netconf: creating rpc request failed");
Tomas Cejka0aeca8b2012-12-22 19:56:03 +0100674 return (NULL);
675 }
676
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100677 res = netconf_op(session_key, rpc, &data);
Tomas Cejka0aeca8b2012-12-22 19:56:03 +0100678 nc_rpc_free (rpc);
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100679 if (res != NULL) {
680 (*err) = res;
681 } else {
682 (*err) = NULL;
Tomas Cejkac7929632013-10-24 19:25:15 +0200683 }
684
Tomas Cejka0aeca8b2012-12-22 19:56:03 +0100685 return (data);
686}
687
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100688static char* netconf_get(const char* session_key, const char* filter, json_object **err)
Radek Krejci8e4632a2012-07-26 13:40:34 +0200689{
690 nc_rpc* rpc;
691 struct nc_filter *f = NULL;
692 char* data = NULL;
Tomas Cejkac7929632013-10-24 19:25:15 +0200693 json_object *res = NULL;
Radek Krejci8e4632a2012-07-26 13:40:34 +0200694
695 /* create filter if set */
696 if (filter != NULL) {
697 f = nc_filter_new(NC_FILTER_SUBTREE, filter);
698 }
699
700 /* create requests */
Tomas Cejka5064c232013-01-17 09:30:58 +0100701 rpc = nc_rpc_get (f);
Radek Krejci8e4632a2012-07-26 13:40:34 +0200702 nc_filter_free(f);
703 if (rpc == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100704 DEBUG("mod_netconf: creating rpc request failed");
Radek Krejci8e4632a2012-07-26 13:40:34 +0200705 return (NULL);
706 }
707
Tomas Cejka94674662013-09-13 15:55:24 +0200708 /* tell server to show all elements even if they have default values */
709 if (nc_rpc_capability_attr(rpc, NC_CAP_ATTR_WITHDEFAULTS_MODE, NCWD_MODE_ALL)) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100710 DEBUG("mod_netconf: setting withdefaults failed");
Tomas Cejka94674662013-09-13 15:55:24 +0200711 }
712
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100713 res = netconf_op(session_key, rpc, &data);
Radek Krejci8e4632a2012-07-26 13:40:34 +0200714 nc_rpc_free (rpc);
Tomas Cejkac7929632013-10-24 19:25:15 +0200715 if (res == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100716 (*err) = res;
717 } else {
718 (*err) = NULL;
Tomas Cejkac7929632013-10-24 19:25:15 +0200719 }
720
Radek Krejci8e4632a2012-07-26 13:40:34 +0200721 return (data);
722}
723
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100724static json_object *netconf_copyconfig(const char* session_key, NC_DATASTORE source, NC_DATASTORE target, const char* config, const char *url)
Radek Krejci8e4632a2012-07-26 13:40:34 +0200725{
726 nc_rpc* rpc;
Tomas Cejkac7929632013-10-24 19:25:15 +0200727 json_object *res = NULL;
Radek Krejci8e4632a2012-07-26 13:40:34 +0200728
729 /* create requests */
Tomas Cejka5064c232013-01-17 09:30:58 +0100730 if ((source == NC_DATASTORE_CONFIG) || (source == NC_DATASTORE_URL)) {
731 if (target == NC_DATASTORE_URL) {
732 rpc = nc_rpc_copyconfig(source, target, config, url);
733 } else {
734 rpc = nc_rpc_copyconfig(source, target, config);
735 }
736 } else {
737 if (target == NC_DATASTORE_URL) {
738 rpc = nc_rpc_copyconfig(source, target, url);
739 } else {
740 rpc = nc_rpc_copyconfig(source, target);
741 }
742 }
Radek Krejci8e4632a2012-07-26 13:40:34 +0200743 if (rpc == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100744 DEBUG("mod_netconf: creating rpc request failed");
Tomas Cejkac7929632013-10-24 19:25:15 +0200745 return create_error("Internal: Creating rpc request failed");
Radek Krejci8e4632a2012-07-26 13:40:34 +0200746 }
747
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100748 res = netconf_op(session_key, rpc, NULL);
Radek Krejci8e4632a2012-07-26 13:40:34 +0200749 nc_rpc_free (rpc);
Tomas Cejkac7929632013-10-24 19:25:15 +0200750
751 return res;
Radek Krejci8e4632a2012-07-26 13:40:34 +0200752}
Radek Krejci035bf4e2012-07-25 10:59:09 +0200753
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100754static json_object *netconf_editconfig(const char* session_key, NC_DATASTORE target, NC_EDIT_DEFOP_TYPE defop, NC_EDIT_ERROPT_TYPE erropt, NC_EDIT_TESTOPT_TYPE testopt, const char* config)
Radek Krejci62ab34b2012-07-26 13:42:05 +0200755{
756 nc_rpc* rpc;
Tomas Cejkac7929632013-10-24 19:25:15 +0200757 json_object *res = NULL;
Radek Krejci62ab34b2012-07-26 13:42:05 +0200758
759 /* create requests */
Tomas Cejka5064c232013-01-17 09:30:58 +0100760 /* TODO source NC_DATASTORE_CONFIG / NC_DATASTORE_URL */
761 rpc = nc_rpc_editconfig(target, NC_DATASTORE_CONFIG, defop, erropt, testopt, config);
Radek Krejci62ab34b2012-07-26 13:42:05 +0200762 if (rpc == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100763 DEBUG("mod_netconf: creating rpc request failed");
Tomas Cejkac7929632013-10-24 19:25:15 +0200764 return create_error("Internal: Creating rpc request failed");
Radek Krejci62ab34b2012-07-26 13:42:05 +0200765 }
766
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100767 res = netconf_op(session_key, rpc, NULL);
Radek Krejci62ab34b2012-07-26 13:42:05 +0200768 nc_rpc_free (rpc);
Tomas Cejkac7929632013-10-24 19:25:15 +0200769
770 return res;
Radek Krejci62ab34b2012-07-26 13:42:05 +0200771}
772
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100773static json_object *netconf_killsession(const char* session_key, const char* sid)
Radek Krejcie34d3eb2012-07-26 15:05:53 +0200774{
775 nc_rpc* rpc;
Tomas Cejkac7929632013-10-24 19:25:15 +0200776 json_object *res = NULL;
Radek Krejcie34d3eb2012-07-26 15:05:53 +0200777
778 /* create requests */
779 rpc = nc_rpc_killsession(sid);
780 if (rpc == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100781 DEBUG("mod_netconf: creating rpc request failed");
Tomas Cejkac7929632013-10-24 19:25:15 +0200782 return create_error("Internal: Creating rpc request failed");
Radek Krejcie34d3eb2012-07-26 15:05:53 +0200783 }
784
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100785 res = netconf_op(session_key, rpc, NULL);
Radek Krejcie34d3eb2012-07-26 15:05:53 +0200786 nc_rpc_free (rpc);
Tomas Cejkac7929632013-10-24 19:25:15 +0200787 return res;
Radek Krejcie34d3eb2012-07-26 15:05:53 +0200788}
789
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100790static json_object *netconf_onlytargetop(const char* session_key, NC_DATASTORE target, nc_rpc* (*op_func)(NC_DATASTORE))
Radek Krejci2f318372012-07-26 14:22:35 +0200791{
792 nc_rpc* rpc;
Tomas Cejkac7929632013-10-24 19:25:15 +0200793 json_object *res = NULL;
Radek Krejci2f318372012-07-26 14:22:35 +0200794
795 /* create requests */
Radek Krejci5cd7d422012-07-26 14:50:29 +0200796 rpc = op_func(target);
Radek Krejci2f318372012-07-26 14:22:35 +0200797 if (rpc == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100798 DEBUG("mod_netconf: creating rpc request failed");
Tomas Cejkac7929632013-10-24 19:25:15 +0200799 return create_error("Internal: Creating rpc request failed");
Radek Krejci2f318372012-07-26 14:22:35 +0200800 }
801
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100802 res = netconf_op(session_key, rpc, NULL);
Radek Krejci2f318372012-07-26 14:22:35 +0200803 nc_rpc_free (rpc);
Tomas Cejkac7929632013-10-24 19:25:15 +0200804 return res;
Radek Krejci2f318372012-07-26 14:22:35 +0200805}
806
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100807static json_object *netconf_deleteconfig(const char* session_key, NC_DATASTORE target, const char *url)
Radek Krejci5cd7d422012-07-26 14:50:29 +0200808{
Tomas Cejka404d37e2013-04-13 02:31:35 +0200809 nc_rpc *rpc = NULL;
Tomas Cejkac7929632013-10-24 19:25:15 +0200810 json_object *res = NULL;
Tomas Cejka404d37e2013-04-13 02:31:35 +0200811 if (target != NC_DATASTORE_URL) {
812 rpc = nc_rpc_deleteconfig(target);
813 } else {
Tomas Cejkac7929632013-10-24 19:25:15 +0200814 rpc = nc_rpc_deleteconfig(target, url);
815 }
816 if (rpc == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100817 DEBUG("mod_netconf: creating rpc request failed");
Tomas Cejkac7929632013-10-24 19:25:15 +0200818 return create_error("Internal: Creating rpc request failed");
Tomas Cejka404d37e2013-04-13 02:31:35 +0200819 }
820
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100821 res = netconf_op(session_key, rpc, NULL);
Tomas Cejkac7929632013-10-24 19:25:15 +0200822 nc_rpc_free (rpc);
823 return res;
Radek Krejci5cd7d422012-07-26 14:50:29 +0200824}
825
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100826static json_object *netconf_lock(const char* session_key, NC_DATASTORE target)
Radek Krejci5cd7d422012-07-26 14:50:29 +0200827{
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100828 return (netconf_onlytargetop(session_key, target, nc_rpc_lock));
Radek Krejci5cd7d422012-07-26 14:50:29 +0200829}
830
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100831static json_object *netconf_unlock(const char* session_key, NC_DATASTORE target)
Radek Krejci5cd7d422012-07-26 14:50:29 +0200832{
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100833 return (netconf_onlytargetop(session_key, target, nc_rpc_unlock));
Radek Krejci5cd7d422012-07-26 14:50:29 +0200834}
835
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100836static json_object *netconf_generic(const char* session_key, const char* content, char** data)
Radek Krejci80c10d92012-07-30 08:38:50 +0200837{
Tomas Cejka00635972013-06-03 15:10:52 +0200838 nc_rpc* rpc = NULL;
Tomas Cejkac7929632013-10-24 19:25:15 +0200839 json_object *res = NULL;
Radek Krejci80c10d92012-07-30 08:38:50 +0200840
841 /* create requests */
842 rpc = nc_rpc_generic(content);
843 if (rpc == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100844 DEBUG("mod_netconf: creating rpc request failed");
Tomas Cejkac7929632013-10-24 19:25:15 +0200845 return create_error("Internal: Creating rpc request failed");
Radek Krejci80c10d92012-07-30 08:38:50 +0200846 }
847
Radek Krejcia332b692012-11-12 16:15:54 +0100848 if (data != NULL) {
Tomas Cejkac7929632013-10-24 19:25:15 +0200849 // TODO ?free(*data);
850 (*data) = NULL;
Radek Krejcia332b692012-11-12 16:15:54 +0100851 }
Radek Krejci80c10d92012-07-30 08:38:50 +0200852
853 /* get session where send the RPC */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100854 res = netconf_op(session_key, rpc, data);
Tomas Cejkac7929632013-10-24 19:25:15 +0200855 nc_rpc_free (rpc);
856 return res;
Radek Krejci80c10d92012-07-30 08:38:50 +0200857}
858
Tomas Cejka0a4bba82013-04-19 11:51:28 +0200859/**
860 * @}
861 *//* netconf_operations */
862
Radek Krejci7338bde2012-08-10 12:57:30 +0200863void clb_print(NC_VERB_LEVEL level, const char* msg)
Radek Krejci469aab82012-07-22 18:42:20 +0200864{
Radek Krejci7338bde2012-08-10 12:57:30 +0200865 switch (level) {
866 case NC_VERB_ERROR:
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100867 DEBUG("%s", msg);
Radek Krejci7338bde2012-08-10 12:57:30 +0200868 break;
869 case NC_VERB_WARNING:
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100870 DEBUG("%s", msg);
Radek Krejci7338bde2012-08-10 12:57:30 +0200871 break;
872 case NC_VERB_VERBOSE:
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100873 DEBUG("%s", msg);
Radek Krejci7338bde2012-08-10 12:57:30 +0200874 break;
875 case NC_VERB_DEBUG:
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100876 DEBUG("%s", msg);
Radek Krejci7338bde2012-08-10 12:57:30 +0200877 break;
878 }
Radek Krejci469aab82012-07-22 18:42:20 +0200879}
880
Tomas Cejka64b87482013-06-03 16:30:53 +0200881/**
Tomas Cejka6e8f4262013-07-10 09:20:19 +0200882 * Receive message from client over UNIX socket and return pointer to it.
Tomas Cejka64b87482013-06-03 16:30:53 +0200883 * Caller should free message memory.
884 * \param[in] client socket descriptor of client
Tomas Cejka64b87482013-06-03 16:30:53 +0200885 * \return pointer to message
886 */
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100887char *get_framed_message(int client)
Tomas Cejka64b87482013-06-03 16:30:53 +0200888{
889 /* read json in chunked framing */
890 unsigned int buffer_size = 0;
891 ssize_t buffer_len = 0;
892 char *buffer = NULL;
893 char c;
894 ssize_t ret;
895 int i, chunk_len;
896 char chunk_len_str[12];
897
898 while (1) {
899 /* read chunk length */
900 if ((ret = recv (client, &c, 1, 0)) != 1 || c != '\n') {
901 if (buffer != NULL) {
902 free (buffer);
903 buffer = NULL;
904 }
905 break;
906 }
907 if ((ret = recv (client, &c, 1, 0)) != 1 || c != '#') {
908 if (buffer != NULL) {
909 free (buffer);
910 buffer = NULL;
911 }
912 break;
913 }
914 i=0;
915 memset (chunk_len_str, 0, 12);
916 while ((ret = recv (client, &c, 1, 0) == 1 && (isdigit(c) || c == '#'))) {
917 if (i==0 && c == '#') {
918 if (recv (client, &c, 1, 0) != 1 || c != '\n') {
919 /* end but invalid */
920 if (buffer != NULL) {
921 free (buffer);
922 buffer = NULL;
923 }
924 }
925 /* end of message, double-loop break */
926 goto msg_complete;
927 }
928 chunk_len_str[i++] = c;
929 if (i==11) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100930 DEBUG("Message is too long, buffer for length is not big enought!!!!");
Tomas Cejka64b87482013-06-03 16:30:53 +0200931 break;
932 }
933 }
934 if (c != '\n') {
935 if (buffer != NULL) {
936 free (buffer);
937 buffer = NULL;
938 }
939 break;
940 }
941 chunk_len_str[i] = 0;
942 if ((chunk_len = atoi (chunk_len_str)) == 0) {
943 if (buffer != NULL) {
944 free (buffer);
945 buffer = NULL;
946 }
947 break;
948 }
949 buffer_size += chunk_len+1;
950 buffer = realloc (buffer, sizeof(char)*buffer_size);
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100951 memset(buffer + (buffer_size-chunk_len-1), 0, chunk_len+1);
Tomas Cejka64b87482013-06-03 16:30:53 +0200952 if ((ret = recv (client, buffer+buffer_len, chunk_len, 0)) == -1 || ret != chunk_len) {
953 if (buffer != NULL) {
954 free (buffer);
955 buffer = NULL;
956 }
957 break;
958 }
959 buffer_len += ret;
960 }
961msg_complete:
962 return buffer;
963}
964
Tomas Cejkad5b53772013-06-08 23:01:07 +0200965NC_DATASTORE parse_datastore(const char *ds)
966{
967 if (strcmp(ds, "running") == 0) {
968 return NC_DATASTORE_RUNNING;
969 } else if (strcmp(ds, "startup") == 0) {
970 return NC_DATASTORE_STARTUP;
971 } else if (strcmp(ds, "candidate") == 0) {
972 return NC_DATASTORE_CANDIDATE;
Tomas Cejka4003a702013-10-01 00:02:45 +0200973 } else if (strcmp(ds, "url") == 0) {
974 return NC_DATASTORE_URL;
Tomas Cejkad5b53772013-06-08 23:01:07 +0200975 }
976 return -1;
977}
978
979json_object *create_error(const char *errmess)
980{
981 json_object *reply = json_object_new_object();
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100982 json_object *array = json_object_new_array();
Tomas Cejkad5b53772013-06-08 23:01:07 +0200983 json_object_object_add(reply, "type", json_object_new_int(REPLY_ERROR));
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100984 json_object_array_add(array, json_object_new_string(errmess));
985 json_object_object_add(reply, "errors", array);
Tomas Cejkad5b53772013-06-08 23:01:07 +0200986 return reply;
987
988}
989
990json_object *create_data(const char *data)
991{
992 json_object *reply = json_object_new_object();
993 json_object_object_add(reply, "type", json_object_new_int(REPLY_DATA));
994 json_object_object_add(reply, "data", json_object_new_string(data));
995 return reply;
996}
997
Tomas Cejkaef531ee2013-11-12 16:07:00 +0100998json_object *create_ok()
999{
1000 json_object *reply = json_object_new_object();
1001 reply = json_object_new_object();
1002 json_object_object_add(reply, "type", json_object_new_int(REPLY_OK));
1003 return reply;
1004}
1005
1006json_object *handle_op_connect(apr_pool_t *pool, json_object *request)
Tomas Cejkad5b53772013-06-08 23:01:07 +02001007{
1008 const char *host = NULL;
1009 const char *port = NULL;
1010 const char *user = NULL;
1011 const char *pass = NULL;
1012 json_object *capabilities = NULL;
1013 json_object *reply = NULL;
1014 char *session_key_hash = NULL;
1015 struct nc_cpblts* cpblts = NULL;
1016 unsigned int len, i;
1017
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001018 DEBUG("Request: Connect");
Tomas Cejkad5b53772013-06-08 23:01:07 +02001019 host = json_object_get_string(json_object_object_get((json_object *) request, "host"));
1020 port = json_object_get_string(json_object_object_get((json_object *) request, "port"));
1021 user = json_object_get_string(json_object_object_get((json_object *) request, "user"));
1022 pass = json_object_get_string(json_object_object_get((json_object *) request, "pass"));
1023
1024 capabilities = json_object_object_get((json_object *) request, "capabilities");
1025 if ((capabilities != NULL) && ((len = json_object_array_length(capabilities)) > 0)) {
1026 cpblts = nc_cpblts_new(NULL);
1027 for (i=0; i<len; i++) {
1028 nc_cpblts_add(cpblts, json_object_get_string(json_object_array_get_idx(capabilities, i)));
1029 }
1030 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001031 DEBUG("no capabilities specified");
Tomas Cejkad5b53772013-06-08 23:01:07 +02001032 }
1033
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001034 DEBUG("host: %s, port: %s, user: %s", host, port, user);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001035 if ((host == NULL) || (user == NULL)) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001036 DEBUG("Cannot connect - insufficient input.");
Tomas Cejkad5b53772013-06-08 23:01:07 +02001037 session_key_hash = NULL;
1038 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001039 session_key_hash = netconf_connect(pool, host, port, user, pass, cpblts);
1040 DEBUG("hash: %s", session_key_hash);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001041 }
1042 if (cpblts != NULL) {
1043 nc_cpblts_free(cpblts);
1044 }
1045
1046 if (session_key_hash == NULL) {
1047 /* negative reply */
1048 if (err_reply == NULL) {
1049 reply = json_object_new_object();
1050 json_object_object_add(reply, "type", json_object_new_int(REPLY_ERROR));
1051 json_object_object_add(reply, "error-message", json_object_new_string("Connecting NETCONF server failed."));
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001052 DEBUG("Connection failed.");
Tomas Cejkad5b53772013-06-08 23:01:07 +02001053 } else {
1054 /* use filled err_reply from libnetconf's callback */
1055 reply = err_reply;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001056 DEBUG("Connect - error from libnetconf's callback.");
Tomas Cejkad5b53772013-06-08 23:01:07 +02001057 }
1058 } else {
1059 /* positive reply */
1060 reply = json_object_new_object();
1061 json_object_object_add(reply, "type", json_object_new_int(REPLY_OK));
1062 json_object_object_add(reply, "session", json_object_new_string(session_key_hash));
1063
1064 free(session_key_hash);
1065 }
1066 return reply;
1067}
1068
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001069json_object *handle_op_get(apr_pool_t *pool, json_object *request, const char *session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02001070{
1071 const char *filter = NULL;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001072 char *data = NULL;
Tomas Cejkad5b53772013-06-08 23:01:07 +02001073 json_object *reply = NULL;
1074
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001075 DEBUG("Request: get (session %s)", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001076
1077 filter = json_object_get_string(json_object_object_get(request, "filter"));
1078
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001079 if ((data = netconf_get(session_key, filter, &reply)) == NULL) {
1080 if (reply == NULL) {
1081 if (err_reply == NULL) {
1082 reply = create_error("Get information failed.");
1083 } else {
1084 /* use filled err_reply from libnetconf's callback */
1085 reply = err_reply;
1086 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02001087 }
1088 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001089 reply = create_data(data);
1090 free(data);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001091 }
1092 return reply;
1093}
1094
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001095json_object *handle_op_getconfig(apr_pool_t *pool, json_object *request, const char *session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02001096{
1097 NC_DATASTORE ds_type_s = -1;
1098 NC_DATASTORE ds_type_t = -1;
1099 const char *filter = NULL;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001100 char *data = NULL;
Tomas Cejkad5b53772013-06-08 23:01:07 +02001101 const char *source = NULL;
1102 const char *target = NULL;
1103 json_object *reply = NULL;
1104
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001105 DEBUG("Request: get-config (session %s)", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001106
1107 filter = json_object_get_string(json_object_object_get(request, "filter"));
1108
1109 /* get parameters */
1110 if ((target = json_object_get_string(json_object_object_get(request, "target"))) != NULL) {
1111 ds_type_t = parse_datastore(target);
1112 }
1113 if ((source = json_object_get_string(json_object_object_get(request, "source"))) != NULL) {
1114 ds_type_s = parse_datastore(source);
1115 }
1116 if (ds_type_s == -1) {
1117 return create_error("Invalid source repository type requested.");
1118 }
1119
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001120 if ((data = netconf_getconfig(session_key, ds_type_s, filter, &reply)) == NULL) {
1121 if (reply == NULL) {
1122 if (err_reply == NULL) {
1123 reply = create_error("Get configuration operation failed.");
1124 } else {
1125 /* use filled err_reply from libnetconf's callback */
1126 reply = err_reply;
1127 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02001128 }
1129 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001130 reply = create_data(data);
1131 free(data);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001132 }
1133 return reply;
1134}
1135
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001136json_object *handle_op_getschema(apr_pool_t *pool, json_object *request, const char *session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02001137{
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001138 char *data = NULL;
Tomas Cejkad5b53772013-06-08 23:01:07 +02001139 const char *identifier = NULL;
1140 const char *version = NULL;
1141 const char *format = NULL;
1142 json_object *reply = NULL;
1143
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001144 DEBUG("Request: get-schema (session %s)", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001145 identifier = json_object_get_string(json_object_object_get(request, "identifier"));
1146 if (identifier == NULL) {
1147 return create_error("No identifier for get-schema supplied.");
1148 }
1149 version = json_object_get_string(json_object_object_get(request, "version"));
1150 format = json_object_get_string(json_object_object_get(request, "format"));
1151
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001152 DEBUG("get-schema(version: %s, format: %s)", version, format);
1153 if ((data = netconf_getschema(session_key, identifier, version, format, &reply)) == NULL) {
1154 if (reply == NULL) {
1155 if (err_reply == NULL) {
1156 reply = create_error("Get models operation failed.");
1157 } else {
1158 /* use filled err_reply from libnetconf's callback */
1159 reply = err_reply;
1160 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02001161 }
1162 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001163 reply = create_data(data);
1164 free(data);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001165 }
1166 return reply;
1167}
1168
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001169json_object *handle_op_editconfig(apr_pool_t *pool, json_object *request, const char *session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02001170{
1171 NC_DATASTORE ds_type_s = -1;
1172 NC_DATASTORE ds_type_t = -1;
1173 NC_EDIT_DEFOP_TYPE defop_type = NC_EDIT_DEFOP_NOTSET;
1174 NC_EDIT_ERROPT_TYPE erropt_type = 0;
1175 const char *defop = NULL;
1176 const char *erropt = NULL;
1177 const char *config = NULL;
1178 const char *source = NULL;
1179 const char *target = NULL;
1180 json_object *reply = NULL;
1181
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001182 DEBUG("Request: edit-config (session %s)", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001183
1184 defop = json_object_get_string(json_object_object_get(request, "default-operation"));
1185 if (defop != NULL) {
1186 if (strcmp(defop, "merge") == 0) {
1187 defop_type = NC_EDIT_DEFOP_MERGE;
1188 } else if (strcmp(defop, "replace") == 0) {
1189 defop_type = NC_EDIT_DEFOP_REPLACE;
1190 } else if (strcmp(defop, "none") == 0) {
1191 defop_type = NC_EDIT_DEFOP_NONE;
1192 } else {
1193 return create_error("Invalid default-operation parameter.");
1194 }
1195 } else {
1196 defop_type = NC_EDIT_DEFOP_NOTSET;
1197 }
1198
1199 erropt = json_object_get_string(json_object_object_get(request, "error-option"));
1200 if (erropt != NULL) {
1201 if (strcmp(erropt, "continue-on-error") == 0) {
1202 erropt_type = NC_EDIT_ERROPT_CONT;
1203 } else if (strcmp(erropt, "stop-on-error") == 0) {
1204 erropt_type = NC_EDIT_ERROPT_STOP;
1205 } else if (strcmp(erropt, "rollback-on-error") == 0) {
1206 erropt_type = NC_EDIT_ERROPT_ROLLBACK;
1207 } else {
1208 return create_error("Invalid error-option parameter.");
1209 }
1210 } else {
1211 erropt_type = 0;
1212 }
1213
1214 /* get parameters */
1215 if ((target = json_object_get_string(json_object_object_get(request, "target"))) != NULL) {
1216 ds_type_t = parse_datastore(target);
1217 }
1218 if ((source = json_object_get_string(json_object_object_get(request, "source"))) != NULL) {
1219 ds_type_s = parse_datastore(source);
1220 }
1221 if (ds_type_t == -1) {
1222 return create_error("Invalid target repository type requested.");
1223 }
1224
1225 config = json_object_get_string(json_object_object_get(request, "config"));
1226 if (config == NULL) {
1227 return create_error("Invalid config data parameter.");
1228 }
1229
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001230 reply = netconf_editconfig(session_key, ds_type_t, defop_type, erropt_type, NC_EDIT_TESTOPT_TESTSET, config);
1231 if (reply == NULL) {
1232 if (err_reply != NULL) {
Tomas Cejkad5b53772013-06-08 23:01:07 +02001233 /* use filled err_reply from libnetconf's callback */
1234 reply = err_reply;
1235 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02001236 }
1237 return reply;
1238}
1239
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001240json_object *handle_op_copyconfig(apr_pool_t *pool, json_object *request, const char *session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02001241{
1242 NC_DATASTORE ds_type_s = -1;
1243 NC_DATASTORE ds_type_t = -1;
1244 const char *config = NULL;
1245 const char *target = NULL;
1246 const char *source = NULL;
1247 json_object *reply = NULL;
1248
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001249 DEBUG("Request: copy-config (session %s)", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001250
1251 /* get parameters */
1252 if ((target = json_object_get_string(json_object_object_get(request, "target"))) != NULL) {
1253 ds_type_t = parse_datastore(target);
1254 }
1255 if ((source = json_object_get_string(json_object_object_get(request, "source"))) != NULL) {
1256 ds_type_s = parse_datastore(source);
1257 }
1258 if (source == NULL) {
1259 /* no explicit source specified -> use config data */
1260 ds_type_s = NC_DATASTORE_CONFIG;
1261 config = json_object_get_string(json_object_object_get(request, "config"));
1262 } else if (ds_type_s == -1) {
1263 /* source datastore specified, but it is invalid */
1264 return create_error("Invalid source repository type requested.");
1265 }
1266
1267 if (ds_type_t == -1) {
1268 /* invalid target datastore specified */
1269 return create_error("Invalid target repository type requested.");
1270 }
1271
1272 if (source == NULL && config == NULL) {
1273 reply = create_error("invalid input parameters - one of source and config is required.");
1274 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001275 reply = netconf_copyconfig(session_key, ds_type_s, ds_type_t, config, "");
1276 if (reply == NULL) {
1277 if (err_reply != NULL) {
Tomas Cejkad5b53772013-06-08 23:01:07 +02001278 /* use filled err_reply from libnetconf's callback */
1279 reply = err_reply;
1280 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02001281 }
1282 }
1283 return reply;
1284}
1285
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001286json_object *handle_op_generic(apr_pool_t *pool, json_object *request, const char *session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02001287{
1288 json_object *reply = NULL;
1289 const char *config = NULL;
1290 char *data = NULL;
1291
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001292 DEBUG("Request: generic request for session %s", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001293
1294 config = json_object_get_string(json_object_object_get(request, "content"));
1295
1296 if (config == NULL) {
1297 return create_error("Missing content parameter.");
1298 }
1299
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001300 /* TODO */
1301 reply = netconf_generic(session_key, config, &data);
1302 if (reply == NULL) {
1303 if (err_reply != NULL) {
Tomas Cejkad5b53772013-06-08 23:01:07 +02001304 /* use filled err_reply from libnetconf's callback */
1305 reply = err_reply;
1306 }
1307 } else {
1308 if (data == NULL) {
1309 reply = json_object_new_object();
1310 json_object_object_add(reply, "type", json_object_new_int(REPLY_OK));
1311 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001312 reply = create_data(data);
1313 free(data);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001314 }
1315 }
1316 return reply;
1317}
1318
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001319json_object *handle_op_disconnect(apr_pool_t *pool, json_object *request, const char *session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02001320{
1321 json_object *reply = NULL;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001322 DEBUG("Request: Disconnect session %s", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001323
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001324 if (netconf_close(session_key, &reply) != EXIT_SUCCESS) {
1325 if (reply == NULL) {
1326 if (err_reply == NULL) {
1327 reply = create_error("Get configuration information from device failed.");
1328 } else {
1329 /* use filled err_reply from libnetconf's callback */
1330 reply = err_reply;
1331 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02001332 }
1333 } else {
1334 reply = json_object_new_object();
1335 json_object_object_add(reply, "type", json_object_new_int(REPLY_OK));
1336 }
1337 return reply;
1338}
1339
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001340json_object *handle_op_kill(apr_pool_t *pool, json_object *request, const char *session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02001341{
1342 json_object *reply = NULL;
1343 const char *sid = NULL;
1344
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001345 DEBUG("Request: kill-session, session %s", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001346
1347 sid = json_object_get_string(json_object_object_get(request, "session-id"));
1348
1349 if (sid == NULL) {
1350 return create_error("Missing session-id parameter.");
1351 }
1352
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001353 reply = netconf_killsession(session_key, sid);
1354 if (reply == NULL) {
1355 if (err_reply != NULL) {
Tomas Cejkad5b53772013-06-08 23:01:07 +02001356 /* use filled err_reply from libnetconf's callback */
1357 reply = err_reply;
1358 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02001359 }
1360 return reply;
1361}
1362
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001363json_object *handle_op_reloadhello(apr_pool_t *pool, json_object *request, const char *session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02001364{
Tomas Cejka47387fd2013-06-10 20:37:46 +02001365 struct nc_session *temp_session = NULL;
Tomas Cejkad5b53772013-06-08 23:01:07 +02001366 struct session_with_mutex * locked_session = NULL;
1367 json_object *reply = NULL;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001368 DEBUG("Request: get info about session %s", session_key);
1369 return create_ok();
Tomas Cejkad5b53772013-06-08 23:01:07 +02001370
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001371 DEBUG("LOCK wrlock %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001372 if (pthread_rwlock_rdlock(&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001373 DEBUG("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejka47387fd2013-06-10 20:37:46 +02001374 return NULL;
1375 }
1376
Tomas Cejkad5b53772013-06-08 23:01:07 +02001377 locked_session = (struct session_with_mutex *)apr_hash_get(netconf_sessions_list, session_key, APR_HASH_KEY_STRING);
1378 if ((locked_session != NULL) && (locked_session->hello_message != NULL)) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001379 DEBUG("LOCK mutex %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001380 pthread_mutex_lock(&locked_session->lock);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001381 DEBUG("UNLOCK wrlock %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001382 if (pthread_rwlock_unlock(&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001383 DEBUG("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejka47387fd2013-06-10 20:37:46 +02001384 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001385 DEBUG("creating temporal NC session.");
Tomas Cejka47387fd2013-06-10 20:37:46 +02001386 temp_session = nc_session_connect_channel(locked_session->session, NULL);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001387 if (temp_session != NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001388 prepare_status_message(locked_session, temp_session);
1389 DEBUG("closing temporal NC session.");
Tomas Cejkaaecc5f72013-10-01 00:03:50 +02001390 nc_session_free(temp_session);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001391 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001392 DEBUG("Reload hello failed due to channel establishment");
Tomas Cejkad5b53772013-06-08 23:01:07 +02001393 reply = create_error("Reload was unsuccessful, connection failed.");
1394 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001395 DEBUG("UNLOCK mutex %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001396 pthread_mutex_unlock(&locked_session->lock);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001397 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001398 DEBUG("UNLOCK wrlock %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001399 if (pthread_rwlock_unlock(&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001400 DEBUG("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejka47387fd2013-06-10 20:37:46 +02001401 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02001402 reply = create_error("Invalid session identifier.");
1403 }
1404
1405 if ((reply == NULL) && (locked_session->hello_message != NULL)) {
1406 reply = locked_session->hello_message;
1407 }
1408 return reply;
1409}
1410
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001411json_object *handle_op_info(apr_pool_t *pool, json_object *request, const char *session_key)
Tomas Cejkad5b53772013-06-08 23:01:07 +02001412{
1413 json_object *reply = NULL;
Tomas Cejka47387fd2013-06-10 20:37:46 +02001414 struct session_with_mutex * locked_session = NULL;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001415 DEBUG("Request: get info about session %s", session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001416
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001417 DEBUG("LOCK wrlock %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001418 if (pthread_rwlock_rdlock(&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001419 DEBUG("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejka47387fd2013-06-10 20:37:46 +02001420 }
1421
Tomas Cejkad5b53772013-06-08 23:01:07 +02001422 locked_session = (struct session_with_mutex *)apr_hash_get(netconf_sessions_list, session_key, APR_HASH_KEY_STRING);
1423 if (locked_session != NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001424 DEBUG("LOCK mutex %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001425 pthread_mutex_lock(&locked_session->lock);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001426 DEBUG("UNLOCK wrlock %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001427 if (pthread_rwlock_unlock(&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001428 DEBUG("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejka47387fd2013-06-10 20:37:46 +02001429 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02001430 if (locked_session->hello_message != NULL) {
1431 reply = locked_session->hello_message;
1432 } else {
1433 reply = create_error("Invalid session identifier.");
1434 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001435 DEBUG("UNLOCK mutex %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001436 pthread_mutex_unlock(&locked_session->lock);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001437 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001438 DEBUG("UNLOCK wrlock %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001439 if (pthread_rwlock_unlock(&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001440 DEBUG("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejka47387fd2013-06-10 20:37:46 +02001441 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02001442 reply = create_error("Invalid session identifier.");
1443 }
1444
Tomas Cejka47387fd2013-06-10 20:37:46 +02001445
Tomas Cejkad5b53772013-06-08 23:01:07 +02001446 return reply;
1447}
1448
Tomas Cejka6b886e02013-07-05 09:53:17 +02001449void notification_history(time_t eventtime, const char *content)
1450{
Tomas Cejkad016f9c2013-07-10 09:16:16 +02001451 json_object *notif_history_array = (json_object *) pthread_getspecific(notif_history_key);
1452 if (notif_history_array == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001453 DEBUG("No list of notification history found.");
Tomas Cejkad016f9c2013-07-10 09:16:16 +02001454 return;
1455 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001456 DEBUG("Got notification from history %lu.", (long unsigned) eventtime);
Tomas Cejka6b886e02013-07-05 09:53:17 +02001457 json_object *notif = json_object_new_object();
1458 if (notif == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001459 DEBUG("Could not allocate memory for notification (json).");
Tomas Cejka6b886e02013-07-05 09:53:17 +02001460 return;
1461 }
1462 json_object_object_add(notif, "eventtime", json_object_new_int64(eventtime));
1463 json_object_object_add(notif, "content", json_object_new_string(content));
1464 json_object_array_add(notif_history_array, notif);
1465}
1466
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001467json_object *handle_op_ntfgethistory(apr_pool_t *pool, json_object *request, const char *session_key)
Tomas Cejka6b886e02013-07-05 09:53:17 +02001468{
1469 json_object *reply = NULL;
1470 const char *sid = NULL;
1471 struct session_with_mutex *locked_session = NULL;
1472 struct nc_session *temp_session = NULL;
1473 nc_rpc *rpc = NULL;
1474 time_t start = 0;
1475 time_t stop = 0;
1476 int64_t from, to;
1477
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001478 DEBUG("Request: get notification history, session %s", session_key);
Tomas Cejka6b886e02013-07-05 09:53:17 +02001479
1480 sid = json_object_get_string(json_object_object_get(request, "session"));
1481 from = json_object_get_int64(json_object_object_get(request, "from"));
1482 to = json_object_get_int64(json_object_object_get(request, "to"));
1483
1484 start = time(NULL) + from;
1485 stop = time(NULL) + to;
1486
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001487 DEBUG("notification history interval %li %li", (long int) from, (long int) to);
Tomas Cejka6b886e02013-07-05 09:53:17 +02001488
1489 if (sid == NULL) {
1490 return create_error("Missing session parameter.");
1491 }
1492
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001493 DEBUG("LOCK wrlock %s", __func__);
Tomas Cejka6b886e02013-07-05 09:53:17 +02001494 if (pthread_rwlock_rdlock(&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001495 DEBUG("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejka6b886e02013-07-05 09:53:17 +02001496 return NULL;
1497 }
1498
1499 locked_session = (struct session_with_mutex *)apr_hash_get(netconf_sessions_list, session_key, APR_HASH_KEY_STRING);
1500 if (locked_session != NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001501 DEBUG("LOCK mutex %s", __func__);
Tomas Cejka6b886e02013-07-05 09:53:17 +02001502 pthread_mutex_lock(&locked_session->lock);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001503 DEBUG("UNLOCK wrlock %s", __func__);
Tomas Cejka6b886e02013-07-05 09:53:17 +02001504 if (pthread_rwlock_unlock(&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001505 DEBUG("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejka6b886e02013-07-05 09:53:17 +02001506 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001507 DEBUG("creating temporal NC session.");
Tomas Cejka6b886e02013-07-05 09:53:17 +02001508 temp_session = nc_session_connect_channel(locked_session->session, NULL);
1509 if (temp_session != NULL) {
1510 rpc = nc_rpc_subscribe(NULL /* stream */, NULL /* filter */, &start, &stop);
1511 if (rpc == NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001512 DEBUG("UNLOCK mutex %s", __func__);
Tomas Cejkac7929632013-10-24 19:25:15 +02001513 pthread_mutex_unlock(&locked_session->lock);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001514 DEBUG("notifications: creating an rpc request failed.");
Tomas Cejka6b886e02013-07-05 09:53:17 +02001515 return create_error("notifications: creating an rpc request failed.");
1516 }
1517
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001518 DEBUG("Send NC subscribe.");
Tomas Cejka6b886e02013-07-05 09:53:17 +02001519 /** \todo replace with sth like netconf_op(http_server, session_hash, rpc) */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001520 json_object *res = netconf_unlocked_op(temp_session, rpc);
Tomas Cejkac7929632013-10-24 19:25:15 +02001521 if (res != NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001522 DEBUG("UNLOCK mutex %s", __func__);
Tomas Cejkac7929632013-10-24 19:25:15 +02001523 pthread_mutex_unlock(&locked_session->lock);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001524 DEBUG("Subscription RPC failed.");
Tomas Cejkac7929632013-10-24 19:25:15 +02001525 return res;
Tomas Cejka6b886e02013-07-05 09:53:17 +02001526 }
1527 rpc = NULL; /* just note that rpc is already freed by send_recv_process() */
1528
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001529 DEBUG("UNLOCK mutex %s", __func__);
Tomas Cejka6b886e02013-07-05 09:53:17 +02001530 pthread_mutex_unlock(&locked_session->lock);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001531 DEBUG("LOCK mutex %s", __func__);
Tomas Cejka6b886e02013-07-05 09:53:17 +02001532 pthread_mutex_lock(&ntf_history_lock);
Tomas Cejkad016f9c2013-07-10 09:16:16 +02001533 json_object *notif_history_array = json_object_new_array();
1534 if (pthread_setspecific(notif_history_key, notif_history_array) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001535 DEBUG("notif_history: cannot set thread-specific hash value.");
Tomas Cejkad016f9c2013-07-10 09:16:16 +02001536 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02001537
1538 ncntf_dispatch_receive(temp_session, notification_history);
1539
1540 reply = json_object_new_object();
1541 json_object_object_add(reply, "notifications", notif_history_array);
1542 //json_object_put(notif_history_array);
1543
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001544 DEBUG("UNLOCK mutex %s", __func__);
Tomas Cejka6b886e02013-07-05 09:53:17 +02001545 pthread_mutex_unlock(&ntf_history_lock);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001546 DEBUG("closing temporal NC session.");
Tomas Cejkaaecc5f72013-10-01 00:03:50 +02001547 nc_session_free(temp_session);
Tomas Cejka6b886e02013-07-05 09:53:17 +02001548 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001549 DEBUG("UNLOCK mutex %s", __func__);
Tomas Cejkac7929632013-10-24 19:25:15 +02001550 pthread_mutex_unlock(&locked_session->lock);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001551 DEBUG("Get history of notification failed due to channel establishment");
Tomas Cejka6b886e02013-07-05 09:53:17 +02001552 reply = create_error("Get history of notification was unsuccessful, connection failed.");
1553 }
Tomas Cejka6b886e02013-07-05 09:53:17 +02001554 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001555 DEBUG("UNLOCK wrlock %s", __func__);
Tomas Cejka6b886e02013-07-05 09:53:17 +02001556 if (pthread_rwlock_unlock(&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001557 DEBUG("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejka6b886e02013-07-05 09:53:17 +02001558 }
1559 reply = create_error("Invalid session identifier.");
1560 }
1561
Tomas Cejka4003a702013-10-01 00:02:45 +02001562 return reply;
1563}
1564
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001565json_object *handle_op_validate(apr_pool_t *pool, json_object *request, const char *session_key)
Tomas Cejka4003a702013-10-01 00:02:45 +02001566{
1567 json_object *reply = NULL;
1568 const char *sid = NULL;
1569 const char *target = NULL;
1570 const char *url = NULL;
1571 struct session_with_mutex *locked_session = NULL;
1572 nc_rpc *rpc = NULL;
1573 NC_DATASTORE target_ds;
1574
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001575 DEBUG("Request: validate datastore, session %s", session_key);
Tomas Cejka4003a702013-10-01 00:02:45 +02001576
1577 sid = json_object_get_string(json_object_object_get(request, "session"));
1578 target = json_object_get_string(json_object_object_get(request, "target"));
1579 url = json_object_get_string(json_object_object_get(request, "url"));
1580
1581
1582 if ((sid == NULL) || (target == NULL)) {
1583 return create_error("Missing session parameter.");
Tomas Cejka6b886e02013-07-05 09:53:17 +02001584 }
Tomas Cejka4003a702013-10-01 00:02:45 +02001585
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001586 /* validation */
1587 target_ds = parse_datastore(target);
1588 if (target_ds == NC_DATASTORE_URL) {
1589 if (url != NULL) {
1590 rpc = nc_rpc_validate(target_ds, url);
Tomas Cejka4003a702013-10-01 00:02:45 +02001591 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001592 } else if ((target_ds == NC_DATASTORE_RUNNING) || (target_ds == NC_DATASTORE_STARTUP)
Tomas Cejka4003a702013-10-01 00:02:45 +02001593 || (target_ds == NC_DATASTORE_CANDIDATE)) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001594 rpc = nc_rpc_validate(target_ds);
1595 }
1596 if (rpc == NULL) {
1597 DEBUG("mod_netconf: creating rpc request failed");
1598 reply = create_error("Creation of RPC request failed.");
1599 DEBUG("UNLOCK mutex %s", __func__);
Tomas Cejka4003a702013-10-01 00:02:45 +02001600 pthread_mutex_unlock(&locked_session->lock);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001601 return reply;
Tomas Cejka4003a702013-10-01 00:02:45 +02001602 }
1603
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001604 DEBUG("Request: validate datastore");
1605 if ((reply = netconf_op(session_key, rpc, NULL)) == NULL) {
1606 reply = json_object_new_object();
1607 json_object_object_add(reply, "type", json_object_new_int(REPLY_OK));
1608 }
1609 nc_rpc_free (rpc);
1610
1611 DEBUG("Request: validate datastore");
Tomas Cejka6b886e02013-07-05 09:53:17 +02001612 return reply;
1613}
1614
David Kupka8e60a372012-09-04 09:15:20 +02001615void * thread_routine (void * arg)
1616{
1617 void * retval = NULL;
David Kupka8e60a372012-09-04 09:15:20 +02001618 struct pollfd fds;
Tomas Cejka00635972013-06-03 15:10:52 +02001619 json_object *request = NULL;
1620 json_object *reply = NULL;
David Kupka8e60a372012-09-04 09:15:20 +02001621 int operation;
Tomas Cejkad5b53772013-06-08 23:01:07 +02001622 int status = 0;
Tomas Cejka45ab59f2013-05-15 00:10:49 +02001623 const char *msgtext;
Tomas Cejkad5b53772013-06-08 23:01:07 +02001624 const char *session_key;
1625 const char *target = NULL;
1626 const char *source = NULL;
Tomas Cejkac7929632013-10-24 19:25:15 +02001627 const char *url = NULL;
Tomas Cejkad5b53772013-06-08 23:01:07 +02001628 NC_DATASTORE ds_type_t = -1;
1629 NC_DATASTORE ds_type_s = -1;
Tomas Cejka64b87482013-06-03 16:30:53 +02001630 char *chunked_out_msg = NULL;
David Kupka8e60a372012-09-04 09:15:20 +02001631 apr_pool_t * pool = ((struct pass_to_thread*)arg)->pool;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001632 //server_rec * server = ((struct pass_to_thread*)arg)->server;
David Kupka8e60a372012-09-04 09:15:20 +02001633 int client = ((struct pass_to_thread*)arg)->client;
1634
Tomas Cejka00635972013-06-03 15:10:52 +02001635 char *buffer = NULL;
David Kupka8e60a372012-09-04 09:15:20 +02001636
1637 while (!isterminated) {
1638 fds.fd = client;
1639 fds.events = POLLIN;
1640 fds.revents = 0;
1641
1642 status = poll(&fds, 1, 1000);
1643
1644 if (status == 0 || (status == -1 && (errno == EAGAIN || (errno == EINTR && isterminated == 0)))) {
1645 /* poll was interrupted - check if the isterminated is set and if not, try poll again */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001646 //DEBUG("poll interrupted");
David Kupka8e60a372012-09-04 09:15:20 +02001647 continue;
1648 } else if (status < 0) {
1649 /* 0: poll time outed
1650 * close socket and ignore this request from the client, it can try it again
1651 * -1: poll failed
1652 * something wrong happend, close this socket and wait for another request
1653 */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001654 //DEBUG("poll failed, status %d(%d: %s)", status, errno, strerror(errno));
David Kupka8e60a372012-09-04 09:15:20 +02001655 close(client);
1656 break;
1657 }
1658 /* status > 0 */
1659
1660 /* check the status of the socket */
1661
1662 /* if nothing to read and POLLHUP (EOF) or POLLERR set */
1663 if ((fds.revents & POLLHUP) || (fds.revents & POLLERR)) {
1664 /* close client's socket (it's probably already closed by client */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001665 //DEBUG("socket error (%d)", fds.revents);
David Kupka8e60a372012-09-04 09:15:20 +02001666 close(client);
1667 break;
1668 }
1669
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001670 DEBUG("Get framed message...");
1671 buffer = get_framed_message(client);
David Kupka8e60a372012-09-04 09:15:20 +02001672
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001673 DEBUG("Check read buffer.");
David Kupka8e60a372012-09-04 09:15:20 +02001674 if (buffer != NULL) {
Tomas Cejka00635972013-06-03 15:10:52 +02001675 enum json_tokener_error jerr;
1676 request = json_tokener_parse_verbose(buffer, &jerr);
1677 if (jerr != json_tokener_success) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001678 DEBUG("JSON parsing error");
Tomas Cejka00635972013-06-03 15:10:52 +02001679 continue;
1680 }
David Kupka8e60a372012-09-04 09:15:20 +02001681 operation = json_object_get_int(json_object_object_get(request, "type"));
1682
Tomas Cejka64b87482013-06-03 16:30:53 +02001683 session_key = json_object_get_string(json_object_object_get(request, "session"));
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001684 DEBUG("operation %d session_key %s.", operation, session_key);
David Kupka8e60a372012-09-04 09:15:20 +02001685 /* DO NOT FREE session_key HERE, IT IS PART OF REQUEST */
1686 if (operation != MSG_CONNECT && session_key == NULL) {
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001687 reply = create_error("Missing session specification.");
David Kupka8e60a372012-09-04 09:15:20 +02001688 msgtext = json_object_to_json_string(reply);
1689 send(client, msgtext, strlen(msgtext) + 1, 0);
1690 json_object_put(reply);
1691 /* there is some stupid client, so close the connection to give a chance to some other client */
1692 close(client);
1693 break;
1694 }
1695
David Kupka8e60a372012-09-04 09:15:20 +02001696 /* null global JSON error-reply */
1697 err_reply = NULL;
1698
1699 /* prepare reply envelope */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001700 if (reply != NULL) {
1701 json_object_put(reply);
1702 }
Tomas Cejkad5b53772013-06-08 23:01:07 +02001703 reply = NULL;
David Kupka8e60a372012-09-04 09:15:20 +02001704
1705 /* process required operation */
1706 switch (operation) {
1707 case MSG_CONNECT:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001708 reply = handle_op_connect(pool, request);
David Kupka8e60a372012-09-04 09:15:20 +02001709 break;
1710 case MSG_GET:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001711 reply = handle_op_get(pool, request, session_key);
David Kupka8e60a372012-09-04 09:15:20 +02001712 break;
1713 case MSG_GETCONFIG:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001714 reply = handle_op_getconfig(pool, request, session_key);
David Kupka8e60a372012-09-04 09:15:20 +02001715 break;
Tomas Cejka0aeca8b2012-12-22 19:56:03 +01001716 case MSG_GETSCHEMA:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001717 reply = handle_op_getschema(pool, request, session_key);
Tomas Cejka0aeca8b2012-12-22 19:56:03 +01001718 break;
David Kupka8e60a372012-09-04 09:15:20 +02001719 case MSG_EDITCONFIG:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001720 reply = handle_op_editconfig(pool, request, session_key);
David Kupka8e60a372012-09-04 09:15:20 +02001721 break;
1722 case MSG_COPYCONFIG:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001723 reply = handle_op_copyconfig(pool, request, session_key);
David Kupka8e60a372012-09-04 09:15:20 +02001724 break;
Tomas Cejkad5b53772013-06-08 23:01:07 +02001725
David Kupka8e60a372012-09-04 09:15:20 +02001726 case MSG_DELETECONFIG:
David Kupka8e60a372012-09-04 09:15:20 +02001727 case MSG_LOCK:
David Kupka8e60a372012-09-04 09:15:20 +02001728 case MSG_UNLOCK:
Tomas Cejkad5b53772013-06-08 23:01:07 +02001729 /* get parameters */
1730 if ((target = json_object_get_string(json_object_object_get(request, "target"))) != NULL) {
1731 ds_type_t = parse_datastore(target);
1732 }
1733 if ((source = json_object_get_string(json_object_object_get(request, "source"))) != NULL) {
1734 ds_type_s = parse_datastore(source);
David Kupka8e60a372012-09-04 09:15:20 +02001735 }
1736
1737 if (ds_type_t == -1) {
Tomas Cejkad5b53772013-06-08 23:01:07 +02001738 reply = create_error("Invalid target repository type requested.");
David Kupka8e60a372012-09-04 09:15:20 +02001739 break;
1740 }
David Kupka8e60a372012-09-04 09:15:20 +02001741 switch(operation) {
1742 case MSG_DELETECONFIG:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001743 DEBUG("Request: delete-config (session %s)", session_key);
Tomas Cejkac7929632013-10-24 19:25:15 +02001744 url = json_object_get_string(json_object_object_get(request, "url"));
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001745 reply = netconf_deleteconfig(session_key, ds_type_t, url);
David Kupka8e60a372012-09-04 09:15:20 +02001746 break;
1747 case MSG_LOCK:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001748 DEBUG("Request: lock (session %s)", session_key);
1749 reply = netconf_lock(session_key, ds_type_t);
David Kupka8e60a372012-09-04 09:15:20 +02001750 break;
1751 case MSG_UNLOCK:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001752 DEBUG("Request: unlock (session %s)", session_key);
1753 reply = netconf_unlock(session_key, ds_type_t);
David Kupka8e60a372012-09-04 09:15:20 +02001754 break;
1755 default:
Tomas Cejkac7929632013-10-24 19:25:15 +02001756 reply = create_error("Internal: Unknown request type.");
David Kupka8e60a372012-09-04 09:15:20 +02001757 break;
1758 }
1759
Tomas Cejkac7929632013-10-24 19:25:15 +02001760 if (reply == NULL) {
David Kupka8e60a372012-09-04 09:15:20 +02001761 if (err_reply == NULL) {
Tomas Cejkad5b53772013-06-08 23:01:07 +02001762 /** \todo more clever error message wanted */
Tomas Cejkac7929632013-10-24 19:25:15 +02001763 reply = json_object_new_object();
1764 json_object_object_add(reply, "type", json_object_new_int(REPLY_OK));
David Kupka8e60a372012-09-04 09:15:20 +02001765 } else {
1766 /* use filled err_reply from libnetconf's callback */
David Kupka8e60a372012-09-04 09:15:20 +02001767 reply = err_reply;
1768 }
David Kupka8e60a372012-09-04 09:15:20 +02001769 }
1770 break;
1771 case MSG_KILL:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001772 reply = handle_op_kill(pool, request, session_key);
David Kupka8e60a372012-09-04 09:15:20 +02001773 break;
1774 case MSG_DISCONNECT:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001775 reply = handle_op_disconnect(pool, request, session_key);
David Kupka8e60a372012-09-04 09:15:20 +02001776 break;
Tomas Cejka45ab59f2013-05-15 00:10:49 +02001777 case MSG_RELOADHELLO:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001778 reply = handle_op_reloadhello(pool, request, session_key);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001779 break;
Tomas Cejka45ab59f2013-05-15 00:10:49 +02001780 case MSG_INFO:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001781 reply = handle_op_info(pool, request, session_key);
David Kupka8e60a372012-09-04 09:15:20 +02001782 break;
1783 case MSG_GENERIC:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001784 reply = handle_op_generic(pool, request, session_key);
David Kupka8e60a372012-09-04 09:15:20 +02001785 break;
Tomas Cejka6b886e02013-07-05 09:53:17 +02001786 case MSG_NTF_GETHISTORY:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001787 reply = handle_op_ntfgethistory(pool, request, session_key);
Tomas Cejka6b886e02013-07-05 09:53:17 +02001788 break;
Tomas Cejka4003a702013-10-01 00:02:45 +02001789 case MSG_VALIDATE:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001790 reply = handle_op_validate(pool, request, session_key);
Tomas Cejka4003a702013-10-01 00:02:45 +02001791 break;
David Kupka8e60a372012-09-04 09:15:20 +02001792 default:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001793 DEBUG("Unknown mod_netconf operation requested (%d)", operation);
Tomas Cejkad5b53772013-06-08 23:01:07 +02001794 reply = create_error("Operation not supported.");
David Kupka8e60a372012-09-04 09:15:20 +02001795 break;
1796 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001797 DEBUG("Clean request json object.");
David Kupka8e60a372012-09-04 09:15:20 +02001798 json_object_put(request);
1799
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001800 DEBUG("Send reply json object.");
David Kupka1e3e4c82012-09-04 09:32:15 +02001801 /* send reply to caller */
1802 if (reply != NULL) {
1803 msgtext = json_object_to_json_string(reply);
Tomas Cejka64b87482013-06-03 16:30:53 +02001804 if (asprintf (&chunked_out_msg, "\n#%d\n%s\n##\n", (int)strlen(msgtext), msgtext) == -1) {
Tomas Cejka00635972013-06-03 15:10:52 +02001805 if (buffer != NULL) {
1806 free(buffer);
1807 buffer = NULL;
1808 }
David Kupka8e60a372012-09-04 09:15:20 +02001809 break;
1810 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001811 DEBUG("Send framed reply json object.");
Tomas Cejka64b87482013-06-03 16:30:53 +02001812 send(client, chunked_out_msg, strlen(chunked_out_msg) + 1, 0);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001813 DEBUG("Clean reply json object.");
David Kupka1e3e4c82012-09-04 09:32:15 +02001814 json_object_put(reply);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001815 reply = NULL;
1816 DEBUG("Clean message buffer.");
Tomas Cejka64b87482013-06-03 16:30:53 +02001817 free(chunked_out_msg);
1818 chunked_out_msg = NULL;
Tomas Cejka00635972013-06-03 15:10:52 +02001819 if (buffer != NULL) {
1820 free(buffer);
1821 buffer = NULL;
1822 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001823 if (err_reply != NULL) {
1824 json_object_put(err_reply);
1825 err_reply = NULL;
1826 }
David Kupka1e3e4c82012-09-04 09:32:15 +02001827 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001828 DEBUG("Reply is NULL, shouldn't be...");
1829 continue;
David Kupka8e60a372012-09-04 09:15:20 +02001830 }
1831 }
1832 }
David Kupka8e60a372012-09-04 09:15:20 +02001833 free (arg);
1834
1835 return retval;
1836}
1837
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001838/**
1839 * \brief Close all open NETCONF sessions.
1840 *
1841 * During termination of mod_netconf, it is useful to close all remaining
1842 * sessions. This function iterates over the list of sessions and close them
1843 * all.
1844 *
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001845 * \param[in] p apr pool needed for hash table iterating
1846 * \param[in] ht hash table of session_with_mutex structs
1847 */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001848static void close_all_nc_sessions(apr_pool_t *p)
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001849{
1850 apr_hash_index_t *hi;
1851 void *val = NULL;
1852 struct session_with_mutex *swm = NULL;
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001853 const char *hashed_key = NULL;
1854 apr_ssize_t hashed_key_length;
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001855 int ret;
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001856
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001857 /* get exclusive access to sessions_list (conns) */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001858 DEBUG("LOCK wrlock %s", __func__);
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001859 if ((ret = pthread_rwlock_wrlock (&session_lock)) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001860 DEBUG("Error while locking rwlock: %d (%s)", ret, strerror(ret));
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001861 return;
1862 }
Tomas Cejka47387fd2013-06-10 20:37:46 +02001863 for (hi = apr_hash_first(p, netconf_sessions_list); hi; hi = apr_hash_next(hi)) {
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001864 apr_hash_this(hi, (const void **) &hashed_key, &hashed_key_length, &val);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001865 DEBUG("Closing NETCONF session (%s).", hashed_key);
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001866 swm = (struct session_with_mutex *) val;
1867 if (swm != NULL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001868 DEBUG("LOCK mutex %s", __func__);
1869 pthread_mutex_lock(&swm->lock);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001870 apr_hash_set(netconf_sessions_list, hashed_key, APR_HASH_KEY_STRING, NULL);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001871 DEBUG("UNLOCK mutex %s", __func__);
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001872 pthread_mutex_unlock(&swm->lock);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001873
1874 /* close_and_free_session handles locking on its own */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001875 close_and_free_session(swm);
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001876 }
1877 }
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001878 /* get exclusive access to sessions_list (conns) */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001879 DEBUG("UNLOCK wrlock %s", __func__);
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001880 if (pthread_rwlock_unlock (&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001881 DEBUG("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001882 }
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001883}
1884
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001885static void check_timeout_and_close(apr_pool_t *p)
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001886{
1887 apr_hash_index_t *hi;
1888 void *val = NULL;
1889 struct nc_session *ns = NULL;
1890 struct session_with_mutex *swm = NULL;
1891 const char *hashed_key = NULL;
1892 apr_ssize_t hashed_key_length;
1893 apr_time_t current_time = apr_time_now();
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001894 int ret;
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001895
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001896 /* get exclusive access to sessions_list (conns) */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001897//DEBUG("LOCK wrlock %s", __func__);
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001898 if ((ret = pthread_rwlock_wrlock (&session_lock)) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001899 DEBUG("Error while locking rwlock: %d (%s)", ret, strerror(ret));
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001900 return;
1901 }
Tomas Cejka47387fd2013-06-10 20:37:46 +02001902 for (hi = apr_hash_first(p, netconf_sessions_list); hi; hi = apr_hash_next(hi)) {
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001903 apr_hash_this(hi, (const void **) &hashed_key, &hashed_key_length, &val);
1904 swm = (struct session_with_mutex *) val;
1905 if (swm == NULL) {
1906 continue;
1907 }
1908 ns = swm->session;
1909 if (ns == NULL) {
1910 continue;
1911 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001912//DEBUG("LOCK mutex %s", __func__);
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001913 pthread_mutex_lock(&swm->lock);
1914 if ((current_time - swm->last_activity) > apr_time_from_sec(ACTIVITY_TIMEOUT)) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001915 DEBUG("Closing NETCONF session (%s).", hashed_key);
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001916 /* remove session from the active sessions list */
Tomas Cejka47387fd2013-06-10 20:37:46 +02001917 apr_hash_set(netconf_sessions_list, hashed_key, APR_HASH_KEY_STRING, NULL);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001918//DEBUG("UNLOCK mutex %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001919 pthread_mutex_unlock(&swm->lock);
1920
1921 /* close_and_free_session handles locking on its own */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001922 close_and_free_session(swm);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001923 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001924//DEBUG("UNLOCK mutex %s", __func__);
Tomas Cejka47387fd2013-06-10 20:37:46 +02001925 pthread_mutex_unlock(&swm->lock);
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001926 }
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001927 }
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001928 /* get exclusive access to sessions_list (conns) */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001929//DEBUG("UNLOCK wrlock %s", __func__);
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001930 if (pthread_rwlock_unlock (&session_lock) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001931 DEBUG("Error while unlocking rwlock: %d (%s)", errno, strerror(errno));
Tomas Cejkabdedcd32013-06-09 11:54:53 +02001932 }
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001933}
1934
1935
1936/**
Radek Krejcif23850c2012-07-23 16:14:17 +02001937 * This is actually implementation of NETCONF client
1938 * - requests are received from UNIX socket in the predefined format
1939 * - results are replied through the same way
1940 * - the daemon run as a separate process, but it is started and stopped
1941 * automatically by Apache.
1942 *
1943 */
Radek Krejci469aab82012-07-22 18:42:20 +02001944static void forked_proc(apr_pool_t * pool, server_rec * server)
1945{
Tomas Cejkad340dbf2013-03-24 20:36:57 +01001946 struct timeval tv;
Radek Krejci469aab82012-07-22 18:42:20 +02001947 struct sockaddr_un local, remote;
David Kupka8e60a372012-09-04 09:15:20 +02001948 int lsock, client, ret, i, pthread_count = 0;
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02001949 unsigned int olds = 0, timediff = 0;
David Kupka8e60a372012-09-04 09:15:20 +02001950 socklen_t len;
Radek Krejciae021c12012-07-25 18:03:52 +02001951 mod_netconf_cfg *cfg;
David Kupka8e60a372012-09-04 09:15:20 +02001952 struct pass_to_thread * arg;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001953 pthread_t * ptids = calloc(1, sizeof(pthread_t));
David Kupka8e60a372012-09-04 09:15:20 +02001954 struct timespec maxtime;
1955 pthread_rwlockattr_t lock_attrs;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001956 char *sockname = NULL;
Tomas Cejka404d37e2013-04-13 02:31:35 +02001957 #ifdef WITH_NOTIFICATIONS
1958 char use_notifications = 0;
1959 #endif
David Kupka8e60a372012-09-04 09:15:20 +02001960
Tomas Cejka6b886e02013-07-05 09:53:17 +02001961 http_server = server;
1962
Tomas Cejka404d37e2013-04-13 02:31:35 +02001963 /* wait at most 5 seconds for every thread to terminate */
David Kupka8e60a372012-09-04 09:15:20 +02001964 maxtime.tv_sec = 5;
1965 maxtime.tv_nsec = 0;
Radek Krejci469aab82012-07-22 18:42:20 +02001966
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001967 #ifndef HTTPD_INDEPENDENT
Radek Krejcif23850c2012-07-23 16:14:17 +02001968 /* change uid and gid of process for security reasons */
Radek Krejci469aab82012-07-22 18:42:20 +02001969 unixd_setup_child();
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001970 #endif
Radek Krejci469aab82012-07-22 18:42:20 +02001971
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001972 if (server != NULL) {
1973 cfg = ap_get_module_config(server->module_config, &netconf_module);
1974 if (cfg == NULL) {
1975 DEBUG("Getting mod_netconf configuration failed");
1976 return;
1977 }
1978 sockname = cfg->sockname;
1979 } else {
1980 sockname = SOCKET_FILENAME;
Radek Krejci8fd1f5e2012-07-24 17:33:36 +02001981 }
Radek Krejci469aab82012-07-22 18:42:20 +02001982
Radek Krejci8fd1f5e2012-07-24 17:33:36 +02001983 /* create listening UNIX socket to accept incoming connections */
Radek Krejci469aab82012-07-22 18:42:20 +02001984 if ((lsock = socket(PF_UNIX, SOCK_STREAM, 0)) == -1) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001985 DEBUG("Creating socket failed (%s)", strerror(errno));
1986 goto error_exit;
Radek Krejci469aab82012-07-22 18:42:20 +02001987 }
1988
1989 local.sun_family = AF_UNIX;
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001990 strncpy(local.sun_path, sockname, sizeof(local.sun_path));
Radek Krejci469aab82012-07-22 18:42:20 +02001991 unlink(local.sun_path);
1992 len = offsetof(struct sockaddr_un, sun_path) + strlen(local.sun_path);
1993
1994 if (bind(lsock, (struct sockaddr *) &local, len) == -1) {
1995 if (errno == EADDRINUSE) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001996 DEBUG("mod_netconf socket address already in use");
1997 goto error_exit;
Radek Krejci469aab82012-07-22 18:42:20 +02001998 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01001999 DEBUG("Binding socket failed (%s)", strerror(errno));
2000 goto error_exit;
Radek Krejci469aab82012-07-22 18:42:20 +02002001 }
2002
2003 if (listen(lsock, MAX_SOCKET_CL) == -1) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002004 DEBUG("Setting up listen socket failed (%s)", strerror(errno));
2005 goto error_exit;
Radek Krejci469aab82012-07-22 18:42:20 +02002006 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002007 chmod(sockname, S_IWUSR | S_IWGRP | S_IWOTH | S_IRUSR | S_IRGRP | S_IROTH);
Radek Krejci469aab82012-07-22 18:42:20 +02002008
Tomas Cejkaba21b382013-04-13 02:37:32 +02002009 /* prepare internal lists */
2010 netconf_sessions_list = apr_hash_make(pool);
2011
Tomas Cejkad340dbf2013-03-24 20:36:57 +01002012 #ifdef WITH_NOTIFICATIONS
Tomas Cejka47387fd2013-06-10 20:37:46 +02002013 if (notification_init(pool, server) == -1) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002014 DEBUG("libwebsockets initialization failed");
Tomas Cejkad340dbf2013-03-24 20:36:57 +01002015 use_notifications = 0;
2016 } else {
2017 use_notifications = 1;
2018 }
2019 #endif
2020
Radek Krejci469aab82012-07-22 18:42:20 +02002021 /* setup libnetconf's callbacks */
2022 nc_verbosity(NC_VERB_DEBUG);
Radek Krejci469aab82012-07-22 18:42:20 +02002023 nc_callback_print(clb_print);
2024 nc_callback_ssh_host_authenticity_check(netconf_callback_ssh_hostkey_check);
2025 nc_callback_sshauth_interactive(netconf_callback_sshauth_interactive);
2026 nc_callback_sshauth_password(netconf_callback_sshauth_password);
Radek Krejcic11fd862012-07-26 12:41:21 +02002027 nc_callback_error_reply(netconf_callback_error_process);
Radek Krejci469aab82012-07-22 18:42:20 +02002028
2029 /* disable publickey authentication */
2030 nc_ssh_pref(NC_SSH_AUTH_PUBLIC_KEYS, -1);
2031
David Kupka8e60a372012-09-04 09:15:20 +02002032 /* create mutex protecting session list */
2033 pthread_rwlockattr_init(&lock_attrs);
2034 /* rwlock is shared only with threads in this process */
2035 pthread_rwlockattr_setpshared(&lock_attrs, PTHREAD_PROCESS_PRIVATE);
2036 /* create rw lock */
2037 if (pthread_rwlock_init(&session_lock, &lock_attrs) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002038 DEBUG("Initialization of mutex failed: %d (%s)", errno, strerror(errno));
2039 goto error_exit;
David Kupka8e60a372012-09-04 09:15:20 +02002040 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002041 pthread_mutex_init(&ntf_history_lock, NULL);
2042 DEBUG("init of notif_history_key.");
Tomas Cejkad016f9c2013-07-10 09:16:16 +02002043 if (pthread_key_create(&notif_history_key, NULL) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002044 DEBUG("init of notif_history_key failed");
Tomas Cejkad016f9c2013-07-10 09:16:16 +02002045 }
Tomas Cejka8a82dab2013-05-30 23:37:23 +02002046
Tomas Cejkad340dbf2013-03-24 20:36:57 +01002047 fcntl(lsock, F_SETFL, fcntl(lsock, F_GETFL, 0) | O_NONBLOCK);
Radek Krejci469aab82012-07-22 18:42:20 +02002048 while (isterminated == 0) {
Tomas Cejkad340dbf2013-03-24 20:36:57 +01002049 gettimeofday(&tv, NULL);
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02002050 timediff = (unsigned int)tv.tv_sec - olds;
Tomas Cejkad340dbf2013-03-24 20:36:57 +01002051 #ifdef WITH_NOTIFICATIONS
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02002052 if (timediff > 60) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002053 DEBUG("handling notifications");
Tomas Cejkad340dbf2013-03-24 20:36:57 +01002054 }
2055 if (use_notifications == 1) {
2056 notification_handle();
2057 }
2058 #endif
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02002059 if (timediff > ACTIVITY_CHECK_INTERVAL) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002060 check_timeout_and_close(pool);
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02002061 }
Radek Krejci469aab82012-07-22 18:42:20 +02002062
2063 /* open incoming connection if any */
David Kupka8e60a372012-09-04 09:15:20 +02002064 len = sizeof(remote);
Tomas Cejkad340dbf2013-03-24 20:36:57 +01002065 if (((unsigned int)tv.tv_sec - olds) > 60) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002066 DEBUG("accepting another client");
Tomas Cejkad340dbf2013-03-24 20:36:57 +01002067 olds = tv.tv_sec;
2068 }
David Kupka8e60a372012-09-04 09:15:20 +02002069 client = accept(lsock, (struct sockaddr *) &remote, &len);
Radek Krejci469aab82012-07-22 18:42:20 +02002070 if (client == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
2071 apr_sleep(SLEEP_TIME);
2072 continue;
2073 } else if (client == -1 && (errno == EINTR)) {
2074 continue;
2075 } else if (client == -1) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002076 DEBUG("Accepting mod_netconf client connection failed (%s)", strerror(errno));
Radek Krejci469aab82012-07-22 18:42:20 +02002077 continue;
2078 }
Radek Krejci469aab82012-07-22 18:42:20 +02002079
2080 /* set client's socket as non-blocking */
Radek Krejcif23850c2012-07-23 16:14:17 +02002081 //fcntl(client, F_SETFL, fcntl(client, F_GETFL, 0) | O_NONBLOCK);
Radek Krejci469aab82012-07-22 18:42:20 +02002082
David Kupka8e60a372012-09-04 09:15:20 +02002083 arg = malloc (sizeof(struct pass_to_thread));
2084 arg->client = client;
2085 arg->pool = pool;
2086 arg->server = server;
2087 arg->netconf_sessions_list = netconf_sessions_list;
Radek Krejci469aab82012-07-22 18:42:20 +02002088
David Kupka8e60a372012-09-04 09:15:20 +02002089 /* start new thread. It will serve this particular request and then terminate */
2090 if ((ret = pthread_create (&ptids[pthread_count], NULL, thread_routine, (void*)arg)) != 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002091 DEBUG("Creating POSIX thread failed: %d\n", ret);
David Kupka8e60a372012-09-04 09:15:20 +02002092 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002093 DEBUG("Thread %lu created", ptids[pthread_count]);
David Kupka8e60a372012-09-04 09:15:20 +02002094 pthread_count++;
2095 ptids = realloc (ptids, sizeof(pthread_t)*(pthread_count+1));
2096 ptids[pthread_count] = 0;
2097 }
Radek Krejci469aab82012-07-22 18:42:20 +02002098
David Kupka8e60a372012-09-04 09:15:20 +02002099 /* check if some thread already terminated, free some resources by joining it */
2100 for (i=0; i<pthread_count; i++) {
2101 if (pthread_tryjoin_np (ptids[i], (void**)&arg) == 0) {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002102 DEBUG("Thread %lu joined with retval %p", ptids[i], arg);
David Kupka8e60a372012-09-04 09:15:20 +02002103 pthread_count--;
2104 if (pthread_count > 0) {
2105 /* place last Thread ID on the place of joined one */
2106 ptids[i] = ptids[pthread_count];
Radek Krejci8fd1f5e2012-07-24 17:33:36 +02002107 }
Radek Krejci469aab82012-07-22 18:42:20 +02002108 }
2109 }
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002110 DEBUG("Running %d threads", pthread_count);
Radek Krejci469aab82012-07-22 18:42:20 +02002111 }
2112
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002113 DEBUG("mod_netconf terminating...");
David Kupka8e60a372012-09-04 09:15:20 +02002114 /* join all threads */
2115 for (i=0; i<pthread_count; i++) {
2116 pthread_timedjoin_np (ptids[i], (void**)&arg, &maxtime);
2117 }
Radek Krejci469aab82012-07-22 18:42:20 +02002118
Tomas Cejkad340dbf2013-03-24 20:36:57 +01002119 #ifdef WITH_NOTIFICATIONS
2120 notification_close();
2121 #endif
2122
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02002123 /* close all NETCONF sessions */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002124 close_all_nc_sessions(pool);
Tomas Cejkaaf7a1562013-04-13 02:27:43 +02002125
David Kupka8e60a372012-09-04 09:15:20 +02002126 /* destroy rwlock */
2127 pthread_rwlock_destroy(&session_lock);
2128 pthread_rwlockattr_destroy(&lock_attrs);
2129
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002130 DEBUG("Exiting from the mod_netconf daemon");
Radek Krejci469aab82012-07-22 18:42:20 +02002131
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002132 free(ptids);
2133 close(lsock);
Radek Krejci469aab82012-07-22 18:42:20 +02002134 exit(APR_SUCCESS);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002135 return;
2136error_exit:
2137 close(lsock);
2138 free(ptids);
2139 return;
Radek Krejci469aab82012-07-22 18:42:20 +02002140}
2141
Radek Krejcif23850c2012-07-23 16:14:17 +02002142static void *mod_netconf_create_conf(apr_pool_t * pool, server_rec * s)
Radek Krejci469aab82012-07-22 18:42:20 +02002143{
Radek Krejcif23850c2012-07-23 16:14:17 +02002144 mod_netconf_cfg *config = apr_pcalloc(pool, sizeof(mod_netconf_cfg));
2145 apr_pool_create(&config->pool, pool);
2146 config->forkproc = NULL;
Radek Krejci8fd1f5e2012-07-24 17:33:36 +02002147 config->sockname = SOCKET_FILENAME;
Radek Krejcif23850c2012-07-23 16:14:17 +02002148
2149 return (void *)config;
Radek Krejci469aab82012-07-22 18:42:20 +02002150}
2151
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002152#ifndef HTTPD_INDEPENDENT
Radek Krejci469aab82012-07-22 18:42:20 +02002153static int mod_netconf_master_init(apr_pool_t * pconf, apr_pool_t * ptemp,
2154 apr_pool_t * plog, server_rec * s)
2155{
Radek Krejcif23850c2012-07-23 16:14:17 +02002156 mod_netconf_cfg *config;
2157 apr_status_t res;
2158
Radek Krejci469aab82012-07-22 18:42:20 +02002159 /* These two help ensure that we only init once. */
Radek Krejcia332b692012-11-12 16:15:54 +01002160 void *data = NULL;
Radek Krejcif23850c2012-07-23 16:14:17 +02002161 const char *userdata_key = "netconf_ipc_init";
Radek Krejci469aab82012-07-22 18:42:20 +02002162
2163 /*
2164 * The following checks if this routine has been called before.
2165 * This is necessary because the parent process gets initialized
2166 * a couple of times as the server starts up.
2167 */
2168 apr_pool_userdata_get(&data, userdata_key, s->process->pool);
2169 if (!data) {
2170 apr_pool_userdata_set((const void *)1, userdata_key, apr_pool_cleanup_null, s->process->pool);
2171 return (OK);
2172 }
2173
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002174 DEBUG("creating mod_netconf daemon");
Radek Krejcif23850c2012-07-23 16:14:17 +02002175 config = ap_get_module_config(s->module_config, &netconf_module);
Radek Krejcidfaa6ea2012-07-23 09:04:43 +02002176
Radek Krejcif23850c2012-07-23 16:14:17 +02002177 if (config && config->forkproc == NULL) {
2178 config->forkproc = apr_pcalloc(config->pool, sizeof(apr_proc_t));
2179 res = apr_proc_fork(config->forkproc, config->pool);
Radek Krejci469aab82012-07-22 18:42:20 +02002180 switch (res) {
2181 case APR_INCHILD:
2182 /* set signal handler */
Radek Krejcif23850c2012-07-23 16:14:17 +02002183 apr_signal_init(config->pool);
Radek Krejci469aab82012-07-22 18:42:20 +02002184 apr_signal(SIGTERM, signal_handler);
2185
2186 /* log start of the separated NETCONF communication process */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002187 DEBUG("mod_netconf daemon started (PID %d)", getpid());
Radek Krejci469aab82012-07-22 18:42:20 +02002188
2189 /* start main loop providing NETCONF communication */
Radek Krejcif23850c2012-07-23 16:14:17 +02002190 forked_proc(config->pool, s);
Radek Krejci469aab82012-07-22 18:42:20 +02002191
Radek Krejcif23850c2012-07-23 16:14:17 +02002192 /* I never should be here, wtf?!? */
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002193 DEBUG("mod_netconf daemon unexpectedly stopped");
Radek Krejci469aab82012-07-22 18:42:20 +02002194 exit(APR_EGENERAL);
2195 break;
2196 case APR_INPARENT:
2197 /* register child to be killed (SIGTERM) when the module config's pool dies */
Radek Krejcif23850c2012-07-23 16:14:17 +02002198 apr_pool_note_subprocess(config->pool, config->forkproc, APR_KILL_AFTER_TIMEOUT);
Radek Krejci469aab82012-07-22 18:42:20 +02002199 break;
2200 default:
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002201 DEBUG("apr_proc_fork() failed");
Radek Krejci469aab82012-07-22 18:42:20 +02002202 break;
2203 }
Radek Krejcif23850c2012-07-23 16:14:17 +02002204 } else {
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002205 DEBUG("mod_netconf misses configuration structure");
Radek Krejci469aab82012-07-22 18:42:20 +02002206 }
2207
2208 return OK;
2209}
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002210#endif
Radek Krejci469aab82012-07-22 18:42:20 +02002211
Radek Krejci469aab82012-07-22 18:42:20 +02002212/**
2213 * Register module hooks
2214 */
2215static void mod_netconf_register_hooks(apr_pool_t * p)
2216{
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002217#ifndef HTTPD_INDEPENDENT
Radek Krejcif23850c2012-07-23 16:14:17 +02002218 ap_hook_post_config(mod_netconf_master_init, NULL, NULL, APR_HOOK_LAST);
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002219#endif
Radek Krejci469aab82012-07-22 18:42:20 +02002220}
2221
Radek Krejci8fd1f5e2012-07-24 17:33:36 +02002222static const char* cfg_set_socket_path(cmd_parms* cmd, void* cfg, const char* arg)
2223{
2224 ((mod_netconf_cfg*)cfg)->sockname = apr_pstrdup(cmd->pool, arg);
2225 return NULL;
2226}
2227
2228static const command_rec netconf_cmds[] = {
2229 AP_INIT_TAKE1("NetconfSocket", cfg_set_socket_path, NULL, OR_ALL, "UNIX socket path for mod_netconf communication."),
2230 {NULL}
2231};
2232
Radek Krejci469aab82012-07-22 18:42:20 +02002233/* Dispatch list for API hooks */
2234module AP_MODULE_DECLARE_DATA netconf_module = {
2235 STANDARD20_MODULE_STUFF,
2236 NULL, /* create per-dir config structures */
2237 NULL, /* merge per-dir config structures */
Radek Krejcif23850c2012-07-23 16:14:17 +02002238 mod_netconf_create_conf, /* create per-server config structures */
Radek Krejci469aab82012-07-22 18:42:20 +02002239 NULL, /* merge per-server config structures */
Radek Krejci8fd1f5e2012-07-24 17:33:36 +02002240 netconf_cmds, /* table of config file commands */
Radek Krejci469aab82012-07-22 18:42:20 +02002241 mod_netconf_register_hooks /* register hooks */
2242};
Radek Krejcia332b692012-11-12 16:15:54 +01002243
Tomas Cejkaef531ee2013-11-12 16:07:00 +01002244int main(int argc, char **argv)
2245{
2246 apr_pool_t *pool;
2247 apr_app_initialize(&argc, (char const *const **) &argv, NULL);
2248 apr_signal(SIGTERM, signal_handler);
2249 apr_signal(SIGINT, signal_handler);
2250 apr_pool_create(&pool, NULL);
2251 forked_proc(pool, NULL);
2252 apr_pool_destroy(pool);
2253 apr_terminate();
2254 DEBUG("Terminated");
2255 return 0;
2256}