00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <config/net_handler.h>
00025 #include <config/net_messages.h>
00026 #include <config/net_list_content.h>
00027 #include <utils/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
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
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
00069 ConfigNetworkHandler::~ConfigNetworkHandler()
00070 {
00071 cancel();
00072 join();
00073 __config->rem_change_handler(this);
00074 __inbound_queue.clear();
00075 }
00076
00077
00078
00079
00080
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
00091
00092
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
00161 void
00162 ConfigNetworkHandler::loop()
00163 {
00164 while ( ! __inbound_queue.empty() ) {
00165 FawkesNetworkMessage *msg = __inbound_queue.front();
00166
00167
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
00491
00492
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
00504
00505
00506
00507 void
00508 ConfigNetworkHandler::client_connected(unsigned int clid)
00509 {
00510 }
00511
00512
00513
00514
00515
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
00532
00533
00534
00535 void
00536 ConfigNetworkHandler::config_tag_changed(const char *new_tag)
00537 {
00538 }
00539
00540
00541 void
00542 ConfigNetworkHandler::config_value_changed(const char *path, bool is_default, int value)
00543 {
00544 __subscribers.lock();
00545 for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00546 try {
00547 config_int_value_msg_t *r = prepare_msg<config_int_value_msg_t>(path, is_default);
00548 r->i = value;
00549 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_INT_VALUE,
00550 r, sizeof(config_int_value_msg_t));
00551 } catch (Exception &e) {
00552 LibLogger::log_warn("ConfigNetworkHandler",
00553 "config_value_changed[int]: Value for %s could not be sent "
00554 "to client %u", path, *__sit);
00555 LibLogger::log_warn("ConfigNetworkHandler", e);
00556 }
00557 }
00558 __subscribers.unlock();
00559 }
00560
00561
00562 void
00563 ConfigNetworkHandler::config_value_changed(const char *path, bool is_default, unsigned int value)
00564 {
00565 __subscribers.lock();
00566 for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00567 try {
00568 config_uint_value_msg_t *r = prepare_msg<config_uint_value_msg_t>(path, is_default);
00569 r->u = value;
00570 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_UINT_VALUE,
00571 r, sizeof(config_uint_value_msg_t));
00572 } catch (Exception &e) {
00573 LibLogger::log_warn("ConfigNetworkHandler",
00574 "config_value_changed[uint]: Value for %s could not be sent "
00575 "to client %u", path, *__sit);
00576 LibLogger::log_warn("ConfigNetworkHandler", e);
00577 }
00578 }
00579 __subscribers.unlock();
00580 }
00581
00582
00583 void
00584 ConfigNetworkHandler::config_value_changed(const char *path, bool is_default, float value)
00585 {
00586 __subscribers.lock();
00587 for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00588 try {
00589 config_float_value_msg_t *r = prepare_msg<config_float_value_msg_t>(path, is_default);
00590 r->f = value;
00591 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_FLOAT_VALUE,
00592 r, sizeof(config_float_value_msg_t));
00593 } catch (Exception &e) {
00594 LibLogger::log_warn("ConfigNetworkHandler",
00595 "config_value_changed[float]: Value for %s could not be sent "
00596 "to client %u", path, *__sit);
00597 LibLogger::log_warn("ConfigNetworkHandler", e);
00598 }
00599 }
00600 __subscribers.unlock();
00601 }
00602
00603
00604 void
00605 ConfigNetworkHandler::config_value_changed(const char *path, bool is_default, bool value)
00606 {
00607 __subscribers.lock();
00608 for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00609 try {
00610 config_bool_value_msg_t *r = prepare_msg<config_bool_value_msg_t>(path, is_default);
00611 r->b = (value ? 1 : 0);
00612 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_BOOL_VALUE,
00613 r, sizeof(config_bool_value_msg_t));
00614 } catch (Exception &e) {
00615 LibLogger::log_warn("ConfigNetworkHandler",
00616 "config_value_changed[bool]: Value for %s could not be sent "
00617 "to client %u", path, *__sit);
00618 LibLogger::log_warn("ConfigNetworkHandler", e);
00619 }
00620 }
00621 __subscribers.unlock();
00622 }
00623
00624
00625 void
00626 ConfigNetworkHandler::config_value_changed(const char *path, bool is_default, const char *value)
00627 {
00628 __subscribers.lock();
00629 for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00630 try {
00631 size_t s_length = strlen(value);
00632 config_string_value_msg_t *r = prepare_string_msg<config_string_value_msg_t>(path, is_default, s_length);
00633 strcpy(r->s, value);
00634 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_STRING_VALUE,
00635 r, sizeof(config_string_value_msg_t) + s_length);
00636 } catch (Exception &e) {
00637 LibLogger::log_warn("ConfigNetworkHandler",
00638 "config_value_changed[string]: Value for %s could not be sent "
00639 "to client %u", path, *__sit);
00640 LibLogger::log_warn("ConfigNetworkHandler", e);
00641 }
00642 }
00643 __subscribers.unlock();
00644 }
00645
00646
00647 void
00648 ConfigNetworkHandler::config_comment_changed(const char *path, bool is_default, const char *comment)
00649 {
00650 __subscribers.lock();
00651 for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00652 try {
00653 size_t s_length = strlen(comment);
00654 config_comment_msg_t *r = prepare_string_msg<config_comment_msg_t>(path, is_default, s_length);
00655 strcpy(r->s, comment);
00656
00657 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_COMMENT_VALUE,
00658 r, sizeof(config_comment_msg_t) + s_length);
00659 } catch (Exception &e) {
00660 LibLogger::log_warn("ConfigNetworkHandler",
00661 "config_value_changed[string]: Value for %s could not be sent "
00662 "to client %u", path, *__sit);
00663 LibLogger::log_warn("ConfigNetworkHandler", e);
00664 }
00665 }
00666 __subscribers.unlock();
00667 }
00668
00669
00670 void
00671 ConfigNetworkHandler::config_value_erased(const char *path, bool is_default)
00672 {
00673 __subscribers.lock();
00674 for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00675 try {
00676 config_value_erased_msg_t *r = prepare_msg<config_value_erased_msg_t>(path, is_default);
00677 __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_VALUE_ERASED,
00678 r, sizeof(config_value_erased_msg_t));
00679 } catch (Exception &e) {
00680 LibLogger::log_warn("ConfigNetworkHandler",
00681 "configValueErased: Value for %s could not be sent "
00682 "to client %u", path, *__sit);
00683 }
00684 }
00685 __subscribers.unlock();
00686 }
00687
00688 }