void tty_input (HANDLE fd, short events, void *udata) { char ch; unsigned n; ARG_NOT_USED (fd) ARG_NOT_USED (events) ARG_NOT_USED (udata) DDS_continue (); n = tty_read (&ch, 1); if (!n) return; if (full) { printf ("\a"); return; } tty_queue [wp++] = ch; if (wp >= MAX_QUEUE) wp = 0; empty = 0; if (wp == rp) full = 1; }
AuthState_t validate_peer_identity (Identity_t id, void *token, unsigned char *identity, size_t identity_length, unsigned char *challenge, size_t *challenge_length) { Identity_t h; AuthState_t r; DDS_IdentityToken rem_idt, *list; DDS_OctetSeq seq; DDS_ReturnCode_t err; ARG_NOT_USED (token) ARG_NOT_USED (challenge) DDS_DataHolder__init (&rem_idt, DDS_DTLS_ID_TOKEN_CLASS); rem_idt.binary_value1 = &seq; DDS_SEQ_INIT (seq); seq._buffer = identity; seq._maximum = seq._length = identity_length; rem_idt.nusers = ~0; list = &rem_idt; r = sec_validate_remote_id (id, &list, NULL, NULL, &h, &err); *challenge_length = 0; if (err) return (AS_FAILED); return (r); }
static int trace_set_fct (Skiplist_t *list, void *node, void *arg) { Endpoint_t *ep, **epp = (Endpoint_t **) node; unsigned *mode = (unsigned *) arg; ARG_NOT_USED (list) ARG_NOT_USED (arg) ep = *epp; if (!ep->rtps) return (1); rtps_trace_set (ep, *mode); return (1); }
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); }
static int sfw_be_new_change (RemReader_t *rrp, Change_t *cp, HCI hci, SequenceNumber_t *snr) { CCREF *rp; ARG_NOT_USED (snr) ctrc_printd (RTPS_ID, RTPS_SFW_BE_NEW, &rrp, sizeof (rrp)); prof_start (rtps_bw_new); RR_SIGNAL (rrp, "BE-NewChange"); #ifdef RTPS_MARKERS if (rrp->rr_writer->endpoint.mark_newch) rtps_marker_notify (rrp->rr_writer->endpoint.endpoint, EM_NEW_CHANGE, "sfw_be_new_change"); #endif rp = change_enqueue (rrp, cp, hci, CS_UNSENT); if (!rp) return (0); rp->ack_req = 1; rrp->rr_unacked++; if (!rrp->rr_unsent_changes) { rrp->rr_unsent_changes = rp; proxy_activate (&rrp->proxy); } NEW_RR_TSTATE (rrp, RRTS_PUSHING, 0); CACHE_CHECK (&rrp->rr_writer->endpoint, "sfw_be_new_change"); prof_stop (rtps_bw_new, 1); return (1); }
char *sys_username (char *buf, size_t length) { #ifdef _WIN32 char ts [UNLEN + 1]; DWORD len = sizeof (ts); if (!GetUserNameA (ts, &len)) fatal_printf ("sys_username(): GetUserNameA() returned error!"); if (len >= length) fatal_printf ("sys_username(): buffer too short!"); memcpy (buf, ts, len); buf [len] = '\0'; #elif defined (NUTTX_RTOS) ARG_NOT_USED (length) strcpy (buf, "NuttX_username"); #else char *cp = getlogin (); if (strlen (cp) >= length) { memcpy (buf, cp, length - 1); buf [length - 1] = '\0'; warn_printf ("sys_username(): login name too long ('%s')!", cp); } else strcpy (buf, cp); #endif return (buf); }
void read_msg (DDS_DataReaderListener *l, DDS_DataReader dr) { ChatMsg_t msg; DDS_InstanceStateKind kind; int valid; DDS_ReturnCode_t ret; ARG_NOT_USED (l) memset (&msg, 0, sizeof (msg)); ret = ChatMsg_read_or_take (dr, &msg, DDS_NOT_READ_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE, 1, &valid, &kind); if (ret == DDS_RETCODE_OK) do { #ifndef DISPLAY_SELF if (!strcmp (msg.from, user_name) && !strcmp (msg.chatroom, chatroom)) break; #endif if (valid) printf ("%s: %s\r\n", msg.from, msg.message); else if (kind == DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE) printf ("%s is busy!\r\n", msg.from); else if (kind == DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE) printf ("%s has left!\r\n", msg.from); } while (0); ChatMsg_cleanup (&msg); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % I n i t i a l i z e P i x e l I t e r a t o r O p t i o n s % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % InitializePixelIteratorOptions() assigns default options to a user-provided % PixelIteratorOptions structure. This function should always be used % to initialize the PixelIteratorOptions structure prior to making any % changes to it. % % The format of the InitializePixelIteratorOptions method is: % % void InitializePixelIteratorOptions(PixelIteratorOptions *options, % ExceptionInfo *exception) % % A description of each parameter follows: % % o options: pointer to PixelIteratorOptions structure to initialize. % % o exception: Return any errors or warnings in this structure. % */ MagickExport void InitializePixelIteratorOptions(PixelIteratorOptions *options, ExceptionInfo *exception) { ARG_NOT_USED(exception); assert(options != (PixelIteratorOptions *) NULL); options->max_threads=0; options->signature=MagickSignature; }
static MagickPassFail CdlImagePixels(void *mutable_data, /* User provided mutable data */ const void *immutable_data, /* User provided immutable data */ Image *image, /* Modify image */ PixelPacket *pixels, /* Pixel row */ IndexPacket *indexes, /* Pixel row indexes */ const long npixels, /* Number of pixels in row */ ExceptionInfo *exception) /* Exception report */ { const CdlImageParameters_t param = *(const CdlImageParameters_t *) immutable_data; register long i; ARG_NOT_USED(mutable_data); ARG_NOT_USED(image); ARG_NOT_USED(indexes); ARG_NOT_USED(exception); if (param.lut != (PixelPacket *) NULL) { for(i = 0; i < npixels; i++) { pixels[i].red=param.lut[pixels[i].red].red; pixels[i].green=param.lut[pixels[i].green].green; pixels[i].blue=param.lut[pixels[i].blue].blue; } } else { for(i = 0; i < npixels; i++) { pixels[i].red=CdlQuantum(pixels[i].red,param.redslope,param.redoffset, param.redpower,param.saturation); pixels[i].green=CdlQuantum(pixels[i].green,param.greenslope,param.greenoffset, param.greenpower,param.saturation); pixels[i].blue=CdlQuantum(pixels[i].blue,param.blueslope,param.blueoffset, param.bluepower,param.saturation); } } return MagickPass; }
char *sys_hostname (char *buf, size_t length) { #if defined (NUTTX_RTOS) ARG_NOT_USED (length) strcpy (buf, "NuttX_hostname"); #else gethostname (buf, length); #endif return (buf); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % I n i t i a l i z e D i f f e r e n c e S t a t i s t i c s % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % InitializeDifferenceStatistics() assigns default options to a user-provided % DifferenceStatistics structure. % % The format of the InitializeDifferenceStatistics method is: % % void InitializeDifferenceStatistics(DifferenceStatistics *options, % ExceptionInfo *exception) % % A description of each parameter follows: % % o options: pointer to DifferenceStatistics structure to initialize. % % o exception: Return any errors or warnings in this structure. % */ MagickExport void InitializeDifferenceStatistics(DifferenceStatistics *statistics, ExceptionInfo *exception) { ARG_NOT_USED(exception); assert(statistics != (DifferenceStatistics *) NULL); statistics->red=0.0; statistics->green=0.0; statistics->blue=0.0; statistics->opacity=0.0; statistics->combined=0.0; }
static int topic_type_check_fct (Skiplist_t *list, void *node, void *arg) { Topic_t *tp, **tpp = (Topic_t **) node; struct type_lookup_st *lookup = (struct type_lookup_st *) arg; ARG_NOT_USED (list) tp = *tpp; if (tp->nlrefs && tp->type == lookup->type) { lookup->nusers++; } return (1); }
static Permissions_t sp_check_rem_perms (const SEC_PERM *pp, Identity_t local, Identity_t remote, DDS_PermissionsToken *token, DDS_PermissionsCredential *cred) { DDS_SecurityReqData data; DDS_ReturnCode_t ret; ARG_NOT_USED (pp) ARG_NOT_USED (token) data.handle = remote; data.secure = local; data.data = DDS_SEQ_DATA (*cred->binary_value1); data.length = DDS_SEQ_LENGTH (*cred->binary_value1); data.name = cred->class_id; ret = sec_access_control_request (DDS_VALIDATE_REMOTE_PERM, &data); if (ret) return (0); return (data.handle); }
/* Compute the squared difference. In this case we sum the square of the difference between channel pixel quantums. */ static MagickPassFail ComputeSquaredError(void *mutable_data, const void *immutable_data, const Image *first_image, const PixelPacket *first_pixels, const IndexPacket *first_indexes, const Image *second_image, const PixelPacket *second_pixels, const IndexPacket *second_indexes, const long npixels, ExceptionInfo *exception) { DifferenceStatistics lstats, *stats = (DifferenceStatistics *) mutable_data; double difference; register long i; ARG_NOT_USED(immutable_data); ARG_NOT_USED(first_image); ARG_NOT_USED(first_indexes); ARG_NOT_USED(second_image); ARG_NOT_USED(second_indexes); ARG_NOT_USED(exception); InitializeDifferenceStatistics(&lstats,exception); for (i=0; i < npixels; i++) { difference=(first_pixels[i].red-(double) second_pixels[i].red)/MaxRGBDouble; lstats.red += difference*difference; difference=(first_pixels[i].green-(double) second_pixels[i].green)/MaxRGBDouble; lstats.green += difference*difference; difference=(first_pixels[i].blue-(double) second_pixels[i].blue)/MaxRGBDouble; lstats.blue += difference*difference; difference=(first_pixels[i].opacity-(double) second_pixels[i].opacity)/MaxRGBDouble; lstats.opacity += difference*difference; } #if defined(HAVE_OPENMP) # pragma omp critical (GM_ComputeSquaredError) #endif { stats->red += lstats.red; stats->green += lstats.green; stats->blue += lstats.blue; stats->opacity += lstats.opacity; } return (MagickPass); }
static int participant_add_handle (Skiplist_t *list, void *node, void *arg) { const Participant_t *pp, **ppp = (const Participant_t **) node; DDS_InstanceHandleSeq *handles = (DDS_InstanceHandleSeq *) arg; DDS_InstanceHandle_t h; ARG_NOT_USED (list) pp = *ppp; if (entity_ignored (pp->p_entity.flags)) return (1); h = pp->p_handle; return (dds_seq_append (handles, &h) == 0); }
static int topic_type_promote_tc_fct (Skiplist_t *list, void *node, void *arg) { Topic_t *tp, **tpp = (Topic_t **) node; TPTC_t *tptc = (TPTC_t *) arg; ARG_NOT_USED (list) tp = *tpp; if (tp->nlrefs && tp->type == tptc->type) { topic_type_promote_tc_eps (tp->writers, tptc, 1); topic_type_promote_tc_eps (tp->readers, tptc, 0); tptc->ntopics--; } return (tptc->ntopics != 0); }
static int topic_add_handle (Skiplist_t *list, void *node, void *arg) { const Topic_t *tp, **tpp = (const Topic_t **) node; DDS_InstanceHandleSeq *handles = (DDS_InstanceHandleSeq *) arg; DDS_InstanceHandle_t h; ARG_NOT_USED (list) tp = *tpp; if (!entity_discovered (tp->entity.flags) || entity_ignored (tp->entity.flags)) return (1); h = tp->entity.handle; return (dds_seq_append (handles, &h) == 0); }
static int delete_type (Skiplist_t *list, void *node, void *arg) { TopicType_t *ttp, **ttpp = (TopicType_t **) node; DDS_DomainParticipant p = (DDS_DomainParticipant) arg; ARG_NOT_USED (list) ttp = *ttpp; if ((ttp->flags & (EF_BUILTIN | EF_LOCAL)) == EF_LOCAL) { dtrc_printf ("participant_delete_contained_entitities: unregister Type (%s)\r\n", str_ptr (ttp->type_name)); DDS_DomainParticipant_unregister_type (p, ttp->type_support, str_ptr (ttp->type_name)); } return (1); }
int dcps_delete_topic (Skiplist_t *list, void *node, void *arg) { Topic_t *tp, **tpp = (Topic_t **) node; DDS_DomainParticipant p = (DDS_DomainParticipant) arg; unsigned n; ARG_NOT_USED (list) tp = *tpp; if ((tp->entity.flags & EF_BUILTIN) == 0) { dtrc_printf ("participant_delete_contained_entitities: delete Topic (%s)\r\n", str_ptr (tp->name)); for (n = tp->nlrefs; n; n--) /* Make sure we *really* delete it! */ DDS_DomainParticipant_delete_topic (p, tp); } return (1); }
static int delete_type_support (Skiplist_t *list, void *node, void *arg) { TopicType_t *typep, **typepp = (TopicType_t **) node; struct type_sup_rem_state_st *state = (struct type_sup_rem_state_st *) arg; ARG_NOT_USED (list) typep = *typepp; if ((typep->flags & EF_LOCAL) != 0 && typep->type_support == state->ts) { state->ret = DDS_DomainParticipant_unregister_type (state->part, state->ts, (void *) str_ptr (typep->type_name)); return (0); } return (1); }
char *sys_osname (char *buf, size_t length) { ARG_NOT_USED (length) #ifdef _WIN32 strcpy (buf, "Windows"); #elif defined (__APPLE__) strcpy (buf, "OSX"); #elif defined (NetBSD) strcpy (buf, "NetBSD"); #elif defined (__FreeBSD__) strcpy (buf, "FreeBSD"); #elif defined (__OpenBSD__) strcpy (buf, "OpenBSD"); #else strcpy (buf, "Linux"); #endif return (buf); }
void read_msg (DDS_DataReaderListener *l, DDS_DataReader dr) { Vector3_dos_t msg; DDS_InstanceStateKind kind; int valid; DDS_ReturnCode_t ret; ARG_NOT_USED (l) memset (&msg, 0, sizeof (msg)); ret = Vector3_dos_read_or_take (dr, &msg, DDS_NOT_READ_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE, 1, &valid, &kind); if (ret == DDS_RETCODE_OK) do { #if 0 /* Use a from field within the message to avoid to read the messages that this node sent. */ #ifndef DISPLAY_SELF if (!strcmp (msg.from, user_name) && !strcmp (msg.chatroom, chatroom)) break; #endif #endif if (valid){ printf ("Vector3_dos message:\r\n"); printf (" uno.x_=%f, uno.y_=%f and uno.z_=%f\r\n", msg.uno.x_, msg.uno.y_, msg.uno.z_); printf (" dos.x_=%f, dos.y_=%f and dos.z_=%f\r\n", msg.dos.x_, msg.dos.y_, msg.dos.z_); } else if (kind == DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE) printf ("DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE!\r\n"); else if (kind == DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE) printf ("DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE!\r\n"); } while (0); Vector3_dos_cleanup (&msg); }
static int subscriber_notify_reader (Skiplist_t *list, void *node, void *args) { Endpoint_t *ep, **epp = (Endpoint_t **) node; Subscriber_t *sp = (Subscriber_t *) args; Reader_t *rp; ARG_NOT_USED (list) ep = *epp; if (!entity_reader (entity_type (&ep->entity)) || ep->u.subscriber != sp) return (1); rp = (Reader_t *) ep; if (dcps_data_available_listener (rp) && (rp->r_status & DDS_DATA_AVAILABLE_STATUS) != 0) dds_notify (NSC_DCPS, (Entity_t *) rp, NT_DATA_AVAILABLE); else if (rp->r_conditions) dcps_waitset_wakeup (rp, rp->r_conditions, &sp->domain->lock); return (1); }
static int subscriber_get_reader (Skiplist_t *list, void *node, void *args) { Endpoint_t *ep, **epp = (Endpoint_t **) node; SubGReaders_t *sp = (SubGReaders_t *) args; Reader_t *rp; ARG_NOT_USED (list) ep = *epp; if (!entity_reader (entity_type (&ep->entity)) || ep->u.subscriber != sp->sp) return (1); rp = (Reader_t *) ep; if (!hc_avail (rp->r_cache, sp->skip)) return (1); if (dds_seq_append (sp->rseq, (DDS_DataReader *) &rp)) { sp->ret = DDS_RETCODE_OUT_OF_RESOURCES; return (0); } return (1); }
static int update_reader_qos (Skiplist_t *list, void *node, void *arg) { Reader_t *rp, **rpp = (Reader_t **) node; Subscriber_t *sp = (Subscriber_t *) arg; ARG_NOT_USED (list) rp = *rpp; if (rp->r_subscriber == sp && (rp->r_flags & EF_ENABLED) != 0) { lock_take (rp->r_topic->lock); #ifdef RW_LOCKS lock_take (rp->r_lock); #endif hc_qos_update (rp->r_cache); disc_reader_update (sp->domain, rp, 1, 0); #ifdef RW_LOCKS lock_release (rp->r_lock); #endif lock_release (rp->r_topic->lock); } return (1); }
static void msg_data_info (Participant_t *pp, ParticipantMessageData *dp, char dir, InfoType_t type) { uint32_t *lp = (uint32_t *) &dp->participantGuidPrefix; ARG_NOT_USED (pp) log_printf (SPDP_ID, 0, "MSG-%c: %08x:%08x:%08x - ", dir, ntohl (lp [0]), ntohl (lp [1]), ntohl (lp [2])); if ((dp->kind [0] & 0x80) != 0) log_printf (SPDP_ID, 0, "Vendor: %02x.%02x.%02x.%02x, ", dp->kind [0], dp->kind [1], dp->kind [2], dp->kind [3]); else if (dp->kind [0] == 0 && dp->kind [1] == 0 && dp->kind [2] == 0 && (dp->kind [3] == 1 || dp->kind [3] == 2)) if (dp->kind [3] == 1) log_printf (SPDP_ID, 0, "Auto Liveliness Update, "); else log_printf (SPDP_ID, 0, "Manual Liveliness Update, "); else log_printf (SPDP_ID, 0, "Reserved: %02x.%02x.%02x.%02x, ", dp->kind [0], dp->kind [1], dp->kind [2], dp->kind [3]); switch (type) { case EI_NEW: log_printf (SPDP_ID, 0, "{New} "); msg_dump_data (&dp->data); break; case EI_UPDATE: msg_dump_data (&dp->data); break; case EI_DELETE: log_printf (SPDP_ID, 0, "{deleted}!\r\n"); break; } }
static int ep_dump_fct (Skiplist_t *list, void *node, void *arg) { LocalEndpoint_t *ep, **epp = (LocalEndpoint_t **) node; DomainId_t *dip = (DomainId_t *) arg; int n; ARG_NOT_USED (list) ep = *epp; dbg_printf (" %u/%02x%02x%02x-%02x %c{%u}\t", *dip, ep->ep.entity_id.id [0], ep->ep.entity_id.id [1], ep->ep.entity_id.id [2], ep->ep.entity_id.id [3], entity_writer (entity_type (&ep->ep.entity)) ? 'W' : 'R', ep->ep.entity.handle); dbg_printf ("%u", hc_total_changes (ep->cache)); if ((n = hc_total_instances (ep->cache)) >= 0) dbg_printf ("/%d", n); dbg_printf ("\t%s/%s\r\n", str_ptr (ep->ep.topic->name), str_ptr (ep->ep.topic->type->type_name)); return (1); }
r = DDS_DomainParticipant_delete_subscriber (p, sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_topic (p, t); fail_unless (r == DDS_RETCODE_OK); unregister_HelloWorldData_type (p); r = DDS_DomainParticipantFactory_delete_participant (p); fail_unless (r == DDS_RETCODE_OK); } static void subscription_matched ( DDS_DataReaderListener *self, DDS_DataReader reader, /* in (variable length) */ DDS_SubscriptionMatchedStatus *status) { ARG_NOT_USED (self) ARG_NOT_USED (reader) ARG_NOT_USED (status) } static void sample_rejected ( DDS_DataReaderListener *self, DDS_DataReader reader, /* in (variable length) */ DDS_SampleRejectedStatus *status) { ARG_NOT_USED (self) ARG_NOT_USED (reader) ARG_NOT_USED (status) } static void data_available (
static Token_t *sp_get_perm_token (const SEC_PERM *pp, Permissions_t id) { Token_t *tp; unsigned char *p; DDS_SecurityReqData data; DDS_PermissionsToken *token; size_t cred_len; DDS_ReturnCode_t error; ARG_NOT_USED (pp) tp = xmalloc (sizeof (Token_t)); if (!tp) return (NULL); token = DDS_DataHolder__alloc (GMCLASSID_SECURITY_PERMISSIONS_TOKEN); if (!token) { xfree (tp); return (NULL); } token->binary_value1 = DDS_OctetSeq__alloc (); if (!token->binary_value1) goto free_dh; error = dds_seq_require (token->binary_value1, 32); if (error) goto free_dh; data.handle = id; data.data = NULL; data.kdata = NULL; data.length = 0; data.rlength = 0; error = sec_access_control_request (DDS_GET_PERM_CRED, &data); if (error) goto free_dh; cred_len = data.rlength; p = xmalloc (cred_len); if (!p) goto free_dh; data.data = p; data.kdata = NULL; data.length = cred_len; error = sec_access_control_request (DDS_GET_PERM_CRED, &data); if (error) goto free_p; error = sec_hash_sha256 ((unsigned char *) p, cred_len, DDS_SEQ_DATA (*token->binary_value1)); xfree (p); if (error) goto free_dh; tp->data = token; tp->nusers = 1; tp->encoding = 0; tp->integral = 0; tp->next = NULL; return (tp); free_p: xfree (p); free_dh: DDS_DataHolder__free (token); xfree (tp); return (NULL); }
tp->next = NULL; return (tp); free_p: xfree (p); free_dh: DDS_DataHolder__free (token); xfree (tp); return (NULL); } /* sp_free_perm_token -- Release a previously received PermissionsToken. */ static void sp_free_perm_token (const SEC_PERM *pp, Permissions_t h) { ARG_NOT_USED (pp) ARG_NOT_USED (h) /* ... TBC ... */ } /* sp_get_perm_creds -- Get a PermissionsCredential token from a permissions handle. */ static DDS_PermissionsCredential *sp_get_perm_creds (const SEC_PERM *pp, Permissions_t id) { ARG_NOT_USED (pp) ARG_NOT_USED (id) /* ... TBC ... */