Fawkes API
Fawkes Development Version
|
00001 00002 /*************************************************************************** 00003 * net_handler.cpp - Fawkes configuration network handler 00004 * 00005 * Generated: Sat Jan 06 22:55:03 2007 00006 * Copyright 2006-2007 Tim Niemueller [www.niemueller.de] 00007 * 00008 ****************************************************************************/ 00009 00010 /* This program is free software; you can redistribute it and/or modify 00011 * it under the terms of the GNU General Public License as published by 00012 * the Free Software Foundation; either version 2 of the License, or 00013 * (at your option) any later version. A runtime exception applies to 00014 * this software (see LICENSE.GPL_WRE file mentioned below for details). 00015 * 00016 * This program is distributed in the hope that it will be useful, 00017 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00018 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00019 * GNU Library General Public License for more details. 00020 * 00021 * Read the full text in the LICENSE.GPL_WRE file in the doc directory. 00022 */ 00023 00024 #include <config/net_handler.h> 00025 #include <config/net_messages.h> 00026 #include <config/net_list_content.h> 00027 #include <logging/liblogger.h> 00028 00029 #include <netcomm/fawkes/component_ids.h> 00030 #include <netcomm/fawkes/hub.h> 00031 #include <config/config.h> 00032 00033 #include <algorithm> 00034 #include <cstring> 00035 00036 namespace fawkes { 00037 00038 /** @class ConfigNetworkHandler <config/net_handler.h> 00039 * Fawkes Configuration Network Handler. 00040 * It provides access to a given config via the network. 00041 * This is mainly used to allow modification of config values over the network. 00042 * 00043 * @author Tim Niemueller 00044 */ 00045 00046 /** Constructor. 00047 * @param config configuration, loaded and ready to be used for getting and 00048 * setting values 00049 * @param hub Fawkes network hub to use for receiving and sending network 00050 * messages 00051 */ 00052 ConfigNetworkHandler::ConfigNetworkHandler(Configuration *config, 00053 FawkesNetworkHub *hub) 00054 : Thread("ConfigNetworkHandler", Thread::OPMODE_WAITFORWAKEUP), 00055 FawkesNetworkHandler(FAWKES_CID_CONFIGMANAGER), 00056 ConfigurationChangeHandler("") 00057 { 00058 __config = config; 00059 __hub = hub; 00060 00061 start(); 00062 00063 __config->add_change_handler(this); 00064 __hub->add_handler( this ); 00065 } 00066 00067 00068 /** Destructor. */ 00069 ConfigNetworkHandler::~ConfigNetworkHandler() 00070 { 00071 cancel(); 00072 join(); 00073 __config->rem_change_handler(this); 00074 __inbound_queue.clear(); 00075 } 00076 00077 00078 /** Send invalid value message. 00079 * @param clid client ID 00080 * @param path path 00081 */ 00082 void 00083 ConfigNetworkHandler::send_inv_value(unsigned int clid, const char *path) 00084 { 00085 config_invval_msg_t *r = prepare_msg<config_invval_msg_t>(path, false); 00086 __hub->send(clid, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_INV_VALUE, r, sizeof(config_invval_msg_t)); 00087 } 00088 00089 00090 /** Send value. 00091 * @param clid client ID 00092 * @param i value 00093 */ 00094 void 00095 ConfigNetworkHandler::send_value(unsigned int clid, Configuration::ValueIterator *i) 00096 { 00097 if ( i->is_float() ) { 00098 try { 00099 config_float_value_msg_t *r = prepare_msg<config_float_value_msg_t>(i->path(), i->is_default()); 00100 r->f = i->get_float(); 00101 __hub->send(clid, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_FLOAT_VALUE, r, sizeof(config_float_value_msg_t)); 00102 } catch (Exception &e) { 00103 LibLogger::log_warn("ConfigNetworkHandler", 00104 "send_value: Value %s could not be sent", 00105 i->path()); 00106 LibLogger::log_warn("ConfigNetworkHandler", e); 00107 } 00108 } else if ( i->is_uint() ) { 00109 try { 00110 config_uint_value_msg_t *r = prepare_msg<config_uint_value_msg_t>(i->path(), i->is_default()); 00111 r->u = i->get_uint(); 00112 __hub->send(clid, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_UINT_VALUE, r, sizeof(config_uint_value_msg_t)); 00113 } catch (Exception &e) { 00114 LibLogger::log_warn("ConfigNetworkHandler", 00115 "send_value: Value %s could not be sent", 00116 i->path()); 00117 LibLogger::log_warn("ConfigNetworkHandler", e); 00118 } 00119 } else if ( i->is_int() ) { 00120 try { 00121 config_int_value_msg_t *r = prepare_msg<config_int_value_msg_t>(i->path(), i->is_default()); 00122 r->i = i->get_int(); 00123 __hub->send(clid, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_INT_VALUE, r, sizeof(config_int_value_msg_t)); 00124 } catch (Exception &e) { 00125 LibLogger::log_warn("ConfigNetworkHandler", 00126 "send_value: Value %s could not be sent", 00127 i->path()); 00128 LibLogger::log_warn("ConfigNetworkHandler", e); 00129 } 00130 } else if ( i->is_bool() ) { 00131 try { 00132 config_bool_value_msg_t *r = prepare_msg<config_bool_value_msg_t>(i->path(), i->is_default()); 00133 r->b = (i->get_bool() ? 1 : 0); 00134 __hub->send(clid, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_BOOL_VALUE, r, sizeof(config_bool_value_msg_t)); 00135 } catch (Exception &e) { 00136 LibLogger::log_warn("ConfigNetworkHandler", 00137 "send_value: Value %s could not be sent", 00138 i->path()); 00139 LibLogger::log_warn("ConfigNetworkHandler", e); 00140 } 00141 } else if ( i->is_string() ) { 00142 try { 00143 size_t sl = sizeof(config_string_value_msg_t) + i->get_string().length(); 00144 config_string_value_msg_t *m = (config_string_value_msg_t *)calloc(1, sl); 00145 strncpy(m->cp.path, i->path(), CONFIG_MSG_PATH_LENGTH); 00146 m->cp.is_default = i->is_default() ? 1 : 0; 00147 m->s_length = i->get_string().length(); 00148 strcpy(m->s, i->get_string().c_str()); 00149 __hub->send(clid, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_STRING_VALUE, m, sl); 00150 } catch (Exception &e) { 00151 LibLogger::log_warn("ConfigNetworkHandler", 00152 "send_value: Value %s could not be sent", 00153 i->path()); 00154 LibLogger::log_warn("ConfigNetworkHandler", e); 00155 } 00156 } 00157 } 00158 00159 00160 /** Process all network messages that have been received. */ 00161 void 00162 ConfigNetworkHandler::loop() 00163 { 00164 while ( ! __inbound_queue.empty() ) { 00165 FawkesNetworkMessage *msg = __inbound_queue.front(); 00166 00167 // printf("Received message of type %u\n", msg->msgid()); 00168 00169 if (msg->msgid() == MSG_CONFIG_SUBSCRIBE) { 00170 00171 __subscribers.push_back_locked(msg->clid()); 00172 __subscribers.sort(); 00173 __subscribers.unique(); 00174 00175 __config->lock(); 00176 ConfigListContent *content = new ConfigListContent(); 00177 Configuration::ValueIterator *i = __config->iterator_default(); 00178 while ( i->next() ) { 00179 content->append(i); 00180 } 00181 delete i; 00182 i = __config->iterator_hostspecific(); 00183 while ( i->next() ) { 00184 content->append(i); 00185 } 00186 delete i; 00187 __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_LIST, content); 00188 __config->unlock(); 00189 00190 } else if (msg->msgid() == MSG_CONFIG_ERASE_VALUE) { 00191 try { 00192 config_erase_value_msg_t *m = msg->msg<config_erase_value_msg_t>(); 00193 char path[CONFIG_MSG_PATH_LENGTH + 1]; 00194 path[CONFIG_MSG_PATH_LENGTH] = 0; 00195 strncpy(path, m->cp.path, CONFIG_MSG_PATH_LENGTH); 00196 00197 if ( m->cp.is_default == 1 ) { 00198 __config->erase_default(path); 00199 } else { 00200 __config->erase(path); 00201 } 00202 00203 config_value_erased_msg_t *r = prepare_msg<config_value_erased_msg_t>(path, (m->cp.is_default == 1)); 00204 __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_VALUE_ERASED, 00205 r, sizeof(config_value_erased_msg_t)); 00206 00207 } catch (Exception &e) { 00208 send_inv_value(msg->clid(), "?"); 00209 e.append("Failed to erase value"); 00210 LibLogger::log_warn("ConfigNetworkHandler", "Failed to erase value"); 00211 LibLogger::log_warn("ConfigNetworkHandler", e); 00212 } 00213 00214 } else if ( (msg->msgid() >= MSG_CONFIG_GET_BEGIN) && 00215 (msg->msgid() <= MSG_CONFIG_GET_END) ) { 00216 00217 if ( msg->payload_size() != sizeof(config_getval_msg_t) ) { 00218 LibLogger::log_warn("ConfigNetworkHandler", 00219 "CONFIG_GET_FLOAT: invalid payload size " 00220 "(received %zu instead of %zu bytes", 00221 msg->payload_size(), sizeof(config_getval_msg_t)); 00222 } else { 00223 config_getval_msg_t *m = (config_getval_msg_t *)msg->payload(); 00224 char path[CONFIG_MSG_PATH_LENGTH + 1]; 00225 path[CONFIG_MSG_PATH_LENGTH] = 0; 00226 strncpy(path, m->cp.path, CONFIG_MSG_PATH_LENGTH); 00227 00228 switch (msg->msgid()) { 00229 case MSG_CONFIG_GET_FLOAT: 00230 try { 00231 float f = __config->get_float(path); 00232 bool d = __config->is_default(path); 00233 config_float_value_msg_t *r = prepare_msg<config_float_value_msg_t>(path, d); 00234 r->f = f; 00235 __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_FLOAT_VALUE, 00236 r, sizeof(config_float_value_msg_t)); 00237 } catch (Exception &e) { 00238 send_inv_value(msg->clid(), path); 00239 LibLogger::log_warn("ConfigNetworkHandler", 00240 "get float: Value %s could not be found", path); 00241 LibLogger::log_warn("ConfigNetworkHandler", e); 00242 } 00243 break; 00244 00245 case MSG_CONFIG_GET_UINT: 00246 try { 00247 unsigned int u = __config->get_uint(path); 00248 bool d = __config->is_default(path); 00249 config_uint_value_msg_t *r = prepare_msg<config_uint_value_msg_t>(path, d); 00250 r->u = u; 00251 __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_UINT_VALUE, 00252 r, sizeof(config_uint_value_msg_t)); 00253 } catch (Exception &e) { 00254 send_inv_value(msg->clid(), path); 00255 LibLogger::log_warn("ConfigNetworkHandler", 00256 "get uint: Value %s could not be found", path); 00257 LibLogger::log_warn("ConfigNetworkHandler", e); 00258 } 00259 break; 00260 00261 case MSG_CONFIG_GET_INT: 00262 try { 00263 int i = __config->get_int(path); 00264 bool d = __config->is_default(path); 00265 config_int_value_msg_t *r = prepare_msg<config_int_value_msg_t>(path, d); 00266 r->i = i; 00267 __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_INT_VALUE, 00268 r, sizeof(config_int_value_msg_t)); 00269 } catch (Exception &e) { 00270 send_inv_value(msg->clid(), path); 00271 LibLogger::log_warn("ConfigNetworkHandler", 00272 "get int: Value %s could not be found", path); 00273 LibLogger::log_warn("ConfigNetworkHandler", e); 00274 } 00275 break; 00276 00277 case MSG_CONFIG_GET_BOOL: 00278 try { 00279 bool b = __config->get_bool(path); 00280 bool d = __config->is_default(path); 00281 config_bool_value_msg_t *r = prepare_msg<config_bool_value_msg_t>(path, d); 00282 r->b = b; 00283 __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_BOOL_VALUE, 00284 r, sizeof(config_bool_value_msg_t)); 00285 } catch (Exception &e) { 00286 send_inv_value(msg->clid(), path); 00287 LibLogger::log_warn("ConfigNetworkHandler", 00288 "get bool: Value %s could not be found", path); 00289 LibLogger::log_warn("ConfigNetworkHandler", e); 00290 } 00291 break; 00292 00293 case MSG_CONFIG_GET_STRING: 00294 try { 00295 std::string s = __config->get_string(path); 00296 bool d = __config->is_default(path); 00297 config_string_value_msg_t *r = prepare_string_msg<config_string_value_msg_t>(path, d, s.length()); 00298 strcpy(r->s, s.c_str()); 00299 __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_STRING_VALUE, 00300 r, sizeof(config_string_value_msg_t)); 00301 } catch (Exception &e) { 00302 send_inv_value(msg->clid(), path); 00303 LibLogger::log_warn("ConfigNetworkHandler", 00304 "get string: Value %s could not be found", path); 00305 LibLogger::log_warn("ConfigNetworkHandler", e); 00306 } 00307 break; 00308 00309 case MSG_CONFIG_GET_VALUE: 00310 try { 00311 Configuration::ValueIterator *i = __config->get_value(path); 00312 if ( i->next() ) { 00313 send_value(msg->clid(), i); 00314 } else { 00315 send_inv_value(msg->clid(), path); 00316 } 00317 delete i; 00318 } catch (ConfigurationException &e) { 00319 LibLogger::log_warn("ConfigNetworkHandler", 00320 "get value: Value %s could not be found", path); 00321 LibLogger::log_warn("ConfigNetworkHandler", e); 00322 } 00323 break; 00324 00325 } 00326 } 00327 } else if ( (msg->msgid() >= MSG_CONFIG_SET_BEGIN) && 00328 (msg->msgid() <= MSG_CONFIG_SET_END) ) { 00329 00330 char path[CONFIG_MSG_PATH_LENGTH + 1]; 00331 if ( msg->payload_size() < sizeof(config_descriptor_t)) { 00332 LibLogger::log_warn("ConfigNetworkHandler", 00333 "inbound set: payload is too small" 00334 "(%zu is less than %zu bytes", 00335 msg->payload_size(), sizeof(config_descriptor_t)); 00336 send_inv_value(msg->clid(), "?"); 00337 } else { 00338 config_descriptor_t *d = (config_descriptor_t *)msg->payload(); 00339 path[CONFIG_MSG_PATH_LENGTH] = 0; 00340 strncpy(path, d->path, CONFIG_MSG_PATH_LENGTH); 00341 00342 switch (msg->msgid()) { 00343 case MSG_CONFIG_SET_FLOAT: 00344 case MSG_CONFIG_SET_DEFAULT_FLOAT: 00345 try { 00346 config_float_value_msg_t *m = msg->msg<config_float_value_msg_t>(); 00347 if ( msg->msgid() == MSG_CONFIG_SET_FLOAT ) { 00348 __config->set_float(path, m->f); 00349 } else { 00350 __config->set_default_float(path, m->f); 00351 } 00352 float f = __config->get_float(path); 00353 config_float_value_msg_t *r = prepare_msg<config_float_value_msg_t>(path, (msg->msgid() == MSG_CONFIG_SET_DEFAULT_FLOAT)); 00354 r->f = f; 00355 __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_FLOAT_VALUE, 00356 r, sizeof(config_float_value_msg_t)); 00357 } catch (Exception &e) { 00358 send_inv_value(msg->clid(), path); 00359 LibLogger::log_warn("ConfigNetworkHandler", 00360 "set float: Value %s could not be set", path); 00361 LibLogger::log_warn("ConfigNetworkHandler", e); 00362 } 00363 break; 00364 00365 case MSG_CONFIG_SET_UINT: 00366 case MSG_CONFIG_SET_DEFAULT_UINT: 00367 try { 00368 config_uint_value_msg_t *m = msg->msg<config_uint_value_msg_t>(); 00369 if ( msg->msgid() == MSG_CONFIG_SET_UINT ) { 00370 __config->set_uint(path, m->u); 00371 } else { 00372 __config->set_default_uint(path, m->u); 00373 } 00374 unsigned int u = __config->get_uint(path); 00375 config_uint_value_msg_t *r = prepare_msg<config_uint_value_msg_t>(path, (msg->msgid() == MSG_CONFIG_SET_DEFAULT_UINT)); 00376 r->u = u; 00377 __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_UINT_VALUE, 00378 r, sizeof(config_uint_value_msg_t)); 00379 } catch (Exception &e) { 00380 send_inv_value(msg->clid(), path); 00381 LibLogger::log_warn("ConfigNetworkHandler", 00382 "set uint: Value %s could not be set", path); 00383 LibLogger::log_warn("ConfigNetworkHandler", e); 00384 } 00385 break; 00386 00387 case MSG_CONFIG_SET_INT: 00388 case MSG_CONFIG_SET_DEFAULT_INT: 00389 try { 00390 config_int_value_msg_t *m = msg->msg<config_int_value_msg_t>(); 00391 if ( msg->msgid() == MSG_CONFIG_SET_INT ) { 00392 __config->set_int(path, m->i); 00393 } else { 00394 __config->set_default_int(path, m->i); 00395 } 00396 int i = __config->get_int(path); 00397 config_int_value_msg_t *r = prepare_msg<config_int_value_msg_t>(path, (msg->msgid() == MSG_CONFIG_SET_DEFAULT_INT)); 00398 r->i = i; 00399 __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_INT_VALUE, 00400 r, sizeof(config_int_value_msg_t)); 00401 } catch (Exception &e) { 00402 send_inv_value(msg->clid(), path); 00403 LibLogger::log_warn("ConfigNetworkHandler", 00404 "set int: Value %s could not be set", path); 00405 LibLogger::log_warn("ConfigNetworkHandler", e); 00406 } 00407 break; 00408 00409 case MSG_CONFIG_SET_BOOL: 00410 case MSG_CONFIG_SET_DEFAULT_BOOL: 00411 try { 00412 config_bool_value_msg_t *m = msg->msg<config_bool_value_msg_t>(); 00413 if ( msg->msgid() == MSG_CONFIG_SET_BOOL ) { 00414 __config->set_bool(path, (m->b != 0)); 00415 } else { 00416 __config->set_default_bool(path, (m->b != 0)); 00417 } 00418 bool b = __config->get_bool(path); 00419 config_bool_value_msg_t *r = prepare_msg<config_bool_value_msg_t>(path, (msg->msgid() == MSG_CONFIG_SET_DEFAULT_BOOL)); 00420 r->b = (b ? 1 : 0); 00421 __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_BOOL_VALUE, 00422 r, sizeof(config_bool_value_msg_t)); 00423 } catch (Exception &e) { 00424 send_inv_value(msg->clid(), path); 00425 LibLogger::log_warn("ConfigNetworkHandler", 00426 "set bool: Value %s could not be set", path); 00427 LibLogger::log_warn("ConfigNetworkHandler", e); 00428 } 00429 break; 00430 00431 case MSG_CONFIG_SET_STRING: 00432 case MSG_CONFIG_SET_DEFAULT_STRING: 00433 try { 00434 config_string_value_msg_t *m = msg->msgge<config_string_value_msg_t>(); 00435 if ( msg->msgid() == MSG_CONFIG_SET_STRING ) { 00436 __config->set_string(path, m->s); 00437 } else { 00438 __config->set_default_string(path, m->s); 00439 } 00440 std::string s = __config->get_string(path); 00441 size_t s_length = s.length(); 00442 config_string_value_msg_t *r = prepare_string_msg<config_string_value_msg_t>(path, (msg->msgid() == MSG_CONFIG_SET_DEFAULT_STRING), s_length); 00443 strcpy(r->s, s.c_str()); 00444 __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_STRING_VALUE, 00445 r, sizeof(config_string_value_msg_t) + s_length); 00446 } catch (Exception &e) { 00447 send_inv_value(msg->clid(), path); 00448 LibLogger::log_warn("ConfigNetworkHandler", 00449 "set string: Value %s could not be set", path); 00450 LibLogger::log_warn("ConfigNetworkHandler", e); 00451 } 00452 break; 00453 00454 case MSG_CONFIG_SET_COMMENT: 00455 case MSG_CONFIG_SET_DEFAULT_COMMENT: 00456 try { 00457 config_comment_msg_t *m = msg->msgge<config_comment_msg_t>(); 00458 std::string s = ""; 00459 if ( msg->msgid() == MSG_CONFIG_SET_COMMENT ) { 00460 __config->set_comment(path, m->s); 00461 s = __config->get_comment(path); 00462 } else { 00463 __config->set_default_comment(path, m->s); 00464 s = __config->get_default_comment(path); 00465 } 00466 size_t s_length = s.length(); 00467 config_comment_msg_t *r = prepare_string_msg<config_comment_msg_t>(path, (msg->msgid() == MSG_CONFIG_SET_DEFAULT_COMMENT), s_length); 00468 strcpy(r->s, s.c_str()); 00469 __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_COMMENT_VALUE, 00470 r, sizeof(config_comment_msg_t) + s_length); 00471 } catch (Exception &e) { 00472 send_inv_value(msg->clid(), path); 00473 LibLogger::log_warn("ConfigNetworkHandler", 00474 "set comment: Value %s could not be set", path); 00475 LibLogger::log_warn("ConfigNetworkHandler", e); 00476 } 00477 break; 00478 00479 } 00480 } 00481 } 00482 00483 00484 msg->unref(); 00485 __inbound_queue.pop_locked(); 00486 } 00487 } 00488 00489 00490 /** Handle network message. 00491 * The message is put into the inbound queue and processed in processAfterLoop(). 00492 * @param msg message 00493 */ 00494 void 00495 ConfigNetworkHandler::handle_network_message(FawkesNetworkMessage *msg) 00496 { 00497 msg->ref(); 00498 __inbound_queue.push_locked(msg); 00499 wakeup(); 00500 } 00501 00502 00503 /** Client connected. 00504 * Ignored. 00505 * @param clid client ID 00506 */ 00507 void 00508 ConfigNetworkHandler::client_connected(unsigned int clid) 00509 { 00510 } 00511 00512 00513 /** Client disconnected. 00514 * If the client was a subscriber it is removed. 00515 * @param clid client ID 00516 */ 00517 void 00518 ConfigNetworkHandler::client_disconnected(unsigned int clid) 00519 { 00520 __subscribers.lock(); 00521 if (find(__subscribers.begin(), __subscribers.end(), clid) != __subscribers.end()) { 00522 LibLogger::log_warn("ConfigNetworkHandler", 00523 "Client %u disconnected without closing the config, removing from list of subscribers", 00524 clid); 00525 __subscribers.remove(clid); 00526 } 00527 __subscribers.unlock(); 00528 } 00529 00530 00531 /** Tag changed. 00532 * Ignored. 00533 * @param new_tag new tag 00534 */ 00535 void 00536 ConfigNetworkHandler::config_tag_changed(const char *new_tag) 00537 { 00538 } 00539 00540 00541 void 00542 ConfigNetworkHandler::config_value_changed(const Configuration::ValueIterator *v) 00543 { 00544 const char *path = v->path(); 00545 bool is_default = v->is_default(); 00546 00547 __subscribers.lock(); 00548 for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) { 00549 try { 00550 if (v->is_string()) { 00551 std::string value = v->get_string(); 00552 size_t s_length = value.length(); 00553 config_string_value_msg_t *r = 00554 prepare_string_msg<config_string_value_msg_t>(path, is_default, 00555 s_length); 00556 strcpy(r->s, value.c_str()); 00557 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_STRING_VALUE, 00558 r, sizeof(config_string_value_msg_t) + s_length); 00559 } else if (v->is_bool()) { 00560 bool value = v->get_bool(); 00561 config_bool_value_msg_t *r = 00562 prepare_msg<config_bool_value_msg_t>(path, is_default); 00563 r->b = (value ? 1 : 0); 00564 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_BOOL_VALUE, 00565 r, sizeof(config_bool_value_msg_t)); 00566 } else if (v->is_int()) { 00567 int value = v->get_int(); 00568 config_int_value_msg_t *r = 00569 prepare_msg<config_int_value_msg_t>(path, is_default); 00570 r->i = value; 00571 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_INT_VALUE, 00572 r, sizeof(config_int_value_msg_t)); 00573 } else if (v->is_uint()) { 00574 unsigned int value = v->get_uint(); 00575 config_uint_value_msg_t *r = 00576 prepare_msg<config_uint_value_msg_t>(path, is_default); 00577 r->u = value; 00578 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_UINT_VALUE, 00579 r, sizeof(config_uint_value_msg_t)); 00580 } else if (v->is_float()) { 00581 float value = v->get_float(); 00582 config_float_value_msg_t *r = 00583 prepare_msg<config_float_value_msg_t>(path, is_default); 00584 r->f = value; 00585 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_FLOAT_VALUE, 00586 r, sizeof(config_float_value_msg_t)); 00587 } 00588 00589 } catch (Exception &e) { 00590 LibLogger::log_warn("ConfigNetworkHandler", 00591 "config_value_changed: Value for %s could not be sent " 00592 "to client %u", path, *__sit); 00593 LibLogger::log_warn("ConfigNetworkHandler", e); 00594 } 00595 } 00596 __subscribers.unlock(); 00597 } 00598 00599 00600 void 00601 ConfigNetworkHandler::config_comment_changed(const Configuration::ValueIterator *v) 00602 { 00603 const char *path = v->path(); 00604 bool is_default = v->is_default(); 00605 std::string comment = v->get_comment(); 00606 __subscribers.lock(); 00607 for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) { 00608 try { 00609 size_t s_length = comment.length(); 00610 config_comment_msg_t *r = 00611 prepare_string_msg<config_comment_msg_t>(path, is_default, s_length); 00612 strcpy(r->s, comment.c_str()); 00613 00614 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_COMMENT_VALUE, 00615 r, sizeof(config_comment_msg_t) + s_length); 00616 } catch (Exception &e) { 00617 LibLogger::log_warn("ConfigNetworkHandler", 00618 "config_comment_changed[string]: Value for %s could " 00619 "not be sent to client %u", path, *__sit); 00620 LibLogger::log_warn("ConfigNetworkHandler", e); 00621 } 00622 } 00623 __subscribers.unlock(); 00624 } 00625 00626 00627 void 00628 ConfigNetworkHandler::config_value_erased(const char *path) 00629 { 00630 __subscribers.lock(); 00631 for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) { 00632 try { 00633 config_value_erased_msg_t *r = 00634 prepare_msg<config_value_erased_msg_t>(path, false); 00635 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_VALUE_ERASED, 00636 r, sizeof(config_value_erased_msg_t)); 00637 } catch (Exception &e) { 00638 LibLogger::log_warn("ConfigNetworkHandler", 00639 "configValueErased: Value for %s could not be sent " 00640 "to client %u", path, *__sit); 00641 } 00642 } 00643 __subscribers.unlock(); 00644 } 00645 00646 } // end namespace fawkes