News from Industry

The registration for the 5th edition of Kamailio World Conference & Exhibition is now open! More details and registration forms are available on the website of the event [1].Like at the previous editions, the event spans over three days, May 8-10, 2017, taking place in Berlin, Germany. The first day contains the technical tutorials, the following two days are for conference presentations and exhibition.The Call For Speakers is still in progress, but we already have a consistent group of confirmed speakers, with a very good balance of new and returning presenters, among them: Allison Smith, the famous world wide IVR and Asterisk voice; Fred Posner, Kamailio’s USA-based heavyweight; James Body with the challenging Dangerous Demos; Randy Resnick, the founder of the weekly VoIP Users Conference podcast; Sandro Gauci, the author of SIP Vicious (aka SIP Friendly Scanner).As usual, expect a big group of Kamailio developers such as Alex Balashov, Carsten Bock, Olle E. Johansson, Andreas Granig, Victor Seva, Elena-Ramona Modroiu, Dragos Vingarzan, Daniel-Constantin Mierla as well as members of Asterisk and FreeSwitch projects.Keep an eye on the website of the event, soon we will publish more details about accepted speakers and the first draft of the agenda.Looking forward to meeting many of you in Berlin at Kamailio World 2017![1] – https://www.kamailioworld.com/k05/registration/

Yap. It is that time of the year for me.

In the past two months there have been lots and lots of summaries, predictions and even reports thrown around about different markets. That’s what you get at the passing of a year.

I had my share of such articles written recently as well:

• WebRTC market expected to see more gradual changes
• CPaaS and API trends: Forecasting the future of embedded communications

But it is now time for something that will become a tradition here I hope, which is the yearly WebRTC Start of the Market infographic. I did one last year, so why not this time around as well?

Yes. I know. This one is almost a month into 2017, and I’ve written 2017 and not 2016 on it. In a sense, it was about practicallity – we care about what comes next more than what happened. To some of us, 2016 is almost a long forgotten memory already.

About the Infographic

What’s different this year in the infographic?

1. I decided to have a sponsor, and Vidyo were kind enough t oblige and assist. As time pass, it is becoming increasingly difficult to collect and maintain all of my WebRTC dataset fresh, so having vendors pitch in and help make it worthwhile is great. So thanks!
2. It includes a webinar
   • Last year I had a private Virtual Coffee session on this topic to my customers
   • This year I am doing a public webinar with Vidyo about this topic and the findings

The Webinar

Vidyo and BlogGeek.me will be hosting a webinar on 2017 WebRTC Market Outlook. I’ll be joining Nicholas Reid, which will make this all the more fun (doing a webinar solo is… lonely).

We will be covering the various stats in the infographic, go over trends and see how we think they will develop into 2017. We will also discuss the just announced Vidyo.io CPaaS and see how it fits into this outlook.

2017 is bound to be interesting and dynamic, so join us.

2017 WebRTC Market Outlook

When? Tuesday, February 7, 2017; 3 pm eastern / noon pacific

Where? Online

The Numbers

• Over 1,100 vendors and projects using WebRTC, and just looking at the adoption numbers of January 2017, I can say we’re in for an interesting ride this year
• Largest markets using WebRTC? Customer Management and specific verticals (Healthcare and Education lead the way)
• Outsourcing vendors are cropping like mushrooms after the rain with growth of over 100% in 2016. With the pressure and challenge of finding experienced developers for WebRTC, it is no surprise that many outsourcing vendors are either adding WebRTC to their technology warchest or going all out and focusing in WebRTC projects
• Live streaming is going strong with 70% growth in 2016. This will continue into 2017 as well, taking a lot of the attention span of enterpreneurs in the social media space
• In CPaaS there are many ways to split the market. One of them, is by horizontal and vertical players. The dynamics here are truly fascinating, along with the acquisitions in this specific domain (Xura, Twilio and Sinch)

The Infographic

PDF | PNG

What’s next?

That’s the big question, and one I’ll be focusing on a lot this year.

Here’s what you can do next:

1. Register to the webinar and meet Nicholas and myself there
2. Subscribe to my newsletter, so you don’t miss out. Lots of interesting announcements coming soon

 

Thanks again for Vidyo for sponsoring this infographic.

The post WebRTC State of the Market 2017 appeared first on BlogGeek.me.

Ansible is a system for rapid deployment of services. Alberto Llamas has shared a link to his Ansible Kamailio Role that could be used as starting point for many people when deploying their Kamailio:

• https://galaxy.ansible.com/albertollamaso/Ansible-kamailio-role/

Over the time there were other people sharing similar resources, such as the one in the article:

• Kamailio HA with Ansible, Corosync and Pacemaker

We welcome any resource, blog post or tools that make it easier to deploy and work with Kamailio and gladly publish news about them. Should you have or know such resource, do not hesitate to contact Kamailio project!Thanks for flying Kamailio!

Kamailio SIP Server v4.4.5 stable is out – a minor release including fixes in code and documentation since v4.4.4. The configuration file and database schema compatibility is preserved, which means you don’t have to change anything to update.Kamailio v4.4.5 is based on the latest version of GIT branch 4.4. We recommend those running previous 4.4.x versions to upgrade. There is no change that has to be done to configuration file or database structure comparing with the previous release of the v4.4 branch.Resources for Kamailio version 4.4.5Source tarballs are available at:

• http://www.kamailio.org/pub/kamailio/4.4.5/src/

Detailed changelog:

