DDS_ReturnCode_t DDS_DataWriter_get_matched_subscription_data (
DDS_DataWriter wp,
DDS_SubscriptionBuiltinTopicData *data,
DDS_InstanceHandle_t handle)
{
Entity_t *ep;
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_DW_G_SUBS_D, &wp, sizeof (wp));
ctrc_contd (&data, sizeof (data));
ctrc_contd (&handle, sizeof (handle));
ctrc_endd ();
if (!data || !handle)
return (DDS_RETCODE_BAD_PARAMETER);
if (!writer_ptr (wp, 1, &ret))
return (ret);
ep = entity_ptr (handle);
if (!ep ||
ep->type != ET_READER ||
entity_ignored (ep->flags)) {
ret = DDS_RETCODE_BAD_PARAMETER;
goto done;
}
if (entity_discovered (ep->flags))
ret = dcps_get_builtin_subscription_data (data, (DiscoveredReader_t *) ep);
else
ret = dcps_get_local_subscription_data (data, (Reader_t *) ep);
done:
lock_release (wp->w_lock);
return (ret);
}
DDS_MultiTopic DDS_DomainParticipant_create_multitopic (
DDS_DomainParticipant dp,
const char *name,
const char *type_name,
const char *subs_expr,
DDS_StringSeq *expr_pars)
{
ctrc_begind (DCPS_ID, DCPS_DP_C_MTOP, &dp, sizeof (dp));
ctrc_contd (name, strlen (name) + 1);
ctrc_contd (type_name, strlen (type_name) + 1);
ctrc_contd (subs_expr, strlen (subs_expr) + 1);
ctrc_contd (&expr_pars, sizeof (expr_pars));
ctrc_endd ();
ARG_NOT_USED (expr_pars)
/* Check some required parameters. */
if (!domain_ptr (dp, 0, NULL))
return (NULL);
if (!subs_expr || !name || !type_name)
return (NULL);
return (NULL);
}
DDS_ReturnCode_t DDS_Subscriber_set_listener (DDS_Subscriber sp,
DDS_SubscriberListener *listener,
DDS_StatusMask mask)
{
Domain_t *dp;
DDS_ReturnCode_t ret;
ctrc_printd (DCPS_ID, DCPS_S_S_LIS, &sp, sizeof (sp));
ctrc_contd (&listener, sizeof (listener));
ctrc_contd (&mask, sizeof (mask));
ctrc_endd ();
if (!subscriber_ptr (sp, &ret))
return (ret);
dp = domain_ptr (sp->domain, 1, &ret);
if (!dp)
return (ret);
dcps_update_listener ((Entity_t *) sp, &dp->lock,
&sp->mask, &sp->listener,
mask, listener);
lock_release (dp->lock);
return (DDS_RETCODE_OK);
}
DDS_ReturnCode_t DDS_DataWriter_dispose (DDS_DataWriter wp,
const void *data,
const DDS_InstanceHandle_t handle)
{
FTime_t time;
ctrc_begind (DCPS_ID, DCPS_DW_DISP, &wp, sizeof (wp));
ctrc_contd (&data, sizeof (data));
ctrc_contd (&handle, sizeof (handle));
ctrc_endd ();
sys_getftime (&time);
return (dcps_dispose (wp, data, 0, handle, &time, NULL));
}
DDS_InstanceHandle_t DDS_DataWriter_register_instance_w_timestamp (
DDS_DataWriter wp,
const void *data,
const DDS_Time_t *time)
{
FTime_t ftime;
ctrc_begind (DCPS_ID, DCPS_DW_R_INST_TS, &wp, sizeof (wp));
ctrc_contd (&data, sizeof (data));
ctrc_contd (time, sizeof (*time));
ctrc_endd ();
FTIME_SET (ftime, time->sec, time->nanosec);
return (dcps_register_instance (wp, data, 0, &ftime));
}
int trc_lock_destroy (pthread_mutex_t *l, const char *file, int line)
{
LockState_t *lp, *prev_lp;
unsigned h;
int res;
ARG_NOT_USED (file)
ARG_NOT_USED (line)
lock_takef (trc_lock);
h = lock_hash (l);
for (prev_lp = NULL, lp = locks [h];
lp && lp->lock != l;
prev_lp = lp, lp = lp->next)
;
if (lp) {
ltrc_print1 ("{Destroy(%s)", lp->name);
if (prev_lp)
prev_lp->next = lp->next;
else
locks [h] = lp->next;
}
#ifdef LOG_LOCKS
else
ltrc_print1 ("{Destroy(%p)", (void *) l);
#endif
ltrc_print1 ("%c}", '!');
#ifdef CTRC_LOCKS
if (ctrace_used) {
ctrc_begind (THREAD_ID, LOCK_DESTROY, &l, sizeof (l));
if (lp && lp->name)
ctrc_contd (lp->name, strlen (lp->name) + 1);
ctrc_contd (file, strlen (file) + 1);
ctrc_contd (&line, sizeof (line));
ctrc_endd ();
}
#endif
res = pthread_mutex_destroy (l);
if (res)
warn_printf ("trc_lock_destroy: pthread_mutex_destroy(%s) returned error: %s",
(lp) ? lp->name : NULL, strerror (res));
if (lp)
Free (lp);
lock_releasef (trc_lock);
return (res);
}
DDS_ReturnCode_t DDS_ContentFilteredTopic_set_expression_parameters (
DDS_ContentFilteredTopic ftp,
DDS_StringSeq *expr_pars)
{
DDS_ReturnCode_t rc;
ctrc_begind (DCPS_ID, DCPS_FT_S_PARS, &ftp, sizeof (ftp));
ctrc_contd (&expr_pars, sizeof (expr_pars));
ctrc_endd ();
if (!topic_ptr (ftp, 1, NULL))
return (DDS_RETCODE_ALREADY_DELETED);
if ((ftp->topic.entity.flags & EF_FILTERED) == 0) {
rc = DDS_RETCODE_ALREADY_DELETED;
goto done;
}
if (!expr_pars || DDS_SEQ_LENGTH (*expr_pars) < ftp->data.program.npars) {
rc = DDS_RETCODE_BAD_PARAMETER;
goto done;
}
rc = dcps_update_str_pars (&ftp->data.filter.expression_pars, expr_pars);
done:
lock_release (ftp->topic.lock);
return (rc);
}
DDS_ReturnCode_t DDS_ContentFilteredTopic_get_expression_parameters (
DDS_ContentFilteredTopic ftp,
DDS_StringSeq *expr_pars)
{
DDS_ReturnCode_t rc;
ctrc_begind (DCPS_ID, DCPS_FT_G_PARS, &ftp, sizeof (ftp));
ctrc_contd (&expr_pars, sizeof (expr_pars));
ctrc_endd ();
if (!topic_ptr (ftp, 1, NULL))
return (DDS_RETCODE_ALREADY_DELETED);
if ((ftp->topic.entity.flags & EF_FILTERED) == 0) {
lock_release (ftp->topic.lock);
return (DDS_RETCODE_ALREADY_DELETED);
}
if (!expr_pars) {
lock_release (ftp->topic.lock);
return (DDS_RETCODE_BAD_PARAMETER);
}
DDS_SEQ_INIT (*expr_pars);
rc = dcps_get_str_pars (expr_pars, ftp->data.filter.expression_pars);
lock_release (ftp->topic.lock);
return (rc);
}
DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_topics (DDS_DomainParticipant dp,
DDS_InstanceHandleSeq *handles)
{
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_DP_G_DISC_T_S, &dp, sizeof (dp));
ctrc_contd (&handles, sizeof (handles));
ctrc_endd ();
if (!handles)
return (DDS_RETCODE_BAD_PARAMETER);
if (!domain_ptr (dp, 1, &ret))
return (ret);
DDS_SEQ_INIT (*handles);
if ((dp->participant.p_flags & EF_ENABLED) == 0) {
lock_release (dp->lock);
return (DDS_RETCODE_NOT_ENABLED);
}
sl_walk (&dp->participant.p_topics, topic_add_handle, handles);
lock_release (dp->lock);
return (ret);
}
DDS_ReturnCode_t DDS_DomainParticipant_set_qos (DDS_DomainParticipant dp,
DDS_DomainParticipantQos *qos)
{
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_DP_S_QOS, &dp, sizeof (dp));
ctrc_contd (&qos, sizeof (qos));
ctrc_endd ();
if (!domain_ptr (dp, 1, &ret))
return (ret);
if (qos == DDS_PARTICIPANT_QOS_DEFAULT)
qos = &dcps_def_participant_qos;
else if (!qos_valid_participant_qos (qos)) {
ret = DDS_RETCODE_BAD_PARAMETER;
goto done;
}
if (dp->participant.p_user_data)
str_unref (dp->participant.p_user_data);
dp->participant.p_user_data = qos_octets2str (&qos->user_data.value);
dp->autoenable = qos->entity_factory.autoenable_created_entities;
if ((dp->participant.p_flags & EF_ENABLED) != 0)
ret = disc_participant_update (dp);
done:
lock_release (dp->lock);
return (ret);
}
DDS_ReturnCode_t DDS_Subscriber_set_default_datareader_qos (DDS_Subscriber sp,
DDS_DataReaderQos *qos)
{
Domain_t *dp;
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_S_S_DR_QOS, &sp, sizeof (sp));
ctrc_contd (&qos, sizeof (qos));
ctrc_endd ();
if (!subscriber_ptr (sp, &ret))
return (ret);
dp = domain_ptr (sp->domain, 1, &ret);
if (!dp)
return (ret);
if (qos == DDS_DATAREADER_QOS_DEFAULT)
qos = (DDS_DataReaderQos *) &qos_def_reader_qos;
else if (!qos_valid_reader_qos (qos)) {
ret = DDS_RETCODE_BAD_PARAMETER;
goto done;
}
sp->def_reader_qos = *qos;
done:
lock_release (dp->lock);
return (ret);
}
DDS_ReturnCode_t DDS_Subscriber_set_qos (DDS_Subscriber sp,
DDS_SubscriberQos *qos)
{
Domain_t *dp;
DDS_ReturnCode_t ret;
ctrc_printd (DCPS_ID, DCPS_S_S_QOS, &sp, sizeof (sp));
ctrc_contd (&qos, sizeof (qos));
ctrc_endd ();
if (!subscriber_ptr (sp, &ret))
return (ret);
dp = domain_ptr (sp->domain, 1, &ret);
if (!dp)
return (ret);
if (qos == DDS_PUBLISHER_QOS_DEFAULT)
qos = &sp->domain->def_subscriber_qos;
else if (!qos_valid_subscriber_qos (qos)) {
ret = DDS_RETCODE_BAD_PARAMETER;
goto done;
}
ret = qos_subscriber_update (&sp->qos, qos);
if (ret == DDS_RETCODE_OK)
sl_walk (&sp->domain->participant.p_endpoints, update_reader_qos, sp);
done:
lock_release (dp->lock);
return (ret);
}
DDS_ReturnCode_t DDS_DomainParticipant_delete_typesupport (DDS_DomainParticipant dp,
DDS_TypeSupport ts)
{
struct type_sup_rem_state_st state;
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_DP_D_TS, &p, sizeof (p));
ctrc_contd (&ts, sizeof (ts));
ctrc_endd ();
/* Validate some required arguments. */
if (!ts)
return (DDS_RETCODE_BAD_PARAMETER);
if (!domain_ptr (dp, 1, &ret))
return (ret);
/* Search type name in participant type list. */
state.part = dp;
state.ts = ts;
state.ret = DDS_RETCODE_ALREADY_DELETED;
sl_walk (&dp->types, delete_type_support, &state);
lock_release (dp->lock);
return (state.ret);
}
DDS_ReturnCode_t DDS_DomainParticipant_ignore_publication (DDS_DomainParticipant dp,
DDS_InstanceHandle_t handle)
{
Entity_t *ep;
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_DP_IGN_PUB, &dp, sizeof (dp));
ctrc_contd (&handle, sizeof (handle));
ctrc_endd ();
if (!domain_ptr (dp, 1, &ret))
return (ret);
if ((dp->participant.p_flags & EF_ENABLED) == 0) {
lock_release (dp->lock);
return (DDS_RETCODE_NOT_ENABLED);
}
ep = entity_ptr (handle);
if (!ep ||
ep->type != ET_WRITER ||
!entity_discovered (ep->flags)) {
ret = DDS_RETCODE_ALREADY_DELETED;
goto done;
}
ret = disc_ignore_writer ((DiscoveredWriter_t *) ep);
done:
lock_release (dp->lock);
return (ret);
}
DDS_ReturnCode_t DDS_Subscriber_get_default_datareader_qos (DDS_Subscriber sp,
DDS_DataReaderQos *qos)
{
Domain_t *dp;
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_S_G_DR_QOS, &sp, sizeof (sp));
ctrc_contd (&qos, sizeof (qos));
ctrc_endd ();
if (!qos) {
log_printf (DCPS_ID, 0, "get_default_datareader_qos: invalid parameters!\r\n");
return (DDS_RETCODE_BAD_PARAMETER);
}
if (!subscriber_ptr (sp, &ret))
return (ret);
dp = domain_ptr (sp->domain, 1, &ret);
if (!dp)
return (ret);
*qos = sp->def_reader_qos;
lock_release (dp->lock);
return (DDS_RETCODE_OK);
}
DDS_ReturnCode_t DDS_DataWriter_set_qos (DDS_DataWriter wp,
DDS_DataWriterQos *qos)
{
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_DW_S_QOS, &wp, sizeof (wp));
ctrc_contd (&qos, sizeof (qos));
ctrc_endd ();
if (!writer_ptr (wp, 1, &ret))
return (ret);
if (qos == DDS_DATAWRITER_QOS_DEFAULT)
qos = &wp->w_publisher->def_writer_qos;
else if (!qos_valid_writer_qos (qos)) {
ret = DDS_RETCODE_BAD_PARAMETER;
goto done;
}
ret = qos_writer_update (&wp->w_qos, qos);
done:
lock_release (wp->w_lock);
if (ret)
return (ret);
lock_take (wp->w_topic->domain->lock);
dcps_update_writer_qos (NULL, &wp, wp->w_publisher);
lock_release (wp->w_topic->domain->lock);
return (ret);
}
DDS_ReturnCode_t DDS_DataWriter_write_w_timestamp (
DDS_DataWriter wp,
const void *data,
const DDS_InstanceHandle_t handle,
const DDS_Time_t *time)
{
FTime_t ftime;
ctrc_begind (DCPS_ID, DCPS_DW_WRITE_TS, &wp, sizeof (wp));
ctrc_contd (&data, sizeof (data));
ctrc_contd (&handle, sizeof (handle));
ctrc_contd (time, sizeof (*time));
ctrc_endd ();
time2ftime ((const Time_t *) time, &ftime);
return (dcps_write (wp, data, 0, handle, &ftime, NULL));
}
DDS_ReturnCode_t DDS_DataWriter_dispose_w_timestamp (
DDS_DataWriter wp,
const void *data,
const DDS_InstanceHandle_t handle,
const DDS_Time_t *time)
{
FTime_t ftime;
ctrc_begind (DCPS_ID, DCPS_DW_DISP_TS, &wp, sizeof (wp));
ctrc_contd (&data, sizeof (data));
ctrc_contd (&handle, sizeof (handle));
ctrc_contd (time, sizeof (*time));
ctrc_endd ();
FTIME_SET (ftime, time->sec, time->nanosec);
return (dcps_dispose (wp, data, 0, handle, &ftime, NULL));
}
DDS_ReturnCode_t DDS_DataWriter_write_directed (
DDS_DataWriter wp,
const void *data,
const DDS_InstanceHandle_t handle,
DDS_InstanceHandleSeq *dests)
{
FTime_t time;
ctrc_begind (DCPS_ID, DCPS_DW_WRITE_D, &wp, sizeof (wp));
ctrc_contd (&data, sizeof (data));
ctrc_contd (&handle, sizeof (handle));
ctrc_contd (&dests, sizeof (dests));
ctrc_endd ();
sys_getftime (&time);
return (dcps_write (wp, data, 0, handle, &time, dests));
}
DDS_ReturnCode_t DDS_DataWriter_unregister_instance_w_timestamp (
DDS_DataWriter wp,
const void *instance_data,
const DDS_InstanceHandle_t handle,
const DDS_Time_t *time)
{
FTime_t ftime;
ctrc_begind (DCPS_ID, DCPS_DW_U_INST_TS, &wp, sizeof (wp));
ctrc_contd (&instance_data, sizeof (instance_data));
ctrc_contd (&handle, sizeof (handle));
ctrc_contd (time, sizeof (*time));
ctrc_endd ();
FTIME_SET (ftime, time->sec, time->nanosec);
return (dcps_unregister_instance (wp, instance_data, 0, handle, &ftime, NULL));
}
DDS_Publisher DDS_DomainParticipant_create_publisher (DDS_DomainParticipant dp,
const DDS_PublisherQos *qos,
const DDS_PublisherListener *listener,
DDS_StatusMask mask)
{
Publisher_t *up;
int enable;
ctrc_begind (DCPS_ID, DCPS_DP_C_PUB, &dp, sizeof (dp));
ctrc_contd (&qos, sizeof (qos));
ctrc_contd (&listener, sizeof (listener));
ctrc_contd (&mask, sizeof (mask));
ctrc_endd ();
prof_start (dcps_create_pub);
if (!domain_ptr (dp, 1, NULL))
return (NULL);
if (qos == DDS_PUBLISHER_QOS_DEFAULT)
qos = &dp->def_publisher_qos;
else if (!qos_valid_publisher_qos (qos)) {
up = NULL;
goto done;
}
up = publisher_create (dp, 0);
if (!up)
goto done;
qos_publisher_new (&up->qos, qos);
if (listener)
up->listener = *listener;
up->mask = mask;
up->def_writer_qos = qos_def_writer_qos;
enable = dp->autoenable;
lock_release (dp->lock);
if (enable)
DDS_Publisher_enable (up);
return (up);
done:
lock_release (dp->lock);
prof_stop (dcps_create_pub, 1);
return (NULL);
}
DDS_Subscriber DDS_DomainParticipant_create_subscriber (DDS_DomainParticipant dp,
const DDS_SubscriberQos *qos,
const DDS_SubscriberListener *listener,
DDS_StatusMask mask)
{
Subscriber_t *sp;
int enable;
ctrc_begind (DCPS_ID, DCPS_DP_C_SUB, &dp, sizeof (dp));
ctrc_contd (&qos, sizeof (qos));
ctrc_contd (&listener, sizeof (listener));
ctrc_contd (&mask, sizeof (mask));
ctrc_endd ();
prof_start (dcps_create_sub);
if (!domain_ptr (dp, 1, NULL))
return (NULL);
if (qos == DDS_SUBSCRIBER_QOS_DEFAULT)
qos = &dp->def_subscriber_qos;
else if (!qos_valid_subscriber_qos (qos)) {
sp = NULL;
goto done;
}
sp = subscriber_create (dp, 0);
if (!sp)
goto done;
qos_subscriber_new (&sp->qos, qos);
if (listener)
sp->listener = *listener;
sp->mask = mask;
enable = dp->autoenable;
lock_release (dp->lock);
if (enable)
DDS_Subscriber_enable (sp);
prof_stop (dcps_create_sub, 1);
return (sp);
done:
lock_release (dp->lock);
return (NULL);
}
int trc_lock_try (pthread_mutex_t *l, const char *file, int line)
{
LockState_t *lp;
int res;
lock_takef (trc_lock);
lp = lock_lookup (l);
#ifdef LOG_LOCKS
if (lp)
ltrc_print1 ("{TRY(%s)", lp->name);
else
ltrc_print1 ("{TRY(%p)", (void *) l);
#endif
lock_releasef (trc_lock);
res = pthread_mutex_trylock (l);
lock_takef (trc_lock);
#ifdef CTRC_LOCKS
if (ctrace_used) {
ctrc_begind (THREAD_ID, LOCK_TRY, &l, sizeof (l));
if (lp && lp->name)
ctrc_contd (lp->name, strlen (lp->name) + 1);
ctrc_contd (file, strlen (file) + 1);
ctrc_contd (&line, sizeof (line));
ctrc_contd (&res, sizeof (res));
ctrc_endd ();
}
#endif
if (res && res != EBUSY)
warn_printf ("trc_lock_try: pthread_mutex_trylock(%s) returned error: %s",
(lp) ? lp->name : NULL, strerror (res));
if (lp && !res) {
lp->state = LS_TAKEN;
lp->file = file;
lp->line = line;
lp->ntakers++;
ltrc_print1 ("{GOT(%s)}", lp->name);
}
else if (res && res != EBUSY)
warn_printf ("trc_lock_try: pthread_mutex_trylock(%s) returned error: %s",
(lp) ? lp->name : NULL, strerror (res));
lock_releasef (trc_lock);
ltrc_print1 (":%d}", res);
return (res != EBUSY);
}
DDS_ReturnCode_t DDS_DataWriter_get_matched_subscriptions(
DDS_DataWriter wp,
DDS_InstanceHandleSeq *handles)
{
Topic_t *tp;
Endpoint_t *ep;
FilteredTopic_t *ftp;
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_DW_G_MATCH_S, &wp, sizeof (wp));
ctrc_contd (&handles, sizeof (handles));
ctrc_endd ();
if (!handles)
return (DDS_RETCODE_BAD_PARAMETER);
DDS_SEQ_INIT (*handles);
if (!writer_ptr (wp, 0, &ret))
return (ret);
tp = wp->w_topic;
if (lock_take (tp->lock))
return (DDS_RETCODE_ALREADY_DELETED);
#ifndef RW_TOPIC_LOCK
if (lock_take (wp->w_lock)) {
lock_release (tp->lock);
return (DDS_RETCODE_ALREADY_DELETED);
}
#endif
for (ep = tp->writers; ep && ep != &wp->w_ep; ep = ep->next)
;
if (!ep) {
ret = DDS_RETCODE_ALREADY_DELETED;
goto done;
}
for (ep = tp->readers; ep; ep = ep->next)
if (check_matched_subscription (wp, ep, handles, NULL)) {
ret = DDS_RETCODE_OUT_OF_RESOURCES;
goto done;
}
for (ftp = tp->filters; ftp; ftp = ftp->next)
for (ep = ftp->topic.readers; ep; ep = ep->next)
if (check_matched_subscription (wp, ep, handles, NULL)) {
ret = DDS_RETCODE_OUT_OF_RESOURCES;
goto done;
}
done:
#ifndef RW_TOPIC_LOCK
lock_release (wp->w_lock);
#endif
lock_release (tp->lock);
return (ret);
}
DDS_ReturnCode_t DDS_DataWriter_dispose_w_timestamp_directed (
DDS_DataWriter wp,
const void *data,
const DDS_InstanceHandle_t handle,
const DDS_Time_t *time,
DDS_InstanceHandleSeq *dests)
{
FTime_t ftime;
ctrc_begind (DCPS_ID, DCPS_DW_DISP_TS_D, &wp, sizeof (wp));
ctrc_contd (&data, sizeof (data));
ctrc_contd (&handle, sizeof (handle));
ctrc_contd (time, sizeof (*time));
ctrc_contd (&dests, sizeof (dests));
ctrc_endd ();
time2ftime ((const Time_t *) time, &ftime);
return (dcps_dispose (wp, data, 0, handle, &ftime, dests));
}
DDS_ReturnCode_t DDS_DataWriter_write_w_timestamp_directed (
DDS_DataWriter wp,
const void *data,
const DDS_InstanceHandle_t handle,
const DDS_Time_t *time,
DDS_InstanceHandleSeq *dests)
{
FTime_t ftime;
ctrc_begind (DCPS_ID, DCPS_DW_WRITE_TS_D, &wp, sizeof (wp));
ctrc_contd (&data, sizeof (data));
ctrc_contd (&handle, sizeof (handle));
ctrc_contd (time, sizeof (*time));
ctrc_contd (dests, sizeof (dests));
ctrc_endd ();
FTIME_SET (ftime, time->sec, time->nanosec);
return (dcps_write (wp, data, 0, handle, &ftime, dests));
}
static void tcp_wait_connect_complete (SOCKET fd, short revents, void *arg)
{
TCP_CON_REQ_ST *p = (TCP_CON_REQ_ST *) arg;
IP_CX *cxp = p->cxp;
socklen_t s;
int err, r;
socklen_t sz;
ctrc_begind (TCPS_ID, TCPS_WCON_EV, &fd, sizeof (fd));
ctrc_contd (&revents, sizeof (revents));
ctrc_endd ();
trace_poll_events (fd, revents, arg);
trc_con2 ("tcp_wait_connect_complete(cp=%p, cxp=%p);\r\n", (void *) p, (void *) cxp);
p = tcp_clear_pending_connect (p);
do {
if ((revents & (POLLERR | POLLNVAL)) != 0) {
sz = sizeof (err);
r = getsockopt (cxp->fd, SOL_SOCKET, SO_ERROR, &err, &sz);
if (r == -1 || err) {
log_printf (RTPS_ID, 0, "POLLERR | POLLNVAL [%d]: %d %s\r\n", cxp->fd, err, strerror (err));
tcp_cleanup_ctx (cxp);
break;
}
}
if ((revents & POLLHUP) != 0) {
tcp_cleanup_ctx (cxp);
break;
}
if ((revents & POLLOUT) != 0) {
s = sizeof (err);
r = getsockopt (cxp->fd, SOL_SOCKET, SO_ERROR, &err, &s);
if (r || err) {
if (r)
perror ("cc_control: getsockopt(SOL_SOCKET/SO_ERROR)");
tcp_cleanup_ctx (cxp);
break;
}
}
log_printf (RTPS_ID, 0, "TCP: server connection established [%d]\r\n", cxp->fd);
cxp->cx_state = CXS_OPEN;
sock_fd_remove_socket (cxp->fd);
sock_fd_add_socket (cxp->fd,
POLLIN | POLLPRI | POLLHUP | POLLNVAL,
tcp_socket_activity,
cxp, "DDS.TCP-H");
ctrc_printd (TCPS_ID, TCPS_CON_COMPL, &fd, sizeof (fd));
cxp->stream_cb->on_connected (cxp);
}
while (0);
if (p)
tcp_do_connect (p);
}
DDS_ReturnCode_t DDS_Topic_set_qos (DDS_Topic tp, DDS_TopicQos *qos)
{
Endpoint_t *ep;
Reader_t *rp;
Writer_t *wp;
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_T_S_QOS, &tp, sizeof (tp));
ctrc_contd (&qos, sizeof (qos));
ctrc_endd ();
if (!topic_ptr (tp, 1, &ret))
return (ret);
if (qos == DDS_TOPIC_QOS_DEFAULT)
qos = &tp->domain->def_topic_qos;
else if (!qos_valid_topic_qos (qos)) {
ret = DDS_RETCODE_BAD_PARAMETER;
goto done;
}
ret = qos_topic_update (&tp->qos, qos);
if (ret != DDS_RETCODE_OK)
goto done;
/* Update all local Readers associated with topic. */
for (ep = tp->readers; ep; ep = ep->next)
if ((ep->entity.flags & EF_LOCAL) != 0) {
rp = (Reader_t *) ep;
#ifdef RW_LOCKS
lock_take (rp->r_lock);
#endif
disc_reader_update (tp->domain, rp, 1, 0);
#ifdef RW_LOCKS
lock_release (rp->r_lock);
#endif
}
/* Update all local Writers associated with topic. */
for (ep = tp->writers; ep; ep = ep->next)
if ((ep->entity.flags & EF_LOCAL) != 0) {
wp = (Writer_t *) ep;
#ifdef RW_LOCKS
lock_take (wp->w_lock);
#endif
disc_writer_update (tp->domain, wp, 1, 0);
#ifdef RW_LOCKS
lock_release (wp->w_lock);
#endif
}
done:
lock_release (tp->lock);
return (ret);
}
DDS_ReturnCode_t DDS_Topic_set_listener (DDS_Topic tp,
DDS_TopicListener *listener,
DDS_StatusMask mask)
{
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_T_S_LIS, &tp, sizeof (tp));
ctrc_contd (&listener, sizeof (listener));
ctrc_contd (&mask, sizeof (mask));
ctrc_endd ();
if (!topic_ptr (tp, 1, &ret))
return (ret);
dcps_update_listener ((Entity_t *) tp, &tp->lock,
&tp->mask, &tp->listener,
mask, listener);
lock_release (tp->lock);
return (DDS_RETCODE_OK);
}
int trc_lock_release (pthread_mutex_t *l, const char *file, int line)
{
LockState_t *lp;
int res;
lock_takef (trc_lock);
lp = lock_lookup (l);
if (lp) {
if (lp->state != LS_TAKEN)
warn_printf ("lock_release(%s) on free lock (%s:%d)",
lp->name, file, line);
ltrc_print1 ("{FREE(%s)", lp->name);
}
#ifdef LOG_LOCKS
else
ltrc_print1 ("{FREE(%p)", (void *) l);
#endif
if (lp) {
if (!--lp->ntakers)
lp->state = LS_INIT;
lp->file = file;
lp->line = line;
}
#ifdef CTRC_LOCKS
if (ctrace_used) {
ctrc_begind (THREAD_ID, LOCK_RELEASE, &l, sizeof (l));
if (lp && lp->name)
ctrc_contd (lp->name, strlen (lp->name) + 1);
ctrc_contd (file, strlen (file) + 1);
ctrc_contd (&line, sizeof (line));
ctrc_endd ();
}
#endif
res = lock_releasef (*l);
if (res)
warn_printf ("trc_lock_release: pthread_mutex_unlock(%s) returned error: %s",
(lp) ? lp->name : NULL, strerror (res));
ltrc_print1 ("%c}", '!');
lock_releasef (trc_lock);
return (res);
}
