static int on_send_packet(const zrtp_stream_t *stream,
char *rtp_packet,
unsigned int rtp_packet_length)
{
struct menc_media *st = zrtp_stream_get_userdata(stream);
struct mbuf *mb;
int err;
if (drop_packets(st))
return zrtp_status_ok;
if (!sa_isset(&st->raddr, SA_ALL))
return zrtp_status_ok;
mb = mbuf_alloc(PRESZ + rtp_packet_length);
if (!mb)
return zrtp_status_alloc_fail;
mb->pos = PRESZ;
(void)mbuf_write_mem(mb, (void *)rtp_packet, rtp_packet_length);
mb->pos = PRESZ;
err = udp_send_helper(st->rtpsock, &st->raddr, mb, st->uh_rtp);
if (err) {
warning("zrtp: udp_send %u bytes (%m)\n",
rtp_packet_length, err);
}
mem_deref(mb);
return zrtp_status_ok;
}
static void on_zrtp_secure(zrtp_stream_t *ctx) {
zrtp_test_id_t *stream_id = zrtp_stream_get_userdata(ctx);
zrtp_test_stream_t *stream = zrtp_test_stream_by_id(*stream_id);
zrtp_test_channel_t *channel = zrtp_test_channel_by_id(stream->channel_id);
zrtp_test_stream_t *remote_stream = (channel->left == stream) ? channel->right : channel->left;
if (stream->zrtp->state == ZRTP_STATE_SECURE &&
remote_stream->zrtp->state == ZRTP_STATE_SECURE) {
channel->is_secure = 1;
}
}
void AmZRTP::on_zrtp_protocol_event(zrtp_stream_t *stream, zrtp_protocol_event_t event) {
DBG("on_zrtp_protocol_event(stream [%p])\n", stream);
if (NULL==stream) {
ERROR("event received without stream context.\n");
return;
}
void* udata = zrtp_stream_get_userdata(stream);
if (NULL == udata) {
ERROR("ZRTP on_send_packet without session set context.\n");
return;
}
AmSession* sess = reinterpret_cast<AmSession*>(udata);
sess->postEvent(new AmZRTPProtocolEvent(event, stream));
}
static void on_zrtp_secure(zrtp_stream_t *stream)
{
const struct menc_media *st = zrtp_stream_get_userdata(stream);
const struct menc_sess *sess = st->sess;
zrtp_session_info_t sess_info;
zrtp_session_get(sess->zrtp_session, &sess_info);
if (!sess_info.sas_is_verified && sess_info.sas_is_ready) {
info("zrtp: verify SAS <%s> <%s> for remote peer %w"
" (press 'Z' <ZID> to verify)\n",
sess_info.sas1.buffer,
sess_info.sas2.buffer,
sess_info.peer_zid.buffer,
(size_t)sess_info.peer_zid.length);
}
}
int AmZRTP::on_send_packet(const zrtp_stream_t *stream, char *packet, unsigned int length) {
DBG("on_send_packet(stream [%p], len=%u)\n", stream, length);
if (NULL==stream) {
ERROR("on_send_packet without stream context.\n");
return -1;
}
void* udata = zrtp_stream_get_userdata(stream);
if (NULL == udata) {
ERROR("ZRTP on_send_packet without session context.\n");
return -1;
}
AmSession* sess = reinterpret_cast<AmSession*>(udata);
return sess->RTPStream()->send_raw(packet, length);
}
static void on_zrtp_security_event(zrtp_stream_t *stream,
zrtp_security_event_t event)
{
debug("zrtp: got security_event '%u'\n", event);
if (event == ZRTP_EVENT_WRONG_SIGNALING_HASH) {
const struct menc_media *st = zrtp_stream_get_userdata(stream);
warning("zrtp: Attack detected!!! Signaling hash from the "
"zrtp-hash SDP attribute doesn't match the hash of "
"the Hello message. Aborting the call.\n");
/* As this was called from zrtp_process_xxx(), we need
a safe shutdown. */
abort_call(st->sess);
}
}
static void on_zrtp_secure(zrtp_stream_t *stream)
{
const struct menc_media *st = zrtp_stream_get_userdata(stream);
const struct menc_sess *sess = st->sess;
zrtp_session_info_t sess_info;
char buf[128] = "";
zrtp_session_get(sess->zrtp_session, &sess_info);
if (!sess_info.sas_is_verified && sess_info.sas_is_ready) {
info("zrtp: verify SAS <%s> <%s> for remote peer %w"
" (type /zrtp_verify %w to verify)\n",
sess_info.sas1.buffer,
sess_info.sas2.buffer,
sess_info.peer_zid.buffer,
(size_t)sess_info.peer_zid.length,
sess_info.peer_zid.buffer,
(size_t)sess_info.peer_zid.length);
if (sess->eventh) {
if (re_snprintf(buf, sizeof(buf), "%s,%s,%w",
sess_info.sas1.buffer,
sess_info.sas2.buffer,
sess_info.peer_zid.buffer,
(size_t)sess_info.peer_zid.length))
(sess->eventh)(MENC_EVENT_VERIFY_REQUEST,
buf, sess->arg);
else
warning("zrtp: failed to print verify "
" arguments\n");
}
}
else if (sess_info.sas_is_verified) {
info("zrtp: secure session with verified remote peer %w\n",
sess_info.peer_zid.buffer,
(size_t)sess_info.peer_zid.length);
if (sess->eventh) {
if (re_snprintf(buf, sizeof(buf), "%w",
sess_info.peer_zid.buffer,
(size_t)sess_info.peer_zid.length))
(sess->eventh)(MENC_EVENT_PEER_VERIFIED,
buf, sess->arg);
else
warning("zrtp: failed to print verified "
" argument\n");
}
}
}
static int on_send_packet(const zrtp_stream_t* ctx, char* message, unsigned int length) {
zrtp_queue_elem_t* elem = zrtp_sys_alloc(sizeof(zrtp_queue_elem_t));
if (elem) {
zrtp_test_packet_t* packet = (zrtp_test_packet_t*) elem->data;
elem->size = length;
packet->is_rtp = 1;
packet->length = length;
zrtp_memcpy(packet->body, message, length);
zrtp_test_id_t *stream_id = zrtp_stream_get_userdata(ctx);
zrtp_test_stream_t *stream = zrtp_test_stream_by_id(*stream_id);
if (stream) {
zrtp_test_queue_push(stream->output, elem);
return zrtp_status_ok;
} else {
return zrtp_status_fail;
}
} else {
return zrtp_status_alloc_fail;
}
}
static void on_zrtp_event(zrtp_stream_t *ctx, zrtp_protocol_event_t event) {
zrtp_test_id_t *stream_id = zrtp_stream_get_userdata(ctx);
zrtp_test_stream_t *stream = zrtp_test_stream_by_id(*stream_id);
stream->zrtp_events_queueu[stream->zrtp_events_count++] = event;
}