• http://www.kamailio.org/pub/kamailio/4.4.5/ChangeLog

Download via GIT: # git clone git://git.kamailio.org/kamailio kamailio
# cd kamailio
# git checkout -b 4.4 origin/4.4Relevant notes, binaries and packages will be uploaded at:

• http://www.kamailio.org/pub/kamailio/4.4.5/

Modules’ documentation:

• http://www.kamailio.org/docs/modules/4.4.x/

What is new in 4.4.x release series is summarized in the announcement of v4.4.0:

• http://www.kamailio.org/w/kamailio-v4-4-0-release-notes/

We hope to meet many of you at the 5th edition of Kamailio World Conference, the project’s annual event, scheduled for May 8-10, 2017, in Berlin, Germany!Thanks for flying Kamailio!

If you think WebRTC is free, then think again.

WebRTC is free

I see it everyday and it is glaringly obvious. I probably haven’t made things any better myself with this slide of mine:

WebRTC is free. But lets consider what exactly is free with this technology:

1. The code. You can go download it from webrtc.org. And then… do with it whatever. It is licensed under BSD
2. The codecs used – and yes – I know – there are people who feel entitled to them through some patents – but no one yet cares about it – almost everyone assumes it is free and uses it – for now
3. It is readily available inside browsers. Well… at least some of them (Chrome, Firefox & Edge. Coming to Safari sometime)
4. And that’s a wrap

It is a hell of a lot to give for free. Especially if you went to sleep ten years ago and just woke up.

What’s missing in WebRTC?

But that’s only a small piece of the puzzle. Or as another slide in my deck usually states:

There are loads of things in WebRTC that you need to do in order to get a service to production. Here’s a shortlist of things that just came to mind:

1. Selecting and implementing singaling
2. Writing the application
3. Installing and deploying TURN servers (preferably at scale)
4. Adding media servers if needed – and making them work for your scenario
5. Testing it all
6. Monitoring it in production
7. Tweaking and upgrading as you go along

How do you fill in these gaps in WebRTC?

All these complementary solutions come in different shapes and sizes:

• Open source frameworks of various kinds you can use. Most will be half baked (=require more work to get them to production), or not exactly fit your needs
• Vendors offering consulting and outsourcing (check out a few of them in the WebRTC Index)
• Different vendors offering hosted and managed services. From signaling, to NAT traversal, testing & monitoring and complete CPaaS

The funny thing is, that whenever you talk to one of the companies developing with WebRTC, they believe everything in WebRTC should be free.

1. STUN servers? Free. There are lists of free STUN servers you can use
2. TURN servers? Free. Or more like “why can’t I find free TURN srevers?” (mind you – you should NEVER use free TURN servers)
3. Using a WebRTC PaaS vendor? That’s waaaay to expensive. We want to build it on our own to keep costs down

The thing is that building these things on your own will take time and money. Lots of both to be exact.

Same thing about how you end up testing it all or monitoring it. I’d say this is how the market looks like when it comes to testing WebRTC:

So what?

If you are planning a product that needs communications, you should definitely consider WebRTC first. Before anything else. It is probably going to be the cheapest technology for your needs but also the best one.

That said, you shouldn’t consider it all free. Plan it. Budget it. Write down your requirements. Decide on your architecture. Figure out who your partners should be in this road.

This is why I decided to start off the year with a giveaway. $1,000 worth of credits on VoxImplant. And all you have to do is signup for it. It just might get you started on your road with WebRTC. And who knows what will happen later on?

 

The post WebRTC is FREE. But Developers Aren’t appeared first on BlogGeek.me.

There are many situations within a day when the CPU fans are going crazy, being it some heavy loaded JavaScript site, compiling Kamailio or other applications. I was looking for tools, either open source or from "trusted?" sources that I can use to check the CPU temperature on my MacOS Sierra, but should work also on older MacOSX versions.

I ended up installing two applications, one command line tool and the other with GUI, both are free to use:

• iStats - open source cli - https://github.com/Chris911/iStats
• Intel (r) Power Gadget - GUI app - https://software.intel.com/en-us/articles/intel-power-gadget-20

iStats is open source, Ruby is already installed on Mac OS, so installing it is as simple as running in a terminal:
sudo gem install iStatsThen execute istats and you should see something like:


Besides the CPU temperature, it shows fan and battery stats.
Intel Power Gadget - not open source (or I missed the link to the repo), but it is free to use and made by the guys that manufacture the CPU, so I expect to get more accurate values. After installation, once you start it and let you run for a while, you should see something like:


It shows the usage of power by CPUs, along with frequency and temperature, tracking the history of the values and displaying the charts for them.
Hopefully this post will save some time for people looking for similar tools!

We are less than two weeks into 2017 and there are plenty of options in the short term to meet with Kamailio around the world:

• Kazoo (Cloud PBX incorporating Kamailio and Freeswitch) Training, Feb 1-3, San Francisco, CA, USA
• FOSDEM 2017, Feb 3-4, Brussels, Belgium – Olle E. Johansson (in RTC devroom) and Daniel-Constantin Mierla (in Lua devroom) will have presentations. Expect a large group of Kamailio friends around (more details soon)
• Asterisk World, Feb 8-10, Fort Lauderdale, FL, USA, with Fred Posner presenting about Kamailio and Asterisk
• SIP Masterclass by Edvina and Avanzada7 with Olle E. Johansson, Feb 20-23, Madrid, Spain
• Call Center World, Feb 21-23, Berlin, Germany
• Mobile World Congress, Feb 27-Mar 2, Barcelona, Spain – Quobis and other Kamailio folks will be there
• RTC Meetup Barcelona, Feb 28, Spain – coordinated by Victor Pascual Avila, usually packed with a consistent group of Kamailio friends
• Kamailio Advanced Training by Asipto with Daniel-Constantin Mierla, Mar 6-8, Berlin, Germany

