static PyObject* qd_set_valid_origins(PyObject *self, PyObject *args) { RouterAdapter *adapter = (RouterAdapter*) self; qd_router_t *router = adapter->router; int router_maskbit; PyObject *origin_list; Py_ssize_t idx; char *error = 0; if (!PyArg_ParseTuple(args, "iO", &router_maskbit, &origin_list)) return 0; do { if (router_maskbit >= qd_bitmask_width() || router_maskbit < 0) { error = "Router bit mask out of range"; break; } if (!PyList_Check(origin_list)) { error = "Expected List as argument 2"; break; } Py_ssize_t origin_count = PyList_Size(origin_list); qd_bitmask_t *core_bitmask = qd_bitmask(0); int maskbit; for (idx = 0; idx < origin_count; idx++) { maskbit = PyInt_AS_LONG(PyList_GetItem(origin_list, idx)); if (maskbit >= qd_bitmask_width() || maskbit < 0) { error = "Origin bit mask out of range"; break; } } if (error == 0) { qd_bitmask_set_bit(core_bitmask, 0); // This router is a valid origin for all destinations for (idx = 0; idx < origin_count; idx++) { maskbit = PyInt_AS_LONG(PyList_GetItem(origin_list, idx)); qd_bitmask_set_bit(core_bitmask, maskbit); } } else { qd_bitmask_free(core_bitmask); break; } qdr_core_set_valid_origins(router->router_core, router_maskbit, core_bitmask); } while (0); if (error) { PyErr_SetString(PyExc_Exception, error); return 0; } Py_INCREF(Py_None); return Py_None; }
static void qdr_map_destination_CT(qdr_core_t *core, qdr_action_t *action, bool discard) { // // TODO - handle the class-prefix and phase explicitly // int router_maskbit = action->args.route_table.router_maskbit; qdr_field_t *address = action->args.route_table.address; if (discard) { qdr_field_free(address); return; } do { if (router_maskbit >= qd_bitmask_width() || router_maskbit < 0) { qd_log(core->log, QD_LOG_CRITICAL, "map_destination: Router maskbit out of range: %d", router_maskbit); break; } if (core->routers_by_mask_bit[router_maskbit] == 0) { qd_log(core->log, QD_LOG_CRITICAL, "map_destination: Router not found"); break; } qd_field_iterator_t *iter = address->iterator; qdr_address_t *addr = 0; qd_hash_retrieve(core->addr_hash, iter, (void**) &addr); if (!addr) { addr = qdr_address_CT(core, qdr_treatment_for_address_hash_CT(core, iter)); qd_hash_insert(core->addr_hash, iter, addr, &addr->hash_handle); DEQ_ITEM_INIT(addr); DEQ_INSERT_TAIL(core->addrs, addr); } qdr_node_t *rnode = core->routers_by_mask_bit[router_maskbit]; qd_bitmask_set_bit(addr->rnodes, router_maskbit); rnode->ref_count++; qdr_addr_start_inlinks_CT(core, addr); // // TODO - If this affects a waypoint, create the proper side effects // } while (false); qdr_field_free(address); }
qd_bitmask_t *qd_tracemask_create(qd_tracemask_t *tm, qd_parsed_field_t *tracelist) { qd_bitmask_t *bm = qd_bitmask(0); int idx = 0; assert(qd_parse_is_list(tracelist)); sys_rwlock_rdlock(tm->lock); qd_parsed_field_t *item = qd_parse_sub_value(tracelist, idx); qdtm_router_t *router = 0; while (item) { qd_field_iterator_t *iter = qd_parse_raw(item); qd_address_iterator_reset_view(iter, ITER_VIEW_NODE_HASH); qd_hash_retrieve(tm->hash, iter, (void*) &router); if (router && router->link_maskbit >= 0) qd_bitmask_set_bit(bm, router->link_maskbit); idx++; item = qd_parse_sub_value(tracelist, idx); } sys_rwlock_unlock(tm->lock); return bm; }
static void qdr_add_router_CT(qdr_core_t *core, qdr_action_t *action, bool discard) { int router_maskbit = action->args.route_table.router_maskbit; qdr_field_t *address = action->args.route_table.address; if (discard) { qdr_field_free(address); return; } do { if (router_maskbit >= qd_bitmask_width() || router_maskbit < 0) { qd_log(core->log, QD_LOG_CRITICAL, "add_router: Router maskbit out of range: %d", router_maskbit); break; } if (core->routers_by_mask_bit[router_maskbit] != 0) { qd_log(core->log, QD_LOG_CRITICAL, "add_router: Router maskbit already in use: %d", router_maskbit); break; } // // Hash lookup the address to ensure there isn't an existing router address. // qd_field_iterator_t *iter = address->iterator; qdr_address_t *addr; qd_address_iterator_reset_view(iter, ITER_VIEW_ADDRESS_HASH); qd_hash_retrieve(core->addr_hash, iter, (void**) &addr); if (addr) { qd_log(core->log, QD_LOG_CRITICAL, "add_router: Data inconsistency for router-maskbit %d", router_maskbit); assert(addr == 0); // Crash in debug mode. This should never happen break; } // // Create an address record for this router and insert it in the hash table. // This record will be found whenever a "foreign" topological address to this // remote router is looked up. // addr = qdr_address_CT(core, QD_TREATMENT_ANYCAST_CLOSEST); qd_hash_insert(core->addr_hash, iter, addr, &addr->hash_handle); DEQ_INSERT_TAIL(core->addrs, addr); // // Create a router-node record to represent the remote router. // qdr_node_t *rnode = new_qdr_node_t(); DEQ_ITEM_INIT(rnode); rnode->owning_addr = addr; rnode->mask_bit = router_maskbit; rnode->next_hop = 0; rnode->peer_control_link = 0; rnode->peer_data_link = 0; rnode->ref_count = 0; rnode->valid_origins = qd_bitmask(0); DEQ_INSERT_TAIL(core->routers, rnode); // // Link the router record to the address record. // qd_bitmask_set_bit(addr->rnodes, router_maskbit); // // Link the router record to the router address records. // Use the T-class addresses only. // qd_bitmask_set_bit(core->router_addr_T->rnodes, router_maskbit); qd_bitmask_set_bit(core->routerma_addr_T->rnodes, router_maskbit); // // Bump the ref-count by three for each of the above links. // rnode->ref_count += 3; // // Add the router record to the mask-bit index. // core->routers_by_mask_bit[router_maskbit] = rnode; } while (false); qdr_field_free(address); }