static void __ortp_logv_out(OrtpLogLevel lev, const char *fmt, va_list args){
const char *lname="undef";
char *msg;
if (__log_file==NULL) __log_file=stderr;
switch(lev){
case ORTP_DEBUG:
lname="debug";
break;
case ORTP_MESSAGE:
lname="message";
break;
case ORTP_WARNING:
lname="warning";
break;
case ORTP_ERROR:
lname="error";
break;
case ORTP_FATAL:
lname="fatal";
break;
default:
ortp_fatal("Bad level !");
}
msg=ortp_strdup_vprintf(fmt,args);
#ifdef _MSC_VER
OutputDebugString(msg);
OutputDebugString("\r\n");
#else
fprintf(__log_file,"ortp-%s-%s" ENDLINE,lname,msg);
fflush(__log_file);
#endif
ortp_free(msg);
}
OrtpZrtpContext* ortp_zrtp_multistream_new(OrtpZrtpContext* activeContext, RtpSession *s, OrtpZrtpParams *params) {
int32_t length;
char *multiparams=NULL;
int i=0;
if (!zrtp_isMultiStreamAvailable(activeContext->zrtpContext)) {
ortp_warning("could't add stream: mutlistream not supported by peer");
}
if (zrtp_isMultiStream(activeContext->zrtpContext)) {
ortp_fatal("Error: should derive multistream from DH or preshared modes only");
}
multiparams=zrtp_getMultiStrParams(activeContext->zrtpContext, &length);
ortp_message("ZRTP multiparams length is %d", length);
for (;i<length;i++) {
ortp_message("%d", multiparams[i]);
}
ortp_message("Initializing ZRTP context");
ZrtpContext *context = zrtp_CreateWrapper();
OrtpZrtpContext *userData=createUserData(context);
userData->session=s;
ortp_zrtp_configure(context);
zrtp_initializeZrtpEngine(context, &userData->zrtp_cb, userAgentStr, params->zid_file, userData, 0);
ortp_message("setting zrtp_setMultiStrParams");
zrtp_setMultiStrParams(context,multiparams,length);
return ortp_zrtp_configure_context(userData,s,params);
}
static void __ortp_logv_out(OrtpLogLevel lev, const char *fmt, va_list args){
const char *lname="undef";
char *msg;
struct timeval tp;
struct tm *lt;
#ifndef _WIN32
struct tm tmbuf;
#endif
time_t tt;
ortp_gettimeofday(&tp,NULL);
tt = (time_t)tp.tv_sec;
#ifdef _WIN32
lt = localtime(&tt);
#else
lt = localtime_r(&tt,&tmbuf);
#endif
if (__log_file==NULL) __log_file=stderr;
switch(lev){
case ORTP_DEBUG:
lname="debug";
break;
case ORTP_MESSAGE:
lname="message";
break;
case ORTP_WARNING:
lname="warning";
break;
case ORTP_ERROR:
lname="error";
break;
case ORTP_FATAL:
lname="fatal";
break;
default:
ortp_fatal("Bad level !");
}
msg=ortp_strdup_vprintf(fmt,args);
#if defined(_MSC_VER) && !defined(_WIN32_WCE)
#ifndef _UNICODE
OutputDebugStringA(msg);
OutputDebugStringA("\r\n");
#else
{
int len=strlen(msg);
wchar_t *tmp=(wchar_t*)ortp_malloc0((len+1)*sizeof(wchar_t));
mbstowcs(tmp,msg,len);
OutputDebugStringW(tmp);
OutputDebugStringW(L"\r\n");
ortp_free(tmp);
}
#endif
#endif
fprintf(__log_file,"%i-%.2i-%.2i %.2i:%.2i:%.2i:%.3i ortp-%s-%s" ENDLINE
,1900+lt->tm_year,1+lt->tm_mon,lt->tm_mday,lt->tm_hour,lt->tm_min,lt->tm_sec
,(int)(tp.tv_usec/1000), lname,msg);
fflush(__log_file);
ortp_free(msg);
}
void ortp_set_memory_functions(OrtpMemoryFunctions *functions){
if (allocator_used){
ortp_fatal("ortp_set_memory_functions() must be called before "
"first use of ortp_malloc or ortp_realloc");
return;
}
ortp_allocator=*functions;
}
RtpEndpoint *rtp_endpoint_new(struct sockaddr *addr, socklen_t addrlen){
RtpEndpoint *ep=ortp_new(RtpEndpoint,1);
if (sizeof(ep->addr)<addrlen){
ortp_free(ep);
ortp_fatal("Bad socklen_t size !");
return NULL;
}
memcpy(&ep->addr,addr,addrlen);
ep->addrlen=addrlen;
return ep;
}
/* get common header; this function will also check the sanity of the packet*/
const rtcp_common_header_t * rtcp_get_common_header(const mblk_t *m){
int size=msgdsize(m);
rtcp_common_header_t *ch;
if (m->b_cont!=NULL){
ortp_fatal("RTCP parser does not work on fragmented mblk_t. Use msgpullup() before to re-assemble the packet.");
return NULL;
}
if (size<sizeof(rtcp_common_header_t)){
ortp_warning("Bad RTCP packet, too short.");
return NULL;
}
ch=(rtcp_common_header_t*)m->b_rptr;
return ch;
}
err_status_t ortp_srtp_init(void)
{
err_status_t st=0;
ortp_message("srtp init");
if (!srtp_init_done) {
st=srtp_init();
if (st==0) {
srtp_init_done++;
}else{
ortp_fatal("Couldn't initialize SRTP library.");
err_reporting_init("oRTP");
}
}else srtp_init_done++;
return st;
}
void ortp_qnx_log_handler(const char *domain, OrtpLogLevel lev, const char *fmt, va_list args) {
uint8_t severity;
uint8_t buffer_idx = 1;
if (slog2_registered != TRUE) {
slog2_buffer_config.buffer_set_name = domain;
slog2_buffer_config.num_buffers = 2;
slog2_buffer_config.verbosity_level = SLOG2_DEBUG2;
slog2_buffer_config.buffer_config[0].buffer_name = "hi_rate";
slog2_buffer_config.buffer_config[0].num_pages = 6;
slog2_buffer_config.buffer_config[1].buffer_name = "lo_rate";
slog2_buffer_config.buffer_config[1].num_pages = 2;
if (slog2_register(&slog2_buffer_config, slog2_buffer_handle, 0) == 0) {
slog2_registered = TRUE;
} else {
fprintf(stderr, "Error registering slogger2 buffer!\n");
return;
}
}
switch (lev) {
case ORTP_DEBUG:
severity = SLOG2_DEBUG1;
buffer_idx = 0;
break;
case ORTP_MESSAGE:
severity = SLOG2_INFO;
buffer_idx = 0;
break;
case ORTP_WARNING:
severity = SLOG2_WARNING;
break;
case ORTP_ERROR:
severity = SLOG2_ERROR;
break;
case ORTP_FATAL:
severity = SLOG2_CRITICAL;
break;
default:
ortp_fatal("Bad level!");
}
vslog2f(slog2_buffer_handle[buffer_idx], 0, severity, fmt, args);
}
void CorePlugin::log(OrtpLogLevel lev, const char *fmt, va_list args) {
const char *lname="undef";
char *msg;
switch(lev){
case ORTP_DEBUG:
lname="debug";
break;
case ORTP_MESSAGE:
lname="message";
break;
case ORTP_WARNING:
lname="warning";
break;
case ORTP_ERROR:
lname="error";
break;
case ORTP_FATAL:
lname="fatal";
break;
default:
ortp_fatal("Bad level !");
}
msg = ortp_strdup_vprintf(fmt, args);
#ifdef DEBUG
#ifdef WIN32
fprintf(s_log_file, FBSTRING_PluginFileName"-%s-%s\r\n", lname, msg);
fflush(s_log_file);
#else //WIN32
fprintf(stdout, FBSTRING_PluginFileName"-%s-%s\r\n", lname, msg);
fflush(stdout);
#endif //WIN32
#endif //DEBUG
CorePluginPtr plugin = s_log_plugin.lock();
if(plugin) {
CoreAPIPtr core = FB::ptr_cast<CoreAPI>(plugin->getRootJSAPI());
if(core) {
core->log(lname, msg);
}
}
ortp_free(msg);
}
/**
*
* According to the ZRTP specification the user must be informed about
* a GoClear request because the ZRTP implementation switches off security
* if it could authenticate the GoClear packet.
*
* <b>Note:</b> GoClear is not yet implemented in GNU ZRTP.
*
* @param ctx
* Pointer to the opaque ZrtpContext structure.
*/
static void ozrtp_handleGoClear(ZrtpContext* ctx) {
ortp_fatal("not implemented");
}
/**
* SRTP crypto data ready for the sender or receiver.
*
* The ZRTP implementation calls this method right after all SRTP
* secrets are computed and ready to be used. The parameter points
* to a structure that contains pointers to the SRTP secrets and a
* <code>enum Role</code>. The called method (the implementation
* of this abstract method) must either copy the pointers to the SRTP
* data or the SRTP data itself to a save place. The SrtpSecret_t
* structure is destroyed after the callback method returns to the
* ZRTP implementation.
*
* The SRTP data themselves are obtained in the ZRtp object and are
* valid as long as the ZRtp object is active. TheZRtp's
* destructor clears the secrets. Thus the called method needs to
* save the pointers only, ZRtp takes care of the data.
*
* The implementing class may enable SRTP processing in this
* method or delay it to srtpSecertsOn().
*
* @param ctx
* Pointer to the opaque ZrtpContext structure.
* @param secrets A pointer to a SrtpSecret_t structure that
* contains all necessary data.
*
* @param part for which part (Sender or Receiver) this data is
* valid.
*
* @return Returns false if something went wrong during
* initialization of SRTP context, for example memory shortage.
*/
static int32_t ozrtp_srtpSecretsReady (ZrtpContext* ctx, C_SrtpSecret_t* secrets, int32_t part ) {
srtp_policy_t policy;
err_status_t srtpCreateStatus;
err_status_t addStreamStatus;
OrtpZrtpContext *userData = user_data(ctx);
ortp_message("ZRTP secrets for %s are ready; auth tag len is %i",
(part == ForSender) ? "sender" : "receiver",secrets->srtpAuthTagLen);
// Get authentication and cipher algorithms in srtp format
if (secrets->authAlgorithm != zrtp_Sha1) {
ortp_fatal("unsupported authentication algorithm by srtp");
}
if (secrets->symEncAlgorithm != zrtp_Aes) {
ortp_fatal("unsupported cipher algorithm by srtp");
}
/*
* Don't use crypto_policy_set_from_profile_for_rtp(), it is totally buggy.
*/
memset(&policy,0,sizeof(policy));
if (secrets->srtpAuthTagLen == 32){
crypto_policy_set_aes_cm_128_hmac_sha1_32(&policy.rtp);
crypto_policy_set_aes_cm_128_hmac_sha1_32(&policy.rtcp);
}else if (secrets->srtpAuthTagLen == 80){
crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtp);
crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtcp);
}else{
ortp_fatal("unsupported auth tag len");
}
if (part == ForSender) {
srtpCreateStatus=srtp_create(&userData->srtpSend, NULL);
policy.ssrc.type=ssrc_specific;
policy.ssrc.value=userData->session->snd.ssrc; // us
policy.key=key_with_salt(secrets, secrets->role);
addStreamStatus=srtp_add_stream(userData->srtpSend, &policy);
} else { //if (part == ForReceiver)
srtpCreateStatus=srtp_create(&userData->srtpRecv, NULL);
policy.ssrc.type = ssrc_any_inbound; /*we don't know the incoming ssrc will be */
int32_t peerRole=secrets->role == Initiator ? Responder : Initiator;
policy.key=key_with_salt(secrets,peerRole);
addStreamStatus=srtp_add_stream(userData->srtpRecv, &policy);
}
ortp_free(policy.key);
if (srtpCreateStatus != err_status_ok) {
ortp_error("ZRTP Error %u during creation of SRTP context for %s",
srtpCreateStatus, (part == ForSender) ? "sender" : "receiver");
return 0;
}
if (addStreamStatus != err_status_ok) {
ortp_error("ZRTP Error %u during addition of SRTP stream for %s",
addStreamStatus, (part == ForSender) ? "sender" : "receiver");
return 0;
}
return 1;
}