An of course, don’t forget the Kamailio World Conference 2017, May 8-10, Berlin, Germany.If you are in the area of an event, but you don’t participate directly to it, just ask around in our forums, there might be group gatherings outside of them, such as dinners, meetups, … where anyone can join or simply people being there want to meet you. For discussions about these events, you can use our public mailing lists.If you organize or you are aware of events involving Kamailio, do not hesitate to contact us, we will gladly publish news about them.Looking forward to meeting many of you around the globe during 2017!Thanks for flying Kamailio!

If you got until here and haven’t entered your email yet, then you should definitely go back up.

I decided to kick off 2017 with a few interesting initiatives. And the first one is this giveaway – a first that I am doing on my website.

I’ve been following the CPaaS space for quite some time now, and have focused on WebRTC PaaS. CPaaS, PaaS and other XaaS acronyms are confusing. For the laymen, if you want to develop something that needs communication capabilities but don’t want to host the communication service itself – that’s what you end up using. And if this is your case, then why not try out one of the interesting vendors out there?

VoxImplant was kind enough to offer $1,000 in credits for one person.

To enter, all you need to do is place your email in the large giveaway box at the top – and that’s about it.

Be sure to share this giveaway with others using that URL you’ll be getting, as that will increase your chances of winning – and if enough people join the giveaway – will get you a nice bonus as well (even if you don’t win in this giveaway).

What do you have to lose?

Join now, and maybe it will get you a bit faster to your application goal with the help of VoxImplant.

The post Jumpstart Your WebRTC Development with $1000 on VoxImplant appeared first on BlogGeek.me.

With a rather busy end of 2016, several additions to Kamailio missed the chance to get into the news as they were imported in the repository. Now it’s time to catch up with some of them, given that development is frozen and the focus is on testing master branch in order to prepare the v5.0.0 release.One of the new modules that will make it into v5.0.0 is named ims_ocs. As the prefix suggests is related to Internet Multimedia Subsystem (aka IMS), the core platform for 4G/VoLTE mobile networks. More specifically, it is an implementation of a simple Online Charging Server, communicating with ims_charging module via Diameter-Ro interface.The module was developed by the folks at NG Voice, led by Carsten Bock. More details about the module can be found in its readme docs:

• http://kamailio.org/docs/modules/devel/modules/ims_ocs.html

Stay tuned for more news about what’s new in upcoming Kamailio v5.0.0!Thanks for flying Kamailio!

On Wednesday, January 11, 2017, at 18:00UTC (12:00CT, 18:00 London, 19:00 Berlin), the Cluecon weekly conference call will focus again on Kamailio and FreeSwitch. Daniel-Constantin Mierla will be joining the call, presenting what is new in latest Kamailio, what to expect at Kamailio World Conference 2017, answering the questions about Kamailio and its options to integrate with FreeSwitch. Expect the FreeSwitch core developers to be around to handle the questions about their project.Participation is open for anyone, you can dial in for audio or video sessions using a SIP phone or webrtc capable browser:

• sip:888@conference.freeswitch.org
• https://conference.freeswitch.org/vc (WebRTC Enabled voice and video, call 888 once you are logged in)

More dial in options (PSTN) are presented at:

• https://freeswitch.org/confluence/display/FREESWITCH/ClueCon+Weekly+Conference+call

Thanks for flying Kamailio!

Submission of presentation proposals for Kamailio World 2017 is open. Deadline for submission is February 10, 2017, notification of accepted proposals will be done latest on March 01, 2017.Be aware that interesting proposals can be accepted before the deadline, we plan to have two intermediate review sessions before February 10, 2017, announcing any accepted presentations immediately. Note also that at the previous edition there were more proposals than available slots and we expect to happen again this time. Therefore it is recommended to send your proposal as soon as possible, do not wait till deadline.To submit the proposal, fill in the web form at:

• https://www.kamailioworld.com/k05/call-for-speakers/

The main topic of the conference is Real Time Communications, with the majority of the content being about Kamailio and other open source projects in the area. However, like for the past editions, we welcome very interesting presentations beyond those subjects.If you are interested to look at the agenda from previous edition, visit:

• https://www.kamailioworld.com/k04/schedule/

Have a great 2017! Looking forward to meeting many of you at the next Kamailio World!

How many WebRTC RTCPeerConnection objects should we be aiming for?

This is something that bothered me in recent weeks during some analysis we’ve done for a specific customer at testRTC.

It all started when a customer using Tokbox came to us. He was complaining he couldn’t get the product he built stabilized enough and due to that, couldn’t really get it launched. The reason behind it was partially his inability to decide how many users in parallel can fit into a single session.

So we took that as a side project at testRTC. It is rather easy for us to get 50, 100, 200 or more browsers to direct towards a single service and session and get the analysis we need. So it was easy to use once we’ve written the script necessary. While we have Tokbox customers using our platform, I never did try to go deeper into the analysis until now for such customers. This time, it was part of what the customer expected of us, so it got me looking closer at Tokbox and how they implement multiparty sessions.

