static int decode_frame(struct aucodec_st *st, struct mbuf *dst,
struct mbuf *src, uint16_t src_len)
{
int ret, err;
if (mbuf_get_left(src) < src_len) {
DEBUG_WARNING("dec: corrupt frame %u < %u\n",
mbuf_get_left(src), src_len);
return EPROTO;
}
/* Make sure there is enough space in the buffer */
if (mbuf_get_space(dst) < st->fsize) {
err = mbuf_resize(dst, dst->size + st->fsize);
if (err)
return err;
}
ret = celt_decode(st->dec, mbuf_buf(src), src_len,
(short *)mbuf_buf(dst), st->frame_size);
if (CELT_OK != ret) {
DEBUG_WARNING("celt_decode: ret=%d\n", ret);
}
DEBUG_INFO("decode: %u -> %u\n", src_len, st->fsize);
if (src)
mbuf_advance(src, src_len);
dst->end += st->fsize;
return 0;
}
static enum pkt_type get_packet_type(const struct mbuf *mb)
{
uint8_t b, pt;
uint32_t magic;
if (mbuf_get_left(mb) < 8)
return PKT_TYPE_UNKNOWN;
b = mbuf_buf(mb)[0];
if (127 < b && b < 192) {
pt = mbuf_buf(mb)[1] & 0x7f;
if (72 <= pt && pt <= 76)
return PKT_TYPE_RTCP;
else
return PKT_TYPE_RTP;
}
else {
memcpy(&magic, &mbuf_buf(mb)[4], 4);
magic = ntohl(magic);
if (magic == ZRTP_PACKETS_MAGIC)
return PKT_TYPE_ZRTP;
}
return PKT_TYPE_UNKNOWN;
}
static int encode(struct aucodec_st *st, struct mbuf *dst, struct mbuf *src)
{
int len;
if (!mbuf_get_left(src))
return 0;
if (mbuf_get_left(src) != st->fsize) {
DEBUG_WARNING("encode: got %d bytes, expected %d\n",
mbuf_get_left(src), st->fsize);
return EINVAL;
}
if (mbuf_get_space(dst) < MAX_PACKET) {
int err = mbuf_resize(dst, dst->pos + MAX_PACKET);
if (err)
return err;
}
len = opus_encode(st->enc, (short *)mbuf_buf(src), st->frame_size,
mbuf_buf(dst), (int)mbuf_get_space(dst));
if (len < 0) {
DEBUG_WARNING("encode error: %d (%u bytes)\n", len,
mbuf_get_left(src));
return EPROTO;
}
src->pos = src->end;
dst->end = dst->pos + len;
return 0;
}
static bool recv_handler(struct sa *src, struct mbuf *mb, void *arg)
{
struct menc_st *st = arg;
err_status_t e;
int len;
(void)src;
if (!st->use_srtp || !is_rtp_or_rtcp(mb))
return false;
len = (int)mbuf_get_left(mb);
if (is_rtcp_packet(mb)) {
e = srtp_unprotect_rtcp(st->srtp_rx, mbuf_buf(mb), &len);
}
else {
e = srtp_unprotect(st->srtp_rx, mbuf_buf(mb), &len);
}
if (e != err_status_ok) {
DEBUG_WARNING("recv: failed to unprotect %s-packet"
" with %d bytes (%H)\n",
is_rtcp_packet(mb) ? "RTCP" : "RTP",
len, errstatus_print, e);
return true; /* error - drop packet */
}
mbuf_set_end(mb, mb->pos + len);
return false; /* continue processing */
}
/* src=NULL means lost packet */
static int decode(struct aucodec_st *st, struct mbuf *dst, struct mbuf *src)
{
int r;
if (!mbuf_get_left(src) && !st->got_packet)
return 0;
/* Make sure there is enough space in the buffer */
if (mbuf_get_space(dst) < st->fsize) {
int err = mbuf_resize(dst, dst->pos + st->fsize);
if (err)
return err;
}
r = opus_decode(st->dec, mbuf_buf(src), (int)mbuf_get_left(src),
(short *)mbuf_buf(dst), st->frame_size, 0);
if (r <= 0) {
DEBUG_WARNING("opus_decode: r=%d (%u bytes)\n",
r, mbuf_get_left(src));
return EBADMSG;
}
if (src)
src->pos = src->end;
dst->end += 2 * r * aucodec_ch(st->ac);
st->got_packet = true;
return 0;
}
/* PLC is only valid for Decoding (RX) */
static int dec(struct aufilt_st *st, struct mbuf *mb)
{
int nsamp = (int)mbuf_get_left(mb) / 2;
if (nsamp) {
nsamp = plc_rx(&st->plc, (int16_t *)mbuf_buf(mb), nsamp);
if (nsamp >= 0)
mb->end = mb->pos + (2*nsamp);
}
else {
nsamp = (int)st->psize / 2;
re_printf("plc: concealing %u bytes\n", st->psize);
if (mbuf_get_space(mb) < st->psize) {
int err = mbuf_resize(mb, st->psize);
if (err)
return err;
}
nsamp = plc_fillin(&st->plc, (int16_t *)mbuf_buf(mb), nsamp);
mb->end = mb->pos + 2 * nsamp;
}
return 0;
}
static void tcp_recv_handler(struct mbuf *mb, void *arg)
{
struct request *request = arg;
int ok;
struct pl ver;
struct pl code;
struct pl phrase;
struct pl headers;
struct pl body;
DEBUG_INFO("recv data[%d]\n", mbuf_get_left(mb));
if(request->state == STREAM) {
request->stream_h(request, HTTP_STREAM_DATA, mb, request->arg);
return;
}
if(request->body) {
ok = mbuf_write_mem(request->body, mbuf_buf(mb), mbuf_get_left(mb));
goto clen;
}
ok = re_regex((const char*)mbuf_buf(mb), mbuf_get_left(mb),
"HTTP/[^ \t\r\n]+ [0-9]+ [^\t\r\n]+\r\n[^]1",
&ver, &code, &phrase, &headers);
// XXX: check ok
// XXX: check headers.l
request->status = pl_u32(&code);
headers.l = mbuf_get_left(mb) - (headers.p - (const char*)mbuf_buf(mb));
body.l = 0;
parse_headers(request, (char*)headers.p, headers.l, &body);
if(body.l) {
request->body = mbuf_alloc(body.l);
mbuf_write_mem(request->body, (const unsigned char*)body.p, body.l);
}
request->response = mem_ref(mb);
clen:
if(request->body && request->clen > request->body->end)
return;
if(request->status >= 200 || request->stream_h == NULL) {
request->done_h(request, request->status, request->arg);
request->state = END;
mem_deref(request);
return;
}
request->state = STREAM;
request->stream_h(request, HTTP_STREAM_EST, mb, request->arg);
}
static void notify_handler(struct sip *sip, const struct sip_msg *msg,
void *arg)
{
enum presence_status status = PRESENCE_CLOSED;
struct presence *pres = arg;
const struct sip_hdr *hdr;
struct pl pl;
pres->failc = 0;
hdr = sip_msg_hdr(msg, SIP_HDR_CONTENT_TYPE);
if (!hdr || 0 != pl_strcasecmp(&hdr->val, "application/pidf+xml")) {
if (hdr)
(void)re_printf("presence: unsupported"
" content-type: '%r'\n",
&hdr->val);
sip_treplyf(NULL, NULL, sip, msg, false,
415, "Unsupported Media Type",
"Accept: application/pidf+xml\r\n"
"Content-Length: 0\r\n"
"\r\n");
return;
}
if (!re_regex((const char *)mbuf_buf(msg->mb), mbuf_get_left(msg->mb),
"<status>[^<]*<basic>[^<]*</basic>[^<]*</status>",
NULL, &pl, NULL)) {
if (!pl_strcasecmp(&pl, "open"))
status = PRESENCE_OPEN;
}
if (!re_regex((const char *)mbuf_buf(msg->mb), mbuf_get_left(msg->mb),
"<rpid:away/>")) {
status = PRESENCE_CLOSED;
}
else if (!re_regex((const char *)mbuf_buf(msg->mb),
mbuf_get_left(msg->mb),
"<rpid:busy/>")) {
status = PRESENCE_BUSY;
}
else if (!re_regex((const char *)mbuf_buf(msg->mb),
mbuf_get_left(msg->mb),
"<rpid:on-the-phone/>")) {
status = PRESENCE_BUSY;
}
(void)sip_treply(NULL, sip, msg, 200, "OK");
contact_set_presence(pres->contact, status);
}
static bool udp_helper_send(int *err, struct sa *dst,
struct mbuf *mb, void *arg)
{
struct menc_media *st = arg;
unsigned int length;
zrtp_status_t s;
const char *proto_name = "rtp";
enum pkt_type ptype = get_packet_type(mb);
if (drop_packets(st))
return true;
length = (unsigned int)mbuf_get_left(mb);
/* only RTP/RTCP packets should be processed */
if (ptype == PKT_TYPE_RTCP) {
proto_name = "rtcp";
s = zrtp_process_rtcp(st->zrtp_stream,
(char *)mbuf_buf(mb), &length);
}
else if (ptype == PKT_TYPE_RTP) {
s = zrtp_process_rtp(st->zrtp_stream,
(char *)mbuf_buf(mb), &length);
}
else
return false;
if (s != zrtp_status_ok) {
if (s == zrtp_status_drop)
return true;
warning("zrtp: send(port=%d): zrtp_process_%s failed"
" (status = %d '%s')\n",
sa_port(dst), proto_name, s, zrtp_log_status2str(s));
return false;
}
/* make sure target buffer is large enough */
if (length > mbuf_get_space(mb)) {
warning("zrtp: zrtp_process_%s: length > space (%u > %u)\n",
proto_name, length, mbuf_get_space(mb));
*err = ENOMEM;
}
mb->end = mb->pos + length;
return false;
}
static bool recv_handler(struct sa *src, struct mbuf *mb, void *arg)
{
struct dtls_flow *flow = arg;
uint8_t b;
int r, n;
if (mbuf_get_left(mb) < 1)
return false;
/* ignore non-DTLS packets */
b = mb->buf[mb->pos];
if (b < 20 || b > 63)
return false;
if (!sa_cmp(src, &flow->peer, SA_ALL))
return false;
/* feed SSL data to the BIO */
r = BIO_write(flow->sbio_in, mbuf_buf(mb), (int)mbuf_get_left(mb));
if (r <= 0)
return true;
n = SSL_read(flow->ssl, mbuf_buf(mb), (int)mbuf_get_space(mb));
if (n <= 0) {
ERR_clear_error();
}
if (!flow->up && SSL_state(flow->ssl) == SSL_ST_OK) {
struct key client_key, server_key;
char profile[256];
int err;
flow->up = true;
err = get_srtp_key_info(flow, profile, sizeof(profile),
&client_key, &server_key);
if (err) {
warning("dtls: SRTP key info: %m\n", err);
return true;
}
flow->estabh(0, flow, profile,
&client_key, &server_key, flow->arg);
}
return true;
}
/**
* Encoder audio and send via stream
*
* @note This function has REAL-TIME properties
*/
static void encode_rtp_send(struct audio *a, struct autx *tx,
int16_t *sampv, size_t sampc)
{
size_t len;
int err;
if (!tx->ac)
return;
tx->mb->pos = tx->mb->end = STREAM_PRESZ;
len = mbuf_get_space(tx->mb);
err = tx->ac->ench(tx->enc, mbuf_buf(tx->mb), &len, sampv, sampc);
if (err) {
DEBUG_WARNING("%s encode error: %d samples (%m)\n",
tx->ac->name, sampc, err);
goto out;
}
tx->mb->pos = STREAM_PRESZ;
tx->mb->end = STREAM_PRESZ + len;
if (mbuf_get_left(tx->mb)) {
err = stream_send(a->strm, tx->marker, -1, tx->ts, tx->mb);
if (err)
goto out;
}
tx->ts += (uint32_t)(tx->is_g722 ? sampc/2 : sampc);
out:
tx->marker = false;
}
/**
* Send progress response
*
* @param sess SIP Session
* @param scode Response status code
* @param reason Response reason phrase
* @param desc Content description (e.g. SDP)
* @param fmt Formatted strings with extra SIP Headers
*
* @return 0 if success, otherwise errorcode
*/
int sipsess_progress(struct sipsess *sess, uint16_t scode, const char *reason,
struct mbuf *desc, const char *fmt, ...)
{
va_list ap;
int err;
if (!sess || !sess->st || !sess->msg || scode < 101 || scode > 199)
return EINVAL;
va_start(ap, fmt);
err = sip_treplyf(&sess->st, NULL, sess->sip, sess->msg, true,
scode, reason,
"Contact: <sip:%s@%J%s>\r\n"
"%v"
"%s%s%s"
"Content-Length: %zu\r\n"
"\r\n"
"%b",
sess->cuser, &sess->msg->dst,
sip_transp_param(sess->msg->tp),
fmt, &ap,
desc ? "Content-Type: " : "",
desc ? sess->ctype : "",
desc ? "\r\n" : "",
desc ? mbuf_get_left(desc) : (size_t)0,
desc ? mbuf_buf(desc) : NULL,
desc ? mbuf_get_left(desc) : (size_t)0);
va_end(ap);
return err;
}
static void udp_recv_handler(const struct sa *src, struct mbuf *mb, void *arg)
{
struct rtp_sock *rs = arg;
struct rtp_header hdr;
int err;
/* Handle RTCP multiplexed on RTP-port */
if (rs->rtcp_mux) {
uint8_t pt;
if (mbuf_get_left(mb) < 2)
return;
pt = mbuf_buf(mb)[1] & 0x7f;
if (64 <= pt && pt <= 95) {
rtcp_recv_handler(src, mb, arg);
return;
}
}
err = rtp_decode(rs, mb, &hdr);
if (err)
return;
if (rs->rtcp) {
rtcp_sess_rx_rtp(rs->rtcp, hdr.seq, hdr.ts,
hdr.ssrc, mbuf_get_left(mb), src);
}
if (rs->recvh)
rs->recvh(src, &hdr, mb, rs->arg);
}
static bool udp_helper_send(int *err, struct sa *dst,
struct mbuf *mb, void *arg)
{
struct menc_media *st = arg;
unsigned int length;
zrtp_status_t s;
(void)dst;
length = (unsigned int)mbuf_get_left(mb);
s = zrtp_process_rtp(st->zrtp_stream, (char *)mbuf_buf(mb), &length);
if (s != zrtp_status_ok) {
warning("zrtp: zrtp_process_rtp failed (status = %d)\n", s);
return false;
}
/* make sure target buffer is large enough */
if (length > mbuf_get_space(mb)) {
warning("zrtp: zrtp_process_rtp: length > space (%u > %u)\n",
length, mbuf_get_space(mb));
*err = ENOMEM;
}
mb->end = mb->pos + length;
return false;
}
static void sipsub_notify_handler(struct sip *sip, const struct sip_msg *msg,
void *arg)
{
struct call *call = arg;
struct pl scode, reason;
uint32_t sc;
if (re_regex((char *)mbuf_buf(msg->mb), mbuf_get_left(msg->mb),
"SIP/2.0 [0-9]+ [^\r\n]+", &scode, &reason)) {
(void)sip_reply(sip, msg, 400, "Bad sipfrag");
return;
}
(void)sip_reply(sip, msg, 200, "OK");
sc = pl_u32(&scode);
if (sc >= 300) {
warning("call: transfer failed: %u %r\n", sc, &reason);
call_event_handler(call, CALL_EVENT_TRANSFER_FAILED,
"%u %r", sc, &reason);
}
else if (sc >= 200) {
call_event_handler(call, CALL_EVENT_CLOSED, "Call transfered");
}
}
void RTPSubscriber::rtp_recv(const struct libre::sa *src, const struct libre::rtp_header *hdr, struct libre::mbuf *mb, void *arg) {
RTPSubscriber *obj=(RTPSubscriber*)arg;
if(!mbuf_get_left(mb))
return;
Message *msg=new Message((char*)mbuf_buf(mb), mbuf_get_left(mb), Message::NONE);
msg->putMeta("type", "RTP");
msg->putMeta("marker", toStr((bool)hdr->m));
msg->putMeta("SSRC", toStr(hdr->ssrc));
msg->putMeta("timestamp", toStr(hdr->ts));
msg->putMeta("payloadType", toStr(hdr->pt));
msg->putMeta("sequenceNumber", toStr(hdr->seq));
if(hdr->seq<obj->_lastSequenceNumber) //test for sequence number overflow
obj->_extendedSequenceNumber++;
obj->_lastSequenceNumber=hdr->seq;
msg->putMeta("extendedSequenceNumber", toStr((obj->_extendedSequenceNumber<<16) + hdr->seq));
msg->putMeta("CSRCCount", toStr(hdr->cc));
for(int i=0; i<hdr->cc; i++)
msg->putMeta("CSRC"+toStr(i), toStr(hdr->csrc[i]));
//push new message into queue
{
RScopeLock lock(obj->_mutex);
obj->_queue.push(msg);
}
obj->_cond.broadcast();
}
static int enqueue(struct tcp_conn *tc, struct mbuf *mb)
{
const size_t n = mbuf_get_left(mb);
struct tcp_qent *qe;
int err;
if (tc->txqsz + n > tc->txqsz_max)
return ENOSPC;
if (!tc->sendq.head && !tc->sendh) {
err = fd_listen(tc->fdc, FD_READ | FD_WRITE,
tcp_recv_handler, tc);
if (err)
return err;
}
qe = mem_zalloc(sizeof(*qe), qent_destructor);
if (!qe)
return ENOMEM;
list_append(&tc->sendq, &qe->le, qe);
mbuf_init(&qe->mb);
err = mbuf_write_mem(&qe->mb, mbuf_buf(mb), n);
qe->mb.pos = 0;
if (err)
mem_deref(qe);
else
tc->txqsz += qe->mb.end;
return err;
}
static void message_handler(const struct pl *peer, const struct pl *ctype,
struct mbuf *body, void *arg)
{
(void)ctype;
(void)arg;
char message[256] = {0};
char s_peer[50] = {0};
struct contacts *contacts = baresip_contacts();
(void)re_snprintf(message, sizeof(message), "%b",
mbuf_buf(body), mbuf_get_left(body));
(void)re_snprintf(s_peer, sizeof(s_peer), "%r", peer);
warning("message from %s: %s\n", s_peer, message);
struct contact *c = contact_find(contacts, s_peer);
if (c) {
const struct sip_addr *addr = contact_addr(c);
(void)re_snprintf(s_peer, sizeof(s_peer), "%r", &addr->dname);
(void)webapp_chat_add(s_peer, message, false);
ws_send_json(WS_CHAT, webapp_messages_get());
}
}
/*
* TODO: check input/output size
*/
static int ffdecode(struct viddec_state *st, struct vidframe *frame,
bool eof, struct mbuf *src)
{
int i, got_picture, ret, err;
/* assemble packets in "mbuf" */
err = mbuf_write_mem(st->mb, mbuf_buf(src), mbuf_get_left(src));
if (err)
return err;
if (!eof)
return 0;
st->mb->pos = 0;
if (!st->got_keyframe) {
err = EPROTO;
goto out;
}
#if LIBAVCODEC_VERSION_INT <= ((52<<16)+(23<<8)+0)
ret = avcodec_decode_video(st->ctx, st->pict, &got_picture,
st->mb->buf,
(int)mbuf_get_left(st->mb));
#else
do {
AVPacket avpkt;
av_init_packet(&avpkt);
avpkt.data = st->mb->buf;
avpkt.size = (int)mbuf_get_left(st->mb);
ret = avcodec_decode_video2(st->ctx, st->pict,
&got_picture, &avpkt);
} while (0);
#endif
if (ret < 0) {
err = EBADMSG;
goto out;
}
mbuf_skip_to_end(src);
if (got_picture) {
for (i=0; i<4; i++) {
frame->data[i] = st->pict->data[i];
frame->linesize[i] = st->pict->linesize[i];
}
frame->size.w = st->ctx->width;
frame->size.h = st->ctx->height;
frame->fmt = VID_FMT_YUV420P;
}
out:
if (eof)
mbuf_rewind(st->mb);
return err;
}
static int general_packetize(struct vidcodec_st *st, struct mbuf *mb)
{
int err = 0;
/* Assemble frame into smaller packets */
while (!err) {
size_t sz, left = mbuf_get_left(mb);
bool last = (left < MAX_RTP_SIZE);
if (!left)
break;
sz = last ? left : MAX_RTP_SIZE;
st->mb_frag->pos = st->mb_frag->end = RTP_PRESZ;
err = mbuf_write_mem(st->mb_frag, mbuf_buf(mb), sz);
if (err)
break;
st->mb_frag->pos = RTP_PRESZ;
err = st->sendh(last, st->mb_frag, st->arg);
mbuf_advance(mb, sz);
}
return err;
}
static bool mbuf_compare(const struct mbuf *mb, const char *str)
{
if (mbuf_get_left(mb) != strlen(str))
return false;
if (0 != memcmp(mbuf_buf(mb), str, strlen(str)))
return false;
return true;
}
static int h263_packetize(struct videnc_state *st, struct mbuf *mb,
videnc_packet_h *pkth, void *arg)
{
struct h263_strm h263_strm;
struct h263_hdr h263_hdr;
size_t pos;
int err;
/* Decode bit-stream header, used by packetizer */
err = h263_strm_decode(&h263_strm, mb);
if (err)
return err;
h263_hdr_copy_strm(&h263_hdr, &h263_strm);
st->mb_frag->pos = st->mb_frag->end = 0;
err = h263_hdr_encode(&h263_hdr, st->mb_frag);
pos = st->mb_frag->pos;
/* Assemble frame into smaller packets */
while (!err) {
size_t sz, left = mbuf_get_left(mb);
bool last = (left < st->encprm.pktsize);
if (!left)
break;
sz = last ? left : st->encprm.pktsize;
st->mb_frag->pos = st->mb_frag->end = pos;
err = mbuf_write_mem(st->mb_frag, mbuf_buf(mb), sz);
if (err)
break;
st->mb_frag->pos = 0;
err = pkth(last, NULL, 0, mbuf_buf(st->mb_frag),
mbuf_get_left(st->mb_frag), arg);
mbuf_advance(mb, sz);
}
return err;
}
static void tcp_estab_handler(void *arg)
{
DEBUG_INFO("connection established\n");
int ok;
struct request * request = arg;
struct mbuf *mb;
char CN[256];
if(request->secure) {
ok = tls_verify_cert(request->ssl, CN, sizeof(CN));
if(ok!=0)
goto fail;
DEBUG_INFO("https CN %s\n", CN);
ok = strcmp(request->host, CN);
if(ok!=0)
goto fail;
}
mb = mbuf_alloc(1024);
mbuf_printf(mb, "%s %s HTTP/1.1\r\n", request->meth, request->path);
mbuf_printf(mb, "Host: %s\r\n", request->host);
write_auth(request, mb);
mbuf_write_str(mb, "Connection: close\r\n");
hash_apply(request->hdrht, hdr_write, mb);
hash_flush(request->hdrht);
if(request->post) {
request->post->pos = 0;
mbuf_printf(mb, "Content-Length: %d\r\n",
mbuf_get_left(request->post));
if(request->form)
mbuf_printf(mb, "Content-Type: "
"application/x-www-form-urlencoded\r\n");
mbuf_printf(mb, "\r\n");
mbuf_write_mem(mb, mbuf_buf(request->post),
mbuf_get_left(request->post));
} else {
mbuf_write_str(mb, "\r\n");
}
mb->pos = 0;
tcp_send(request->tcp, mb);
mem_deref(mb);
return;
fail:
DEBUG_WARNING("ssl fail %p %d\n", request->app->tls, ok);
}
int sipsess_reply_2xx(struct sipsess *sess, const struct sip_msg *msg,
uint16_t scode, const char *reason, struct mbuf *desc,
const char *fmt, va_list *ap)
{
struct sipsess_reply *reply;
struct sip_contact contact;
int err = ENOMEM;
reply = mem_zalloc(sizeof(*reply), destructor);
if (!reply)
goto out;
list_append(&sess->replyl, &reply->le, reply);
reply->seq = msg->cseq.num;
reply->msg = mem_ref((void *)msg);
reply->sess = sess;
sip_contact_set(&contact, sess->cuser, &msg->dst, msg->tp);
err = sip_treplyf(&sess->st, &reply->mb, sess->sip,
msg, true, scode, reason,
"%H"
"%v"
"%s%s%s"
"Content-Length: %zu\r\n"
"\r\n"
"%b",
sip_contact_print, &contact,
fmt, ap,
desc ? "Content-Type: " : "",
desc ? sess->ctype : "",
desc ? "\r\n" : "",
desc ? mbuf_get_left(desc) : (size_t)0,
desc ? mbuf_buf(desc) : NULL,
desc ? mbuf_get_left(desc) : (size_t)0);
if (err)
goto out;
tmr_start(&reply->tmr, 64 * SIP_T1, tmr_handler, reply);
tmr_start(&reply->tmrg, SIP_T1, retransmit_handler, reply);
if (!mbuf_get_left(msg->mb) && desc) {
reply->awaiting_answer = true;
sess->awaiting_answer = true;
}
out:
if (err) {
sess->st = mem_deref(sess->st);
mem_deref(reply);
}
return err;
}
/**
* Decode incoming packets using the Audio decoder
*
* NOTE: mb=NULL if no packet received
*/
static int aurx_stream_decode(struct aurx *rx, struct mbuf *mb)
{
size_t sampc = AUDIO_SAMPSZ;
int16_t *sampv;
struct le *le;
int err = 0;
/* No decoder set */
if (!rx->ac) return 0;
if (mbuf_get_left(mb)) {
err = rx->ac->dech(rx->dec, rx->sampv, &sampc, mbuf_buf(mb), mbuf_get_left(mb));
} else if (rx->ac->plch) {
err = rx->ac->plch(rx->dec, rx->sampv, &sampc);
} else {
/* no PLC in the codec, might be done in filters below */
sampc = 0;
}
if (err) {
DEBUG_WARNING("%s codec decode %u bytes: %m\n", rx->ac->name, mbuf_get_left(mb), err);
goto out;
}
/* Process exactly one audio-frame in reverse list order */
for (le = rx->filtl.tail; le; le = le->prev) {
struct aufilt_dec_st *st = le->data;
if (st->af && st->af->dech) {
err |= st->af->dech(st, rx->sampv, &sampc);
}
}
if (!rx->ab) goto out;
sampv = rx->sampv;
/* optional resampler */
if (rx->resamp) {
size_t sampc_rs = AUDIO_SAMPSZ;
err = auresamp_process(rx->resamp, rx->sampv_rs, &sampc_rs, rx->sampv, sampc);
if (err) return err;
sampv = rx->sampv_rs;
sampc = sampc_rs;
}
err = aubuf_write_samp(rx->ab, sampv, sampc);
if (err) goto out;
out:
return err;
}
/*
* See RFC 5764 figure 3:
*
* +----------------+
* | 127 < B < 192 -+--> forward to RTP
* | |
* packet --> | 19 < B < 64 -+--> forward to DTLS
* | |
* | B < 2 -+--> forward to STUN
* +----------------+
*
*/
bool packet_is_rtp_or_rtcp(const struct mbuf *mb)
{
uint8_t b;
if (mbuf_get_left(mb) < 1)
return false;
b = mbuf_buf(mb)[0];
return 127 < b && b < 192;
}
bool packet_is_rtcp_packet(const struct mbuf *mb)
{
uint8_t pt;
if (mbuf_get_left(mb) < 2)
return false;
pt = mbuf_buf(mb)[1] & 0x7f;
return 64 <= pt && pt <= 95;
}
void rtp_p(srtp_t srtp, struct mbuf *mb)
{
int err, len;
if(srtp) {
len = (int)mbuf_get_left(mb);
err = srtp_protect(srtp, mbuf_buf(mb), &len);
if(err)
printf("srtp failed %d\n", err);
mb->end = len;
}
}
static void notify_handler(struct sip *sip, const struct sip_msg *msg,
void *arg)
{
struct mwi *mwi = arg;
if (mbuf_get_left(msg->mb)) {
re_printf("----- MWI for %s -----\n", ua_aor(mwi->ua));
re_printf("%b\n", mbuf_buf(msg->mb), mbuf_get_left(msg->mb));
}
(void)sip_treply(NULL, sip, msg, 200, "OK");
}
static bool udp_helper_recv(struct sa *src, struct mbuf *mb, void *arg)
{
struct menc_media *st = arg;
unsigned int length;
zrtp_status_t s;
const char *proto_name = "srtp";
enum pkt_type ptype = get_packet_type(mb);
if (drop_packets(st))
return true;
length = (unsigned int)mbuf_get_left(mb);
if (ptype == PKT_TYPE_RTCP) {
proto_name = "srtcp";
s = zrtp_process_srtcp(st->zrtp_stream,
(char *)mbuf_buf(mb), &length);
}
else if (ptype == PKT_TYPE_RTP || ptype == PKT_TYPE_ZRTP) {
s = zrtp_process_srtp(st->zrtp_stream,
(char *)mbuf_buf(mb), &length);
}
else
return false;
if (s != zrtp_status_ok) {
if (s == zrtp_status_drop)
return true;
warning("zrtp: recv(port=%d): zrtp_process_%s: %d '%s'\n",
sa_port(src), proto_name, s, zrtp_log_status2str(s));
return false;
}
mb->end = mb->pos + length;
return false;
}
