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); }