In the past couple of weeks we’ve done our digging and got to conclusions of our own. I haven’t meant to write about them here, but a recent question on Stack Overflow compelled me to do so – Maximum number of RTCPeerConnection:

I know web browsers have a limit on the amount of simultaneous http requests etc. But is there also a limit on the amount of open RTCPeerConnection’s a web page can have?

And somewhat related: RTCPeerConnection allows to send multiple streams over 1 connection. What would be the trade-offs between combining multiple streams in 1 connection or setting up multiple connections (e.g. 1 for each stream)?

The answer I wrote there, slightly modified is this one:

Not sure about the limit. It was around 256, though I heard it was increased. If you try to open up such peer connections in a tight loop – Chrome will crash. You should also not assume the same limit on all browsers anyway.

Multiple RTCPeerConnection objects are great:

• They are easy to add and remove, so offer a higher degree of flexibility when joining or leaving a group call
  They can be connected to different destinations

That said, they have their own challenges and overheads:

• Each RTCPeerConnection carries its own NAT configuration – so STUN and TURN bindings and traffic takes place in parallel across RTCPeerConnection objects even if they get connected to the same entity (an SFU for example). This overhead is one of local resources like memory and CPU as well as network traffic (not huge overhead, but it is there to deal with)
• They clutter your webrtc-internals view on Chrome with multiple tabs (a matter of taste), and SSRC might have the same values between them, making them a bit harder to trace and debug (again, a matter of taste)

A single RTCPeerConnection object suffers from having to renegotiate it all whenever someone needs to be added to the list (or removed).

I’d like to take a step further here in the explanation and show a bit of the analysis. To that end, I am going to use the following:

1. testRTC – the service I’ll use to collect the information, visualize and analyze it
2. Tokbox’ Opentok demo – Tokbox demo, running a multiparty video call, and using a single RTCPeerConnection per user
3. Jitsi meet demo/service – Jitsi Videobridge service, running a multiparty video, and using a shared RTCPeerConnection for all users

If you rather consume your data from a slidedeck, then I’ve made a short one for you – explaining the RTCPeerConnection count issue. You can download the deck here.

But first things first. What’s the relationship between these multiparty video services and RTCPeerConnection count?

WebRTC RTCPeerConnection and a multiparty video service

While the question on Stack Overflow can relate to many issues (such as P2P CDN technology), the context I want to look at it here is video conferencing that uses the SFU model.

The illustration above shows a video conferencing between 5 participants. I’ve “taken the liberty” of picking it up from my Advanced WebRTC Architecture Course.

What happens here is that each participant in the session is sending a single media stream and receiving 4 media streams for the other participants. These media streams all get routed through the SFU – the box in the middle.

So. Should the SFU box create 4 RTCPeerConnection objects in front of each participant, each such object holding the media of one of the other participants, or should it just cram all media streams into a single RTCPeerConnection in front of each participant?

Let’s start from the end: both options will work just fine. But each has its advantages and shortcomings.

Opentok: RTCPeerConnection per user

If you are following the series of articles Fippo wrote with me on testRTC about how to read webrtc-internals, then you should know a thing or two about its analysis.

Here’s how that session looks like when I join on my own and get testRTC to add the 4 additional participants into the room:

Here’s a quick screenshot of the webrtc-internals tab when used in a 5-way video call on the Opentok demo:

One thing that should pop up by now (especially with them green squares I’ve added) – TokBox’ Opentok uses a strategy of one RTCPeerConnection per user.

One of these tabs in the green squares is the outgoing media streams from my own browser while the other four are incoming media streams from the testRTC browser probes that are aggregated and routed through the TokBox SFU.

To understand the effect of having open RTCPeerConnections that aren’t used, I’ve ran the same test scenario again, but this time, I had all participants mute their outgoing media streams. This is how the session looked like:

To achieve that with the Opentok demo, I had to use a combination of the onscreen mute audio button and having all participants mute their video when they join. So I added the following lines to the testRTC script – practically clicking on the relevant video mute button on the UI:

After this most engaging session, I looked at the webrtc-internals dump that testRTC collected for one of the participants.

Let’s start with what testRTC has to offer immediately by looking at the high level graphs of one of the probes that participated in this session:

1. There is no incoming data on the channels
2. There is some out going media, though quite low when it comes to bitrate

What we will be doing, is ignore the outgoing media and focus on the incoming one only. Remember – this is Opentok, so we have 5 peer connections here: 1 outgoing, 4 incoming.

A few things to note about Opentok:

1. Opentok uses BUNDLE and rtcp-mux, so the audio and video share the same connection. This is rather typical of WebRTC services
2. Opentok “randomly” picks SSRC values to be numbered 1, 2, … – probably to make it easy to debug
3. Since each stream goes on a different peer connection, there will be one Conn-audio-1-0 in each session – the differences between them will be the indexed SSRC values.

For this test run that I did, I had “Conn-audio-1-0 (connection 363-1)” up to “Conn-audio-1-0 (connection 363-5)”. The first one is the sender and the rest are our 4 receivers. Since we are interested here in what happens in a muted peer connection, we will look into “Conn-audio-1-0 (connection 363-2)”. You can assume the rest are practically the same.

Here’s what the testRTC advanced graphs had to show for it:

I removed some of the information to show these two lines – the yellow one showing responsesReceived and the orange one showing requestsReceived. These are STUN related messages. On a peer connection where there’s no real incoming media of any type. That’s almost 120 incoming STUN related messages in total for a span of 3 minutes. As we have 4 such peer connections that are receive only and silent – we get to roughly 480 incoming STUN related messages for the 3 minutes of this session – 160 incoming messages a minute – 2-3 incoming messages a second. Multiply the number by 2 so we include also the outgoing STUN messages and you get this nice picture.

