int zmq::tipc_address_t::resolve (const char *name)
{
int res;
unsigned int type = 0;
unsigned int lower = 0;
unsigned int upper = 0;
res = sscanf(name, "{%u,%u,%u}", &type, &lower, &upper);
if (res == 3)
goto nameseq;
else if (res == 2 && type > TIPC_RESERVED_TYPES) {
address.family = AF_TIPC;
address.addrtype = TIPC_ADDR_NAME;
address.addr.name.name.type = type;
address.addr.name.name.instance = lower;
/* Since we can't specify lookup domain when connecting
* (and we're not sure that we want it to be configurable)
* Change from 'closest first' approach, to search entire zone */
address.addr.name.domain = tipc_addr(1, 0, 0);
address.scope = 0;
return 0;
}
else
return EINVAL;
nameseq:
if (type < TIPC_RESERVED_TYPES || upper < lower)
return EINVAL;
address.family = AF_TIPC;
address.addrtype = TIPC_ADDR_NAMESEQ;
address.addr.nameseq.type = type;
address.addr.nameseq.lower = lower;
address.addr.nameseq.upper = upper;
address.scope = TIPC_ZONE_SCOPE;
return 0;
}
static __u32 str2addr(char *str)
{
uint z, c, n;
char dummy;
if (sscanf(str, "%u.%u.%u%c", &z, &c, &n, &dummy) != 3)
fatal("invalid network address, use syntax: Z.C.N\n");
if ((z != delimit(z, 0, 255)) ||
(c != delimit(c, 0, 4095)) ||
(n != delimit(n, 0, 4095)))
fatal("network address field value(s) too large\n");
return tipc_addr(z, c, n);
}
__u32 str2addr(char *str)
{
unsigned int z, c, n;
char dummy;
if (sscanf(str, "%u.%u.%u%c", &z, &c, &n, &dummy) != 3) {
log_err("invalid network address, syntax: Z.C.N\n");
return 0;
}
if (IN_RANGE(z, 0, 255) && IN_RANGE(c, 0, 4095) && IN_RANGE(n, 0, 4095))
return tipc_addr(z, c, n);
log_err("invalid network address\n");
return 0;
}
struct cluster *tipc_cltr_create(u32 addr)
{
struct _zone *z_ptr;
struct cluster *c_ptr;
int max_nodes;
c_ptr = kzalloc(sizeof(*c_ptr), GFP_ATOMIC);
if (c_ptr == NULL) {
warn("Cluster creation failure, no memory\n");
return NULL;
}
c_ptr->addr = tipc_addr(tipc_zone(addr), tipc_cluster(addr), 0);
if (in_own_cluster(addr))
max_nodes = LOWEST_SLAVE + tipc_max_slaves;
else
max_nodes = tipc_max_nodes + 1;
c_ptr->nodes = kcalloc(max_nodes + 1, sizeof(void*), GFP_ATOMIC);
if (c_ptr->nodes == NULL) {
warn("Cluster creation failure, no memory for node area\n");
kfree(c_ptr);
return NULL;
}
if (in_own_cluster(addr))
tipc_local_nodes = c_ptr->nodes;
c_ptr->highest_slave = LOWEST_SLAVE - 1;
c_ptr->highest_node = 0;
z_ptr = tipc_zone_find(tipc_zone(addr));
if (!z_ptr) {
z_ptr = tipc_zone_create(addr);
}
if (!z_ptr) {
kfree(c_ptr->nodes);
kfree(c_ptr);
return NULL;
}
tipc_zone_attach_cluster(z_ptr, c_ptr);
c_ptr->owner = z_ptr;
return c_ptr;
}
struct _zone *tipc_zone_create(u32 addr)
{
struct _zone *z_ptr;
u32 z_num;
if (!tipc_addr_domain_valid(addr)) {
err("Zone creation failed, invalid domain 0x%x\n", addr);
return NULL;
}
z_ptr = kzalloc(sizeof(*z_ptr), GFP_ATOMIC);
if (!z_ptr) {
warn("Zone creation failed, insufficient memory\n");
return NULL;
}
z_num = tipc_zone(addr);
z_ptr->addr = tipc_addr(z_num, 0, 0);
tipc_net.zones[z_num] = z_ptr;
return z_ptr;
}
void tipc_cltr_recv_routing_table(struct sk_buff *buf)
{
struct tipc_msg *msg = buf_msg(buf);
struct cluster *c_ptr;
struct tipc_node *n_ptr;
unchar *node_table;
u32 table_size;
u32 router;
u32 rem_node = msg_remote_node(msg);
u32 z_num;
u32 c_num;
u32 n_num;
c_ptr = tipc_cltr_find(rem_node);
if (!c_ptr) {
c_ptr = tipc_cltr_create(rem_node);
if (!c_ptr) {
buf_discard(buf);
return;
}
}
node_table = buf->data + msg_hdr_sz(msg);
table_size = msg_size(msg) - msg_hdr_sz(msg);
router = msg_prevnode(msg);
z_num = tipc_zone(rem_node);
c_num = tipc_cluster(rem_node);
switch (msg_type(msg)) {
case LOCAL_ROUTING_TABLE:
assert(is_slave(tipc_own_addr));
case EXT_ROUTING_TABLE:
for (n_num = 1; n_num < table_size; n_num++) {
if (node_table[n_num]) {
u32 addr = tipc_addr(z_num, c_num, n_num);
n_ptr = c_ptr->nodes[n_num];
if (!n_ptr) {
n_ptr = tipc_node_create(addr);
}
if (n_ptr)
tipc_node_add_router(n_ptr, router);
}
}
break;
case SLAVE_ROUTING_TABLE:
assert(!is_slave(tipc_own_addr));
assert(in_own_cluster(c_ptr->addr));
for (n_num = 1; n_num < table_size; n_num++) {
if (node_table[n_num]) {
u32 slave_num = n_num + LOWEST_SLAVE;
u32 addr = tipc_addr(z_num, c_num, slave_num);
n_ptr = c_ptr->nodes[slave_num];
if (!n_ptr) {
n_ptr = tipc_node_create(addr);
}
if (n_ptr)
tipc_node_add_router(n_ptr, router);
}
}
break;
case ROUTE_ADDITION:
if (!is_slave(tipc_own_addr)) {
assert(!in_own_cluster(c_ptr->addr) ||
is_slave(rem_node));
} else {
assert(in_own_cluster(c_ptr->addr) &&
!is_slave(rem_node));
}
n_ptr = c_ptr->nodes[tipc_node(rem_node)];
if (!n_ptr)
n_ptr = tipc_node_create(rem_node);
if (n_ptr)
tipc_node_add_router(n_ptr, router);
break;
case ROUTE_REMOVAL:
if (!is_slave(tipc_own_addr)) {
assert(!in_own_cluster(c_ptr->addr) ||
is_slave(rem_node));
} else {
assert(in_own_cluster(c_ptr->addr) &&
!is_slave(rem_node));
}
n_ptr = c_ptr->nodes[tipc_node(rem_node)];
if (n_ptr)
tipc_node_remove_router(n_ptr, router);
break;
default:
assert(!"Illegal routing manager message received\n");
}
buf_discard(buf);
}
