• Main Page
• Related Pages
• Modules
• Namespaces
• Data Structures
• Files
• Examples

• Data Structures
• Data Structure Index
• Class Hierarchy
• Data Fields

• classAVPQueue.html
• classQueueRTCPManager.html
• classRTPDataQueue.html
• classIncomingDataQueue.html
• classIncomingDataQueueBase.html
• classRTPQueueBase.html
• classOutgoingDataQueueBase.html
• classMembershipBookkeeping.html
• classSyncSourceHandler.html
• classParticipantHandler.html
• classApplicationHandler.html
• classConflictHandler.html
• classMembers.html
• classOutgoingDataQueue.html
• classDestinationListHandler.html
• classRTCPCompoundHandler.html
• classZrtpCallback.html

• classAVPQueue.html
• classQueueRTCPManager.html
• classRTPDataQueue.html
• classIncomingDataQueue.html
• classIncomingDataQueueBase.html
• classMembershipBookkeeping.html
• classString.html
• classMemPager.html
• structMemPager_1_1__page.html
• classThread.html
• classOutgoingDataQueueBase.html
• classRTPApplication.html
• classOutgoingDataQueue.html
• classMutex.html
• classThreadLock.html
• classSemaphore.html
• classRTCPCompoundHandler.html
• classTimerPort.html
• classDestinationListHandler.html
• classSDESItemsHolder.html
• classParticipant.html
• structRTPApplication_1_1ParticipantLink.html
• classZrtpCallback.html
• classZrtpUserCallback.html

GNU ccRTP extension to support GNU ZRTP.

ZRTP was developed by Phil Zimmermann and provides functions to negotiate keys and other necessary data (crypto data) to set-up the Secure RTP (SRTP) crypto context. Refer to Phil's ZRTP specification at his Zfone project site to get more detailed imformation about the capabilities of ZRTP.

Short overview of the ZRTP implementation

ZRTP is a specific protocol to negotiate encryption algorithms and the required key material. ZRTP uses a RTP session to exchange its protocol messages.

A complete GNU ZRTP implementation consists of two parts, the GNU ZRTP core and specific code that binds the GNU ZRTP core to the underlying RTP/SRTP stack and the operating system:

• The GNU ZRTP core is independent of a specific RTP/SRTP stack and the operationg system and consists of the ZRTP protocol state engine, the ZRTP protocol messages, and the GNU ZRTP engine. The GNU ZRTP engine provides methods to setup ZRTP message and to analyze received ZRTP messages, to compute the crypto data required for SRTP, and to maintain the required hashes and HMAC.
• The second part of an implementation is specific glue code the binds the GNU ZRTP core to the actual RTP/SRTP implementation and other operating system specific services such as timers.

The GNU ZRTP core uses a callback interface class (refer to ZrtpCallback) to access RTP/SRTP or operating specific methods, for example to send data via the RTP/SRTP stack, to access timers, provide mutex handling, and to report events to the application.

The ZrtpQueue

ZrtpQueue implements code that is specific to the GNU ccRTP implementation. ZrtpQueue also implements the specific code to provide the mutex and timeout handling to the GNU ZRTP core. Both, the mutex and the timeout handling, use the GNU Common C++ library to stay independent of the operating seystem. For more information refer to the GNU Common C++ web site.

To perform its tasks ZrtpQueue

• extends GNU ccRTP classes to use the underlying ccRTP methods and the RTP/SRTP send and receive queues
• implements the ZrtpCallback interface to provide ccRTP access and other specific services (timer, mutex) to GNU ZRTP
• provides ZRTP specific methods that applications may use to control and setup GNU ZRTP
• can register and use an application specific callback class (refer to ZrtpUserCallback)

After instantiating a GNU ZRTP session (see below for a short example) applications may use the ZRTP specific methods of ZrtpQueue to control and setup GNU ZRTP, for example enable or disable ZRTP processing or getting ZRTP status information.

GNU ZRTP provides a ZrtpUserCallback class that an application may extend and register with ZrtpQueue. GNU ZRTP and ZrtpQueue use the ZrtpUserCallback methods to report ZRTP events to the application. The application may display this information to the user or act otherwise.

The following figure depicts the relationships between ZrtpQueue, ccRTP RTP/SRTP implementation, the GNU ZRTP core, and an application that provides an ZrtpUserCallback class.

 +----------+
 | ccRTP |
 | RTP/SRTP |
 | |
 +----------+
 ^
 | extends
 |
+----------------+ +-----+------+
| Application | | | +-----------------+
| instantiates | uses | ZrtpQueue | uses | |
| a ZRTP Session +------+ implements +------+ GNU ZRTP |
| and provides | |ZrtpCallback| | core |
|ZrtpUserCallback| | | | implementation |
+----------------+ +------------+ | (ZRtp et al) |
 | |
 +-----------------+

Because ZrtpQueue extends the ccRTP RTP/SRTP implementation (AVPQueue) all public methods defined by ccRTP are also available for a ZRTP session. ZrtpQueue overwrites some of the public methods of ccRTP (AVPQueue) to implement ZRTP specific code.

GNU ZRTP provides a SymmetricZRTPSession type to simplify its use. An application uses this type in the same way as it would use the normal ccRTP SymmetricRTPSession type. The following short code snippets show how an application could instantiate ccRTP and GNU ZRTP sessions. The first snippet shows how to instantiate a ccRTP session:

The same code as above but using a GNU ZRTP session this time:

The only differences are the different include statements and the different session types.

The demo folder contains a small example that shows how to use GNU ZRTP.

Please refer to the GNU ccRTP documentation for a description of ccRTP methods and functions. This ZrtpQueue documentation shows the ZRTP specific extensions and describes overloaded methods and a possible different behaviour.

Author

Werner Dittmann Werne.nosp@m.r.Di.nosp@m.ttman.nosp@m.n@t-.nosp@m.onlin.nosp@m.e.de

Definition at line 187 of file ZrtpQueue.h.