There’s an overhead for a peer connection. It comes in the form of keeping that peer connection open and running for a rainy day. And that is costing us:

• Network
  • Some small amount of bitrate for STUN messages
  • Maybe some RTCP messages going back and forth for reporting purposes – I wasn’t able to see them in this streams, but I bet you’d find them with Wireshark (I just personally hate using that tool. Never liked it)
  • This means we pay extra on the network for maintenance instead of using it for our media
• Processing
  • That’s CPU and memory
  • We need to somewhere maintain that information in memory and then work with it at all times
  • Not much, but it adds up the larger the session is going to be

Now, this overhead is low. 2-3 incoming messages a second is something we shouldn’t fret about when we get around 50 incoming audio packets a second. But it can add up. I got to notice this when a customer at testRTC wanted to have 50 or more peer connections with only a few of them active (the rest muted). It got kinda crowded. Oh – and it crashed Chrome quite a lot.

Jitsi Videobridge: Shared RTCPeerConnection

Now that we know how a 5-way video call looks like on Opentok, let’s see how it looks like with the Jitsi Videobridge.

For this, I again “hired” the help of testRTC and got a simple test script to bring 4 additional browsers into a Jitsi meeting room that I joined with my own laptop. The layout is somewhat different and resembles the Google Hangouts layout more:

What we are interested here is actually the peer connections. Here’s what we get in webrtc-internals:

A single peer connection for all incoming media channels.

And again, as with the TokBox option – I’ll mute the video. For that purpose, I’ll need to get the participants to mute their media “voluntarily”, which is easy to achieve by a change in the testRTC script:

