/** * Set async I/O polling method. This function can also be called while the * program is running. * * @param method New polling method * * @return 0 if success, otherwise errorcode */ int poll_method_set(enum poll_method method) { struct re *re; int err; switch (method) { #ifdef HAVE_POLL case METHOD_POLL: break; #endif #ifdef HAVE_SELECT case METHOD_SELECT: break; #endif #ifdef HAVE_EPOLL case METHOD_EPOLL: if (!epoll_check()) return EINVAL; break; #endif #ifdef HAVE_ACTSCHED case METHOD_ACTSCHED: break; #endif default: DEBUG_WARNING("poll method not supported: '%s'\n", poll_method_name(method)); return EINVAL; } re = re_get(); re->method = method; re->update = true; DEBUG_INFO("Setting async I/O polling method to `%s'\n", poll_method_name(re->method)); err = fd_setsize(DEFAULT_MAXFDS); if (err) return err; err = poll_init(re); if (err) return err; return rebuild_fds(re); }
int audio_encoder_set(struct audio *a, const struct aucodec *ac, int pt_tx, const char *params, struct user_extra_data_t *user_data) { struct autx *tx; int err = 0; bool reset; if (!a || !ac) return EINVAL; tx = &a->tx; reset = !aucodec_equal(ac, tx->ac); if (ac != tx->ac) { re_printf("Set audio encoder: %s %uHz %dch\n", ac->name, get_srate(ac), ac->ch); /* Audio source must be stopped first */ if (reset) { tx->ausrc = mem_deref(tx->ausrc); } tx->is_g722 = (0 == str_casecmp(ac->name, "G722")); tx->enc = mem_deref(tx->enc); tx->ac = ac; } if (ac->encupdh) { struct auenc_param prm; prm.ptime = tx->ptime; err = ac->encupdh(&tx->enc, ac, &prm, params); if (err) { DEBUG_WARNING("alloc encoder: %m\n", err); return err; } } stream_set_srate(a->strm, get_srate(ac), get_srate(ac)); stream_update_encoder(a->strm, pt_tx); if (!tx->ausrc) { err |= audio_start(a, user_data); } return err; }
void stream_send_fir(struct stream *s, bool pli) { int err; if (!s) return; if (pli) err = rtcp_send_pli(s->rtp, s->ssrc_rx); else err = rtcp_send_fir(s->rtp, rtp_sess_ssrc(s->rtp)); if (err) { DEBUG_WARNING("Send FIR: %m\n", err); } }
/** * Get one frame from the jitter buffer * * @param jb Jitter buffer * @param hdr Returned RTP Header * @param mem Pointer to memory object storage - referenced on success * * @return 0 if success, otherwise errorcode */ int jbuf_get(struct jbuf *jb, struct rtp_header *hdr, void **mem) { struct frame *f; if (!jb || !hdr || !mem) return EINVAL; STAT_INC(n_get); if (jb->n <= jb->min || !jb->framel.head) { DEBUG_INFO("not enough buffer frames - wait.. (n=%u min=%u)\n", jb->n, jb->min); STAT_INC(n_underflow); return ENOENT; } /* When we get one frame F[i], check that the next frame F[i+1] is present and have a seq no. of seq[i] + 1 ! if not, we should consider that packet lost */ f = jb->framel.head->data; #if JBUF_STAT /* Check timestamp of previously played frame */ if (jb->seq_get) { const int16_t seq_diff = f->hdr.seq - jb->seq_get; if (seq_less(f->hdr.seq, jb->seq_get)) { DEBUG_WARNING("get: seq=%u too late\n", f->hdr.seq); } else if (seq_diff > 1) { STAT_ADD(n_lost, 1); DEBUG_INFO("get: n_lost: diff=%d,seq=%u,seq_get=%u\n", seq_diff, f->hdr.seq, jb->seq_get); } } /* Update sequence number for 'get' */ jb->seq_get = f->hdr.seq; #endif *hdr = f->hdr; *mem = mem_ref(f->mem); frame_deref(jb, f); return 0; }
static int mod_srtp_init(void) { err_status_t err; err = srtp_init(); if (err_status_ok != err) { DEBUG_WARNING("srtp_init() failed (%H)\n", errstatus_print, err); return ENOSYS; } menc_register(&menc_srtp_opt); menc_register(&menc_srtp_mand); menc_register(&menc_srtp_mandf); return 0; }
jboolean JNICALL ScriptMethodsServerUINamespace::clearSuiDataSourceContainer(JNIEnv * env, jobject self, jint pageId, jstring dataSourceContainer) { JavaStringParam localDataSource(dataSourceContainer); ServerUIPage * const p = ServerUIManager::getPage(pageId); if(!p) { DEBUG_WARNING(true, ("SUI: Could not find page %d, cannot clear datasource", pageId)); return JNI_FALSE; } std::string ds; JavaLibrary::convert(localDataSource, ds); p->clearDataSourceContainer(ds); return JNI_TRUE; }
int audio_decoder_set(struct audio *a, const struct aucodec *ac, int pt_rx, const char *params) { struct aurx *rx; bool reset = false; int err = 0; if (!a || !ac) return EINVAL; rx = &a->rx; reset = !aucodec_equal(ac, rx->ac); if (ac != rx->ac) { (void)re_fprintf(stderr, "Set audio decoder: %s %uHz %dch\n", ac->name, get_srate(ac), ac->ch); rx->pt = pt_rx; rx->ac = ac; rx->dec = mem_deref(rx->dec); } if (ac->decupdh) { err = ac->decupdh(&rx->dec, ac, params); if (err) { DEBUG_WARNING("alloc decoder: %m\n", err); return err; } } stream_set_srate(a->strm, get_srate(ac), get_srate(ac)); if (reset) { rx->auplay = mem_deref(rx->auplay); /* Reset audio filter chain */ list_flush(&a->filtl); err |= audio_start(a); } return err; }
/** * Read a block of memory from a memory buffer * * @param mb Memory buffer * @param buf Buffer to read data to * @param size Size of buffer * * @return 0 if success, otherwise errorcode */ int mbuf_read_mem(struct mbuf *mb, uint8_t *buf, size_t size) { if (!mb || !buf) return EINVAL; if (size > mbuf_get_left(mb)) { DEBUG_WARNING("tried to read beyond mbuf end (%u > %u)\n", size, mbuf_get_left(mb)); return EOVERFLOW; } memcpy(buf, mb->buf + mb->pos, size); mb->pos += size; return 0; }
const char* inet_ntop(int af, const void *src, char *dst, size_t size) { switch (af) { case AF_INET: return inet_ntop4(src, dst, size); #ifdef HAVE_INET6 case AF_INET6: return inet_ntop6(src, dst, size); #endif default: DEBUG_WARNING("inet_ntop: unknown address family %d\n", af); return NULL; } }
/** * Call the application event handler * * @param re Poll state * @param fd File descriptor * @param flags Event flags */ static void fd_handler(struct re *re, int fd, int flags) { const uint64_t tick = tmr_jiffies(); uint32_t diff; DEBUG_INFO("event on fd=%d (flags=0x%02x)...\n", fd, flags); re->fhs[fd].fh(flags, re->fhs[fd].arg); diff = (uint32_t)(tmr_jiffies() - tick); if (diff > MAX_BLOCKING) { DEBUG_WARNING("long async blocking: %u>%u ms (h=%p arg=%p)\n", diff, MAX_BLOCKING, re->fhs[fd].fh, re->fhs[fd].arg); } }
static void decode_param(const struct pl *name, const struct pl *val, void *arg) { struct aucodec_st *st = arg; int err; if (0 == pl_strcasecmp(name, "bitrate")) { st->bitrate = pl_u32(val) * 1000; } else if (0 == pl_strcasecmp(name, "frame-size")) { st->frame_size = pl_u32(val); if (st->frame_size & 0x1) { DEBUG_WARNING("frame-size is NOT even: %u\n", st->frame_size); } } else if (0 == pl_strcasecmp(name, "low-overhead")) { struct pl fs, bpfv; uint32_t i; st->low_overhead = true; err = re_regex(val->p, val->l, "[0-9]+/[0-9,]+", &fs, &bpfv); if (err) return; st->frame_size = pl_u32(&fs); for (i=0; i<ARRAY_SIZE(st->bpfv) && bpfv.l > 0; i++) { struct pl bpf, co; co.l = 0; if (re_regex(bpfv.p, bpfv.l, "[0-9]+[,]*", &bpf, &co)) break; pl_advance(&bpfv, bpf.l + co.l); st->bpfv[i] = pl_u32(&bpf); } st->bpfn = i; } else { DEBUG_NOTICE("unknown param: %r = %r\n", name, val); } }
void rtcp_sess_rx_rtp(struct rtcp_sess *sess, uint16_t seq, uint32_t ts, uint32_t ssrc, size_t payload_size, const struct sa *peer) { struct rtp_member *mbr; if (!sess) return; mbr = get_member(sess, ssrc); if (!mbr) { DEBUG_NOTICE("could not add member: 0x%08x\n", ssrc); return; } if (!mbr->s) { mbr->s = mem_zalloc(sizeof(*mbr->s), NULL); if (!mbr->s) { DEBUG_NOTICE("could not add sender: 0x%08x\n", ssrc); return; } /* first packet - init sequence number */ source_init_seq(mbr->s, seq); mbr->s->max_seq = seq - 1; /* probation not used */ sa_cpy(&mbr->s->rtp_peer, peer); ++sess->senderc; } if (!source_update_seq(mbr->s, seq)) { DEBUG_WARNING("rtp_update_seq() returned 0\n"); } if (sess->srate_rx) { uint32_t ts_arrive; /* Convert from wall-clock time to timestamp units */ ts_arrive = (uint32_t)(tmr_jiffies()) * sess->srate_rx / 1000; source_calc_jitter(mbr->s, ts, ts_arrive); } mbr->s->rtp_rx_bytes += payload_size; }
static int play_alloc(struct auplay_st **stp, struct auplay *ap, struct auplay_prm *prm, const char *device, auplay_write_h *wh, void *arg) { struct auplay_st *st; int err; int i; (void)device; if (play_dev_count < 1) { DEBUG_WARNING("no winwave play devices\n"); return ENODEV; } st = mem_zalloc(sizeof(*st), auplay_destructor); if (!st) return ENOMEM; st->ap = mem_ref(ap); st->wh = wh; st->arg = arg; if (prm) { prm->fmt = AUFMT_S16LE; st->prm = *prm; } err = write_stream_open(st); if (err) goto out; /* The write runs at 100ms intervals * prepare enough buffers to suite its needs */ for (i = 0; i < 5; i++) dsp_write(st); out: if (err) mem_deref(st); else *stp = st; return err; }
void CTcpSock::RunL() { DEBUG_INFO("CTcpSock RunL (%p) iStatus=%d ts=%p\n", this, iStatus.Int(), ts); /* This happens after calling cancel functions in socket */ if (iStatus == KErrCancel || iStatus == KErrAbort) { iStatus = KErrNone; return; } else if (iStatus != KErrNone) { DEBUG_WARNING("RunL received iStatus %d\n", iStatus.Int()); } /* Incoming CONNECT */ DEBUG_INFO("CTcpSock RunL (%p) Incoming CONNECT\n", this); ts->tcp_conn_handler(); }
static void tcp_conn_handler(const struct sa *peer, void *arg) { struct ice_lcand *lcand = arg; int err; #if 0 trice_printf(lcand->icem, "[local=%H] incoming TCP-connect from %J\n", trice_cand_print, lcand, peer); #endif err = trice_conn_alloc(&lcand->icem->connl, lcand->icem, lcand->attr.compid, false, &lcand->attr.addr, peer, lcand->ts, lcand->layer, tcpconn_frame_handler, lcand); if (err) { DEBUG_WARNING("ice_conn_alloc error (%m)\n", err); } }
static void add_wave_in(struct ausrc_st *st) { MMRESULT res; struct dspbuf *db = &st->bufs[st->pos]; WAVEHDR *wh = &db->wh; wh->lpData = (LPSTR)db->mb->buf; wh->dwBufferLength = db->mb->size; wh->dwBytesRecorded = 0; wh->dwFlags = 0; wh->dwUser = (DWORD_PTR) db->mb; waveInPrepareHeader(st->wavein, wh, sizeof(WAVEHDR)); res = waveInAddBuffer(st->wavein, wh, sizeof(WAVEHDR)); if (res != MMSYSERR_NOERROR) DEBUG_WARNING("add_wave_in: waveOutWrite fail: %08x\n", res); INC_RPOS(st->pos); st->inuse++; }
void ServerIntangibleObjectTemplate::_Ingredient::getIngredientsMax(SimpleIngredient &data, int index, bool versionOk) const { const ServerIntangibleObjectTemplate::_Ingredient * base = NULL; if (m_baseData != NULL) { base = dynamic_cast<const ServerIntangibleObjectTemplate::_Ingredient *>(m_baseData); } if (!m_ingredientsLoaded) { if (ms_allowDefaultTemplateParams && /*!versionOk &&*/ base == NULL) { DEBUG_WARNING(true, ("Returning default value for missing parameter ingredients in template %s", DataResource::getName())); return ; } else { DEBUG_FATAL(base == NULL, ("Template parameter ingredients has not been defined in template %s!", DataResource::getName())); base->getIngredientsMax(data, index, versionOk); return; } } if (m_ingredientsAppend && base != NULL) { int baseCount = base->getIngredientsCount(); if (index < baseCount) { base->getIngredientsMax(data, index, versionOk); return; } index -= baseCount; } DEBUG_FATAL(index < 0 || static_cast<size_t>(index) >= m_ingredients.size(), ("template param index out of range")); const ObjectTemplate * structTemplate = (*m_ingredients[index]).getValue(); NOT_NULL(structTemplate); const _SimpleIngredient *param = dynamic_cast<const _SimpleIngredient *>(structTemplate); NOT_NULL(param); data.name = param->getName(versionOk); data.ingredient = param->getIngredient(versionOk); data.count = param->getCountMax(versionOk); } // ServerIntangibleObjectTemplate::_Ingredient::getIngredientsMax
/** * Debug all allocated memory objects */ void mem_debug(void) { #if MEM_DEBUG uint32_t n; mem_lock(); n = list_count(&meml); mem_unlock(); if (!n) return; DEBUG_WARNING("Memory leaks (%u):\n", n); mem_lock(); (void)list_apply(&meml, true, debug_handler, NULL); mem_unlock(); #endif }
void CUdpSocket::RunL() { DEBUG_INFO("RunL iStatus=%d\n", iStatus.Int()); /* This happens after calling cancel functions in socket */ if (iStatus == KErrCancel || iStatus == KErrAbort) { iStatus = KErrNone; } else if (iStatus == KErrGeneral) { /* cache error code */ us->cerr = ECONNREFUSED; } else if (iStatus != KErrNone) { DEBUG_WARNING("RunL received iStatus %d\n", iStatus.Int()); } else if (iBufRx.Length()) { us->recv(); } }
static void *read_thread(void *arg) { struct vidsrc_st *st = arg; while (st->run) { ssize_t n; n = read(st->fd, st->mb->buf, st->mb->size); if ((ssize_t)st->mb->size != n) { DEBUG_WARNING("video read: %d -> %d bytes\n", st->mb->size, n); continue; } call_frame_handler(st, st->mb->buf); } return NULL; }
void ServerManufactureSchematicObjectTemplate::getAttributesMax(SchematicAttribute &data, int index) const { const ServerManufactureSchematicObjectTemplate * base = NULL; if (m_baseData != NULL) { base = dynamic_cast<const ServerManufactureSchematicObjectTemplate *>(m_baseData); } if (!m_attributesLoaded) { if (ms_allowDefaultTemplateParams && /*!m_versionOk &&*/ base == NULL) { DEBUG_WARNING(true, ("Returning default value for missing parameter attributes in template %s", DataResource::getName())); return ; } else { DEBUG_FATAL(base == NULL, ("Template parameter attributes has not been defined in template %s!", DataResource::getName())); base->getAttributesMax(data, index); return; } } if (m_attributesAppend && base != NULL) { int baseCount = base->getAttributesCount(); if (index < baseCount) { base->getAttributesMax(data, index); return; } index -= baseCount; } DEBUG_FATAL(index < 0 || static_cast<size_t>(index) >= m_attributes.size(), ("template param index out of range")); const ObjectTemplate * structTemplate = (*m_attributes[index]).getValue(); NOT_NULL(structTemplate); const _SchematicAttribute *param = dynamic_cast<const _SchematicAttribute *>(structTemplate); NOT_NULL(param); data.name = param->getName(m_versionOk); data.value = param->getValueMax(m_versionOk); } // ServerManufactureSchematicObjectTemplate::getAttributesMax
/** * Check List and Timer State Updates */ void icem_checklist_update(struct icem *icem) { struct le *le; bool compl; int err = 0; compl = iscompleted(icem); if (!compl) return; /* * If there is not a pair in the valid list for each component of the * media stream, the state of the check list is set to Failed. */ for (le = icem->compl.head; le; le = le->next) { struct icem_comp *comp = le->data; if (!icem_candpair_find_compid(&icem->validl, comp->id)) { DEBUG_WARNING("{%s.%u} no valid candidate pair" " (validlist=%u)\n", icem->name, comp->id, list_count(&icem->validl)); err = ENOENT; break; } concluding_ice(comp); if (!comp->cp_sel) continue; icem_comp_keepalive(comp, true); } icem->state = err ? CHECKLIST_FAILED : CHECKLIST_COMPLETED; if (icem->chkh) { icem->chkh(err, icem->ice->lrole == ROLE_CONTROLLING, icem->arg); } }
static int read_stream_open(struct ausrc_st *st) { MMRESULT err; WAVEFORMATEX wfmt; int i; /* Open an audio INPUT stream. */ st->wavein = NULL; st->pos = 0; st->rdy = false; st->stop = false; for (i = 0; i < READ_BUFFERS; i++) { memset(&st->bufs[i].wh, 0, sizeof(WAVEHDR)); st->bufs[i].mb = mbuf_alloc(2 * st->prm.frame_size); } wfmt.wFormatTag = WAVE_FORMAT_PCM; wfmt.nChannels = st->prm.ch; wfmt.nSamplesPerSec = st->prm.srate; wfmt.wBitsPerSample = 16; wfmt.nBlockAlign = (st->prm.ch * wfmt.wBitsPerSample) / 8; wfmt.nAvgBytesPerSec = wfmt.nSamplesPerSec * wfmt.nBlockAlign; wfmt.cbSize = 0; err = waveInOpen(&st->wavein, WAVE_MAPPER, &wfmt, (DWORD_PTR) waveInCallback, (DWORD_PTR) st, CALLBACK_FUNCTION | WAVE_FORMAT_DIRECT); if (err != MMSYSERR_NOERROR) { DEBUG_WARNING("waveInOpen: failed %d\n", err); return EINVAL; } /* Prepare enough IN buffers to suite at least 50ms of data */ for (i = 0; i < READ_BUFFERS; i++) add_wave_in(st); waveInStart(st->wavein); return 0; }
int trice_alloc(struct trice **icemp, const struct trice_conf *conf, bool controlling, const char *lufrag, const char *lpwd) { struct trice *icem; int err = 0; if (!icemp || !lufrag || !lpwd) return EINVAL; if (str_len(lufrag) < 4 || str_len(lpwd) < 22) { DEBUG_WARNING("alloc: lufrag/lpwd is too short\n"); return EINVAL; } icem = mem_zalloc(sizeof(*icem), trice_destructor); if (!icem) return ENOMEM; icem->conf = conf ? *conf : conf_default; list_init(&icem->lcandl); list_init(&icem->rcandl); list_init(&icem->checkl); list_init(&icem->validl); icem->controlling = controlling; icem->tiebrk = rand_u64(); err |= str_dup(&icem->lufrag, lufrag); err |= str_dup(&icem->lpwd, lpwd); if (err) goto out; out: if (err) mem_deref(icem); else *icemp = icem; return err; }
/** * Listen to a SIP Session socket for incoming connections * * @param sockp Pointer to allocated SIP Session socket * @param sip SIP Stack instance * @param htsize Hashtable size * @param connh Connection handler * @param arg Handler argument * * @return 0 if success, otherwise errorcode */ int sipsess_listen(struct sipsess_sock **sockp, struct sip *sip, int htsize, sipsess_conn_h *connh, void *arg) { struct sipsess_sock *sock; int err; DEBUG_WARNING("re.sipsess.listen.sipsess_listen()\n"); if (!sockp || !sip || !htsize) return EINVAL; sock = mem_zalloc(sizeof(*sock), destructor); if (!sock) return ENOMEM; err = sip_listen(&sock->lsnr_resp, sip, false, response_handler, sock); if (err) goto out; err = sip_listen(&sock->lsnr_req, sip, true, request_handler, sock); if (err) goto out; err = hash_alloc(&sock->ht_sess, htsize); if (err) goto out; err = hash_alloc(&sock->ht_ack, htsize); if (err) goto out; sock->sip = sip; sock->connh = connh ? connh : internal_connect_handler; sock->arg = connh ? arg : sock; out: if (err) mem_deref(sock); else *sockp = sock; return err; }
void stream_start_keepalive(struct stream *s) { const char *rtpkeep; if (!s) return; rtpkeep = ua_param(call_get_ua(s->call), "rtpkeep"); s->rtpkeep = mem_deref(s->rtpkeep); if (rtpkeep && sdp_media_rformat(s->sdp, NULL)) { int err; err = rtpkeep_alloc(&s->rtpkeep, rtpkeep, IPPROTO_UDP, s->rtp, s->sdp); if (err) { DEBUG_WARNING("rtpkeep_alloc failed: %m\n", err); } } }
/** * Decode SDP session attributes * * @param ice ICE Session * @param name Name of the SDP attribute * @param value Value of the SDP attribute (optional) * * @return 0 if success, otherwise errorcode */ int ice_sdp_decode(struct ice *ice, const char *name, const char *value) { if (!ice) return EINVAL; if (0 == str_casecmp(name, ice_attr_lite)) { if (ICE_MODE_LITE == ice->lmode) { DEBUG_WARNING("we are lite, peer is also lite!\n"); return EPROTO; } ice->rmode = ICE_MODE_LITE; ice->lrole = ROLE_CONTROLLING; } else if (0 == str_casecmp(name, ice_attr_ufrag)) return ufrag_decode(ice, value); else if (0 == str_casecmp(name, ice_attr_pwd)) return pwd_decode(ice, value); return 0; }
static void sniff_stun(struct mbuf *mb) { struct stun_msg *msg; size_t pos; int err; pos = mb->pos; err = stun_msg_decode(&msg, mb, NULL); if (err) { DEBUG_WARNING("could not decode STUN packet (%m)\n", err); return; } stun_msg_attr_apply(msg, stun_attr_handler, 0); (void)re_printf("\n"); mem_deref(msg); mb->pos = pos; }
const StringId ServerIntangibleObjectTemplate::_SchematicAttribute::getName(bool versionOk, bool testData) const { #ifdef _DEBUG StringId testDataValue = DefaultStringId; #else UNREF(testData); #endif const ServerIntangibleObjectTemplate::_SchematicAttribute * base = NULL; if (m_baseData != NULL) { base = dynamic_cast<const ServerIntangibleObjectTemplate::_SchematicAttribute *>(m_baseData); #ifdef _DEBUG if (testData && base != NULL) testDataValue = base->getName(true); #endif } if (!m_name.isLoaded()) { if (ms_allowDefaultTemplateParams && /*!versionOk &&*/ base == NULL) { DEBUG_WARNING(true, ("Returning default value for missing parameter name in template %s", DataResource::getName())); return DefaultStringId; } else { DEBUG_FATAL(base == NULL, ("Template parameter name has not been defined in template %s!", DataResource::getName())); return base->getName(versionOk); } } const StringId value = m_name.getValue(); #ifdef _DEBUG if (testData && base != NULL) { } #endif return value; } // ServerIntangibleObjectTemplate::_SchematicAttribute::getName
const std::string & ServerIntangibleObjectTemplate::_Ingredient::getSkillCommand(bool versionOk, bool testData) const { #ifdef _DEBUG std::string testDataValue = DefaultString; #else UNREF(testData); #endif const ServerIntangibleObjectTemplate::_Ingredient * base = NULL; if (m_baseData != NULL) { base = dynamic_cast<const ServerIntangibleObjectTemplate::_Ingredient *>(m_baseData); #ifdef _DEBUG if (testData && base != NULL) testDataValue = base->getSkillCommand(true); #endif } if (!m_skillCommand.isLoaded()) { if (ms_allowDefaultTemplateParams && /*!versionOk &&*/ base == NULL) { DEBUG_WARNING(true, ("Returning default value for missing parameter skillCommand in template %s", DataResource::getName())); return DefaultString; } else { DEBUG_FATAL(base == NULL, ("Template parameter skillCommand has not been defined in template %s!", DataResource::getName())); return base->getSkillCommand(versionOk); } } const std::string & value = m_skillCommand.getValue(); #ifdef _DEBUG if (testData && base != NULL) { } #endif return value; } // ServerIntangibleObjectTemplate::_Ingredient::getSkillCommand