void rtps_rw_state_change (RemWriter_t *rwp,
unsigned s,
unsigned prev_s,
int init,
unsigned type)
{
const char *sp;
Locator_t *lp;
if (init)
sp = ".";
else if (s != prev_s)
sp = rtps_rw_state_str (type, prev_s);
else
return;
if (rwp->rw_reader->endpoint.stateful) {
if (rwp->rw_uc_locs)
lp = &rwp->rw_uc_locs->data->locator;
else if (rwp->rw_mc_locs)
lp = &rwp->rw_mc_locs->data->locator;
else
lp = NULL;
}
else
lp = NULL;
rtps_trace_r_event (rwp->rw_reader, 'S', locator_str (lp));
log_printf (RTPS_ID, 0, "%s -> %s\r\n", sp, rtps_rw_state_str (type, s));
}
void rtps_rw_signal (RemWriter_t *rwp, const char *s)
{
Locator_t *lp;
if (rwp->rw_uc_locs)
lp = &rwp->rw_uc_locs->data->locator;
else if (rwp->rw_mc_locs)
lp = &rwp->rw_mc_locs->data->locator;
else
lp = NULL;
rtps_trace_r_event (rwp->rw_reader, 'C', locator_str (lp));
log_printf (RTPS_ID, 0, "%s;\r\n", s);
}
void rtps_r_tmr_action (READER *rp,
const Locator_t *lp,
const char *type,
int start,
unsigned ticks,
const char *sp)
{
rtps_trace_r_event (rp, 'T', type);
if (lp)
log_printf (RTPS_ID, 0, "%s: ", locator_str (lp));
log_printf (RTPS_ID, 0, "%s Timer", (start) ? "Start" : "Stop");
if (sp)
log_printf (RTPS_ID, 0, "_%s", sp);
if (start)
log_printf (RTPS_ID, 0, " (%u.%02u secs)", ticks / 100, ticks % 100);
log_printf (RTPS_ID, 0, "\r\n");
}
void rtps_rr_signal (RemReader_t *rrp, const char *s)
{
Locator_t *lp;
if (rrp->rr_writer->endpoint.stateful) {
if (rrp->rr_uc_locs)
lp = &rrp->rr_uc_locs->data->locator;
else if (rrp->rr_mc_locs)
lp = &rrp->rr_mc_locs->data->locator;
else
lp = NULL;
}
else
lp = &rrp->rr_locator->locator;
rtps_trace_w_event (rrp->rr_writer, 'C', locator_str (lp));
log_printf (RTPS_ID, 0, "%s;\r\n", s);
}
int locator_list_copy_node (LocatorList_t *list,
LocatorNode_t *np)
{
LocatorRef_t *rp, *p;
for (rp = *list; rp; rp = rp->next)
if (rp->data == np) /* Already there! */
return (0);
#ifdef LOG_LOCATORS
log_printf (LOC_ID, 0, "LOC: locator_list_copy_node (list=%p, %s)\r\n", (void *) list, locator_str (&np->locator));
#endif
rp = mds_pool_alloc (&mem_blocks [MB_LOCREF]);
if (!rp)
return (1);
rp->next = NULL;
rp->data = np;
np->users++;
if (*list) {
for (p = *list; p->next; p = p->next)
;
p->next = rp;
}
else
*list = rp;
return (0);
}
LocatorNode_t *locator_list_add (LocatorList_t *list,
LocatorKind_t kind,
const unsigned char *addr,
uint32_t port,
uint32_t scope_id,
Scope_t scope,
unsigned flags,
unsigned sproto)
{
LocatorNode_t *np;
LocatorRef_t *rp, *p;
lock_take (loc_lock);
np = locator_new_node (kind, addr, port);
if (!np) {
lock_release (loc_lock);
return (NULL);
}
if (np->users == 1) {
np->locator.scope_id = scope_id;
np->locator.scope = scope;
np->locator.flags = flags;
np->locator.sproto = sproto;
}
else {
if (np->locator.scope_id != scope_id ||
(np->locator.scope && scope && np->locator.scope != scope) ||
/*(np->locator.flags && flags &&
(np->locator.flags & LOCF_MFLAGS) != (flags & LOCF_MFLAGS)) ||*/
(np->locator.sproto && sproto && np->locator.sproto != sproto))
log_printf (LOC_ID, 0, "locator_list_add: incompatible locator attributes for %s, "
"%u:%u, %u:%u, 0x%x:0x%x, %u:%u!\r\n",
locator_str (&np->locator),
np->locator.scope_id, scope_id,
np->locator.scope, scope,
np->locator.flags, flags,
np->locator.sproto, sproto);
if (!np->locator.scope_id && scope_id)
np->locator.scope_id = scope_id;
if (!np->locator.scope && scope)
np->locator.scope = scope;
if (flags && np->locator.flags != flags)
np->locator.flags |= flags;
if (!np->locator.sproto && sproto)
np->locator.sproto = sproto;
/* Check if already in list. */
for (rp = *list; rp; rp = rp->next)
if (rp->data == np) { /* Already there! */
np->users--;
lock_release (loc_lock);
return (0);
}
}
#ifdef LOG_LOCATORS
log_printf (LOC_ID, 0, "LOC: locator_list_add (list=%p, %s)\r\n", (void *) list, locator_str (&np->locator));
#endif
rp = mds_pool_alloc (&mem_blocks [MB_LOCREF]);
if (!rp) {
warn_printf ("locator_list_add: not enough memory for locator reference!\r\n");
lock_release (loc_lock);
locator_unref (np);
return (NULL);
}
rp->next = NULL;
rp->data = np;
lock_release (loc_lock);
if (*list) {
for (p = *list; p->next; p = p->next)
;
p->next = rp;
}
else
*list = rp;
return (np);
}
LocatorNode_t *locator_list_add (LocatorList_t *list,
LocatorKind_t kind,
const unsigned char *addr,
uint32_t port,
uint32_t scope_id,
Scope_t scope,
unsigned flags,
unsigned sproto)
{
LocSearchData data;
LocatorNode_t **npp, *np;
LocatorRef_t *rp, *p;
int is_new;
data.kind = kind;
data.addr = addr;
data.port = port;
lock_take (loc_lock);
npp = sl_insert (&loc_list, &data, &is_new, loc_cmp);
if (!npp) {
warn_printf ("locator_list_add: not enough memory for list node!");
lock_release (loc_lock);
return (NULL);
}
if (is_new) {
np = mds_pool_alloc (&mem_blocks [MB_LOCATOR]);
if (!np) {
warn_printf ("locator_list_add: not enough memory for locator node!");
#ifdef LIST_DELETE_NODE
sl_delete_node (&loc_list, npp);
#else
sl_delete (&loc_list, &data, loc_cmp);
#endif
lock_release (loc_lock);
return (NULL);
}
np->users = 0;
np->locator.kind = kind;
np->locator.port = port;
memcpy (np->locator.address, addr, sizeof (np->locator.address));
np->locator.scope_id = scope_id;
np->locator.scope = scope;
np->locator.flags = flags;
np->locator.sproto = sproto;
np->locator.intf = 0;
np->locator.handle = 0;
*npp = np;
}
else {
np = *npp;
if (np->locator.scope_id != scope_id ||
(np->locator.scope && scope && np->locator.scope != scope) ||
/*(np->locator.flags && flags &&
(np->locator.flags & LOCF_MFLAGS) != (flags & LOCF_MFLAGS)) ||*/
(np->locator.sproto && sproto && np->locator.sproto != sproto))
log_printf (LOC_ID, 0, "locator_list_add: incompatible locator attributes for %s, "
"%u:%u, %u:%u, 0x%x:0x%x, %u:%u!\r\n",
locator_str (&np->locator),
np->locator.scope_id, scope_id,
np->locator.scope, scope,
np->locator.flags, flags,
np->locator.sproto, sproto);
if (!np->locator.scope_id && scope_id)
np->locator.scope_id = scope_id;
if (!np->locator.scope && scope)
np->locator.scope = scope;
if (flags && np->locator.flags != flags)
np->locator.flags |= flags;
if (!np->locator.sproto && sproto)
np->locator.sproto = sproto;
/* Check if already in list. */
for (rp = *list; rp; rp = rp->next)
if (rp->data == np) { /* Already there! */
lock_release (loc_lock);
return (0);
}
}
#ifdef LOG_LOCATORS
log_printf (LOC_ID, 0, "LOC: locator_list_add (list=%p, %s)\r\n", (void *) list, locator_str (&np->locator));
#endif
rp = mds_pool_alloc (&mem_blocks [MB_LOCREF]);
if (!rp) {
warn_printf ("locator_list_add: not enough memory for locator reference!\r\n");
if (is_new) {
mds_pool_free (&mem_blocks [MB_LOCATOR], np);
#ifdef LIST_DELETE_NODE
sl_delete_node (&loc_list, npp);
#else
sl_delete (&loc_list, &data, loc_cmp);
#endif
}
lock_release (loc_lock);
return (NULL);
}
rp->next = NULL;
rp->data = np;
np->users++;
lock_release (loc_lock);
if (*list) {
for (p = *list; p->next; p = p->next)
;
p->next = rp;
}
else
*list = rp;
return (np);
}