What I did was just was instruct each of my automated testRTC friends that are joining Jitsi to immediately mute their camera and microphone by clicking the relevant on-screen buttons based on their HTML id tags (#toolbar_button_mute and #toolbar_button_camera), causing them to send no media over the network towards the Jitsi Videobridge.

To some extent, we ended up with the same boring user experience as we did with the Opentok demo: a 5-way video call with everyone muted and no one sending any media on the network.

Let’s see if we can notice some differences by diving into the webrtc-internals data.

A few things we can see here:

• Jitsi Videobridge has 5 incoming video and audio channels instead of 4. Jitsi reserves and pre-opens an extra channel for future use of screen sharing
• Bitrates are 0, so all is quiet and muted
• Remeber that all channels here share a single peer connection

To make sure we’ve handled this properly, here’s a view of the video channels’ bitrate values:

There’s the obvious initial spike – that’s the time it took us to mute the channels at the beginning of the session. Other than that, it is all quiet.

Now here’s the thing – when we look at the active connection, it doesn’t look much different than the ones we’ve seen in Opentok:

We end up with 140 incoming messages for the span of 3 minutes – but we don’t multiply it by 4 or 5. This happens once for ALL media channels.

Shared or per user RCTPeerConnection?

This is a tough question.

A single RTCPeerConnection means less overhead on the network and the browser resources. But it has its drawbacks. When someone needs to join or leave, there’s a need to somehow renegotiate the session – for everyone. And there’s also the extra complexity of writing the code itself and debugging it.

With multiple RTCPeerConnection we’ve got a lot more flexibility, since the sessions are now independent – each encapsulated in its own RTCPeerConnection. On the other hand, there’s this overhead we’re incurring.

Here’s a quick table to summarize the differences:

What’s Next?

Here’s what we did:

1. We selected two seemingly “identical” services
   • The free Jitsi Videobridge service and the Opektok demo
   • We focused on doing a 5-way video session – the same one in both
   • We searched for differences: Opentok had 5 RTCPeerConnections whereas Jitsi had 1 RTCPeerConnection
2. We then used testRTC to define the test scripts and run our scenario
   • Have 4 testRTC browser probes join the session
   • Have them mute themselves
   • Have me join as another participant from my own laptop into the session
   • Run the scenario and collect the data
3. Looked into the statistics to see what happens
   • Saw the overhead of the peer connection

I have only scratched the surface here: There are other issues at play – creating a RTCPeerConnection is a traumatic event. When I grew up, I was told connecting TCP is hellish due to its 3-way handshake. RTCPeerConnection is a lot more time consuming and energy consuming than a TCP 3-way handshake and it involves additional players (STUN and TURN servers).

Rather consume your information from a slidedeck? Or have it shared/printed with others in your office? You can download the RTCPeerConnection count deck here.

 

The post WebRTC RTCPeerConnection. One to rule them all, or one per stream? appeared first on BlogGeek.me.

The development (master) branch of Kamailio enters now in pre-release phase for version 5.0.0. Therefore, no new feature should be pushed to master until we create a dedicated branch for 5.0 (expected to be in about 4 weeks or so).If in doubt to push or not a commit to master branch, push it first on a personal branch (or attach to an email) and discuss it on sr-dev mailing list. The new modules can be a bit more dynamic if there is need to get them to the right shape (e.g., like decision to rename functions, parameters or adjust database structure).We hope to get many people involved in testing, to reach a stable state before releasing 5.0.0. If you want to get involved and need assistance, don’t hesitate to write to mailing lists.Besides the new features, there were two major changes for 5.0:

• source code tree restructuring – this should not affect the stability of the code, only installation scripts or packaging may still need tuning
• mi (management/control interface) code has been removed. SIP routing code should not be affected by this change that much, but testing of RPC commands needs a special care. There are few RPC commands not ported yet from the MI code, they can be done during the testing period

Moreover, help with updating the wiki page for migration from 4.4 to 5.0 as well as what is new in 5.0 is very appreciated. More updates about them very soon.Many thanks to everyone involved in development of 5.0 and the early testers that played with master branch so far.Thank you for flying Kamailio!Looking forward to meeting many of you at Kamailio World 2017!

No active MI (aka management interface) related code should be in Kamailio master branch starting with today, Jan 4, 2017. The internal library kmi, the modules mi_datagram, mi_fifo, mi_xmlrpc, mi_rpc and pua_mi were removed.The MI was a custom mechanism introduced in the early days of the project (like 2001-2002) to interact with Kamailio at runtime, using a line-based text protocol through FIFO file, with alternative transport via datagram sockets or xmlrpc. It was declared deprecated several years ago in favour of using the RPC interface. The RPC interface offers a better structured interaction protocol, with transports for XMLRPC, BINRPC and JSONRPC over HTTP(S), TCP, UDP, UNIXSOCKET or FIFO files.Couple of modules still have some mi code disabled with ifdefs, they are pending the port to RPC commands. These are: carrierroute, ims_dialog, mohqueue, p_usrloc, userblacklist, utils. They should be updated in the next few days.With MI code removed, the code base got slimmer, the future development and maintenance effort is reduced.From now on, the RPC interface has to be used for interacting with kamailio at runtime.The CLI tools were updated as well:

• kamctl – was already migrated to use RPC via jsonrpcs module.
• kamcmd – was developed to use only RPC interface via ctl module.
• kamcli – is also working with RPC via jsonrpcs module

Helping with testing the RPC commands is very appreciated — open an issue on bug tracker whenever you discover a problem.Thanks for flying Kamailio!

2016 has reached its end, a special one for Kamailio by celebrating 15 years of development! Thank you everyone for contributing to the project!We are looking forward to a great 2017, the release of v5.0.0 is around the corner! We wish a healthy and prosperous year 2017 to all Kamailio friends, hoping to meet many of you at Kamailio World Conference and other events around the globe!Thanks for flying Kamailio!Enjoy and stay safe!Happy New Year!

Passing the 15 years of development marker for Kamailio project few months ago, we are now approaching the end of 2016. A long list of people devoted a lot of time in sustaining the project with resources for development, support and advertising. So this is a good moment to thank and greet them, everyone involved in Kamailio project, old and new friends, developers, contributors, the engaged and warm community members.We are very close to the moment of freezing the version 5.0.0, a new major milestone in the project evolution, with a restructured source code tree, cleaner and slimmer code base, a new flexible configuration file framework that allows building SIP routing script in embedded languages such as Lua and Python, a.s.o. – all making a very solid foundation for developing next releases! Good premises to expect a lot of new stuff in 2017!The 5th edition of Kamailio World Conference, the project’s annual event, is scheduled for May 8-10, 2017, in Berlin, Germany. We look forward to meeting many of the community members there!Merry Christmas and Happy Winter Holidays!Santa is flying Kamailio!

There is no real peak telephony.

[Chad Hart is no stranger to my readers here. He runs webrtcHacks, part of the Kranky Geek team and works at Voxbone. This time, he takes a look at telephony and where it stands today – with and without WebRTC]

Back in April of 2015, I recall Google WebRTC Product Manager Serge LaChapell talking about the WebRTC team’s focus on mobile and how they wanted to kick “VoLTE’s butt”. To be fair he was referencing call connection times, but reading between the lines I like to believe he has had ambitions well beyond that – namely beating VoLTE and the traditional telephony network in minutes.

"We want to kick VoLTE's butt" @slac talking about #webrtc mobile improvements pic.twitter.com/f1aVnSbgMK

— Chad Hart (@chadwallacehart) April 15, 2015

For many years I have tried to keep track of how the traditional telecoms has fared against the emerging VoIP application world (what they sometimes derogatorily call “OTT”).  I have had two hypotheses for several years now:

1. Traditional telecoms over the PSTN is past “peak” and will continue to decline
2. Real time communications (RTC) in general has been on the decline but is poised to make a comeback thanks to better implementations and technologies like WebRTC

Let’s check the data to test these statements.

Peak Telephony? Maybe Not…

Digging into the statistics from various sources, I was surprised to find I was wrong about my first hypothesis on peak telephony.

The US market

Let’s start by taking a look at the situation in the US, one of the world’s largest communications markets. The Consumer Telecommunications Industry Association (CTIA) provides an annual update that sometimes includes Minutes of Use (MoU) and subscriber data. The data shows that on a subscriber-level, mobile telephony usage already peaked on a per-subscriber basis in 2007.

However, there is a growing number of data-only subscriptions for our tablets and other devices counted as subscribers. This negatively skews the numbers. Looking at “minutes” on a per capita basis is a cleaner metric, so let’s divide the minute figures by the US population. This shows a much more interesting picture where mobile phone usage for traditional calling actually went up by 16%.

Total US cellular telephony minutes appear to be rising after stalling for many years (my calculations)

Checking the data against other FCC sources, this growth may be overstated but there is no clear evidence of decline. So what’s going on? Much of cellular’s continued volumes can be attributed to fixed-mobile substitution – both in terms of people dropping their fixed lines and as the FCC reports  “A significant percentage of homes with both landline and wireless phone access received all or almost all calls on wireless telephones despite also having a landline telephone.” If we assumed total PSTN calling was flat, then according to my estimates, a 30% annual decline in fixed line minutes would be required to explain the decrease. This is possible, but way faster than past usage declines in fixed so it is more likely cellular usage did indeed have a very good year in 2015.

There is no clear evidence of peak PSTN telephony in the US, so let’s check some other sources.

The UK market

The UK’s Ofcom is generally a much better datasource than the FCC since they look at communications as a whole within the UK and compare it to other countries.

They are a lot more pessimistic when it comes to PSTN-based telephony. Their data is very definitive showing a continued, gradual decline in PSTN call volumes going back to 2010.  With a -3% 5 year CAGR, no matter how you cut it, “operator” traffic is down.

Ofcom CMR 2016 report shows declines in operator voice usage

They have not released their global figures for 2015, but their 2014 report showed similar trends with mature markets declining (US, Western Europe, Japan & Korea). However, emerging marketings like China, India, and Russia show show growth and just make up for declines in the mature markets in 2014.

Does anyone care about the PSTN anyway?

Outside of adding touch tone dialing and going cordless, the Public Switched Telephone Network (PSTN) telephony user experience hasn’t exactly changed a whole lot in a hundred years. The PSTN is only one way to make calls – now we dedicated VoIP apps,  messenger apps with voice, and a growing number of video communications options. Do these new forms for RTC give us any hope of reversing traditional telephony’s demise? The data here is more positive.

Ofcom’s data shows an increasing usage of VoIP for voice calls and a very definitive increase in video call usage. This is consistent with their international research from a year earlier:

VoIP Apps Save the Day

So where do newer RTC apps and features fit into all this? Using Ofcom’s methodology, the 18 countries they track produce somewhere around 10 Trillion minutes a year. Microsoft has previously claimed Skype does up to 3 Billion minutes a day – that’s a Trillion minutes a year if one assumes around a 3 Billion daily average. Even if the true annual value is half of that, clearly Skype alone is meaningful compared to PSTN volumes.

Apple does not release any figures for its FaceTime service introduced in 2011, but presumably its usage is substantial, although less than Skype’s based on Ofcom’s past user surveys. WeChat, Line, and Viber all have more than 200 million monthly active users with various VoIP features. WhatsApp now has more than 1 billion MAU. Its VoIP calling feature launched in April 2015 has more than 100 million voice calls a day. Taken together, these other VoIP services are easily more than a trillion minutes a year.

At 10 to 20% of the PSTN’s volume, clearly VoIP traffic has a ways to go before it dominates the PSTN, but there is no doubt its volumes are meaningful in comparison.  Furthermore, these services are still growing. Certainly some of that growth will come at the expense of the PSTN, but it appears they are also encouraging more RTC use in general.

Does WebRTC matter?

WebRTC does not factor heavily into the services cited above, but that is poised to change. At only 5 years old, WebRTC has not had that much time to widely establish itself in relation to other VoIP technologies. Still, there are a few notable standouts – particularly notably Facebook Messenger. Facebook has stated it has more than 300 million monthly active users of Messenger’s VoIP features and just this week announced it had 245 million monthly video users. Other notable users include Snapchat and of course Google’s Hangouts and Duo services.

There are a lot of other WebRTC apps showing big user gains too such as Houseparty which reported it had 20 million minutes of usage a day last month – not bad for an app that only emerged from the ruins of Meerkat a few months ago. In addition, more traditional VoIP apps like Whatsapp and Skype are starting to use WebRTC, albeit in limited circumstances today but that will certainly grow too.

In aggregate, I estimate WebRTC-based services easily have over 500 million MAU this year across 2 billion devices. Comparing this to other VoIP technologies at the 5 year mark, WebRTC is way ahead. This bodes well for WebRTC to be an incremental driver of VoIP traffic and further accelerator of RTC.

Conclusions

I have been concerned that the desire of people communicate in real time reached its pinnacle long ago. Why focus on RTC if the trend is clearly toward “messaging” and other forms of textual interaction?  Has telephony peaked? The evidence suggests that is probably the case for the PSTN in developed markets, but there are plenty of pockets of growth. Where declines exist, they are gradual. Even better, there is a large body of evidence that VoIP services are more than making up the gaps of any declines and then some. This indicates that we are actually using real time communications more than even. The recent and rapid rise of many WebRTC services is a further shows that this trend is very likely to continue, or perhaps even accelerate. That’s great news for the hundreds of WebRTC vendors out there and those that have yet to come.

The post Can WebRTC save telephony? appeared first on BlogGeek.me.

Management Interface (MI), the old line-based text protocol interface to interact with Kamailio is going to be removed in the near future. It was declared obsolete several years ago, when we introduced the RPC interface. With upcoming version 5.0 already having the code source tree restructured, this step makes a better and slimmer foundation for next generation of releases.The default configuration file is now shipping with jsonrpcs module and kamctl tool is using the RPC interface via jsonrpcs. The command line parameters for kamctl should be the same like for the past releases, but the output is now in jsonrpc format.The RPC interface is implemented by the following modules:

• ctl – binary rpc protocol – with transport layers for FIFO file, unix sockets and IP sockets (both datagram and stream). It is the module used by the kamcmd tool.
• jsonrpcs – jsonrpc protocol – with transport layers for FIFO file, unix and IP sockets (datagram) and HTTP via xhttp module. It is the module used by kamctl and kamcli tools.
• xmlrpc – xmlrpc protocol – with transport layer for HTTP

If you were using mi_fifo or mi_datagram modules, then you can switch to jsonrpcs module (it offers the transports for the two mi modules). If you were using mi_xmlrpc, then you can switch to xmlrpc module.Thanks for flying Kamailio!

WebRTC is the most secure technology for video communications. And yet – developers can screw this for you.

There is a rise in security breaches and data theft incidents in 2016. You see this from the amount of information out there. I’ve written about WebRTC and security for quite some time, but a recent post I’ve read compelled me to write about it again.

The post? Red Cross Blood Service in Australia leaks personal data.

The gist:

• Site is secure
• A contractor places database dump on the internet for backup
• And that get found

It probably happens more often than not. You build a service. You take care of its security. And then, someone down the lines screws you over with his maintenance processes. To some extent, this is just as bad as social engineering, where a hacker tries to gain access by fooling people to believe he is someone else.

Make sure to download the WebRTC Security checklist. Print it and stick it on the wall behind your monitor so you don’t forget.WebRTC Security baseline

WebRTC comes with a few security concepts that are quite new and innovative in VoIP:

1. In WebRTC, EVERYTHING is encrypted. Not only by default, but also in a way that can’t be modified – there is no way to send data over WebRTC in the clear
2. WebRTC forces you to operate over HTTPS and WSS in your web application, so signaling gets encrypted as well
3. Screensharing requires an additional layer of consent, be it whitelisting of your site or a creation of a browser extension
4. Browsers today update frequently and automatically, so any security threat found gets patched faster than most enterprise and VoIP vendors react to their security breaches

The thing people forget is that WebRTC is just a piece of technology. A building block. It is up to the developers to decide how to use it in their own product. During that integration, security breaches can be created quite easily.

In the WebRTC course I launched two months ago, I’ve added a lesson dealing with WebRTC security. It goes through the mechanisms that exist in WebRTC and the areas that need to be further secured by the application.

Two big issues left to developers today are TURN passwords and access to backend server resources.

#1 – TURN passwords

TURN servers predate WebRTC. They are used by SIP (or at least are found in the spec), and there, the notion is that the user agent (=device/endpoint) is secure and “named”. So a username and password mechanism was created to get a TURN binding. The reason you want such a mechanism in the first place is because TURN servers are bandwidth hogs – they relay media, and by doing that they cost a lot in terms of bandwidth. So if you are paying for it, you don’t want others to piggyback on it.

The problem with this approach in WebRTC is that the username and password needs to be passed from your JavaScript code inside the browser to the server. Which means that information is available in the clear for many use cases – those where you don’t need or want the user to identify with the network at all.You also don’t want someone sniffing your code in the browser and then reusing these credentials elsewhere.

The current approach out there is to use temporary passwords (I like calling them ephemeral – it makes me sound intelligent). Ones that become useless in an hour or two.

This means that someone in your backend randomly creates a password that is short-lived and shares it with both the TURN server and the client.

The above illustrates how this is done.

• The App Server, in charge of signaling in this case, creates a password. It updates the TURN server about said password and also gives that information to the User
• The User then creates a peer connection, configuring the TURN server in it with the relevant temporary password

Great.

Now lets add a media server into the mix.

Who should be generating that password and passing it around to whom? Should the Media Server now be in charge of it, or is it up to the App Server still to take care of this?

Which leads me to the second important security aspect of WebRTC when it comes to your development – backend server resources you need to protect.

#2 – Backend server resources

In many cases, I find that when the work is outsourced, the end result tends to be a jumble of an architecture if things aren’t thought out properly from the beginning.

This usually causes the wrong servers to need to connect and communicate directly with the User. While not an issue on its own, it can easily turn into a headache:

• Not having a clear picture of the state in your backend means you lose control – this can turn ugly when issues arise
• Opening up more of your backend towards the internet means more points to secure against penetration
  • And yes – I know there’s a trend to treat servers in the cloud as if they are always open to the internet
  • Which means you need to think about how best to protect them in the first place anyway, which happens to be closing them as much as possible

What I suggest in many cases is:

1. Media servers should never be controlled or accessed directly from the Internet
2. Media servers should only pass media to and from the Internet
3. Whenever they need to be controlled, you do that using backend-to-backend communication from other servers you have that are already managing the users on the Internet

What’s next?

I am not a security expert. I know a bit about it and try to stay informed, but I am by no means an expert in it.

You should make sure to take security into consideration when developing your service and don’t assume WebRTC does everything for you. It doesn’t, but it is the best starting point you’ll get.

If you want to learn more about WebRTC, I will be opening the course again for another round. Probably during April.

If you are a corporate looking to have an open access to course materials throughout the year for your workforce – I am going to announce such a plan soon, but feel free to reach out to me before that happens.

Just do me a favor – don’t leave WebRTC security to chance.

Need a reminder? Download the WebRTC Security checklist. Print it and stick it on the wall behind your monitor so you don’t forget.

The post The Best WebRTC Security is Prone to the Stupidest Developer appeared first on BlogGeek.me.

Slack is an über popular and fast growing communications tool that has a ton of integrations with various WebRTC services. It also acquired a WebRTC company a year ago and launched its own audio conferencing service earlier this year which we analyzed here and here. Earlier this week they launched video. Does this work the same? Are […]

The post Slack Does WebRTC Video – Here’s How (Gustavo Garcia) appeared first on webrtcHacks.