pubsub_check.c (11512B)
1 /* Copyright (c) 2001, Matej Pfajfar. 2 * Copyright (c) 2001-2004, Roger Dingledine. 3 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. 4 * Copyright (c) 2007-2021, The Tor Project, Inc. */ 5 /* See LICENSE for licensing information */ 6 7 /** 8 * @file pubsub_check.c 9 * @brief Enforce various requirements on a pubsub_builder. 10 **/ 11 12 /** @{ */ 13 #define PUBSUB_PRIVATE 14 /** @} */ 15 16 #include "lib/dispatch/dispatch_naming.h" 17 #include "lib/dispatch/msgtypes.h" 18 #include "lib/pubsub/pubsub_flags.h" 19 #include "lib/pubsub/pubsub_builder_st.h" 20 #include "lib/pubsub/pubsub_build.h" 21 22 #include "lib/container/bitarray.h" 23 #include "lib/container/smartlist.h" 24 #include "lib/log/util_bug.h" 25 #include "lib/malloc/malloc.h" 26 #include "lib/string/compat_string.h" 27 28 #include <string.h> 29 30 static void pubsub_adjmap_add(pubsub_adjmap_t *map, 31 const pubsub_cfg_t *item); 32 33 /** 34 * Helper: construct and return a new pubsub_adjacency_map from <b>cfg</b>. 35 * Return NULL on error. 36 **/ 37 static pubsub_adjmap_t * 38 pubsub_build_adjacency_map(const pubsub_items_t *cfg) 39 { 40 pubsub_adjmap_t *map = tor_malloc_zero(sizeof(*map)); 41 const size_t n_subsystems = get_num_subsys_ids(); 42 const size_t n_msgs = get_num_message_ids(); 43 44 map->n_subsystems = n_subsystems; 45 map->n_msgs = n_msgs; 46 47 map->pub_by_subsys = tor_calloc(n_subsystems, sizeof(smartlist_t*)); 48 map->sub_by_subsys = tor_calloc(n_subsystems, sizeof(smartlist_t*)); 49 map->pub_by_msg = tor_calloc(n_msgs, sizeof(smartlist_t*)); 50 map->sub_by_msg = tor_calloc(n_msgs, sizeof(smartlist_t*)); 51 52 SMARTLIST_FOREACH_BEGIN(cfg->items, const pubsub_cfg_t *, item) { 53 pubsub_adjmap_add(map, item); 54 } SMARTLIST_FOREACH_END(item); 55 56 return map; 57 } 58 59 /** 60 * Helper: add a single pubsub_cfg_t to an adjacency map. 61 **/ 62 static void 63 pubsub_adjmap_add(pubsub_adjmap_t *map, 64 const pubsub_cfg_t *item) 65 { 66 smartlist_t **by_subsys; 67 smartlist_t **by_msg; 68 69 tor_assert(item->subsys < map->n_subsystems); 70 tor_assert(item->msg < map->n_msgs); 71 72 if (item->is_publish) { 73 by_subsys = &map->pub_by_subsys[item->subsys]; 74 by_msg = &map->pub_by_msg[item->msg]; 75 } else { 76 by_subsys = &map->sub_by_subsys[item->subsys]; 77 by_msg = &map->sub_by_msg[item->msg]; 78 } 79 80 if (! *by_subsys) 81 *by_subsys = smartlist_new(); 82 if (! *by_msg) 83 *by_msg = smartlist_new(); 84 smartlist_add(*by_subsys, (void*) item); 85 smartlist_add(*by_msg, (void *) item); 86 } 87 88 /** 89 * Release all storage held by m and set m to NULL. 90 **/ 91 #define pubsub_adjmap_free(m) \ 92 FREE_AND_NULL(pubsub_adjmap_t, pubsub_adjmap_free_, m) 93 94 /** 95 * Free every element of an <b>n</b>-element array of smartlists, then 96 * free the array itself. 97 **/ 98 static void 99 pubsub_adjmap_free_helper(smartlist_t **lsts, size_t n) 100 { 101 if (!lsts) 102 return; 103 104 for (unsigned i = 0; i < n; ++i) { 105 smartlist_free(lsts[i]); 106 } 107 tor_free(lsts); 108 } 109 110 /** 111 * Release all storage held by <b>map</b>. 112 **/ 113 static void 114 pubsub_adjmap_free_(pubsub_adjmap_t *map) 115 { 116 if (!map) 117 return; 118 pubsub_adjmap_free_helper(map->pub_by_subsys, map->n_subsystems); 119 pubsub_adjmap_free_helper(map->sub_by_subsys, map->n_subsystems); 120 pubsub_adjmap_free_helper(map->pub_by_msg, map->n_msgs); 121 pubsub_adjmap_free_helper(map->sub_by_msg, map->n_msgs); 122 tor_free(map); 123 } 124 125 /** 126 * Helper: return the length of <b>sl</b>, or 0 if sl is NULL. 127 **/ 128 static int 129 smartlist_len_opt(const smartlist_t *sl) 130 { 131 if (sl) 132 return smartlist_len(sl); 133 else 134 return 0; 135 } 136 137 /** Return a pointer to a statically allocated string encoding the 138 * dispatcher flags in <b>flags</b>. */ 139 static const char * 140 format_flags(unsigned flags) 141 { 142 static char buf[32]; 143 buf[0] = 0; 144 if (flags & DISP_FLAG_EXCL) { 145 strlcat(buf, " EXCL", sizeof(buf)); 146 } 147 if (flags & DISP_FLAG_STUB) { 148 strlcat(buf, " STUB", sizeof(buf)); 149 } 150 return buf[0] ? buf+1 : buf; 151 } 152 153 /** 154 * Log a message containing a description of <b>cfg</b> at severity, prefixed 155 * by the string <b>prefix</b>. 156 */ 157 static void 158 pubsub_cfg_dump(const pubsub_cfg_t *cfg, int severity, const char *prefix) 159 { 160 tor_assert(prefix); 161 162 tor_log(severity, LD_MESG, 163 "%s%s %s: %s{%s} on %s (%s) <%u %u %u %u %x> [%s:%d]", 164 prefix, 165 get_subsys_id_name(cfg->subsys), 166 cfg->is_publish ? "PUB" : "SUB", 167 get_message_id_name(cfg->msg), 168 get_msg_type_id_name(cfg->type), 169 get_channel_id_name(cfg->channel), 170 format_flags(cfg->flags), 171 cfg->subsys, cfg->msg, cfg->type, cfg->channel, cfg->flags, 172 cfg->added_by_file, cfg->added_by_line); 173 } 174 175 /** 176 * Helper: fill a bitarray <b>out</b> with entries corresponding to the 177 * subsystems listed in <b>items</b>. 178 **/ 179 static void 180 get_message_bitarray(const pubsub_adjmap_t *map, 181 const smartlist_t *items, 182 bitarray_t **out) 183 { 184 *out = bitarray_init_zero((unsigned)map->n_subsystems); 185 if (! items) 186 return; 187 188 SMARTLIST_FOREACH_BEGIN(items, const pubsub_cfg_t *, cfg) { 189 bitarray_set(*out, cfg->subsys); 190 } SMARTLIST_FOREACH_END(cfg); 191 } 192 193 /** 194 * Helper for lint_message: check that all the pubsub_cfg_t items in the two 195 * respective smartlists obey our local graph topology rules. 196 * 197 * (Right now this is just a matter of "each subsystem only 198 * publishes/subscribes once; no subsystem is a publisher and subscriber for 199 * the same message.") 200 * 201 * Return 0 on success, -1 on failure. 202 **/ 203 static int 204 lint_message_graph(const pubsub_adjmap_t *map, 205 message_id_t msg, 206 const smartlist_t *pub, 207 const smartlist_t *sub) 208 { 209 bitarray_t *published_by = NULL; 210 bitarray_t *subscribed_by = NULL; 211 bool ok = true; 212 213 get_message_bitarray(map, pub, &published_by); 214 get_message_bitarray(map, sub, &subscribed_by); 215 216 /* Check whether any subsystem is publishing and subscribing the same 217 * message. [??] 218 */ 219 for (unsigned i = 0; i < map->n_subsystems; ++i) { 220 if (bitarray_is_set(published_by, i) && 221 bitarray_is_set(subscribed_by, i)) { 222 log_warn(LD_MESG|LD_BUG, 223 "Message \"%s\" is published and subscribed by the same " 224 "subsystem \"%s\".", 225 get_message_id_name(msg), 226 get_subsys_id_name(i)); 227 ok = false; 228 } 229 } 230 231 bitarray_free(published_by); 232 bitarray_free(subscribed_by); 233 234 return ok ? 0 : -1; 235 } 236 237 /** 238 * Helper for lint_message: check that all the pubsub_cfg_t items in the two 239 * respective smartlists have compatible flags, channels, and types. 240 **/ 241 static int 242 lint_message_consistency(message_id_t msg, 243 const smartlist_t *pub, 244 const smartlist_t *sub) 245 { 246 if (!smartlist_len_opt(pub) && !smartlist_len_opt(sub)) 247 return 0; // LCOV_EXCL_LINE -- this was already checked. 248 249 /* The 'all' list has the publishers and the subscribers. */ 250 smartlist_t *all = smartlist_new(); 251 if (pub) 252 smartlist_add_all(all, pub); 253 if (sub) 254 smartlist_add_all(all, sub); 255 256 const pubsub_cfg_t *item0 = smartlist_get(all, 0); 257 258 /* Indicates which subsystems we've found publishing/subscribing here. */ 259 bool pub_excl = false, sub_excl = false, chan_same = true, type_same = true; 260 261 /* Simple message consistency properties across messages. 262 */ 263 SMARTLIST_FOREACH_BEGIN(all, const pubsub_cfg_t *, cfg) { 264 chan_same &= (cfg->channel == item0->channel); 265 type_same &= (cfg->type == item0->type); 266 if (cfg->is_publish) 267 pub_excl |= (cfg->flags & DISP_FLAG_EXCL) != 0; 268 else 269 sub_excl |= (cfg->flags & DISP_FLAG_EXCL) != 0; 270 } SMARTLIST_FOREACH_END(cfg); 271 272 bool ok = true; 273 274 if (! chan_same) { 275 log_warn(LD_MESG|LD_BUG, 276 "Message \"%s\" is associated with multiple inconsistent " 277 "channels.", 278 get_message_id_name(msg)); 279 ok = false; 280 } 281 if (! type_same) { 282 log_warn(LD_MESG|LD_BUG, 283 "Message \"%s\" is associated with multiple inconsistent " 284 "message types.", 285 get_message_id_name(msg)); 286 ok = false; 287 } 288 289 /* Enforce exclusive-ness for publishers and subscribers that have asked for 290 * it. 291 */ 292 if (pub_excl && smartlist_len_opt(pub) > 1) { 293 log_warn(LD_MESG|LD_BUG, 294 "Message \"%s\" has multiple publishers, but at least one is " 295 "marked as exclusive.", 296 get_message_id_name(msg)); 297 ok = false; 298 } 299 if (sub_excl && smartlist_len_opt(sub) > 1) { 300 log_warn(LD_MESG|LD_BUG, 301 "Message \"%s\" has multiple subscribers, but at least one is " 302 "marked as exclusive.", 303 get_message_id_name(msg)); 304 ok = false; 305 } 306 307 smartlist_free(all); 308 309 return ok ? 0 : -1; 310 } 311 312 /** 313 * Check whether there are any errors or inconsistencies for the message 314 * described by <b>msg</b> in <b>map</b>. If there are problems, log about 315 * them, and return -1. Otherwise return 0. 316 **/ 317 static int 318 lint_message(const pubsub_adjmap_t *map, message_id_t msg) 319 { 320 /* NOTE: Some of the checks in this function are maybe over-zealous, and we 321 * might not want to have them forever. I've marked them with [?] below. 322 */ 323 if (BUG(msg >= map->n_msgs)) 324 return 0; // LCOV_EXCL_LINE 325 326 const smartlist_t *pub = map->pub_by_msg[msg]; 327 const smartlist_t *sub = map->sub_by_msg[msg]; 328 329 const size_t n_pub = smartlist_len_opt(pub); 330 const size_t n_sub = smartlist_len_opt(sub); 331 332 if (n_pub == 0 && n_sub == 0) { 333 log_info(LD_MESG, "Nobody is publishing or subscribing to message " 334 "\"%s\".", 335 get_message_id_name(msg)); 336 return 0; // No publishers or subscribers: nothing to do. 337 } 338 /* We'll set this to false if there are any problems. */ 339 bool ok = true; 340 341 /* First make sure that if there are publishers, there are subscribers. */ 342 if (n_pub == 0) { 343 log_warn(LD_MESG|LD_BUG, 344 "Message \"%s\" has subscribers, but no publishers.", 345 get_message_id_name(msg)); 346 ok = false; 347 } else if (n_sub == 0) { 348 log_warn(LD_MESG|LD_BUG, 349 "Message \"%s\" has publishers, but no subscribers.", 350 get_message_id_name(msg)); 351 ok = false; 352 } 353 354 /* Check the message graph topology. */ 355 if (lint_message_graph(map, msg, pub, sub) < 0) 356 ok = false; 357 358 /* Check whether the messages have the same fields set on them. */ 359 if (lint_message_consistency(msg, pub, sub) < 0) 360 ok = false; 361 362 if (!ok) { 363 /* There was a problem -- let's log all the publishers and subscribers on 364 * this message */ 365 if (pub) { 366 SMARTLIST_FOREACH(pub, pubsub_cfg_t *, cfg, 367 pubsub_cfg_dump(cfg, LOG_WARN, " ")); 368 } 369 if (sub) { 370 SMARTLIST_FOREACH(sub, pubsub_cfg_t *, cfg, 371 pubsub_cfg_dump(cfg, LOG_WARN, " ")); 372 } 373 } 374 375 return ok ? 0 : -1; 376 } 377 378 /** 379 * Check all the messages in <b>map</b> for consistency. Return 0 on success, 380 * -1 on problems. 381 **/ 382 static int 383 pubsub_adjmap_check(const pubsub_adjmap_t *map) 384 { 385 bool all_ok = true; 386 for (unsigned i = 0; i < map->n_msgs; ++i) { 387 if (lint_message(map, i) < 0) { 388 all_ok = false; 389 } 390 } 391 return all_ok ? 0 : -1; 392 } 393 394 /** 395 * Check builder for consistency and various constraints. Return 0 on success, 396 * -1 on failure. 397 **/ 398 int 399 pubsub_builder_check(pubsub_builder_t *builder) 400 { 401 pubsub_adjmap_t *map = pubsub_build_adjacency_map(builder->items); 402 int rv = -1; 403 404 if (!map) 405 goto err; // should be impossible 406 407 if (pubsub_adjmap_check(map) < 0) 408 goto err; 409 410 rv = 0; 411 err: 412 pubsub_adjmap_free(map); 413 return rv; 414 }