29 files changed, 11778 insertions, 0 deletions

diff --git a/src/contrib/service/conversation/.gitignore b/src/contrib/service/conversation/.gitignore
new file mode 100644
index 000000000..e74e259bf
--- /dev/null
+++ b/src/contrib/service/conversation/.gitignore
@@ -0,0 +1,8 @@
+gnunet-service-conversation
+gnunet-conversation
+gnunet-conversation-test
+gnunet-helper-audio-playback
+gnunet-helper-audio-record
+test_conversation_api
+test_conversation_api_reject
+test_conversation_api_twocalls
diff --git a/src/contrib/service/conversation/Makefile.am b/src/contrib/service/conversation/Makefile.am
new file mode 100644
index 000000000..b573208e6
--- /dev/null
+++ b/src/contrib/service/conversation/Makefile.am
@@ -0,0 +1,263 @@
+# This Makefile.am is in the public domain
+SUBDIRS = .
+
+plugindir = $(libdir)/gnunet
+
+AM_CPPFLAGS = \
+  $(GNUNET_CPPFLAGS) \
+  -I$(top_srcdir)/src/include \
+  -I$(top_srcdir)
+
+
+if BUILD_CONVERSATION
+lib_LTLIBRARIES = \
+ libgnunetmicrophone.la \
+ libgnunetspeaker.la \
+ libgnunetconversation.la
+
+bin_PROGRAMS = \
+ gnunet-conversation-test \
+ gnunet-conversation
+
+libexec_PROGRAMS = \
+  gnunet-service-conversation
+
+check_PROGRAMS = \
+ test_conversation_api \
+ test_conversation_api_reject \
+ test_conversation_api_twocalls
+
+pkgcfg_DATA = conversation.conf
+endif
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+plugin_LTLIBRARIES = \
+  libgnunet_plugin_gnsrecord_conversation.la
+
+
+libgnunet_plugin_gnsrecord_conversation_la_SOURCES = \
+  plugin_gnsrecord_conversation.c
+libgnunet_plugin_gnsrecord_conversation_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_plugin_gnsrecord_conversation_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+
+libgnunetmicrophone_la_SOURCES = \
+  microphone.c
+libgnunetmicrophone_la_LIBADD = \
+ $(top_builddir)/src/lib/util/libgnunetutil.la
+libgnunetmicrophone_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)   \
+  -version-info 0:0:0
+
+libgnunetspeaker_la_SOURCES = \
+  speaker.c
+libgnunetspeaker_la_LIBADD = \
+ $(top_builddir)/src/lib/util/libgnunetutil.la
+libgnunetspeaker_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)   \
+  -version-info 0:0:0
+
+
+libgnunetconversation_la_SOURCES = \
+  conversation_api.c \
+  conversation_api_call.c \
+  conversation.h
+libgnunetconversation_la_LIBADD = \
+  $(top_builddir)/src/service/gns/libgnunetgns.la \
+  $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
+  $(top_builddir)/src/service/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+
+libgnunetconversation_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)   \
+  -version-info 0:0:0
+
+
+if BUILD_PULSE_HELPERS
+AUDIO_HELPER_RECD=gnunet-helper-audio-record
+AUDIO_HELPER_PLAY=gnunet-helper-audio-playback
+AUDIO_TESTS=$(check_PROGRAMS)
+else
+if BUILD_GST_HELPERS
+AUDIO_HELPER_RECD=gnunet-helper-audio-record
+AUDIO_HELPER_PLAY=gnunet-helper-audio-playback
+AUDIO_TESTS=$(check_PROGRAMS)
+else
+if BUILD_EXPERIMENTAL_HELPERS
+AUDIO_HELPER_RECD=gnunet-helper-audio-record
+AUDIO_HELPER_PLAY=gnunet-helper-audio-playback
+AUDIO_TESTS=$(check_PROGRAMS)
+endif
+endif
+endif
+
+if BUILD_CONVERSATION
+libexec_PROGRAMS += \
+  $(AUDIO_HELPER_RECD) \
+  $(AUDIO_HELPER_PLAY)
+endif
+
+AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PATH=$${GNUNET_PREFIX:-@prefix@}/bin:$$PATH;unset XDG_DATA_HOME;unset XDG_CONFIG_HOME;
+if ENABLE_TEST_RUN
+TESTS = $(AUDIO_TESTS)
+endif
+
+if BUILD_PULSE_HELPERS
+gnunet_helper_audio_record_SOURCES = \
+  gnunet-helper-audio-record.c
+gnunet_helper_audio_record_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  -lpulse  -lopus -logg \
+  $(INTLLIBS)
+#gnunet_helper_audio_record_LDFLAGS = \
+#  
+
+gnunet_helper_audio_playback_SOURCES = \
+  gnunet-helper-audio-playback.c
+gnunet_helper_audio_playback_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  -lpulse -lopus -logg \
+  $(INTLLIBS)
+#gnunet_helper_audio_playback_LDFLAGS = \
+#  
+else
+if BUILD_GST_HELPERS
+gnunet_helper_audio_record_SOURCES = \
+  gnunet-helper-audio-record-gst.c
+gnunet_helper_audio_record_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GST_LIBS) \
+  $(INTLLIBS)
+gnunet_helper_audio_record_LDFLAGS = \
+   $(GST_LDFLAGS)
+gnunet_helper_audio_record_CFLAGS = \
+ $(GST_CFLAGS)
+
+gnunet_helper_audio_playback_SOURCES = \
+    gnunet-helper-audio-playback-gst.c
+gnunet_helper_audio_playback_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GST_LIBS) \
+  $(INTLLIBS)
+gnunet_helper_audio_playback_LDFLAGS = \
+   $(GST_LDFLAGS)
+gnunet_helper_audio_playback_CFLAGS = \
+ $(GST_CFLAGS) -DIS_SPEAKER
+else
+if BUILD_EXPERIMENTAL_HELPERS
+gnunet_helper_audio_record_SOURCES = \
+  gnunet_gst_test.c gnunet_gst.c
+gnunet_helper_audio_record_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GST_LIBS) \
+  $(INTLLIBS)
+gnunet_helper_audio_record_LDFLAGS = \
+   $(GST_LDFLAGS)
+gnunet_helper_audio_record_CFLAGS = \
+ $(GST_CFLAGS) -DIS_MIC
+
+gnunet_helper_audio_playback_SOURCES = \
+    gnunet_gst_test.c gnunet_gst.c
+gnunet_helper_audio_playback_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GST_LIBS) \
+  $(INTLLIBS)
+gnunet_helper_audio_playback_LDFLAGS = \
+   $(GST_LDFLAGS)
+gnunet_helper_audio_playback_CFLAGS = \
+ $(GST_CFLAGS) -DIS_SPEAKER
+endif
+endif
+endif
+
+gnunet_service_conversation_SOURCES = \
+  gnunet-service-conversation.c
+gnunet_service_conversation_LDADD = \
+  libgnunetconversation.la \
+  libgnunetspeaker.la \
+  libgnunetmicrophone.la \
+  $(top_builddir)/src/service/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(INTLLIBS)
+#gnunet_service_conversation_LDFLAGS = \
+#  
+
+gnunet_conversation_SOURCES = \
+  gnunet-conversation.c
+gnunet_conversation_LDADD = \
+  libgnunetmicrophone.la \
+  libgnunetspeaker.la \
+  libgnunetconversation.la \
+  $(top_builddir)/src/service/gns/libgnunetgns.la \
+  $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
+  $(top_builddir)/src/service/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(INTLLIBS)
+#gnunet_conversation_LDFLAGS = \
+# 
+
+gnunet_conversation_test_SOURCES = \
+  gnunet-conversation-test.c
+gnunet_conversation_test_LDADD = \
+  libgnunetmicrophone.la \
+  libgnunetspeaker.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la  \
+  $(INTLLIBS)
+#gnunet_conversation_test_LDFLAGS = \
+# 
+
+
+test_conversation_api_SOURCES = \
+ test_conversation_api.c
+test_conversation_api_LDADD = \
+  libgnunetconversation.la \
+  libgnunetspeaker.la \
+  libgnunetmicrophone.la \
+  $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
+  $(top_builddir)/src/service/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/service/testing/libgnunettesting.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+test_conversation_api_LDFLAGS = \
+  -export-dynamic
+
+test_conversation_api_twocalls_SOURCES = \
+ test_conversation_api_twocalls.c
+test_conversation_api_twocalls_LDADD = \
+  libgnunetconversation.la \
+  libgnunetspeaker.la \
+  libgnunetmicrophone.la \
+  $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
+  $(top_builddir)/src/service/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/service/testing/libgnunettesting.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+test_conversation_api_twocalls_LDFLAGS = \
+  -export-dynamic
+
+test_conversation_api_reject_SOURCES = \
+ test_conversation_api_reject.c
+test_conversation_api_reject_LDADD = \
+  libgnunetconversation.la \
+  libgnunetspeaker.la \
+  libgnunetmicrophone.la \
+  $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
+  $(top_builddir)/src/service/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/service/testing/libgnunettesting.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+test_conversation_api_reject_LDFLAGS = \
+  -export-dynamic
+
+
+
+EXTRA_DIST = test_conversation.conf
diff --git a/src/contrib/service/conversation/build_gst_test.sh b/src/contrib/service/conversation/build_gst_test.sh
new file mode 100644
index 000000000..1feb9e1c4
--- /dev/null
+++ b/src/contrib/service/conversation/build_gst_test.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+colorgcc  -DIS_MIC -g gnunet_gst_test.c gnunet_gst.c -o gnunet-helper-audio-record-experimental `pkg-config --cflags --libs gstreamer-app-1.0 gnunetutil gnunetconversation gnunetenv  gstreamer-app-1.0 gstreamer-1.0 gstreamer-audio-1.0 gstreamer-pbutils-1.0 gstreamer-video-1.0` -O0 -march=native  -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-conversion  -Wformat -Wformat-security -fstack-protector -D_FORTIFY_SOURCE=2 -std=c99  -D_GNU_SOURCE
+
+colorgcc -DIS_SPEAKER -g gnunet_gst_test.c gnunet_gst.c -o gnunet-helper-audio-playback-experimental `pkg-config --cflags --libs gstreamer-app-1.0 gnunetutil gnunetconversation gnunetenv  gstreamer-app-1.0 gstreamer-1.0 gstreamer-audio-1.0 gstreamer-pbutils-1.0 gstreamer-video-1.0` -O0 -march=native  -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-conversion  -Wformat -Wformat-security -fstack-protector -D_FORTIFY_SOURCE=2 -std=c99  -D_GNU_SOURCE
+
+
+
+#colorgcc  -g gnunet_gst_test.c gnunet_gst.c -o gnunet_gst_test `pkg-config --cflags --libs  gstreamer-app-1.0 gstreamer-1.0 gstreamer-audio-1.0 gstreamer-pbutils-1.0 gstreamer-video-1.0` -O0 -march=native -Wall -Wextra -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-conversion -Wpedantic -Wformat -Wformat-security -fstack-protector -D_FORTIFY_SOURCE=2 -std=c99  -D_GNU_SOURCE
diff --git a/src/contrib/service/conversation/conversation.conf.in b/src/contrib/service/conversation/conversation.conf.in
new file mode 100644
index 000000000..b28fb6e1f
--- /dev/null
+++ b/src/contrib/service/conversation/conversation.conf.in
@@ -0,0 +1,29 @@
+[conversation]
+START_ON_DEMAND = @START_ON_DEMAND@
+BINARY = gnunet-service-conversation
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-conversation.sock
+HOSTNAME = localhost
+@UNIXONLY@ PORT = 2120
+
+# Desired phone line.  Change if multiple users are using
+# the same peer and we thus need disjoint phone lines.
+LINE = 1
+
+# Should the phone record be private? (only set to YES if
+# you really know what you are doing, you will then likely
+# not be able to receive calls).
+RECORD_IS_PRIVATE = NO
+
+# How long should phone records remain published in GNS?
+# A long expiration time has the advantage that the phone
+# is more likely found and/or resolved faster, OTOH it
+# then takes longer to change the phone line if necessary.
+# The default should be fine for most users.
+RECORD_EXPIRATION = 1 day
+
+
+ACCEPT_FROM = 127.0.0.1;
+ACCEPT_FROM6 = ::1;
+UNIX_MATCH_UID = NO
+UNIX_MATCH_GID = YES
+
diff --git a/src/contrib/service/conversation/conversation.h b/src/contrib/service/conversation/conversation.h
new file mode 100644
index 000000000..ee4ca372c
--- /dev/null
+++ b/src/contrib/service/conversation/conversation.h
@@ -0,0 +1,407 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013-2016 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file conversation/conversation.h
+ * @brief constants for network protocols
+ * @author Siomon Dieterle
+ * @author Andreas Fuchs
+ */
+#ifndef CONVERSATION_H
+#define CONVERSATION_H
+
+#include "gnunet_identity_service.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+#define MAX_TRANSMIT_DELAY GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_SECONDS, 60)
+
+
+/**
+ * Highest bit in a 32-bit unsigned integer,
+ * bit set if we are making an outgoing call,
+ * bit unset for local lines.
+ */
+#define HIGH_BIT ((uint32_t) (1LL << 31))
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+
+/**
+ * Message to transmit the audio (between client and helpers).
+ */
+struct AudioMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /* followed by audio data */
+};
+
+
+/**
+ * Client -> Service message to register a phone.
+ */
+struct ClientPhoneRegisterMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * Phone line / CADET port to register.
+   */
+  struct GNUNET_HashCode line_port;
+};
+
+
+/**
+ * Service -> Client message for phone is ringing.
+ */
+struct ClientPhoneRingMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * CID, internal caller ID number used in the future to identify
+   * which active call we are talking about.
+   */
+  uint32_t cid GNUNET_PACKED;
+
+  /**
+   * The identity key length
+   */
+  uint32_t key_len;
+
+  /**
+   * followed by who is calling us?, a public key
+   */
+};
+
+
+/**
+ * Service <-> Client message for phone was suspended.
+ */
+struct ClientPhoneSuspendMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * CID, internal caller ID to identify which active call we are
+   * talking about.
+   */
+  uint32_t cid GNUNET_PACKED;
+};
+
+
+/**
+ * Service <-> Client message for phone was resumed.
+ */
+struct ClientPhoneResumeMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * CID, internal caller ID to identify which active call we are
+   * talking about.
+   */
+  uint32_t cid GNUNET_PACKED;
+};
+
+
+/**
+ * Client -> Service pick up phone that is ringing.
+ */
+struct ClientPhonePickupMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICK_UP
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * CID, internal caller ID to identify which active call we are
+   * talking about.
+   */
+  uint32_t cid GNUNET_PACKED;
+};
+
+
+/**
+ * Client <-> Service hang up phone that may or may not be ringing.
+ * Also sent in response to a (failed) `struct ClientCallMessage`.
+ */
+struct ClientPhoneHangupMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * CID, internal caller ID to identify which active call we are
+   * talking about.
+   */
+  uint32_t cid GNUNET_PACKED;
+};
+
+
+/**
+ * Message Client <-> Service to transmit the audio.
+ */
+struct ClientAudioMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * CID, internal caller ID to identify which active call we are
+   * sending data to.
+   */
+  uint32_t cid GNUNET_PACKED;
+
+  /* followed by audio data */
+};
+
+
+/**
+ * Client -> Service message to call a phone.
+ */
+struct ClientCallMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * Which peer is hosting the line?
+   */
+  struct GNUNET_PeerIdentity target;
+
+  /**
+   * Which phone line to call at the peer?
+   */
+  struct GNUNET_HashCode line_port;
+
+  /**
+   * The identity key length
+   */
+  uint32_t key_len;
+
+  /**
+   * followed by the identity of the caller.
+   */
+};
+
+
+/**
+ * Service -> Client: other peer has picked up the phone, we are
+ * now talking.
+ */
+struct ClientPhonePickedupMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Call ID of the corresponding
+   * #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL
+   */
+  uint32_t cid GNUNET_PACKED;
+};
+
+
+/**
+ * Information signed in a `struct CadetPhoneRingMessage`
+ * whereby the caller self-identifies to the receiver.
+ */
+struct CadetPhoneRingInfoPS
+{
+  /**
+   * Purpose for the signature, must be
+   * #GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING.
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Which port did the call go to?
+   */
+  struct GNUNET_HashCode line_port;
+
+  /**
+   * Which peer is the call for?
+   */
+  struct GNUNET_PeerIdentity target_peer;
+
+  /**
+   * When does the signature expire?
+   */
+  struct GNUNET_TIME_AbsoluteNBO expiration_time;
+};
+
+
+/**
+ * Cadet message to make a phone ring.  Sent to the port
+ * of the respective phone.
+ */
+struct CadetPhoneRingMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * When does the signature expire?
+   */
+  struct GNUNET_TIME_AbsoluteNBO expiration_time;
+
+  /**
+   * The length of the key
+   */
+  uint32_t key_len;
+
+  /**
+   * The length of the signature
+   */
+  uint32_t sig_len;
+
+  /**
+   * Followed by the public key of who is calling us? (also who is signing).
+   * followed by the signature over a `struct CadetPhoneRingInfoPS`
+   */
+};
+
+
+/**
+ * Cadet message for hanging up.
+ */
+struct CadetPhoneHangupMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP
+   */
+  struct GNUNET_MessageHeader header;
+};
+
+
+/**
+ * Cadet message for picking up.
+ */
+struct CadetPhonePickupMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP
+   */
+  struct GNUNET_MessageHeader header;
+};
+
+
+/**
+ * Cadet message for phone suspended.
+ */
+struct CadetPhoneSuspendMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND
+   */
+  struct GNUNET_MessageHeader header;
+};
+
+
+/**
+ * Cadet message for phone resumed.
+ */
+struct CadetPhoneResumeMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME
+   */
+  struct GNUNET_MessageHeader header;
+};
+
+
+/**
+ * Cadet message to transmit the audio.
+ */
+struct CadetAudioMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /* followed by audio data */
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+/* ifndef GNUNET_PROTOCOLS_CONVERSATION_H */
+#endif
+/* end of gnunet_protocols_conversation.h */
diff --git a/src/contrib/service/conversation/conversation_api.c b/src/contrib/service/conversation/conversation_api.c
new file mode 100644
index 000000000..ed22bf9cf
--- /dev/null
+++ b/src/contrib/service/conversation/conversation_api.c
@@ -0,0 +1,897 @@
+/*
+   This file is part of GNUnet
+   Copyright (C) 2013, 2014 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file conversation/conversation_api.c
+ * @brief phone and caller API to the conversation service
+ * @author Simon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_conversation_service.h"
+#include "conversation.h"
+
+
+/**
+ * Possible states of a caller.
+ */
+enum CallerState
+{
+  /**
+   * The phone is ringing (user knows about incoming call).
+   */
+  CS_RINGING,
+
+  /**
+   * The phone is in an active conversation.
+   */
+  CS_ACTIVE,
+
+  /**
+   * We suspended the conversation.
+   */
+  CS_CALLEE_SUSPENDED,
+
+  /**
+   * Caller suspended the conversation.
+   */
+  CS_CALLER_SUSPENDED,
+
+  /**
+   * Both sides suspended the conversation.
+   */
+  CS_BOTH_SUSPENDED
+};
+
+
+/**
+ * A caller is the handle we have for an incoming call.
+ */
+struct GNUNET_CONVERSATION_Caller
+{
+  /**
+   * We keep all callers in a DLL.
+   */
+  struct GNUNET_CONVERSATION_Caller *next;
+
+  /**
+   * We keep all callers in a DLL.
+   */
+  struct GNUNET_CONVERSATION_Caller *prev;
+
+  /**
+   * Our phone.
+   */
+  struct GNUNET_CONVERSATION_Phone *phone;
+
+  /**
+   * Function to call for phone events.
+   */
+  GNUNET_CONVERSATION_CallerEventHandler event_handler;
+
+  /**
+   * Closure for @e event_handler
+   */
+  void *event_handler_cls;
+
+  /**
+   * Speaker, or NULL if none is attached.
+   */
+  struct GNUNET_SPEAKER_Handle *speaker;
+
+  /**
+   * Microphone, or NULL if none is attached.
+   */
+  struct GNUNET_MICROPHONE_Handle *mic;
+
+  /**
+   * Identity of the person calling us.
+   */
+  struct GNUNET_CRYPTO_PublicKey caller_id;
+
+  /**
+   * Internal handle to identify the caller with the service.
+   */
+  uint32_t cid;
+
+  /**
+   * State machine for the phone.
+   */
+  enum CallerState state;
+};
+
+
+/**
+ * Possible states of a phone.
+ */
+enum PhoneState
+{
+  /**
+   * We still need to register the phone.
+   */
+  PS_REGISTER = 0,
+
+  /**
+   * We are waiting for calls.
+   */
+  PS_READY
+};
+
+
+/**
+ * A phone is a device that can ring to signal an incoming call and
+ * that you can pick up to answer the call and hang up to terminate
+ * the call.  You can also hang up a ringing phone immediately
+ * (without picking it up) to stop it from ringing.  Phones have
+ * caller ID.  You can ask the phone for its record and make that
+ * record available (via GNS) to enable others to call you.
+ * Multiple phones maybe connected to the same line (the line is
+ * something rather internal to a phone and not obvious from it).
+ * You can only have one conversation per phone at any time.
+ */
+struct GNUNET_CONVERSATION_Phone
+{
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * We keep all callers in a DLL.
+   */
+  struct GNUNET_CONVERSATION_Caller *caller_head;
+
+  /**
+   * We keep all callers in a DLL.
+   */
+  struct GNUNET_CONVERSATION_Caller *caller_tail;
+
+  /**
+   * Function to call for phone events.
+   */
+  GNUNET_CONVERSATION_PhoneEventHandler event_handler;
+
+  /**
+   * Closure for @e event_handler
+   */
+  void *event_handler_cls;
+
+  /**
+   * Connection to NAMESTORE (for reverse lookup).
+   */
+  struct GNUNET_NAMESTORE_Handle *ns;
+
+  /**
+   * Handle for transmitting to the CONVERSATION service.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * This phone's record.
+   */
+  struct GNUNET_CONVERSATION_PhoneRecord my_record;
+
+  /**
+   * My GNS zone.
+   */
+  struct GNUNET_CRYPTO_PrivateKey my_zone;
+
+  /**
+   * State machine for the phone.
+   */
+  enum PhoneState state;
+};
+
+
+/**
+ * The phone got disconnected, reconnect to the service.
+ *
+ * @param phone phone to reconnect
+ */
+static void
+reconnect_phone (struct GNUNET_CONVERSATION_Phone *phone);
+
+
+/**
+ * Process recorded audio data.
+ *
+ * @param cls closure with the `struct GNUNET_CONVERSATION_Caller`
+ * @param data_size number of bytes in @a data
+ * @param data audio data to play
+ */
+static void
+transmit_phone_audio (void *cls,
+                      size_t data_size,
+                      const void *data)
+{
+  struct GNUNET_CONVERSATION_Caller *caller = cls;
+  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientAudioMessage *am;
+
+  e = GNUNET_MQ_msg_extra (am,
+                           data_size,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO);
+  am->cid = caller->cid;
+  GNUNET_memcpy (&am[1],
+                 data,
+                 data_size);
+  GNUNET_MQ_send (phone->mq,
+                  e);
+}
+
+/**
+ * We received a `struct ClientPhoneRingMessage`
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param ring the message
+ */
+static enum GNUNET_GenericReturnValue
+check_phone_ring (void *cls,
+                   const struct ClientPhoneRingMessage *ring)
+{
+  //FIXME
+  return GNUNET_OK;
+}
+/**
+ * We received a `struct ClientPhoneRingMessage`
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param ring the message
+ */
+static void
+handle_phone_ring (void *cls,
+                   const struct ClientPhoneRingMessage *ring)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = cls;
+  struct GNUNET_CONVERSATION_Caller *caller;
+  struct GNUNET_CRYPTO_PublicKey caller_id;
+  size_t key_len;
+  size_t read;
+
+  key_len = ntohl (ring->key_len);
+  switch (phone->state)
+  {
+  case PS_REGISTER:
+    GNUNET_assert (0);
+    break;
+
+  case PS_READY:
+    if ((GNUNET_SYSERR ==
+         GNUNET_CRYPTO_read_public_key_from_buffer (&ring[1],
+                                                      key_len,
+                                                      &caller_id,
+                                                      &read)) ||
+        (read != key_len))
+    {
+      GNUNET_break (0);
+      break;
+    }
+    caller = GNUNET_new (struct GNUNET_CONVERSATION_Caller);
+    caller->phone = phone;
+    GNUNET_CONTAINER_DLL_insert (phone->caller_head,
+                                 phone->caller_tail,
+                                 caller);
+    caller->caller_id = caller_id;
+    caller->cid = ring->cid;
+    caller->state = CS_RINGING;
+    phone->event_handler (phone->event_handler_cls,
+                          GNUNET_CONVERSATION_EC_PHONE_RING,
+                          caller,
+                          &caller->caller_id);
+    break;
+  }
+}
+
+
+/**
+ * Find the record of the caller matching the @a cid
+ *
+ * @param phone phone to search
+ * @param cid caller ID to search for (in NBO)
+ * @return NULL if @a cid was not found
+ */
+static struct GNUNET_CONVERSATION_Caller *
+find_caller (struct GNUNET_CONVERSATION_Phone *phone,
+             uint32_t cid)
+{
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  for (caller = phone->caller_head; NULL != caller; caller = caller->next)
+    if (cid == caller->cid)
+      return caller;
+  return NULL;
+}
+
+
+/**
+ * We received a `struct ClientPhoneHangupMessage`.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone *`
+ * @param hang the message
+ */
+static void
+handle_phone_hangup (void *cls,
+                     const struct ClientPhoneHangupMessage *hang)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = cls;
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  caller = find_caller (phone,
+                        hang->cid);
+  if (NULL == caller)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received HANG_UP message for unknown caller ID %u\n",
+                (unsigned int) hang->cid);
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received HANG_UP message, terminating call with `%s'\n",
+              GNUNET_GNSRECORD_pkey_to_zkey (&caller->caller_id));
+  switch (caller->state)
+  {
+  case CS_RINGING:
+    phone->event_handler (phone->event_handler_cls,
+                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,
+                          caller,
+                          &caller->caller_id);
+    break;
+
+  case CS_ACTIVE:
+    caller->speaker->disable_speaker (caller->speaker->cls);
+    caller->mic->disable_microphone (caller->mic->cls);
+    phone->event_handler (phone->event_handler_cls,
+                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,
+                          caller,
+                          &caller->caller_id);
+    break;
+
+  case CS_CALLEE_SUSPENDED:
+  case CS_CALLER_SUSPENDED:
+  case CS_BOTH_SUSPENDED:
+    phone->event_handler (phone->event_handler_cls,
+                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,
+                          caller,
+                          &caller->caller_id);
+    break;
+  }
+  GNUNET_CONTAINER_DLL_remove (phone->caller_head,
+                               phone->caller_tail,
+                               caller);
+  GNUNET_free (caller);
+}
+
+
+/**
+ * We received a `struct ClientPhoneSuspendMessage`.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param suspend the message
+ */
+static void
+handle_phone_suspend (void *cls,
+                      const struct ClientPhoneSuspendMessage *suspend)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = cls;
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  caller = find_caller (phone,
+                        suspend->cid);
+  if (NULL == caller)
+    return;
+  switch (caller->state)
+  {
+  case CS_RINGING:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_ACTIVE:
+    caller->state = CS_CALLER_SUSPENDED;
+    caller->speaker->disable_speaker (caller->speaker->cls);
+    caller->mic->disable_microphone (caller->mic->cls);
+    caller->event_handler (caller->event_handler_cls,
+                           GNUNET_CONVERSATION_EC_CALLER_SUSPEND);
+    break;
+
+  case CS_CALLEE_SUSPENDED:
+    caller->state = CS_BOTH_SUSPENDED;
+    caller->event_handler (caller->event_handler_cls,
+                           GNUNET_CONVERSATION_EC_CALLER_SUSPEND);
+    break;
+
+  case CS_CALLER_SUSPENDED:
+  case CS_BOTH_SUSPENDED:
+    GNUNET_break_op (0);
+    break;
+  }
+}
+
+
+/**
+ * We received a `struct ClientPhoneResumeMessage`.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param resume the message
+ */
+static void
+handle_phone_resume (void *cls,
+                     const struct ClientPhoneResumeMessage *resume)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = cls;
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  caller = find_caller (phone,
+                        resume->cid);
+  if (NULL == caller)
+    return;
+  switch (caller->state)
+  {
+  case CS_RINGING:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_ACTIVE:
+  case CS_CALLEE_SUSPENDED:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_CALLER_SUSPENDED:
+    caller->state = CS_ACTIVE;
+    caller->speaker->enable_speaker (caller->speaker->cls);
+    caller->mic->enable_microphone (caller->mic->cls,
+                                    &transmit_phone_audio,
+                                    caller);
+    caller->event_handler (caller->event_handler_cls,
+                           GNUNET_CONVERSATION_EC_CALLER_RESUME);
+    break;
+
+  case CS_BOTH_SUSPENDED:
+    caller->state = CS_CALLEE_SUSPENDED;
+    caller->event_handler (caller->event_handler_cls,
+                           GNUNET_CONVERSATION_EC_CALLER_RESUME);
+    break;
+  }
+}
+
+
+/**
+ * We received a `struct ClientAudioMessage`, check it is well-formed.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param am the message
+ * @return #GNUNET_OK if @a am is well-formed
+ */
+static int
+check_phone_audio (void *cls,
+                   const struct ClientAudioMessage *am)
+{
+  (void) cls;
+  (void) am;
+
+  /* any variable-size payload is OK */
+  return GNUNET_OK;
+}
+
+
+/**
+ * We received a `struct ClientAudioMessage`
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param am the message
+ */
+static void
+handle_phone_audio (void *cls,
+                    const struct ClientAudioMessage *am)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = cls;
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  caller = find_caller (phone,
+                        am->cid);
+  if (NULL == caller)
+    return;
+  switch (caller->state)
+  {
+  case CS_RINGING:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_ACTIVE:
+    caller->speaker->play (caller->speaker->cls,
+                           ntohs (am->header.size) - sizeof(struct
+                                                            ClientAudioMessage),
+                           &am[1]);
+    break;
+
+  case CS_CALLEE_SUSPENDED:
+  case CS_CALLER_SUSPENDED:
+  case CS_BOTH_SUSPENDED:
+    break;
+  }
+}
+
+
+/**
+ * We encountered an error talking with the conversation service.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param error details about the error
+ */
+static void
+phone_error_handler (void *cls,
+                     enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = cls;
+
+  (void) error;
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              _ (
+                "Connection to conversation service lost, trying to reconnect\n"));
+  reconnect_phone (phone);
+}
+
+
+/**
+ * Clean up all callers of the given phone.
+ *
+ * @param phone phone to clean up callers for
+ */
+static void
+clean_up_callers (struct GNUNET_CONVERSATION_Phone *phone)
+{
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  while (NULL != (caller = phone->caller_head))
+  {
+    /* make sure mic/speaker are disabled *before* callback */
+    if (CS_ACTIVE == caller->state)
+    {
+      caller->speaker->disable_speaker (caller->speaker->cls);
+      caller->mic->disable_microphone (caller->mic->cls);
+      caller->state = CS_CALLER_SUSPENDED;
+    }
+    phone->event_handler (phone->event_handler_cls,
+                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,
+                          caller,
+                          &caller->caller_id);
+    GNUNET_CONVERSATION_caller_hang_up (caller);
+  }
+}
+
+
+/**
+ * The phone got disconnected, reconnect to the service.
+ *
+ * @param phone phone to reconnect
+ */
+static void
+reconnect_phone (struct GNUNET_CONVERSATION_Phone *phone)
+{
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_var_size (phone_ring,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING,
+                           struct ClientPhoneRingMessage,
+                           phone),
+    GNUNET_MQ_hd_fixed_size (phone_hangup,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP,
+                             struct ClientPhoneHangupMessage,
+                             phone),
+    GNUNET_MQ_hd_fixed_size (phone_suspend,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND,
+                             struct ClientPhoneSuspendMessage,
+                             phone),
+    GNUNET_MQ_hd_fixed_size (phone_resume,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME,
+                             struct ClientPhoneResumeMessage,
+                             phone),
+    GNUNET_MQ_hd_var_size (phone_audio,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO,
+                           struct ClientAudioMessage,
+                           phone),
+    GNUNET_MQ_handler_end ()
+  };
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhoneRegisterMessage *reg;
+
+  clean_up_callers (phone);
+  if (NULL != phone->mq)
+  {
+    GNUNET_MQ_destroy (phone->mq);
+    phone->mq = NULL;
+  }
+  phone->state = PS_REGISTER;
+  phone->mq = GNUNET_CLIENT_connect (phone->cfg,
+                                     "conversation",
+                                     handlers,
+                                     &phone_error_handler,
+                                     phone);
+  if (NULL == phone->mq)
+    return;
+  e = GNUNET_MQ_msg (reg,
+                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER);
+  reg->line_port = phone->my_record.line_port;
+  GNUNET_MQ_send (phone->mq,
+                  e);
+  phone->state = PS_READY;
+}
+
+
+/**
+ * Create a new phone.
+ *
+ * @param cfg configuration for the phone; specifies the phone service and
+ *        which line the phone is to be connected to
+ * @param ego ego to use for name resolution (when determining caller ID)
+ * @param event_handler how to notify the owner of the phone about events
+ * @param event_handler_cls closure for @a event_handler
+ * @return NULL on error (no valid line configured)
+ */
+struct GNUNET_CONVERSATION_Phone *
+GNUNET_CONVERSATION_phone_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                                  const struct GNUNET_IDENTITY_Ego *ego,
+                                  GNUNET_CONVERSATION_PhoneEventHandler
+                                  event_handler,
+                                  void *event_handler_cls)
+{
+  struct GNUNET_CONVERSATION_Phone *phone;
+  char *line;
+  struct GNUNET_HashCode line_port;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "CONVERSATION",
+                                             "LINE",
+                                             &line))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "CONVERSATION",
+                               "LINE");
+    return NULL;
+  }
+  GNUNET_CRYPTO_hash (line,
+                      strlen (line),
+                      &line_port);
+  GNUNET_free (line);
+  phone = GNUNET_new (struct GNUNET_CONVERSATION_Phone);
+  if (GNUNET_OK !=
+      GNUNET_CRYPTO_get_peer_identity (cfg,
+                                       &phone->my_record.peer))
+  {
+    GNUNET_break (0);
+    GNUNET_free (phone);
+    return NULL;
+  }
+  phone->cfg = cfg;
+  phone->my_zone = *GNUNET_IDENTITY_ego_get_private_key (ego);
+  phone->event_handler = event_handler;
+  phone->event_handler_cls = event_handler_cls;
+  phone->ns = GNUNET_NAMESTORE_connect (cfg);
+  phone->my_record.version = htonl (1);
+  phone->my_record.reserved = htonl (0);
+  phone->my_record.line_port = line_port;
+  reconnect_phone (phone);
+  if ((NULL == phone->mq) ||
+      (NULL == phone->ns))
+  {
+    GNUNET_break (0);
+    GNUNET_CONVERSATION_phone_destroy (phone);
+    return NULL;
+  }
+  return phone;
+}
+
+
+/**
+ * Fill in a namestore record with the contact information
+ * for this phone.  Note that the filled in "data" value
+ * is only valid until the phone is destroyed.
+ *
+ * @param phone phone to create a record for
+ * @param rd namestore record to fill in
+ */
+void
+GNUNET_CONVERSATION_phone_get_record (struct GNUNET_CONVERSATION_Phone *phone,
+                                      struct GNUNET_GNSRECORD_Data *rd)
+{
+  rd->data = &phone->my_record;
+  rd->expiration_time = 0;
+  rd->data_size = sizeof(struct GNUNET_CONVERSATION_PhoneRecord);
+  rd->record_type = GNUNET_GNSRECORD_TYPE_PHONE;
+  rd->flags = GNUNET_GNSRECORD_RF_NONE;
+}
+
+
+/**
+ * Picks up a (ringing) phone.  This will connect the speaker
+ * to the microphone of the other party, and vice versa.
+ *
+ * @param caller handle that identifies which caller should be answered
+ * @param event_handler how to notify about events by the caller
+ * @param event_handler_cls closure for @a event_handler
+ * @param speaker speaker to use
+ * @param mic microphone to use
+ */
+void
+GNUNET_CONVERSATION_caller_pick_up (struct GNUNET_CONVERSATION_Caller *caller,
+                                    GNUNET_CONVERSATION_CallerEventHandler
+                                    event_handler,
+                                    void *event_handler_cls,
+                                    struct GNUNET_SPEAKER_Handle *speaker,
+                                    struct GNUNET_MICROPHONE_Handle *mic)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhonePickupMessage *pick;
+
+  GNUNET_assert (CS_RINGING == caller->state);
+  caller->speaker = speaker;
+  caller->mic = mic;
+  e = GNUNET_MQ_msg (pick,
+                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICK_UP);
+  pick->cid = caller->cid;
+  GNUNET_MQ_send (phone->mq,
+                  e);
+  caller->state = CS_ACTIVE;
+  caller->event_handler = event_handler;
+  caller->event_handler_cls = event_handler_cls;
+  caller->speaker->enable_speaker (caller->speaker->cls);
+  caller->mic->enable_microphone (caller->mic->cls,
+                                  &transmit_phone_audio,
+                                  caller);
+}
+
+
+/**
+ * Hang up up a (possibly ringing) phone.  This will notify the other
+ * party that we are no longer interested in talking with them.
+ *
+ * @param caller conversation to hang up on
+ */
+void
+GNUNET_CONVERSATION_caller_hang_up (struct GNUNET_CONVERSATION_Caller *caller)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhoneHangupMessage *hang;
+
+  switch (caller->state)
+  {
+  case CS_ACTIVE:
+    caller->speaker->disable_speaker (caller->speaker->cls);
+    caller->mic->disable_microphone (caller->mic->cls);
+    break;
+
+  default:
+    break;
+  }
+  GNUNET_CONTAINER_DLL_remove (phone->caller_head,
+                               phone->caller_tail,
+                               caller);
+  e = GNUNET_MQ_msg (hang,
+                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);
+  hang->cid = caller->cid;
+  GNUNET_MQ_send (phone->mq,
+                  e);
+  GNUNET_free (caller);
+}
+
+
+/**
+ * Destroys a phone.
+ *
+ * @param phone phone to destroy
+ */
+void
+GNUNET_CONVERSATION_phone_destroy (struct GNUNET_CONVERSATION_Phone *phone)
+{
+  clean_up_callers (phone);
+  if (NULL != phone->ns)
+  {
+    GNUNET_NAMESTORE_disconnect (phone->ns);
+    phone->ns = NULL;
+  }
+  if (NULL != phone->mq)
+  {
+    GNUNET_MQ_destroy (phone->mq);
+    phone->mq = NULL;
+  }
+  GNUNET_free (phone);
+}
+
+
+/**
+ * Pause conversation of an active call.  This will disconnect the speaker
+ * and the microphone.  The call can later be resumed with
+ * #GNUNET_CONVERSATION_caller_resume.
+ *
+ * @param caller call to suspend
+ */
+void
+GNUNET_CONVERSATION_caller_suspend (struct GNUNET_CONVERSATION_Caller *caller)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhoneSuspendMessage *suspend;
+
+  GNUNET_assert ((CS_ACTIVE == caller->state) ||
+                 (CS_CALLER_SUSPENDED == caller->state));
+  if (CS_ACTIVE == caller->state)
+  {
+    caller->speaker->disable_speaker (caller->speaker->cls);
+    caller->mic->disable_microphone (caller->mic->cls);
+  }
+  caller->speaker = NULL;
+  caller->mic = NULL;
+  e = GNUNET_MQ_msg (suspend,
+                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND);
+  suspend->cid = caller->cid;
+  GNUNET_MQ_send (phone->mq,
+                  e);
+  if (CS_ACTIVE == caller->state)
+    caller->state = CS_CALLEE_SUSPENDED;
+  else
+    caller->state = CS_BOTH_SUSPENDED;
+}
+
+
+/**
+ * Resume suspended conversation of a phone.
+ *
+ * @param caller call to resume
+ * @param speaker speaker to use
+ * @param mic microphone to use
+ */
+void
+GNUNET_CONVERSATION_caller_resume (struct GNUNET_CONVERSATION_Caller *caller,
+                                   struct GNUNET_SPEAKER_Handle *speaker,
+                                   struct GNUNET_MICROPHONE_Handle *mic)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhoneResumeMessage *resume;
+
+  GNUNET_assert ((CS_CALLEE_SUSPENDED == caller->state) ||
+                 (CS_BOTH_SUSPENDED == caller->state));
+  caller->speaker = speaker;
+  caller->mic = mic;
+  e = GNUNET_MQ_msg (resume,
+                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME);
+  resume->cid = caller->cid;
+  GNUNET_MQ_send (phone->mq,
+                  e);
+  if (CS_CALLEE_SUSPENDED == caller->state)
+  {
+    caller->state = CS_ACTIVE;
+    caller->speaker->enable_speaker (caller->speaker->cls);
+    caller->mic->enable_microphone (caller->mic->cls,
+                                    &transmit_phone_audio,
+                                    caller);
+  }
+  else
+  {
+    caller->state = CS_CALLER_SUSPENDED;
+  }
+}
+
+
+/* end of conversation_api.c */
diff --git a/src/contrib/service/conversation/conversation_api_call.c b/src/contrib/service/conversation/conversation_api_call.c
new file mode 100644
index 000000000..cd59678d9
--- /dev/null
+++ b/src/contrib/service/conversation/conversation_api_call.c
@@ -0,0 +1,749 @@
+/*
+   This file is part of GNUnet
+   Copyright (C) 2013, 2016 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file conversation/conversation_api_call.c
+ * @brief call API to the conversation service
+ * @author Simon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_conversation_service.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_gns_service.h"
+#include "conversation.h"
+
+
+/**
+ * Possible states of the phone.
+ */
+enum CallState
+{
+  /**
+   * We still need to lookup the callee.
+   */
+  CS_LOOKUP = 0,
+
+  /**
+   * The call is ringing.
+   */
+  CS_RINGING,
+
+  /**
+   * The call is in an active conversation.
+   */
+  CS_ACTIVE,
+
+  /**
+   * The call is in termination.
+   */
+  CS_SHUTDOWN,
+
+  /**
+   * The call was suspended by the caller.
+   */
+  CS_SUSPENDED_CALLER,
+
+  /**
+   * The call was suspended by the callee.
+   */
+  CS_SUSPENDED_CALLEE,
+
+  /**
+   * The call was suspended by both caller and callee.
+   */
+  CS_SUSPENDED_BOTH
+};
+
+
+/**
+ * Handle for an outgoing call.
+ */
+struct GNUNET_CONVERSATION_Call
+{
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Our caller identity.
+   */
+  struct GNUNET_IDENTITY_Ego *caller_id;
+
+  /**
+   * Target callee as a GNS address/name.
+   */
+  char *callee;
+
+  /**
+   * Our speaker.
+   */
+  struct GNUNET_SPEAKER_Handle *speaker;
+
+  /**
+   * Our microphone.
+   */
+  struct GNUNET_MICROPHONE_Handle *mic;
+
+  /**
+   * Function to call with events.
+   */
+  GNUNET_CONVERSATION_CallEventHandler event_handler;
+
+  /**
+   * Closure for @e event_handler
+   */
+  void *event_handler_cls;
+
+  /**
+   * Handle for transmitting to the CONVERSATION service.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Connection to GNS (can be NULL).
+   */
+  struct GNUNET_GNS_Handle *gns;
+
+  /**
+   * Active GNS lookup (or NULL).
+   */
+  struct GNUNET_GNS_LookupWithTldRequest *gns_lookup;
+
+  /**
+   * Target phone record, only valid after the lookup is done.
+   */
+  struct GNUNET_CONVERSATION_PhoneRecord phone_record;
+
+  /**
+   * State machine for the call.
+   */
+  enum CallState state;
+};
+
+
+/**
+ * The call got disconnected, reconnect to the service.
+ *
+ * @param call call to reconnect
+ */
+static void
+fail_call (struct GNUNET_CONVERSATION_Call *call);
+
+
+/**
+ * Process recorded audio data.
+ *
+ * @param cls closure with the `struct GNUNET_CONVERSATION_Call`
+ * @param data_size number of bytes in @a data
+ * @param data audio data to play
+ */
+static void
+transmit_call_audio (void *cls,
+                     size_t data_size,
+                     const void *data)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientAudioMessage *am;
+
+  GNUNET_assert (CS_ACTIVE == call->state);
+  e = GNUNET_MQ_msg_extra (am,
+                           data_size,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO);
+  GNUNET_memcpy (&am[1],
+                 data,
+                 data_size);
+  GNUNET_MQ_send (call->mq,
+                  e);
+}
+
+
+/**
+ * We received a #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param msg the message
+ */
+static void
+handle_call_suspend (void *cls,
+                     const struct ClientPhoneSuspendMessage *msg)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+
+  (void) msg;
+  switch (call->state)
+  {
+  case CS_LOOKUP:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_RINGING:
+    GNUNET_break_op (0);
+    fail_call (call);
+    break;
+
+  case CS_SUSPENDED_CALLER:
+    call->state = CS_SUSPENDED_BOTH;
+    call->event_handler (call->event_handler_cls,
+                         GNUNET_CONVERSATION_EC_CALL_SUSPENDED);
+    break;
+
+  case CS_SUSPENDED_CALLEE:
+  case CS_SUSPENDED_BOTH:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_ACTIVE:
+    call->state = CS_SUSPENDED_CALLEE;
+    call->speaker->disable_speaker (call->speaker->cls);
+    call->mic->disable_microphone (call->mic->cls);
+    call->event_handler (call->event_handler_cls,
+                         GNUNET_CONVERSATION_EC_CALL_SUSPENDED);
+    break;
+
+  case CS_SHUTDOWN:
+    GNUNET_CONVERSATION_call_stop (call);
+    break;
+  }
+}
+
+
+/**
+ * We received a #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param msg the message
+ */
+static void
+handle_call_resume (void *cls,
+                    const struct ClientPhoneResumeMessage *msg)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+
+  (void) msg;
+  switch (call->state)
+  {
+  case CS_LOOKUP:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_RINGING:
+    GNUNET_break_op (0);
+    fail_call (call);
+    break;
+
+  case CS_SUSPENDED_CALLER:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_SUSPENDED_CALLEE:
+    call->state = CS_ACTIVE;
+    call->speaker->enable_speaker (call->speaker->cls);
+    call->mic->enable_microphone (call->mic->cls,
+                                  &transmit_call_audio,
+                                  call);
+    call->event_handler (call->event_handler_cls,
+                         GNUNET_CONVERSATION_EC_CALL_RESUMED);
+    break;
+
+  case CS_SUSPENDED_BOTH:
+    call->state = CS_SUSPENDED_CALLER;
+    call->event_handler (call->event_handler_cls,
+                         GNUNET_CONVERSATION_EC_CALL_RESUMED);
+    break;
+
+  case CS_ACTIVE:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_SHUTDOWN:
+    GNUNET_CONVERSATION_call_stop (call);
+    break;
+  }
+}
+
+
+/**
+ * We received a #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param msg the message
+ */
+static void
+handle_call_picked_up (void *cls,
+                       const struct ClientPhonePickedupMessage *msg)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+
+  (void) msg;
+  switch (call->state)
+  {
+  case CS_LOOKUP:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_RINGING:
+    call->state = CS_ACTIVE;
+    call->speaker->enable_speaker (call->speaker->cls);
+    call->mic->enable_microphone (call->mic->cls,
+                                  &transmit_call_audio,
+                                  call);
+    call->event_handler (call->event_handler_cls,
+                         GNUNET_CONVERSATION_EC_CALL_PICKED_UP);
+    break;
+
+  case CS_SUSPENDED_CALLER:
+  case CS_SUSPENDED_CALLEE:
+  case CS_SUSPENDED_BOTH:
+  case CS_ACTIVE:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_SHUTDOWN:
+    GNUNET_CONVERSATION_call_stop (call);
+    break;
+  }
+}
+
+
+/**
+ * We received a #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_HANG_UP.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param msg the message
+ */
+static void
+handle_call_hangup (void *cls,
+                    const struct ClientPhoneHangupMessage *msg)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+  GNUNET_CONVERSATION_CallEventHandler eh;
+  void *eh_cls;
+
+  (void) msg;
+  switch (call->state)
+  {
+  case CS_LOOKUP:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_RINGING:
+  case CS_SUSPENDED_CALLER:
+  case CS_SUSPENDED_CALLEE:
+  case CS_SUSPENDED_BOTH:
+  case CS_ACTIVE:
+    eh = call->event_handler;
+    eh_cls = call->event_handler_cls;
+    GNUNET_CONVERSATION_call_stop (call);
+    eh (eh_cls,
+        GNUNET_CONVERSATION_EC_CALL_HUNG_UP);
+    return;
+
+  case CS_SHUTDOWN:
+    GNUNET_CONVERSATION_call_stop (call);
+    break;
+  }
+}
+
+
+/**
+ * We received a `struct ClientAudioMessage`, check it is well-formed.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param am the message
+ * @return #GNUNET_OK (always well-formed)
+ */
+static int
+check_call_audio (void *cls,
+                  const struct ClientAudioMessage *am)
+{
+  (void) cls;
+  (void) am;
+  /* any payload is OK */
+  return GNUNET_OK;
+}
+
+
+/**
+ * We received a `struct ClientAudioMessage`
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param am the message
+ */
+static void
+handle_call_audio (void *cls,
+                   const struct ClientAudioMessage *am)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+
+  switch (call->state)
+  {
+  case CS_LOOKUP:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_RINGING:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_SUSPENDED_CALLER:
+    /* can happen: we suspended, other peer did not yet
+       learn about this. */
+    break;
+
+  case CS_SUSPENDED_CALLEE:
+  case CS_SUSPENDED_BOTH:
+    /* can (rarely) also happen: other peer suspended, but cadet might
+       have had delayed data on the unreliable channel */
+    break;
+
+  case CS_ACTIVE:
+    call->speaker->play (call->speaker->cls,
+                         ntohs (am->header.size) - sizeof(struct
+                                                          ClientAudioMessage),
+                         &am[1]);
+    break;
+
+  case CS_SHUTDOWN:
+    GNUNET_CONVERSATION_call_stop (call);
+    break;
+  }
+}
+
+
+/**
+ * Iterator called on obtained result for a GNS lookup.
+ *
+ * @param cls closure with the `struct GNUNET_CONVERSATION_Call`
+ * @param was_gns #GNUNET_NO if name was not a GNS name
+ * @param rd_count number of records in @a rd
+ * @param rd the records in reply
+ */
+static void
+handle_gns_response (void *cls,
+                     int was_gns,
+                     uint32_t rd_count,
+                     const struct GNUNET_GNSRECORD_Data *rd)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientCallMessage *ccm;
+  const struct GNUNET_CRYPTO_PrivateKey *caller_id;
+  size_t key_len;
+
+  (void) was_gns;
+  GNUNET_break (NULL != call->gns_lookup);
+  GNUNET_break (CS_LOOKUP == call->state);
+  call->gns_lookup = NULL;
+  for (uint32_t i = 0; i < rd_count; i++)
+  {
+    if (GNUNET_GNSRECORD_TYPE_PHONE == rd[i].record_type)
+    {
+      if (rd[i].data_size != sizeof(struct GNUNET_CONVERSATION_PhoneRecord))
+      {
+        GNUNET_break_op (0);
+        continue;
+      }
+      GNUNET_memcpy (&call->phone_record,
+                     rd[i].data,
+                     rd[i].data_size);
+      caller_id = GNUNET_IDENTITY_ego_get_private_key (call->caller_id);
+      key_len = GNUNET_CRYPTO_private_key_get_length (caller_id);
+      e = GNUNET_MQ_msg_extra (ccm, key_len,
+                               GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL);
+      ccm->line_port = call->phone_record.line_port;
+      ccm->target = call->phone_record.peer;
+      GNUNET_CRYPTO_write_private_key_to_buffer (caller_id,
+                                                   &ccm[1], key_len);
+      ccm->key_len = htonl (key_len);
+      GNUNET_MQ_send (call->mq,
+                      e);
+      call->state = CS_RINGING;
+      call->event_handler (call->event_handler_cls,
+                           GNUNET_CONVERSATION_EC_CALL_RINGING);
+      return;
+    }
+  }
+  /* not found */
+  call->event_handler (call->event_handler_cls,
+                       GNUNET_CONVERSATION_EC_CALL_GNS_FAIL);
+  GNUNET_CONVERSATION_call_stop (call);
+}
+
+
+/**
+ * We encountered an error talking with the conversation service.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param error details about the error
+ */
+static void
+call_error_handler (void *cls,
+                    enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+
+  (void) error;
+  if (CS_SHUTDOWN == call->state)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              _ (
+                "Connection to conversation service lost, trying to reconnect\n"));
+  fail_call (call);
+}
+
+
+/**
+ * The call got disconnected, destroy the handle.
+ *
+ * @param call call to reconnect
+ */
+static void
+fail_call (struct GNUNET_CONVERSATION_Call *call)
+{
+  if (CS_ACTIVE == call->state)
+  {
+    call->speaker->disable_speaker (call->speaker->cls);
+    call->mic->disable_microphone (call->mic->cls);
+  }
+  if (NULL != call->mq)
+  {
+    GNUNET_MQ_destroy (call->mq);
+    call->mq = NULL;
+  }
+  call->state = CS_SHUTDOWN;
+  call->event_handler (call->event_handler_cls,
+                       GNUNET_CONVERSATION_EC_CALL_ERROR);
+  GNUNET_CONVERSATION_call_stop (call);
+}
+
+
+/**
+ * Call the phone of another user.
+ *
+ * @param cfg configuration to use, specifies our phone service
+ * @param caller_id identity of the caller
+ * @param callee GNS name of the callee (used to locate the callee's record)
+ * @param speaker speaker to use (will be used automatically immediately once the
+ *        #GNUNET_CONVERSATION_EC_CALL_PICKED_UP event is generated); we will NOT generate
+ *        a ring tone on the speaker
+ * @param mic microphone to use (will be used automatically immediately once the
+ *        #GNUNET_CONVERSATION_EC_CALL_PICKED_UP event is generated)
+ * @param event_handler how to notify the owner of the phone about events
+ * @param event_handler_cls closure for @a event_handler
+ * @return handle for the call, NULL on hard errors
+ */
+struct GNUNET_CONVERSATION_Call *
+GNUNET_CONVERSATION_call_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                                struct GNUNET_IDENTITY_Ego *caller_id,
+                                const char *callee,
+                                struct GNUNET_SPEAKER_Handle *speaker,
+                                struct GNUNET_MICROPHONE_Handle *mic,
+                                GNUNET_CONVERSATION_CallEventHandler
+                                event_handler,
+                                void *event_handler_cls)
+{
+  struct GNUNET_CONVERSATION_Call *call
+    = GNUNET_new (struct GNUNET_CONVERSATION_Call);
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_fixed_size (call_suspend,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND,
+                             struct ClientPhoneSuspendMessage,
+                             call),
+    GNUNET_MQ_hd_fixed_size (call_resume,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME,
+                             struct ClientPhoneResumeMessage,
+                             call),
+    GNUNET_MQ_hd_fixed_size (call_picked_up,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP,
+                             struct ClientPhonePickedupMessage,
+                             call),
+    GNUNET_MQ_hd_fixed_size (call_hangup,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP,
+                             struct ClientPhoneHangupMessage,
+                             call),
+    GNUNET_MQ_hd_var_size (call_audio,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO,
+                           struct ClientAudioMessage,
+                           call),
+    GNUNET_MQ_handler_end ()
+  };
+
+  call->mq = GNUNET_CLIENT_connect (cfg,
+                                    "conversation",
+                                    handlers,
+                                    &call_error_handler,
+                                    call);
+  if (NULL == call->mq)
+  {
+    GNUNET_break (0);
+    GNUNET_free (call);
+    return NULL;
+  }
+  call->cfg = cfg;
+  call->caller_id = caller_id;
+  call->callee = GNUNET_strdup (callee);
+  call->speaker = speaker;
+  call->mic = mic;
+  call->event_handler = event_handler;
+  call->event_handler_cls = event_handler_cls;
+  call->gns = GNUNET_GNS_connect (cfg);
+  if (NULL == call->gns)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    return NULL;
+  }
+  call->state = CS_LOOKUP;
+  call->gns_lookup = GNUNET_GNS_lookup_with_tld (call->gns,
+                                                 call->callee,
+                                                 GNUNET_GNSRECORD_TYPE_PHONE,
+                                                 GNUNET_GNS_LO_DEFAULT,
+                                                 &handle_gns_response,
+                                                 call);
+  if (NULL == call->gns_lookup)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    return NULL;
+  }
+  return call;
+}
+
+
+/**
+ * Terminate a call.  The call may be ringing or ready at this time.
+ *
+ * @param call call to terminate
+ */
+void
+GNUNET_CONVERSATION_call_stop (struct GNUNET_CONVERSATION_Call *call)
+{
+  if ((NULL != call->speaker) &&
+      (CS_ACTIVE == call->state))
+    call->speaker->disable_speaker (call->speaker->cls);
+  if ((NULL != call->mic) &&
+      (CS_ACTIVE == call->state))
+    call->mic->disable_microphone (call->mic->cls);
+  if (CS_SHUTDOWN != call->state)
+  {
+    call->state = CS_SHUTDOWN;
+  }
+  if (NULL != call->mq)
+  {
+    GNUNET_MQ_destroy (call->mq);
+    call->mq = NULL;
+  }
+  if (NULL != call->gns_lookup)
+  {
+    GNUNET_GNS_lookup_with_tld_cancel (call->gns_lookup);
+    call->gns_lookup = NULL;
+  }
+  if (NULL != call->gns)
+  {
+    GNUNET_GNS_disconnect (call->gns);
+    call->gns = NULL;
+  }
+  GNUNET_free (call->callee);
+  GNUNET_free (call);
+}
+
+
+/**
+ * Pause a call.  Temporarily suspends the use of speaker and
+ * microphone.
+ *
+ * @param call call to pause
+ */
+void
+GNUNET_CONVERSATION_call_suspend (struct GNUNET_CONVERSATION_Call *call)
+{
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhoneSuspendMessage *suspend;
+
+  GNUNET_assert ((CS_SUSPENDED_CALLEE == call->state) ||
+                 (CS_ACTIVE == call->state));
+  if (CS_ACTIVE == call->state)
+  {
+    call->speaker->disable_speaker (call->speaker->cls);
+    call->mic->disable_microphone (call->mic->cls);
+  }
+  call->speaker = NULL;
+  call->mic = NULL;
+  e = GNUNET_MQ_msg (suspend,
+                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND);
+  GNUNET_MQ_send (call->mq,
+                  e);
+  if (CS_SUSPENDED_CALLER == call->state)
+    call->state = CS_SUSPENDED_BOTH;
+  else
+    call->state = CS_SUSPENDED_CALLER;
+}
+
+
+/**
+ * Resumes a call after #GNUNET_CONVERSATION_call_suspend.
+ *
+ * @param call call to resume
+ * @param speaker speaker to use
+ *        a ring tone on the speaker
+ * @param mic microphone to use
+ */
+void
+GNUNET_CONVERSATION_call_resume (struct GNUNET_CONVERSATION_Call *call,
+                                 struct GNUNET_SPEAKER_Handle *speaker,
+                                 struct GNUNET_MICROPHONE_Handle *mic)
+{
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhoneResumeMessage *resume;
+
+  GNUNET_assert ((CS_SUSPENDED_CALLER == call->state) ||
+                 (CS_SUSPENDED_BOTH == call->state));
+  e = GNUNET_MQ_msg (resume, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME);
+  GNUNET_MQ_send (call->mq, e);
+  call->speaker = speaker;
+  call->mic = mic;
+  if (CS_SUSPENDED_CALLER == call->state)
+  {
+    call->state = CS_ACTIVE;
+    call->speaker->enable_speaker (call->speaker->cls);
+    call->mic->enable_microphone (call->mic->cls,
+                                  &transmit_call_audio,
+                                  call);
+  }
+  else
+  {
+    call->state = CS_SUSPENDED_CALLEE;
+  }
+}
+
+
+/* end of conversation_api_call.c */
diff --git a/src/contrib/service/conversation/displaydot.sh b/src/contrib/service/conversation/displaydot.sh
new file mode 100644
index 000000000..16ee23409
--- /dev/null
+++ b/src/contrib/service/conversation/displaydot.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+dot -Tpng `ls -tr1 /tmp/*rec*.dot | tail -1` | display /dev/stdin &
+dot -Tpng `ls -tr1 /tmp/*play*.dot | tail -1` | display /dev/stdin &
diff --git a/src/contrib/service/conversation/gnunet-conversation-test.c b/src/contrib/service/conversation/gnunet-conversation-test.c
new file mode 100644
index 000000000..5e6bc805f
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-conversation-test.c
@@ -0,0 +1,265 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file conversation/gnunet-conversation-test.c
+ * @brief tool to test speaker and microphone (for end users!)
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_speaker_lib.h"
+#include "gnunet_microphone_lib.h"
+
+/**
+ * How long do we record before we replay?
+ */
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
+
+
+/**
+ * A recording we made.
+ */
+struct Recording
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct Recording *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct Recording *prev;
+
+  /**
+   * Number of bytes that follow.
+   */
+  size_t size;
+};
+
+
+/**
+ * Final status code.
+ */
+static int ret;
+
+/**
+ * Handle to the microphone.
+ */
+static struct GNUNET_MICROPHONE_Handle *microphone;
+
+/**
+ * Handle to the speaker.
+ */
+static struct GNUNET_SPEAKER_Handle *speaker;
+
+/**
+ * Task scheduled to switch from recording to playback.
+ */
+static struct GNUNET_SCHEDULER_Task *switch_task;
+
+/**
+ * The shutdown task.
+ */
+static struct GNUNET_SCHEDULER_Task *st;
+
+/**
+ * Head of DLL with recorded frames.
+ */
+static struct Recording *rec_head;
+
+/**
+ * Tail of DLL with recorded frames.
+ */
+static struct Recording *rec_tail;
+
+
+/**
+ * Terminate test.
+ *
+ * @param cls NULL
+ */
+static void
+do_shutdown (void *cls)
+{
+  struct Recording *rec;
+
+  (void) cls;
+  if (NULL != switch_task)
+    GNUNET_SCHEDULER_cancel (switch_task);
+  if (NULL != microphone)
+    GNUNET_MICROPHONE_destroy (microphone);
+  if (NULL != speaker)
+    GNUNET_SPEAKER_destroy (speaker);
+  while (NULL != (rec = rec_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (rec_head,
+                                 rec_tail,
+                                 rec);
+    GNUNET_free (rec);
+  }
+  fprintf (stderr,
+           _ ("\nEnd of transmission.  Have a GNU day.\n"));
+}
+
+
+/**
+ * Terminate recording process and switch to playback.
+ *
+ * @param cls NULL
+ */
+static void
+switch_to_speaker (void *cls)
+{
+  (void) cls;
+  switch_task = NULL;
+  microphone->disable_microphone (microphone->cls);
+  if (GNUNET_OK !=
+      speaker->enable_speaker (speaker->cls))
+  {
+    fprintf (stderr,
+             "Failed to enable microphone\n");
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  fprintf (stderr,
+           _ (
+             "\new are now playing your recording back.  If you can hear it, your audio settings are working..."));
+  for (struct Recording *rec = rec_head; NULL != rec; rec = rec->next)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Replaying %u bytes\n",
+                (unsigned int) rec->size);
+    speaker->play (speaker->cls,
+                   rec->size,
+                   &rec[1]);
+  }
+  GNUNET_SCHEDULER_cancel (st);
+  st = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                     &do_shutdown,
+                                     NULL);
+}
+
+
+/**
+ * Process recorded audio data.
+ *
+ * @param cls clsoure
+ * @param data_size number of bytes in @a data
+ * @param data audio data to play
+ */
+static void
+record (void *cls,
+        size_t data_size,
+        const void *data)
+{
+  struct Recording *rec;
+
+  (void) cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Recorded %u bytes\n",
+              (unsigned int) data_size);
+  rec = GNUNET_malloc (sizeof(struct Recording) + data_size);
+  rec->size = data_size;
+  GNUNET_memcpy (&rec[1], data, data_size);
+  GNUNET_CONTAINER_DLL_insert_tail (rec_head,
+                                    rec_tail,
+                                    rec);
+}
+
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param cfg configuration
+ */
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  (void) cls;
+  (void) args;
+  (void) cfgfile;
+  microphone = GNUNET_MICROPHONE_create_from_hardware (cfg);
+  GNUNET_assert (NULL != microphone);
+  speaker = GNUNET_SPEAKER_create_from_hardware (cfg);
+  GNUNET_assert (NULL != speaker);
+  switch_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                              &switch_to_speaker,
+                                              NULL);
+  st = GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
+                                      NULL);
+  fprintf (stderr,
+           _ (
+             "We will now be recording you for %s. After that time, the recording will be played back to you..."),
+           GNUNET_STRINGS_relative_time_to_string (TIMEOUT, GNUNET_YES));
+  if (GNUNET_OK !=
+      microphone->enable_microphone (microphone->cls,
+                                     &record, NULL))
+  {
+    fprintf (stderr,
+             "Failed to enable microphone\n");
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+}
+
+
+/**
+ * The main function of our code to test microphone and speaker.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc,
+      char *const *argv)
+{
+  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  if (GNUNET_OK !=
+      GNUNET_STRINGS_get_utf8_args (argc, argv,
+                                    &argc, &argv))
+    return 2;
+
+  ret = (GNUNET_OK ==
+         GNUNET_PROGRAM_run (argc, argv,
+                             "gnunet-conversation-test",
+                             gettext_noop ("help text"),
+                             options,
+                             &run,
+                             NULL)) ? ret : 1;
+  GNUNET_free_nz ((void *) argv);
+  return ret;
+}
+
+
+/* end of gnunet-conversation-test.c */
diff --git a/src/contrib/service/conversation/gnunet-conversation.c b/src/contrib/service/conversation/gnunet-conversation.c
new file mode 100644
index 000000000..41fc7bd0b
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-conversation.c
@@ -0,0 +1,1232 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2013 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/gnunet-conversation.c
+ * @brief conversation implementation
+ * @author Simon Dieterle
+ * @author Andreas Fuchs
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_constants.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_conversation_service.h"
+#include "gnunet_namestore_service.h"
+
+/**
+ * Maximum length allowed for the command line input.
+ */
+#define MAX_MESSAGE_LENGTH 1024
+
+#define XSTRINGIFY(x) STRINGIFY (x)
+
+#define STRINGIFY(x) (#x)
+
+/**
+ * Possible states of the phone.
+ */
+enum PhoneState
+{
+  /**
+   * We're waiting for our own idenitty.
+   */
+  PS_LOOKUP_EGO,
+
+  /**
+   * We're listening for calls
+   */
+  PS_LISTEN,
+
+  /**
+   * We accepted an incoming phone call.
+   */
+  PS_ACCEPTED,
+
+  /**
+   * Internal error
+   */
+  PS_ERROR
+};
+
+
+/**
+ * States for current outgoing call.
+ */
+enum CallState
+{
+  /**
+   * We are looking up some other participant.
+   */
+  CS_RESOLVING,
+
+  /**
+   * We are now ringing the other participant.
+   */
+  CS_RINGING,
+
+  /**
+   * The other party accepted our call and we are now connected.
+   */
+  CS_CONNECTED,
+
+  /**
+   * The call is currently suspended (by us).
+   */
+  CS_SUSPENDED
+};
+
+
+/**
+ * List of incoming calls
+ */
+struct CallList
+{
+  /**
+   * A DLL.
+   */
+  struct CallList *prev;
+
+  /**
+   * A DLL.
+   */
+  struct CallList *next;
+
+  /**
+   * Handle to hang up or activate.
+   */
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  /**
+   * Public key identifying the caller.
+   */
+  struct GNUNET_CRYPTO_PublicKey caller_id;
+
+  /**
+   * Unique number of the call.
+   */
+  unsigned int caller_num;
+};
+
+
+/**
+ * Phone handle
+ */
+static struct GNUNET_CONVERSATION_Phone *phone;
+
+/**
+ * Call handle (for active outgoing call).
+ */
+static struct GNUNET_CONVERSATION_Call *call;
+
+/**
+ * Caller handle (for active incoming call).
+ * This call handler is NOT in the #cl_head / #cl_tail list.
+ */
+static struct CallList *cl_active;
+
+/**
+ * Head of calls waiting to be accepted.
+ */
+static struct CallList *cl_head;
+
+/**
+ * Tail of calls waiting to be accepted.
+ */
+static struct CallList *cl_tail;
+
+/**
+ * Desired phone line (string to be converted to a hash).
+ */
+static char *line;
+
+/**
+ * Task which handles the commands
+ */
+static struct GNUNET_SCHEDULER_Task *handle_cmd_task;
+
+/**
+ * Our speaker.
+ */
+static struct GNUNET_SPEAKER_Handle *speaker;
+
+/**
+ * Our microphone.
+ */
+static struct GNUNET_MICROPHONE_Handle *mic;
+
+/**
+ * Our configuration.
+ */
+static struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Our ego.
+ */
+static struct GNUNET_IDENTITY_Ego *my_caller_id;
+
+/**
+ * Handle to identity service.
+ */
+static struct GNUNET_IDENTITY_Handle *id;
+
+/**
+ * Name of our ego.
+ */
+static char *ego_name;
+
+/**
+ * Public key of active conversation partner (if any).
+ */
+static struct GNUNET_CRYPTO_PublicKey peer_key;
+
+/**
+ * Name of active conversation partner (if any).
+ */
+static char *peer_name;
+
+/**
+ * File handle for stdin.
+ */
+static struct GNUNET_DISK_FileHandle *stdin_fh;
+
+/**
+ * Our phone's current state.
+ */
+static enum PhoneState phone_state;
+
+/**
+ * Our call's current state.
+ */
+static enum CallState call_state;
+
+/**
+ * Counts the number of incoming calls we have had so far.
+ */
+static unsigned int caller_num_gen;
+
+/**
+ * GNS address for this phone.
+ */
+static char *address;
+
+/**
+ * Be verbose.
+ */
+static int verbose;
+
+
+/**
+ * Function called with an event emitted by a phone.
+ *
+ * @param cls closure
+ * @param code type of the event
+ * @param caller handle for the caller
+ * @param caller_id public key of the caller (in GNS)
+ */
+static void
+phone_event_handler (void *cls,
+                     enum GNUNET_CONVERSATION_PhoneEventCode code,
+                     struct GNUNET_CONVERSATION_Caller *caller,
+                     const struct GNUNET_CRYPTO_PublicKey *caller_id)
+{
+  struct CallList *cl;
+
+  (void) cls;
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_PHONE_RING:
+    /*
+     * FIXME: we should be playing our ringtones from contrib/sounds now!
+     *
+       ring_my_bell();
+     *
+     * see https://gstreamer.freedesktop.org/documentation/application-development/highlevel/playback-components.html on how to play a wav using the gst framework being used here
+     */fprintf (
+      stdout,
+      _ (
+        "Incoming call from `%s'. Please /accept %u or /cancel %u the call.\n"),
+      GNUNET_GNSRECORD_pkey_to_zkey (caller_id),
+      caller_num_gen,
+      caller_num_gen);
+    cl = GNUNET_new (struct CallList);
+    cl->caller = caller;
+    cl->caller_id = *caller_id;
+    cl->caller_num = caller_num_gen++;
+    GNUNET_CONTAINER_DLL_insert (cl_head, cl_tail, cl);
+    break;
+
+  case GNUNET_CONVERSATION_EC_PHONE_HUNG_UP:
+    for (cl = cl_head; NULL != cl; cl = cl->next)
+      if (caller == cl->caller)
+        break;
+    if ((NULL == cl) && (caller == cl_active->caller))
+      cl = cl_active;
+    if (NULL == cl)
+    {
+      GNUNET_break (0);
+      return;
+    }
+    fprintf (stdout,
+             _ ("Call from `%s' terminated\n"),
+             GNUNET_GNSRECORD_pkey_to_zkey (&cl->caller_id));
+    if (cl == cl_active)
+    {
+      cl_active = NULL;
+      phone_state = PS_LISTEN;
+    }
+    else
+    {
+      GNUNET_CONTAINER_DLL_remove (cl_head, cl_tail, cl);
+    }
+    GNUNET_free (cl);
+    break;
+  }
+}
+
+
+/**
+ * Function called with an event emitted by a caller.
+ *
+ * @param cls closure with the `struct CallList` of the caller
+ * @param code type of the event issued by the caller
+ */
+static void
+caller_event_handler (void *cls, enum GNUNET_CONVERSATION_CallerEventCode code)
+{
+  struct CallList *cl = cls;
+
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALLER_SUSPEND:
+    fprintf (stdout,
+             _ ("Call from `%s' suspended by other user\n"),
+             GNUNET_GNSRECORD_pkey_to_zkey (&cl->caller_id));
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALLER_RESUME:
+    fprintf (stdout,
+             _ ("Call from `%s' resumed by other user\n"),
+             GNUNET_GNSRECORD_pkey_to_zkey (&cl->caller_id));
+    break;
+  }
+}
+
+
+/**
+ * Start our phone.
+ */
+static void
+start_phone ()
+{
+  struct GNUNET_GNSRECORD_Data rd;
+
+  if (NULL == my_caller_id)
+  {
+    fprintf (stderr,
+             _ ("Ego `%s' no longer available, phone is now down.\n"),
+             ego_name);
+    phone_state = PS_LOOKUP_EGO;
+    return;
+  }
+  GNUNET_assert (NULL == phone);
+  phone = GNUNET_CONVERSATION_phone_create (cfg,
+                                            my_caller_id,
+                                            &phone_event_handler,
+                                            NULL);
+  /* FIXME: get record and print full GNS record info later here... */
+  if (NULL == phone)
+  {
+    fprintf (stderr, "%s", _ ("Failed to setup phone (internal error)\n"));
+    phone_state = PS_ERROR;
+  }
+  else
+  {
+    GNUNET_CONVERSATION_phone_get_record (phone, &rd);
+    GNUNET_free (address);
+    address =
+      GNUNET_GNSRECORD_value_to_string (rd.record_type, rd.data, rd.data_size);
+    fprintf (
+      stdout,
+      _ (
+        "Phone active at `%s'.  Type `/help' for a list of available commands\n"),
+      address);
+    phone_state = PS_LISTEN;
+  }
+}
+
+
+/**
+ * Function called with an event emitted by a call.
+ *
+ * @param cls closure, NULL
+ * @param code type of the event on the call
+ */
+static void
+call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
+{
+  (void) cls;
+
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALL_RINGING:
+    GNUNET_break (CS_RESOLVING == call_state);
+    fprintf (stdout,
+             _ ("Resolved address of `%s'. Now ringing other party.\n"),
+             peer_name);
+    call_state = CS_RINGING;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
+    GNUNET_break (CS_RINGING == call_state);
+    fprintf (stdout, _ ("Connection established to `%s'\n"), peer_name);
+    call_state = CS_CONNECTED;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
+    GNUNET_break (CS_RESOLVING == call_state);
+    fprintf (stdout, _ ("Failed to resolve `%s'\n"), peer_name);
+    GNUNET_free (peer_name);
+    peer_name = NULL;
+    call = NULL;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
+    fprintf (stdout, _ ("Call to `%s' terminated\n"), peer_name);
+    GNUNET_free (peer_name);
+    peer_name = NULL;
+    call = NULL;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
+    GNUNET_break (CS_CONNECTED == call_state);
+    fprintf (stdout,
+             _ ("Connection to `%s' suspended (by other user)\n"),
+             peer_name);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_RESUMED:
+    GNUNET_break (CS_CONNECTED == call_state);
+    fprintf (stdout,
+             _ ("Connection to `%s' resumed (by other user)\n"),
+             peer_name);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_ERROR:
+    fprintf (stdout, _ ("Error with the call, restarting it\n"));
+    GNUNET_free (peer_name);
+    peer_name = NULL;
+    call = NULL;
+    break;
+  }
+}
+
+
+/**
+ * Function declareation for executing a action
+ *
+ * @param arguments arguments given to the function
+ */
+typedef void (*ActionFunction) (const char *arguments);
+
+
+/**
+ * Structure which defines a command
+ */
+struct VoipCommand
+{
+  /**
+   * Command the user needs to enter.
+   */
+  const char *command;
+
+  /**
+   * Function to call on command.
+   */
+  ActionFunction Action;
+
+  /**
+   * Help text for the command.
+   */
+  const char *helptext;
+};
+
+
+/**
+ * Action function to print help for the command shell.
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_help (const char *args);
+
+
+/**
+ * Terminate the client
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_quit (const char *args)
+{
+  (void) args;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Handler for unknown command.
+ *
+ * @param msg arguments given to the command
+ */
+static void
+do_unknown (const char *msg)
+{
+  fprintf (stderr, _ ("Unknown command `%s'\n"), msg);
+}
+
+
+/**
+ * Initiating a new call
+ *
+ * @param arg arguments given to the command
+ */
+static void
+do_call (const char *arg)
+{
+  if (NULL == my_caller_id)
+  {
+    fprintf (stderr, _ ("Ego `%s' not available\n"), ego_name);
+    return;
+  }
+  if (NULL != call)
+  {
+    fprintf (stderr,
+             _ ("You are calling someone else already, hang up first!\n"));
+    return;
+  }
+  switch (phone_state)
+  {
+  case PS_LOOKUP_EGO:
+    fprintf (stderr, _ ("Ego `%s' not available\n"), ego_name);
+    return;
+
+  case PS_LISTEN:
+    /* ok to call! */
+    break;
+
+  case PS_ACCEPTED:
+    fprintf (
+      stderr,
+      _ (
+        "You are answering call from `%s', hang up or suspend that call first!\n"),
+      GNUNET_GNSRECORD_pkey_to_zkey (&peer_key));
+    return;
+
+  case PS_ERROR:
+    /* ok to call */
+    break;
+  }
+  if (NULL == arg)
+  {
+    fprintf (stderr, _ ("Call recipient missing.\n"));
+    do_help ("/call");
+    return;
+  }
+  peer_name = GNUNET_strdup (arg);
+  call_state = CS_RESOLVING;
+  GNUNET_assert (NULL == call);
+  call = GNUNET_CONVERSATION_call_start (cfg,
+                                         my_caller_id,
+                                         arg,
+                                         speaker,
+                                         mic,
+                                         &call_event_handler,
+                                         NULL);
+}
+
+
+/**
+ * Accepting an incoming call
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_accept (const char *args)
+{
+  struct CallList *cl;
+  char buf[32];
+
+  if ((NULL != call) && (CS_SUSPENDED != call_state))
+  {
+    fprintf (stderr,
+             _ ("You are calling someone else already, hang up first!\n"));
+    return;
+  }
+  switch (phone_state)
+  {
+  case PS_LOOKUP_EGO:
+    GNUNET_break (0);
+    break;
+
+  case PS_LISTEN:
+    /* this is the expected state */
+    break;
+
+  case PS_ACCEPTED:
+    fprintf (
+      stderr,
+      _ (
+        "You are answering call from `%s', hang up or suspend that call first!\n"),
+      GNUNET_GNSRECORD_pkey_to_zkey (&peer_key));
+    return;
+
+  case PS_ERROR:
+    GNUNET_break (0);
+    break;
+  }
+  cl = cl_head;
+  if (NULL == cl)
+  {
+    fprintf (stderr, _ ("There is no incoming call to accept here!\n"));
+    return;
+  }
+  if ((NULL != cl->next) || (NULL != args))
+  {
+    for (cl = cl_head; NULL != cl; cl = cl->next)
+    {
+      GNUNET_snprintf (buf, sizeof(buf), "%u", cl->caller_num);
+      if (0 == strcmp (buf, args))
+        break;
+    }
+  }
+  if (NULL == cl)
+  {
+    fprintf (stderr,
+             _ ("There is no incoming call `%s' to accept right now!\n"),
+             args);
+    return;
+  }
+  GNUNET_CONTAINER_DLL_remove (cl_head, cl_tail, cl);
+  cl_active = cl;
+  peer_key = cl->caller_id;
+  phone_state = PS_ACCEPTED;
+  GNUNET_CONVERSATION_caller_pick_up (cl->caller,
+                                      &caller_event_handler,
+                                      cl,
+                                      speaker,
+                                      mic);
+}
+
+
+/**
+ * Print address information for this phone.
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_address (const char *args)
+{
+  (void) args;
+  if (NULL == address)
+  {
+    fprintf (stdout, "%s", _ ("We currently do not have an address.\n"));
+    return;
+  }
+  fprintf (stdout, "%s\n", address);
+}
+
+
+/**
+ * Accepting an incoming call
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_status (const char *args)
+{
+  struct CallList *cl;
+
+  (void) args;
+  switch (phone_state)
+  {
+  case PS_LOOKUP_EGO:
+    fprintf (
+      stdout,
+      _ (
+        "We are currently trying to locate the private key for the ego `%s'.\n"),
+      ego_name);
+    break;
+
+  case PS_LISTEN:
+    fprintf (stdout,
+             _ (
+               "We are listening for incoming calls for ego `%s' on line `%s'.\n"),
+             ego_name,
+             line);
+    break;
+
+  case PS_ACCEPTED:
+    fprintf (stdout,
+             _ ("You are having a conversation with `%s'.\n"),
+             GNUNET_GNSRECORD_pkey_to_zkey (&peer_key));
+    ;
+    break;
+
+  case PS_ERROR:
+    fprintf (
+      stdout,
+      _ (
+        "We had an internal error setting up our phone line. You can still make calls.\n"));
+    break;
+  }
+  if (NULL != call)
+  {
+    switch (call_state)
+    {
+    case CS_RESOLVING:
+      fprintf (stdout,
+               _ ("We are trying to find the network address to call `%s'.\n"),
+               peer_name);
+      break;
+
+    case CS_RINGING:
+      fprintf (stdout,
+               _ ("We are calling `%s', their phone should be ringing.\n"),
+               peer_name);
+      break;
+
+    case CS_CONNECTED:
+      fprintf (stdout,
+               _ ("You are having a conversation with `%s'.\n"),
+               peer_name);
+      break;
+
+    case CS_SUSPENDED:
+      /* ok to accept incoming call right now */
+      break;
+    }
+  }
+  if ((NULL != cl_head) && ((cl_head != cl_active) || (cl_head != cl_tail)))
+  {
+    fprintf (stdout, "%s", _ ("Calls waiting:\n"));
+    for (cl = cl_head; NULL != cl; cl = cl->next)
+    {
+      if (cl == cl_active)
+        continue;
+      fprintf (stdout,
+               _ ("#%u: `%s'\n"),
+               cl->caller_num,
+               GNUNET_GNSRECORD_pkey_to_zkey (&cl->caller_id));
+    }
+    fprintf (stdout, "%s", "\n");
+  }
+}
+
+
+/**
+ * Suspending a call
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_suspend (const char *args)
+{
+  (void) args;
+  if (NULL != call)
+  {
+    switch (call_state)
+    {
+    case CS_RESOLVING:
+    case CS_RINGING:
+    case CS_SUSPENDED:
+      fprintf (stderr,
+               "%s",
+               _ ("There is no call that could be suspended right now.\n"));
+      return;
+
+    case CS_CONNECTED:
+      call_state = CS_SUSPENDED;
+      GNUNET_CONVERSATION_call_suspend (call);
+      return;
+    }
+  }
+  switch (phone_state)
+  {
+  case PS_LOOKUP_EGO:
+  case PS_LISTEN:
+  case PS_ERROR:
+    fprintf (stderr,
+             "%s",
+             _ ("There is no call that could be suspended right now.\n"));
+    return;
+
+  case PS_ACCEPTED:
+    /* expected state, do rejection logic */
+    break;
+  }
+  GNUNET_assert (NULL != cl_active);
+  GNUNET_CONVERSATION_caller_suspend (cl_active->caller);
+  cl_active = NULL;
+  phone_state = PS_LISTEN;
+}
+
+
+/**
+ * Resuming a call
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_resume (const char *args)
+{
+  struct CallList *cl;
+  char buf[32];
+
+  if (NULL != call)
+  {
+    switch (call_state)
+    {
+    case CS_RESOLVING:
+    case CS_RINGING:
+    case CS_CONNECTED:
+      fprintf (stderr,
+               "%s",
+               _ ("There is no call that could be resumed right now.\n"));
+      return;
+
+    case CS_SUSPENDED:
+      call_state = CS_CONNECTED;
+      GNUNET_CONVERSATION_call_resume (call, speaker, mic);
+      return;
+    }
+  }
+  switch (phone_state)
+  {
+  case PS_LOOKUP_EGO:
+  case PS_ERROR:
+    fprintf (stderr,
+             "%s",
+             _ ("There is no call that could be resumed right now.\n"));
+    return;
+
+  case PS_LISTEN:
+    /* expected state, do resume logic */
+    break;
+
+  case PS_ACCEPTED:
+    fprintf (stderr,
+             _ ("Already talking with `%s', cannot resume a call right now.\n"),
+             GNUNET_GNSRECORD_pkey_to_zkey (&peer_key));
+    return;
+  }
+  GNUNET_assert (NULL == cl_active);
+  cl = cl_head;
+  if (NULL == cl)
+  {
+    fprintf (stderr, _ ("There is no incoming call to resume here!\n"));
+    return;
+  }
+  if ((NULL != cl->next) || (NULL != args))
+  {
+    for (cl = cl_head; NULL != cl; cl = cl->next)
+    {
+      GNUNET_snprintf (buf, sizeof(buf), "%u", cl->caller_num);
+      if (0 == strcmp (buf, args))
+        break;
+    }
+  }
+  if (NULL == cl)
+  {
+    fprintf (stderr,
+             _ ("There is no incoming call `%s' to resume right now!\n"),
+             args);
+    return;
+  }
+  cl_active = cl;
+  GNUNET_CONVERSATION_caller_resume (cl_active->caller, speaker, mic);
+  phone_state = PS_ACCEPTED;
+}
+
+
+/**
+ * Rejecting a call
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_reject (const char *args)
+{
+  struct CallList *cl;
+  char buf[32];
+
+  if (NULL != call)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    call = NULL;
+    return;
+  }
+  switch (phone_state)
+  {
+  case PS_LOOKUP_EGO:
+  case PS_ERROR:
+    fprintf (stderr,
+             "%s",
+             _ ("There is no call that could be cancelled right now.\n"));
+    return;
+
+  case PS_LISTEN:
+    /* look for active incoming calls to refuse */
+    cl = cl_head;
+    if (NULL == cl)
+    {
+      fprintf (stderr, _ ("There is no incoming call to refuse here!\n"));
+      return;
+    }
+    if ((NULL != cl->next) || (NULL != args))
+    {
+      for (cl = cl_head; NULL != cl; cl = cl->next)
+      {
+        GNUNET_snprintf (buf, sizeof(buf), "%u", cl->caller_num);
+        if (0 == strcmp (buf, args))
+          break;
+      }
+    }
+    if (NULL == cl)
+    {
+      fprintf (stderr,
+               _ ("There is no incoming call `%s' to refuse right now!\n"),
+               args);
+      return;
+    }
+    GNUNET_CONVERSATION_caller_hang_up (cl->caller);
+    GNUNET_CONTAINER_DLL_remove (cl_head, cl_tail, cl);
+    GNUNET_free (cl);
+    break;
+
+  case PS_ACCEPTED:
+    /* expected state, do rejection logic */
+    GNUNET_assert (NULL != cl_active);
+    GNUNET_CONVERSATION_caller_hang_up (cl_active->caller);
+    cl_active = NULL;
+    phone_state = PS_LISTEN;
+    break;
+  }
+}
+
+
+/**
+ * List of supported commands.
+ */
+static struct VoipCommand commands[] = {
+  { "/address",
+    &do_address,
+    gettext_noop (
+      "Use `/address' to find out which address this phone should have in GNS") },
+  { "/call", &do_call, gettext_noop ("Use `/call USER.gnu' to call USER") },
+  { "/accept",
+    &do_accept,
+    gettext_noop ("Use `/accept #NUM' to accept incoming call #NUM") },
+  { "/suspend",
+    &do_suspend,
+    gettext_noop ("Use `/suspend' to suspend the active call") },
+  { "/resume",
+    &do_resume,
+    gettext_noop (
+      "Use `/resume [#NUM]' to resume a call, #NUM is needed to resume incoming calls, no argument is needed to resume the current outgoing call.") },
+  { "/cancel",
+    &do_reject,
+    gettext_noop ("Use `/cancel' to reject or terminate a call") },
+  { "/status",
+    &do_status,
+    gettext_noop ("Use `/status' to print status information") },
+  { "/quit",
+    &do_quit,
+    gettext_noop ("Use `/quit' to terminate gnunet-conversation") },
+  { "/help",
+    &do_help,
+    gettext_noop ("Use `/help command' to get help for a specific command") },
+  { "", &do_unknown, NULL },
+  { NULL, NULL, NULL },
+};
+
+
+/**
+ * Action function to print help for the command shell.
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_help (const char *args)
+{
+  unsigned int i;
+
+  i = 0;
+  while ((NULL != args) && (0 != strlen (args)) &&
+         (commands[i].Action != &do_help))
+  {
+    if (0 == strncasecmp (&args[1], &commands[i].command[1], strlen (args) - 1))
+    {
+      fprintf (stdout, "%s\n", gettext (commands[i].helptext));
+      return;
+    }
+    i++;
+  }
+  i = 0;
+  fprintf (stdout, "%s", "Available commands:\n");
+  while (commands[i].Action != &do_help)
+  {
+    fprintf (stdout, "%s\n", gettext (commands[i].command));
+    i++;
+  }
+  fprintf (stdout, "%s", "\n");
+  fprintf (stdout, "%s\n", gettext (commands[i].helptext));
+}
+
+
+/**
+ * Task run during shutdown.
+ *
+ * @param cls NULL
+ */
+static void
+do_stop_task (void *cls)
+{
+  (void) cls;
+  if (NULL != call)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    call = NULL;
+  }
+  if (NULL != phone)
+  {
+    GNUNET_CONVERSATION_phone_destroy (phone);
+    phone = NULL;
+  }
+  if (NULL != handle_cmd_task)
+  {
+    GNUNET_SCHEDULER_cancel (handle_cmd_task);
+    handle_cmd_task = NULL;
+  }
+  if (NULL != id)
+  {
+    GNUNET_IDENTITY_disconnect (id);
+    id = NULL;
+  }
+  GNUNET_SPEAKER_destroy (speaker);
+  speaker = NULL;
+  GNUNET_MICROPHONE_destroy (mic);
+  mic = NULL;
+  GNUNET_free (ego_name);
+  ego_name = NULL;
+  GNUNET_free (peer_name);
+  peer_name = NULL;
+  phone_state = PS_ERROR;
+}
+
+
+/**
+ * Handle user command.
+ *
+ * @param message command the user typed in
+ * @param str_len number of bytes to process in @a message
+ */
+static void
+handle_command_string (char *message, size_t str_len)
+{
+  size_t i;
+  const char *ptr;
+
+  if (0 == str_len)
+    return;
+  if (message[str_len - 1] == '\n')
+    message[str_len - 1] = '\0';
+  if (message[str_len - 2] == '\r')
+    message[str_len - 2] = '\0';
+  if (0 == strlen (message))
+    return;
+  i = 0;
+  while (
+    (NULL != commands[i].command) &&
+    (0 !=
+     strncasecmp (commands[i].command, message, strlen (commands[i].command))))
+    i++;
+  ptr = &message[strlen (commands[i].command)];
+  while (isspace ((unsigned char) *ptr))
+    ptr++;
+  if ('\0' == *ptr)
+    ptr = NULL;
+  commands[i].Action (ptr);
+}
+
+
+/**
+ * Task to handle commands from the terminal.
+ *
+ * @param cls NULL
+ */
+static void
+handle_command (void *cls)
+{
+  char message[MAX_MESSAGE_LENGTH + 1];
+
+  (void) cls;
+  handle_cmd_task =
+    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                    stdin_fh,
+                                    &handle_command,
+                                    NULL);
+  /* read message from command line and handle it */
+  memset (message, 0, MAX_MESSAGE_LENGTH + 1);
+  if (NULL == fgets (message, MAX_MESSAGE_LENGTH, stdin))
+    return;
+  handle_command_string (message, strlen (message));
+}
+
+
+/**
+ * Function called by identity service with information about egos.
+ *
+ * @param cls NULL
+ * @param ego ego handle
+ * @param ctx unused
+ * @param name name of the ego
+ */
+static void
+identity_cb (void *cls,
+             struct GNUNET_IDENTITY_Ego *ego,
+             void **ctx,
+             const char *name)
+{
+  (void) cls;
+  (void) ctx;
+  if (NULL == name)
+    return;
+  if (ego == my_caller_id)
+  {
+    if (verbose)
+      fprintf (stdout, _ ("Name of our ego changed to `%s'\n"), name);
+    GNUNET_free (ego_name);
+    ego_name = GNUNET_strdup (name);
+    return;
+  }
+  if (0 != strcmp (name, ego_name))
+    return;
+  if (NULL == ego)
+  {
+    if (verbose)
+      fprintf (stdout, _ ("Our ego `%s' was deleted!\n"), ego_name);
+    my_caller_id = NULL;
+    return;
+  }
+  my_caller_id = ego;
+  GNUNET_CONFIGURATION_set_value_string (cfg, "CONVERSATION", "LINE", line);
+  start_phone ();
+}
+
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param c configuration
+ */
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
+{
+  (void) cls;
+  (void) args;
+  (void) cfgfile;
+  cfg = GNUNET_CONFIGURATION_dup (c);
+  speaker = GNUNET_SPEAKER_create_from_hardware (cfg);
+  mic = GNUNET_MICROPHONE_create_from_hardware (cfg);
+  if (NULL == ego_name)
+  {
+    fprintf (stderr, "%s", _ ("You must specify the NAME of an ego to use\n"));
+    return;
+  }
+  id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
+  handle_cmd_task =
+    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_UI,
+                                        &handle_command,
+                                        NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_stop_task, NULL);
+}
+
+
+/**
+ * The main function to conversation.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char *const *argv)
+{
+  struct GNUNET_GETOPT_CommandLineOption options[] =
+  { GNUNET_GETOPT_option_string (
+      'e',
+      "ego",
+      "NAME",
+      gettext_noop ("sets the NAME of the ego to use for the caller ID"),
+      &ego_name),
+    GNUNET_GETOPT_option_string ('p',
+                                 "phone",
+                                 "LINE",
+                                 gettext_noop (
+                                   "sets the LINE to use for the phone"),
+                                 &line),
+    GNUNET_GETOPT_OPTION_END };
+  int ret;
+
+  int flags;
+  flags = fcntl (0, F_GETFL, 0);
+  flags |= O_NONBLOCK;
+  if (0 != fcntl (0, F_SETFL, flags))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");
+  stdin_fh = GNUNET_DISK_get_handle_from_int_fd (0);
+
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+    return 2;
+  ret =
+    GNUNET_PROGRAM_run (argc,
+                        argv,
+                        "gnunet-conversation",
+                        gettext_noop (
+                          "Enables having a conversation with other GNUnet users."),
+                        options,
+                        &run,
+                        NULL);
+  GNUNET_free_nz ((void *) argv);
+  if (NULL != cfg)
+  {
+    GNUNET_CONFIGURATION_destroy (cfg);
+    cfg = NULL;
+  }
+  return (GNUNET_OK == ret) ? 0 : 1;
+}
+
+
+/* end of gnunet-conversation.c */
diff --git a/src/contrib/service/conversation/gnunet-helper-audio-playback-gst.c b/src/contrib/service/conversation/gnunet-helper-audio-playback-gst.c
new file mode 100644
index 000000000..f1e1e773d
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-helper-audio-playback-gst.c
@@ -0,0 +1,405 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/gnunet-helper-audio-playback-gst.c
+ * @brief program to playback audio data to the speaker (GStreamer version)
+ * @author LRN
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "conversation.h"
+#include "gnunet_constants.h"
+#include "gnunet_core_service.h"
+
+#include <gst/gst.h>
+#include <gst/audio/gstaudiobasesrc.h>
+#include <gst/app/gstappsrc.h>
+#include <glib.h>
+
+#define DEBUG_READ_PURE_OGG 1
+
+/**
+ * How much data to read in one go
+ */
+#define MAXLINE 4096
+
+/**
+ * Max number of microseconds to buffer in audiosink.
+ * Default is 1000
+ */
+#define BUFFER_TIME 1000
+
+/**
+ * Min number of microseconds to buffer in audiosink.
+ * Default is 1000
+ */
+#define LATENCY_TIME 1000
+
+/**
+ * Tokenizer for the data we get from stdin
+ */
+struct GNUNET_MessageStreamTokenizer *stdin_mst;
+
+/**
+ * Main pipeline.
+ */
+static GstElement *pipeline;
+
+/**
+ * Appsrc instance into which we write data for the pipeline.
+ */
+static GstElement *source;
+
+static GstElement *demuxer;
+static GstElement *decoder;
+static GstElement *conv;
+static GstElement *resampler;
+static GstElement *sink;
+
+/**
+ * Set to 1 to break the reading loop
+ */
+static int abort_read;
+
+
+static void
+sink_child_added (GstChildProxy *child_proxy,
+                  GObject *object,
+                  gchar *name,
+                  gpointer user_data)
+{
+  if (GST_IS_AUDIO_BASE_SRC (object))
+    g_object_set (object,
+                  "buffer-time", (gint64) BUFFER_TIME,
+                  "latency-time", (gint64) LATENCY_TIME,
+                  NULL);
+}
+
+
+static void
+ogg_pad_added (GstElement *element,
+               GstPad *pad,
+               gpointer data)
+{
+  GstPad *sinkpad;
+  GstElement *decoder = (GstElement *) data;
+
+  /* We can now link this pad with the opus-decoder sink pad */
+  sinkpad = gst_element_get_static_pad (decoder, "sink");
+
+  gst_pad_link (pad, sinkpad);
+
+  gst_element_link_many (decoder, conv, resampler, sink, NULL);
+
+  gst_object_unref (sinkpad);
+}
+
+
+static void
+quit ()
+{
+  if (NULL != source)
+    gst_app_src_end_of_stream (GST_APP_SRC (source));
+  if (NULL != pipeline)
+    gst_element_set_state (pipeline, GST_STATE_NULL);
+  abort_read = 1;
+}
+
+
+static gboolean
+bus_call (GstBus *bus, GstMessage *msg, gpointer data)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Bus message\n");
+  switch (GST_MESSAGE_TYPE (msg))
+  {
+  case GST_MESSAGE_EOS:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "End of stream\n");
+    quit ();
+    break;
+
+  case GST_MESSAGE_ERROR:
+    {
+      gchar  *debug;
+      GError *error;
+
+      gst_message_parse_error (msg, &error, &debug);
+      g_free (debug);
+
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Error: %s\n",
+                  error->message);
+      g_error_free (error);
+
+      quit ();
+      break;
+    }
+
+  default:
+    break;
+  }
+
+  return TRUE;
+}
+
+
+static void
+signalhandler (int s)
+{
+  quit ();
+}
+
+
+static int
+feed_buffer_to_gst (const char *audio, size_t b_len)
+{
+  GstBuffer *b;
+  gchar *bufspace;
+  GstFlowReturn flow;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Feeding %u bytes to GStreamer\n",
+              (unsigned int) b_len);
+
+  bufspace = g_memdup2 (audio, b_len);
+  b = gst_buffer_new_wrapped (bufspace, b_len);
+  if (NULL == b)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Failed to wrap a buffer\n");
+    g_free (bufspace);
+    return GNUNET_SYSERR;
+  }
+  flow = gst_app_src_push_buffer (GST_APP_SRC (source), b);
+  /* They all return GNUNET_OK, because currently player stops when
+   * data stops coming. This might need to be changed for the player
+   * to also stop when pipeline breaks.
+   */
+  switch (flow)
+  {
+  case GST_FLOW_OK:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Fed %u bytes to the pipeline\n",
+                (unsigned int) b_len);
+    break;
+
+  case GST_FLOW_FLUSHING:
+    /* buffer was dropped, because pipeline state is not PAUSED or PLAYING */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Dropped a buffer\n");
+    break;
+
+  case GST_FLOW_EOS:
+    /* end of stream */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "EOS\n");
+    break;
+
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Unexpected push result\n");
+    break;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Message callback
+ *
+ * @param msg message we received.
+ * @return #GNUNET_OK on success,
+ *     #GNUNET_NO to stop further processing due to disconnect (no error)
+ *     #GNUNET_SYSERR to stop further processing due to error
+ */
+static int
+stdin_receiver (void *cls,
+                const struct GNUNET_MessageHeader *msg)
+{
+  struct AudioMessage *audio;
+  size_t b_len;
+
+  switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO:
+    audio = (struct AudioMessage *) msg;
+
+    b_len = ntohs (audio->header.size) - sizeof(struct AudioMessage);
+    feed_buffer_to_gst ((const char *) &audio[1], b_len);
+    break;
+
+  default:
+    break;
+  }
+  return GNUNET_OK;
+}
+
+
+int
+main (int argc, char **argv)
+{
+  GstBus *bus;
+  guint bus_watch_id;
+  uint64_t toff;
+
+  typedef void (*SignalHandlerPointer) (int);
+
+  SignalHandlerPointer inthandler, termhandler;
+#ifdef DEBUG_READ_PURE_OGG
+  int read_pure_ogg = getenv ("GNUNET_READ_PURE_OGG") ? 1 : 0;
+#endif
+
+  inthandler = signal (SIGINT,
+                       &signalhandler);
+  termhandler = signal (SIGTERM,
+                        &signalhandler);
+
+  /* Initialisation */
+  gst_init (&argc, &argv);
+
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_log_setup ("gnunet-helper-audio-playback-gst",
+                                   "WARNING",
+                                   NULL));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Audio sink starts\n");
+
+  stdin_mst = GNUNET_MST_create (&stdin_receiver,
+                                 NULL);
+
+  /* Create gstreamer elements */
+  pipeline = gst_pipeline_new ("audio-player");
+  source = gst_element_factory_make ("appsrc", "audio-input");
+  demuxer = gst_element_factory_make ("oggdemux", "ogg-demuxer");
+  decoder = gst_element_factory_make ("opusdec", "opus-decoder");
+  conv = gst_element_factory_make ("audioconvert", "converter");
+  resampler = gst_element_factory_make ("audioresample", "resampler");
+  sink = gst_element_factory_make ("autoaudiosink", "audiosink");
+
+  if (! pipeline || ! source || ! conv || ! resampler || ! decoder ||
+      ! demuxer || ! sink)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "One element could not be created. Exiting.\n");
+    return -1;
+  }
+
+  g_signal_connect (sink,
+                    "child-added",
+                    G_CALLBACK (sink_child_added),
+                    NULL);
+  g_signal_connect (demuxer,
+                    "pad-added",
+                    G_CALLBACK (ogg_pad_added),
+                    decoder);
+
+  /* Keep a reference to it, we operate on it */
+  gst_object_ref (GST_OBJECT (source));
+
+  /* Set up the pipeline */
+
+  /* we feed appsrc as fast as possible, it just blocks when it's full */
+  g_object_set (G_OBJECT (source),
+/*      "format", GST_FORMAT_TIME,*/
+                "block", TRUE,
+                "is-live", TRUE,
+                NULL);
+
+  g_object_set (G_OBJECT (decoder),
+/*      "plc", FALSE,*/
+/*      "apply-gain", TRUE,*/
+                "use-inband-fec", TRUE,
+                NULL);
+
+  /* we add a message handler */
+  bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
+  bus_watch_id = gst_bus_add_watch (bus, bus_call, pipeline);
+  gst_object_unref (bus);
+
+  /* we add all elements into the pipeline */
+  /* audio-input | ogg-demuxer | opus-decoder | converter | resampler | audiosink */
+  gst_bin_add_many (GST_BIN (pipeline), source, demuxer, decoder, conv,
+                    resampler, sink, NULL);
+
+  /* we link the elements together */
+  gst_element_link_many (source, demuxer, NULL);
+
+  /* Set the pipeline to "playing" state*/
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Now playing\n");
+  gst_element_set_state (pipeline, GST_STATE_PLAYING);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running...\n");
+  /* Iterate */
+  toff = 0;
+  while (! abort_read)
+  {
+    char readbuf[MAXLINE];
+    int ret;
+
+    ret = read (0, readbuf, sizeof(readbuf));
+    if (0 > ret)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("Read error from STDIN: %d %s\n"),
+                  ret, strerror (errno));
+      break;
+    }
+    toff += ret;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received %d bytes of audio data (total: %llu)\n",
+                (int) ret,
+                (unsigned long long) toff);
+    if (0 == ret)
+      break;
+#ifdef DEBUG_READ_PURE_OGG
+    if (read_pure_ogg)
+    {
+      feed_buffer_to_gst (readbuf, ret);
+    }
+    else
+#endif
+    GNUNET_MST_from_buffer (stdin_mst,
+                            readbuf,
+                            ret,
+                            GNUNET_NO,
+                            GNUNET_NO);
+  }
+  GNUNET_MST_destroy (stdin_mst);
+
+  signal (SIGINT, inthandler);
+  signal (SIGINT, termhandler);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Returned, stopping playback\n");
+  quit ();
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Deleting pipeline\n");
+  gst_object_unref (GST_OBJECT (source));
+  source = NULL;
+  gst_object_unref (GST_OBJECT (pipeline));
+  pipeline = NULL;
+  g_source_remove (bus_watch_id);
+
+  return 0;
+}
diff --git a/src/contrib/service/conversation/gnunet-helper-audio-playback.c b/src/contrib/service/conversation/gnunet-helper-audio-playback.c
new file mode 100644
index 000000000..dfa400d71
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-helper-audio-playback.c
@@ -0,0 +1,888 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/gnunet-helper-audio-playback.c
+ * @brief program to playback audio data to the speaker
+ * @author Siomon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "conversation.h"
+#include "gnunet_constants.h"
+#include "gnunet_core_service.h"
+
+#include <pulse/simple.h>
+#include <pulse/error.h>
+#include <pulse/rtclock.h>
+
+#include <pulse/pulseaudio.h>
+#include <opus/opus.h>
+#include <opus/opus_types.h>
+#include <ogg/ogg.h>
+
+#define DEBUG_READ_PURE_OGG 1
+#define DEBUG_DUMP_DECODED_OGG 1
+
+#define MAXLINE 4096
+
+#define SAMPLING_RATE 48000
+
+#define CHANNELS 1
+
+/* 120ms at 48000 */
+#define MAX_FRAME_SIZE (960 * 6)
+
+/**
+ * Pulseaudio specification. May change in the future.
+ */
+static pa_sample_spec sample_spec = {
+  .format = PA_SAMPLE_FLOAT32LE,
+  .rate = SAMPLING_RATE,
+  .channels = CHANNELS
+};
+
+#ifdef DEBUG_DUMP_DECODED_OGG
+static int dump_to_stdout;
+#endif
+
+/**
+ * Pulseaudio mainloop api
+ */
+static pa_mainloop_api *mainloop_api;
+
+/**
+ * Pulseaudio threaded mainloop
+ */
+static pa_threaded_mainloop *m;
+
+/**
+ * Pulseaudio context
+ */
+static pa_context *context;
+
+/**
+ * Pulseaudio output stream
+ */
+static pa_stream *stream_out;
+
+/**
+ * OPUS decoder
+ */
+static OpusDecoder *dec;
+
+/**
+ * PCM data buffer
+ */
+static float *pcm_buffer;
+
+/**
+ * Number of samples for one frame
+ */
+static int frame_size;
+
+/**
+ * Pipe we use to signal the main loop that we are ready to receive.
+ */
+static int ready_pipe[2];
+
+/**
+ * Ogg I/O state.
+ */
+static ogg_sync_state oy;
+
+/**
+ * Ogg stream state.
+ */
+static ogg_stream_state os;
+
+static int channels;
+
+static int preskip;
+
+static float gain;
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/* OggOpus spec says the numbers must be in little-endian order */
+struct OpusHeadPacket
+{
+  uint8_t magic[8];
+  uint8_t version;
+  uint8_t channels;
+  uint16_t preskip GNUNET_PACKED;
+  uint32_t sampling_rate GNUNET_PACKED;
+  uint16_t gain GNUNET_PACKED;
+  uint8_t channel_mapping;
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+/**
+ * Process an Opus header and setup the opus decoder based on it.
+ * It takes several pointers for header values which are needed
+ * elsewhere in the code.
+ */
+static OpusDecoder *
+process_header (ogg_packet *op)
+{
+  int err;
+  OpusDecoder *dec;
+  struct OpusHeadPacket header;
+
+  if (((unsigned int) op->bytes) < sizeof(header))
+    return NULL;
+  GNUNET_memcpy (&header,
+                 op->packet,
+                 sizeof(header));
+  header.preskip = GNUNET_le16toh (header.preskip);
+  header.sampling_rate = GNUNET_le32toh (header.sampling_rate);
+  header.gain = GNUNET_le16toh (header.gain);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Header: v%u, %u-ch, skip %u, %uHz, %u gain\n",
+              header.version,
+              header.channels,
+              header.preskip,
+              header.sampling_rate,
+              header.gain);
+  channels = header.channels;
+  preskip = header.preskip;
+
+  if (header.channel_mapping != 0)
+  {
+    fprintf (stderr,
+             "This implementation does not support non-mono streams\n");
+    return NULL;
+  }
+
+  dec = opus_decoder_create (SAMPLING_RATE, channels, &err);
+  if (OPUS_OK != err)
+  {
+    fprintf (stderr,
+             "Cannot create encoder: %s\n",
+             opus_strerror (err));
+    return NULL;
+  }
+  if (! dec)
+  {
+    fprintf (stderr,
+             "Decoder initialization failed: %s\n",
+             opus_strerror (err));
+    return NULL;
+  }
+
+  if (0 != header.gain)
+  {
+    /*Gain API added in a newer libopus version, if we don't have it
+       we apply the gain ourselves. We also add in a user provided
+       manual gain at the same time.*/
+    int gainadj = (int) header.gain;
+    err = opus_decoder_ctl (dec, OPUS_SET_GAIN (gainadj));
+    if (OPUS_UNIMPLEMENTED == err)
+    {
+      gain = pow (10.0, gainadj / 5120.0);
+    }
+    else if (OPUS_OK != err)
+    {
+      fprintf (stderr, "Error setting gain: %s\n", opus_strerror (err));
+      return NULL;
+    }
+  }
+
+  return dec;
+}
+
+
+#ifdef DEBUG_DUMP_DECODED_OGG
+static size_t
+fwrite_le32 (opus_int32 i32, FILE *file)
+{
+  unsigned char buf[4];
+
+  buf[0] = (unsigned char) (i32 & 0xFF);
+  buf[1] = (unsigned char) (i32 >> 8 & 0xFF);
+  buf[2] = (unsigned char) (i32 >> 16 & 0xFF);
+  buf[3] = (unsigned char) (i32 >> 24 & 0xFF);
+  return fwrite (buf, 4, 1, file);
+}
+
+
+static size_t
+fwrite_le16 (int i16, FILE *file)
+{
+  unsigned char buf[2];
+
+  buf[0] = (unsigned char) (i16 & 0xFF);
+  buf[1] = (unsigned char) (i16 >> 8 & 0xFF);
+  return fwrite (buf, 2, 1, file);
+}
+
+
+static int
+write_wav_header ()
+{
+  int ret;
+  FILE *file = stdout;
+
+  ret = fprintf (file, "RIFF") >= 0;
+  ret &= fwrite_le32 (0x7fffffff, file);
+
+  ret &= fprintf (file, "WAVEfmt ") >= 0;
+  ret &= fwrite_le32 (16, file);
+  ret &= fwrite_le16 (1, file);
+  ret &= fwrite_le16 (channels, file);
+  ret &= fwrite_le32 (SAMPLING_RATE, file);
+  ret &= fwrite_le32 (2 * channels * SAMPLING_RATE, file);
+  ret &= fwrite_le16 (2 * channels, file);
+  ret &= fwrite_le16 (16, file);
+
+  ret &= fprintf (file, "data") >= 0;
+  ret &= fwrite_le32 (0x7fffffff, file);
+
+  return ! ret ? -1 : 16;
+}
+
+
+#endif
+
+
+static int64_t
+audio_write (int64_t maxout)
+{
+  int64_t sampout = 0;
+  int tmp_skip;
+  unsigned out_len;
+  unsigned to_write;
+  float *output;
+
+#ifdef DEBUG_DUMP_DECODED_OGG
+  static int wrote_wav_header;
+
+  if (dump_to_stdout && ! wrote_wav_header)
+  {
+    write_wav_header ();
+    wrote_wav_header = 1;
+  }
+#endif
+  maxout = 0 > maxout ? 0 : maxout;
+  do
+  {
+    tmp_skip = (preskip > frame_size) ? (int) frame_size : preskip;
+    preskip -= tmp_skip;
+    output = pcm_buffer + channels * tmp_skip;
+    out_len = frame_size - tmp_skip;
+    if (out_len > MAX_FRAME_SIZE)
+      exit (6);
+    frame_size = 0;
+
+    to_write = out_len < maxout ? out_len : (unsigned) maxout;
+    if (0 < maxout)
+    {
+      int64_t wrote = 0;
+      wrote = to_write;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Writing %u * %u * %u = %llu bytes into PA\n",
+                  to_write,
+                  channels,
+                  (unsigned int) sizeof(float),
+                  (unsigned long long) (to_write * channels * sizeof(float)));
+#ifdef DEBUG_DUMP_DECODED_OGG
+      if (dump_to_stdout)
+      {
+# define fminf(_x, _y) ((_x) < (_y) ? (_x) : (_y))
+# define fmaxf(_x, _y) ((_x) > (_y) ? (_x) : (_y))
+# define float2int(flt) ((int) (floor (.5 + flt)))
+        int i;
+        int16_t *out = alloca (sizeof(short) * MAX_FRAME_SIZE * channels);
+        for (i = 0; i < (int) out_len * channels; i++)
+          out[i] = (short) float2int (fmaxf (-32768, fminf (output[i] * 32768.f,
+                                                            32767)));
+
+        fwrite (out, 2 * channels, out_len < maxout ? out_len : maxout, stdout);
+      }
+      else
+#endif
+      if (pa_stream_write
+            (stream_out, output, to_write * channels * sizeof(float), NULL, 0,
+            PA_SEEK_RELATIVE) < 0)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("pa_stream_write() failed: %s\n"),
+                    pa_strerror (pa_context_errno (context)));
+      }
+      sampout += wrote;
+      maxout -= wrote;
+    }
+  }
+  while (0 < frame_size && 0 < maxout);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Wrote %" PRId64 " samples\n",
+              sampout);
+  return sampout;
+}
+
+
+/**
+ * Pulseaudio shutdown task
+ */
+static void
+quit (int ret)
+{
+  mainloop_api->quit (mainloop_api,
+                      ret);
+  exit (ret);
+}
+
+
+static void
+ogg_demux_and_decode ()
+{
+  ogg_page og;
+  static int stream_init;
+  int64_t page_granule = 0;
+  ogg_packet op;
+  static int has_opus_stream;
+  static int has_tags_packet;
+  static int32_t opus_serialno;
+  static int64_t link_out;
+  static int64_t packet_count;
+  int eos = 0;
+  static int total_links;
+  static int gran_offset;
+
+  while (1 == ogg_sync_pageout (&oy, &og))
+  {
+    if (0 == stream_init)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Initialized the stream\n");
+      ogg_stream_init (&os, ogg_page_serialno (&og));
+      stream_init = 1;
+    }
+    if (ogg_page_serialno (&og) != os.serialno)
+    {
+      /* so all streams are read. */
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Re-set serial number\n");
+      ogg_stream_reset_serialno (&os, ogg_page_serialno (&og));
+    }
+    /*Add page to the bitstream*/
+    ogg_stream_pagein (&os, &og);
+    page_granule = ogg_page_granulepos (&og);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Reading page that ends at %" PRId64 "\n",
+                page_granule);
+    /*Extract all available packets*/
+    while (1 == ogg_stream_packetout (&os, &op))
+    {
+      /*OggOpus streams are identified by a magic string in the initial
+         stream header.*/
+      if (op.b_o_s && (op.bytes >= 8) && ! memcmp (op.packet, "OpusHead", 8))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Got Opus Header\n");
+        if (has_opus_stream && has_tags_packet)
+        {
+          /*If we're seeing another BOS OpusHead now it means
+             the stream is chained without an EOS.
+             This can easily happen if record helper is terminated unexpectedly.
+           */
+          has_opus_stream = 0;
+          if (dec)
+            opus_decoder_destroy (dec);
+          dec = NULL;
+          fprintf (stderr,
+                   "\nWarning: stream %" PRId64
+                   " ended without EOS and a new stream began.\n",
+                   (int64_t) os.serialno);
+        }
+        if (! has_opus_stream)
+        {
+          if ((packet_count > 0) && (opus_serialno == os.serialno) )
+          {
+            fprintf (stderr,
+                     "\nError: Apparent chaining without changing serial number (%"
+                     PRId64 "==%" PRId64 ").\n",
+                     (int64_t) opus_serialno, (int64_t) os.serialno);
+            quit (1);
+          }
+          opus_serialno = os.serialno;
+          has_opus_stream = 1;
+          has_tags_packet = 0;
+          link_out = 0;
+          packet_count = 0;
+          eos = 0;
+          total_links++;
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Got header for stream %" PRId64 ", this is %dth link\n",
+                      (int64_t) opus_serialno, total_links);
+        }
+        else
+        {
+          fprintf (stderr, "\nWarning: ignoring opus stream %" PRId64 "\n",
+                   (int64_t) os.serialno);
+        }
+      }
+      if (! has_opus_stream || (os.serialno != opus_serialno) )
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "breaking out\n");
+        break;
+      }
+      /*If first packet in a logical stream, process the Opus header*/
+      if (0 == packet_count)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Decoding header\n");
+        dec = process_header (&op);
+        if (! dec)
+          quit (1);
+
+        if ((0 != ogg_stream_packetout (&os, &op)) || (255 ==
+                                                       og.header[og.header_len
+                                                                 - 1]) )
+        {
+          /*The format specifies that the initial header and tags packets are on their
+             own pages. To aid implementors in discovering that their files are wrong
+             we reject them explicitly here. In some player designs files like this would
+             fail even without an explicit test.*/
+          fprintf (stderr,
+                   "Extra packets on initial header page. Invalid stream.\n");
+          quit (1);
+        }
+
+        /*Remember how many samples at the front we were told to skip
+           so that we can adjust the timestamp counting.*/
+        gran_offset = preskip;
+
+        if (! pcm_buffer)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Allocating %u * %u * %u = %llu bytes of buffer space\n",
+                      MAX_FRAME_SIZE,
+                      channels,
+                      (unsigned int) sizeof(float),
+                      (unsigned long long) (MAX_FRAME_SIZE * channels
+                                            * sizeof(float)));
+          pcm_buffer = pa_xmalloc (sizeof(float) * MAX_FRAME_SIZE * channels);
+        }
+      }
+      else if (1 == packet_count)
+      {
+        has_tags_packet = 1;
+        if ((0 != ogg_stream_packetout (&os, &op)) || (255 ==
+                                                       og.header[og.header_len
+                                                                 - 1]) )
+        {
+          fprintf (stderr,
+                   "Extra packets on initial tags page. Invalid stream.\n");
+          quit (1);
+        }
+      }
+      else
+      {
+        int ret;
+        int64_t maxout;
+        int64_t outsamp;
+
+        /*End of stream condition*/
+        if (op.e_o_s && (os.serialno == opus_serialno) )
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Got EOS\n");
+          eos = 1;         /* don't care for anything except opus eos */
+        }
+
+        /*Decode Opus packet*/
+        ret = opus_decode_float (dec,
+                                 (const unsigned char *) op.packet,
+                                 op.bytes,
+                                 pcm_buffer,
+                                 MAX_FRAME_SIZE, 0);
+
+        /*If the decoder returned less than zero, we have an error.*/
+        if (0 > ret)
+        {
+          fprintf (stderr, "Decoding error: %s\n", opus_strerror (ret));
+          break;
+        }
+        frame_size = ret;
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Decoded %d bytes/channel (%d bytes) from %u compressed bytes\n",
+                    ret,
+                    ret * channels,
+                    (unsigned int) op.bytes);
+
+        /*Apply header gain, if we're not using an opus library new
+           enough to do this internally.*/
+        if (0 != gain)
+        {
+          int i;
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Applying gain %f\n",
+                      gain);
+          for (i = 0; i < frame_size * channels; i++)
+            pcm_buffer[i] *= gain;
+        }
+
+        /*This handles making sure that our output duration respects
+           the final end-trim by not letting the output sample count
+           get ahead of the granpos indicated value.*/
+        maxout = ((page_granule - gran_offset) * SAMPLING_RATE / 48000)
+                 - link_out;
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Writing audio packet %" PRId64 ", at most %" PRId64
+                    " samples\n",
+                    packet_count, maxout);
+
+        outsamp = audio_write (0 > maxout ? 0 : maxout);
+        link_out += outsamp;
+      }
+      packet_count++;
+    }
+    if (eos)
+    {
+      has_opus_stream = 0;
+      if (dec)
+        opus_decoder_destroy (dec);
+      dec = NULL;
+    }
+  }
+}
+
+
+/**
+ * Message callback
+ *
+ * @param msg message we received.
+ * @return #GNUNET_OK on success,
+ *     #GNUNET_NO to stop further processing due to disconnect (no error)
+ *     #GNUNET_SYSERR to stop further processing due to error
+ */
+static int
+stdin_receiver (void *cls,
+                const struct GNUNET_MessageHeader *msg)
+{
+  struct AudioMessage *audio;
+  char *data;
+  size_t payload_len;
+
+  (void) cls;
+  switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO:
+    audio = (struct AudioMessage *) msg;
+    payload_len = ntohs (audio->header.size) - sizeof(struct AudioMessage);
+
+    /*Get the ogg buffer for writing*/
+    data = ogg_sync_buffer (&oy, payload_len);
+    /*Read bitstream from input file*/
+    GNUNET_memcpy (data, (const unsigned char *) &audio[1], payload_len);
+    ogg_sync_wrote (&oy, payload_len);
+
+    ogg_demux_and_decode ();
+    break;
+
+  default:
+    break;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Callback when data is there for playback
+ */
+static void
+stream_write_callback (pa_stream *s,
+                       size_t length,
+                       void *userdata)
+{
+  /* unblock 'main' */
+  (void) userdata;
+  (void) length;
+  (void) s;
+  if (-1 != ready_pipe[1])
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Unblocking main loop!\n");
+    (void) write (ready_pipe[1], "r", 1);
+  }
+}
+
+
+/**
+ * Exit callback for SIGTERM and SIGINT
+ */
+static void
+exit_signal_callback (pa_mainloop_api *m,
+                      pa_signal_event *e,
+                      int sig,
+                      void *userdata)
+{
+  (void) m;
+  (void) e;
+  (void) sig;
+  (void) userdata;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("gnunet-helper-audio-playback - Got signal, exiting\n"));
+  quit (1);
+}
+
+
+/**
+ * Pulseaudio stream state callback
+ */
+static void
+context_state_callback (pa_context *c,
+                        void *userdata)
+{
+  int p;
+
+  (void) userdata;
+  GNUNET_assert (NULL != c);
+  switch (pa_context_get_state (c))
+  {
+  case PA_CONTEXT_CONNECTING:
+  case PA_CONTEXT_AUTHORIZING:
+  case PA_CONTEXT_SETTING_NAME:
+    break;
+
+  case PA_CONTEXT_READY:
+    {
+      GNUNET_assert (! stream_out);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Connection established.\n"));
+      if (! (stream_out =
+               pa_stream_new (c, "GNUNET VoIP playback", &sample_spec, NULL)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("pa_stream_new() failed: %s\n"),
+                    pa_strerror (pa_context_errno (c)));
+        goto fail;
+      }
+      pa_stream_set_write_callback (stream_out,
+                                    &stream_write_callback,
+                                    NULL);
+      if ((p =
+             pa_stream_connect_playback (stream_out, NULL,
+                                         NULL,
+                                         PA_STREAM_ADJUST_LATENCY
+                                         | PA_STREAM_INTERPOLATE_TIMING
+                                         | PA_STREAM_AUTO_TIMING_UPDATE,
+                                         NULL, NULL)) < 0)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("pa_stream_connect_playback() failed: %s\n"),
+                    pa_strerror (pa_context_errno (c)));
+        goto fail;
+      }
+      break;
+    }
+
+  case PA_CONTEXT_TERMINATED:
+    quit (0);
+    break;
+
+  case PA_CONTEXT_FAILED:
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Connection failure: %s\n"),
+                pa_strerror (pa_context_errno (c)));
+    goto fail;
+  }
+  return;
+fail:
+  quit (1);
+}
+
+
+/**
+ * Pulseaudio initialization
+ */
+static void
+pa_init ()
+{
+  int r;
+
+  if (! pa_sample_spec_valid (&sample_spec))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _ ("Wrong Spec\n"));
+  }
+  /* set up threaded playback mainloop */
+  if (! (m = pa_threaded_mainloop_new ()))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_mainloop_new() failed.\n"));
+  }
+  mainloop_api = pa_threaded_mainloop_get_api (m);
+  /* listen to signals */
+  r = pa_signal_init (mainloop_api);
+  GNUNET_assert (r == 0);
+  pa_signal_new (SIGINT, exit_signal_callback, NULL);
+  pa_signal_new (SIGTERM, exit_signal_callback, NULL);
+
+
+  /* connect to the main pulseaudio context */
+  if (! (context = pa_context_new (mainloop_api, "GNUnet VoIP")))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_context_new() failed.\n"));
+  }
+  pa_context_set_state_callback (context, context_state_callback, NULL);
+
+  if (pa_context_connect (context, NULL, 0, NULL) < 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_context_connect() failed: %s\n"),
+                pa_strerror (pa_context_errno (context)));
+  }
+  if (pa_threaded_mainloop_start (m) < 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_mainloop_run() failed.\n"));
+  }
+}
+
+
+static void
+ogg_init ()
+{
+  ogg_sync_init (&oy);
+}
+
+
+static void
+drain_callback (pa_stream*s, int success, void *userdata)
+{
+  (void) s;
+  (void) success;
+  (void) userdata;
+  pa_threaded_mainloop_signal (m,
+                               0);
+}
+
+
+/**
+ * The main function for the playback helper.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char *argv[])
+{
+  static unsigned long long toff;
+  char readbuf[MAXLINE];
+  struct GNUNET_MessageStreamTokenizer *stdin_mst;
+  char c;
+  ssize_t ret;
+
+#ifdef DEBUG_READ_PURE_OGG
+  int read_pure_ogg = getenv ("GNUNET_READ_PURE_OGG") ? 1 : 0;
+#endif
+
+  (void) argc;
+  (void) argv;
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_log_setup ("gnunet-helper-audio-playback",
+                                   "WARNING",
+                                   NULL));
+  if (0 != pipe (ready_pipe))
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "pipe");
+    return 1;
+  }
+  stdin_mst = GNUNET_MST_create (&stdin_receiver, NULL);
+  ogg_init ();
+  pa_init ();
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Waiting for PulseAudio to be ready.\n");
+  GNUNET_assert (1 == read (ready_pipe[0], &c, 1));
+  close (ready_pipe[0]);
+  close (ready_pipe[1]);
+  ready_pipe[0] = -1;
+  ready_pipe[1] = -1;
+#ifdef DEBUG_DUMP_DECODED_OGG
+  dump_to_stdout = getenv ("GNUNET_DUMP_DECODED_OGG") ? 1 : 0;
+#endif
+  while (1)
+  {
+    ret = read (STDIN_FILENO,
+                readbuf,
+                sizeof(readbuf));
+    toff += ret;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received %d bytes of audio data (total: %llu)\n",
+                (int) ret,
+                toff);
+    if (0 > ret)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("Read error from STDIN: %s\n"),
+                  strerror (errno));
+      break;
+    }
+    if (0 == ret)
+      break;
+#ifdef DEBUG_READ_PURE_OGG
+    if (read_pure_ogg)
+    {
+      char *data = ogg_sync_buffer (&oy, ret);
+      GNUNET_memcpy (data, readbuf, ret);
+      ogg_sync_wrote (&oy, ret);
+      ogg_demux_and_decode ();
+    }
+    else
+#endif
+    GNUNET_MST_from_buffer (stdin_mst,
+                            readbuf, ret,
+                            GNUNET_NO, GNUNET_NO);
+  }
+  GNUNET_MST_destroy (stdin_mst);
+  if (stream_out)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Locking\n");
+    pa_threaded_mainloop_lock (m);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Draining\n");
+    pa_operation *o = pa_stream_drain (stream_out, drain_callback, NULL);
+    while (pa_operation_get_state (o) == PA_OPERATION_RUNNING)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Waiting\n");
+      pa_threaded_mainloop_wait (m);
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Unreffing\n");
+    pa_operation_unref (o);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Unlocking\n");
+    pa_threaded_mainloop_unlock (m);
+  }
+  return 0;
+}
diff --git a/src/contrib/service/conversation/gnunet-helper-audio-record-gst.c b/src/contrib/service/conversation/gnunet-helper-audio-record-gst.c
new file mode 100644
index 000000000..883dd9eea
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-helper-audio-record-gst.c
@@ -0,0 +1,393 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/gnunet-helper-audio-record-gst.c
+ * @brief program to record audio data from the microphone (GStreamer version)
+ * @author LRN
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "conversation.h"
+#include "gnunet_constants.h"
+#include "gnunet_core_service.h"
+
+#include <gst/gst.h>
+#include <gst/app/gstappsink.h>
+#include <gst/audio/gstaudiobasesrc.h>
+#include <glib.h>
+
+#define DEBUG_RECORD_PURE_OGG 1
+
+/**
+ * Number of channels.
+ * Must be one of the following (from libopusenc documentation):
+ * 1, 2
+ */
+#define OPUS_CHANNELS 1
+
+/**
+ * Maximal size of a single opus packet.
+ */
+#define MAX_PAYLOAD_SIZE (1024 / OPUS_CHANNELS)
+
+/**
+ * Size of a single frame fed to the encoder, in ms.
+ * Must be one of the following (from libopus documentation):
+ * 2.5, 5, 10, 20, 40 or 60
+ */
+#define OPUS_FRAME_SIZE 40
+
+/**
+ * Expected packet loss to prepare for, in percents.
+ */
+#define PACKET_LOSS_PERCENTAGE 1
+
+/**
+ * Set to 1 to enable forward error correction.
+ * Set to 0 to disable.
+ */
+#define INBAND_FEC_MODE 1
+
+/**
+ * Max number of microseconds to buffer in audiosource.
+ * Default is 200000
+ */
+#define BUFFER_TIME 1000 /* 1ms */
+
+/**
+ * Min number of microseconds to buffer in audiosource.
+ * Default is 10000
+ */
+#define LATENCY_TIME 1000 /* 1ms */
+
+/**
+ * Maximum delay in multiplexing streams, in ns.
+ * Setting this to 0 forces page flushing, which
+ * decreases delay, but increases overhead.
+ */
+#define OGG_MAX_DELAY 0
+
+/**
+ * Maximum delay for sending out a page, in ns.
+ * Setting this to 0 forces page flushing, which
+ * decreases delay, but increases overhead.
+ */
+#define OGG_MAX_PAGE_DELAY 0
+
+/**
+ * Main pipeline.
+ */
+static GstElement *pipeline;
+
+#ifdef DEBUG_RECORD_PURE_OGG
+static int dump_pure_ogg;
+#endif
+
+static void
+quit ()
+{
+  if (NULL != pipeline)
+    gst_element_set_state (pipeline, GST_STATE_NULL);
+}
+
+
+static gboolean
+bus_call (GstBus *bus, GstMessage *msg, gpointer data)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Bus message\n");
+  switch (GST_MESSAGE_TYPE (msg))
+  {
+  case GST_MESSAGE_EOS:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "End of stream\n");
+    quit ();
+    break;
+
+  case GST_MESSAGE_ERROR:
+    {
+      gchar  *debug;
+      GError *error;
+
+      gst_message_parse_error (msg, &error, &debug);
+      g_free (debug);
+
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error: %s\n", error->message);
+      g_error_free (error);
+
+      quit ();
+      break;
+    }
+
+  default:
+    break;
+  }
+
+  return TRUE;
+}
+
+
+void
+source_child_added (GstChildProxy *child_proxy, GObject *object, gchar *name,
+                    gpointer user_data)
+{
+  if (GST_IS_AUDIO_BASE_SRC (object))
+    g_object_set (object, "buffer-time", (gint64) BUFFER_TIME, "latency-time",
+                  (gint64) LATENCY_TIME, NULL);
+}
+
+
+static void
+signalhandler (int s)
+{
+  quit ();
+}
+
+
+int
+main (int argc, char **argv)
+{
+  GstElement *source, *filter, *encoder, *conv, *resampler, *sink, *oggmux;
+  GstCaps *caps;
+  GstBus *bus;
+  guint bus_watch_id;
+  struct AudioMessage audio_message;
+  int abort_send = 0;
+
+  typedef void (*SignalHandlerPointer) (int);
+
+  SignalHandlerPointer inthandler, termhandler;
+  inthandler = signal (SIGINT, signalhandler);
+  termhandler = signal (SIGTERM, signalhandler);
+
+#ifdef DEBUG_RECORD_PURE_OGG
+  dump_pure_ogg = getenv ("GNUNET_RECORD_PURE_OGG") ? 1 : 0;
+#endif
+
+  /* Initialisation */
+  gst_init (&argc, &argv);
+
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_log_setup ("gnunet-helper-audio-record",
+                                   "WARNING",
+                                   NULL));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Audio source starts\n");
+
+  audio_message.header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+
+  /* Create gstreamer elements */
+  pipeline = gst_pipeline_new ("audio-recorder");
+  source = gst_element_factory_make ("autoaudiosrc", "audiosource");
+  filter = gst_element_factory_make ("capsfilter", "filter");
+  conv = gst_element_factory_make ("audioconvert", "converter");
+  resampler = gst_element_factory_make ("audioresample", "resampler");
+  encoder = gst_element_factory_make ("opusenc", "opus-encoder");
+  oggmux = gst_element_factory_make ("oggmux", "ogg-muxer");
+  sink = gst_element_factory_make ("appsink", "audio-output");
+
+  if (! pipeline || ! filter || ! source || ! conv || ! resampler ||
+      ! encoder || ! oggmux || ! sink)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "One element could not be created. Exiting.\n");
+    return -1;
+  }
+
+  g_signal_connect (source, "child-added", G_CALLBACK (source_child_added),
+                    NULL);
+
+  /* Set up the pipeline */
+
+  caps = gst_caps_new_simple ("audio/x-raw",
+                              "format", G_TYPE_STRING, "S16LE",
+/*    "rate", G_TYPE_INT, SAMPLING_RATE,*/
+                              "channels", G_TYPE_INT, OPUS_CHANNELS,
+/*    "layout", G_TYPE_STRING, "interleaved",*/
+                              NULL);
+  g_object_set (G_OBJECT (filter),
+                "caps", caps,
+                NULL);
+  gst_caps_unref (caps);
+
+  g_object_set (G_OBJECT (encoder),
+/*      "bitrate", 64000, */
+/*      "bandwidth", OPUS_BANDWIDTH_FULLBAND, */
+                "inband-fec", INBAND_FEC_MODE,
+                "packet-loss-percentage", PACKET_LOSS_PERCENTAGE,
+                "max-payload-size", MAX_PAYLOAD_SIZE,
+                "audio", FALSE, /* VoIP, not audio */
+                "frame-size", OPUS_FRAME_SIZE,
+                NULL);
+
+  g_object_set (G_OBJECT (oggmux),
+                "max-delay", OGG_MAX_DELAY,
+                "max-page-delay", OGG_MAX_PAGE_DELAY,
+                NULL);
+
+  /* we add a message handler */
+  bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
+  bus_watch_id = gst_bus_add_watch (bus, bus_call, pipeline);
+  gst_object_unref (bus);
+
+  /* we add all elements into the pipeline */
+  /* audiosource | converter | resampler | opus-encoder | audio-output */
+  gst_bin_add_many (GST_BIN (pipeline), source, filter, conv, resampler,
+                    encoder,
+                    oggmux, sink, NULL);
+
+  /* we link the elements together */
+  gst_element_link_many (source, filter, conv, resampler, encoder, oggmux, sink,
+                         NULL);
+
+  /* Set the pipeline to "playing" state*/
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Now playing\n");
+  gst_element_set_state (pipeline, GST_STATE_PLAYING);
+
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running...\n");
+  /* Iterate */
+  while (! abort_send)
+  {
+    GstSample *s;
+    GstBuffer *b;
+    GstMapInfo m;
+    size_t len, msg_size;
+    const char *ptr;
+    int phase;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "pulling...\n");
+    s = gst_app_sink_pull_sample (GST_APP_SINK (sink));
+    if (NULL == s)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "pulled NULL\n");
+      break;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "...pulled!\n");
+    {
+      const GstStructure *si;
+      char *si_str;
+      GstCaps *s_caps;
+      char *caps_str;
+      si = gst_sample_get_info (s);
+      if (si)
+      {
+        si_str = gst_structure_to_string (si);
+        if (si_str)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample %s\n", si_str);
+          g_free (si_str);
+        }
+      }
+      else
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample with no info\n");
+      s_caps = gst_sample_get_caps (s);
+      if (s_caps)
+      {
+        caps_str = gst_caps_to_string (s_caps);
+        if (caps_str)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample with caps %s\n",
+                      caps_str);
+          g_free (caps_str);
+        }
+      }
+      else
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample with no caps\n");
+    }
+    b = gst_sample_get_buffer (s);
+    if ((NULL == b) || ! gst_buffer_map (b, &m, GST_MAP_READ))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "got NULL buffer %p or failed to map the buffer\n", b);
+      gst_sample_unref (s);
+      continue;
+    }
+
+    len = m.size;
+    if (len > UINT16_MAX - sizeof(struct AudioMessage))
+    {
+      GNUNET_break (0);
+      len = UINT16_MAX - sizeof(struct AudioMessage);
+    }
+    msg_size = sizeof(struct AudioMessage) + len;
+    audio_message.header.size = htons ((uint16_t) msg_size);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending %u bytes of audio data\n", (unsigned int) msg_size);
+    for (phase = 0; phase < 2; phase++)
+    {
+      size_t offset;
+      size_t to_send;
+      ssize_t ret;
+      if (0 == phase)
+      {
+#ifdef DEBUG_RECORD_PURE_OGG
+        if (dump_pure_ogg)
+          continue;
+#endif
+        ptr = (const char *) &audio_message;
+        to_send = sizeof(audio_message);
+      }
+      else
+      {
+        ptr = (const char *) m.data;
+        to_send = len;
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Sending %u bytes on phase %d\n", (unsigned int) to_send,
+                  phase);
+      for (offset = 0; offset < to_send; offset += ret)
+      {
+        ret = write (1, &ptr[offset], to_send - offset);
+        if (0 >= ret)
+        {
+          if (-1 == ret)
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                        "Failed to write %u bytes at offset %u (total %u) in phase %d: %s\n",
+                        (unsigned int) (to_send - offset),
+                        (unsigned int) offset,
+                        (unsigned int) (to_send + offset),
+                        phase,
+                        strerror (errno));
+          abort_send = 1;
+          break;
+        }
+      }
+      if (abort_send)
+        break;
+    }
+    gst_buffer_unmap (b, &m);
+    gst_sample_unref (s);
+  }
+
+  signal (SIGINT, inthandler);
+  signal (SIGINT, termhandler);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Returned, stopping playback\n");
+  quit ();
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Deleting pipeline\n");
+  gst_object_unref (GST_OBJECT (pipeline));
+  pipeline = NULL;
+  g_source_remove (bus_watch_id);
+
+  return 0;
+}
diff --git a/src/contrib/service/conversation/gnunet-helper-audio-record.c b/src/contrib/service/conversation/gnunet-helper-audio-record.c
new file mode 100644
index 000000000..060a7c779
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-helper-audio-record.c
@@ -0,0 +1,807 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/gnunet-helper-audio-record.c
+ * @brief program to record audio data from the microphone
+ * @author Siomon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "conversation.h"
+#include "gnunet_constants.h"
+#include "gnunet_core_service.h"
+
+#include <pulse/simple.h>
+#include <pulse/error.h>
+#include <pulse/rtclock.h>
+
+#include <pulse/pulseaudio.h>
+#include <opus/opus.h>
+#include <opus/opus_types.h>
+#include <ogg/ogg.h>
+
+#define DEBUG_RECORD_PURE_OGG 1
+
+/**
+ * Sampling rate
+ */
+#define SAMPLING_RATE 48000
+
+/**
+ * How many ms of audio to buffer before encoding them.
+ * Possible values:
+ * 60, 40, 20, 10, 5, 2.5
+ */
+#define FRAME_SIZE_MS 40
+
+/**
+ * How many samples to buffer before encoding them.
+ */
+#define FRAME_SIZE (SAMPLING_RATE / 1000 * FRAME_SIZE_MS)
+
+/**
+ * Pages are committed when their size goes over this value.
+ * Note that in practice we flush pages VERY often (every frame),
+ * which means that pages NEVER really get to be this big.
+ * With one-packet-per-page, pages are roughly 100-300 bytes each.
+ *
+ * This value is chosen to make MAX_PAYLOAD_BYTES=1024 fit
+ * into a single page.
+ */
+#define PAGE_WATERLINE 800
+
+/**
+ * Maximum length of opus payload
+ */
+#define MAX_PAYLOAD_BYTES 1024
+
+/**
+ * Number of channels
+ */
+#define CHANNELS 1
+
+/**
+ * Configures the encoder's expected packet loss percentage.
+ *
+ * Higher values will trigger progressively more loss resistant behavior
+ * in the encoder at the expense of quality at a given bitrate
+ * in the lossless case, but greater quality under loss.
+ */
+#define CONV_OPUS_PACKET_LOSS_PERCENTAGE 1
+
+/**
+ * Configures the encoder's computational complexity.
+ *
+ * The supported range is 0-10 inclusive with 10 representing
+ * the highest complexity.
+ */
+#define CONV_OPUS_ENCODING_COMPLEXITY 10
+
+/**
+ * Configures the encoder's use of inband forward error correction (FEC).
+ *
+ * Note: This is only applicable to the LPC layer.
+ */
+#define CONV_OPUS_INBAND_FEC 1
+
+/**
+ * Configures the type of signal being encoded.
+ *
+ * This is a hint which helps the encoder's mode selection.
+ *
+ * Possible values:
+ * OPUS_AUTO - (default) Encoder detects the type automatically.
+ * OPUS_SIGNAL_VOICE - Bias thresholds towards choosing LPC or Hybrid modes.
+ * OPUS_SIGNAL_MUSIC - Bias thresholds towards choosing MDCT modes.
+ */
+#define CONV_OPUS_SIGNAL OPUS_SIGNAL_VOICE
+
+/**
+ * Coding mode.
+ *
+ * Possible values:
+ * OPUS_APPLICATION_VOIP - gives best quality at a given bitrate for voice
+ * signals. It enhances the input signal by high-pass filtering and
+ * emphasizing formants and harmonics. Optionally it includes in-band forward
+ * error correction to protect against packet loss. Use this mode for typical
+ * VoIP applications. Because of the enhancement, even at high bitrates
+ * the output may sound different from the input.
+ * OPUS_APPLICATION_AUDIO - gives best quality at a given bitrate for most
+ * non-voice signals like music. Use this mode for music and mixed
+ * (music/voice) content, broadcast, and applications requiring less than
+ * 15 ms of coding delay.
+ * OPUS_APPLICATION_RESTRICTED_LOWDELAY - configures low-delay mode that
+ * disables the speech-optimized mode in exchange for slightly reduced delay.
+ * This mode can only be set on an newly initialized or freshly reset encoder
+ * because it changes the codec delay.
+ */
+#define CONV_OPUS_APP_TYPE OPUS_APPLICATION_VOIP
+
+/**
+ * Specification for recording. May change in the future to spec negotiation.
+ */
+static pa_sample_spec sample_spec = {
+  .format = PA_SAMPLE_FLOAT32LE,
+  .rate = SAMPLING_RATE,
+  .channels = CHANNELS
+};
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/* OggOpus spec says the numbers must be in little-endian order */
+struct OpusHeadPacket
+{
+  uint8_t magic[8];
+  uint8_t version;
+  uint8_t channels;
+  uint16_t preskip GNUNET_PACKED;
+  uint32_t sampling_rate GNUNET_PACKED;
+  uint16_t gain GNUNET_PACKED;
+  uint8_t channel_mapping;
+};
+
+struct OpusCommentsPacket
+{
+  uint8_t magic[8];
+  uint32_t vendor_length;
+  /* followed by:
+     char vendor[vendor_length];
+     uint32_t string_count;
+     followed by @a string_count pairs of:
+       uint32_t string_length;
+       char string[string_length];
+   */
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+/**
+ * Pulseaudio mainloop api
+ */
+static pa_mainloop_api *mainloop_api;
+
+/**
+ * Pulseaudio mainloop
+ */
+static pa_mainloop *m;
+
+/**
+ * Pulseaudio context
+ */
+static pa_context *context;
+
+/**
+ * Pulseaudio recording stream
+ */
+static pa_stream *stream_in;
+
+/**
+ * Pulseaudio io events
+ */
+static pa_io_event *stdio_event;
+
+/**
+ * OPUS encoder
+ */
+static OpusEncoder *enc;
+
+/**
+ * Buffer for encoded data
+ */
+static unsigned char *opus_data;
+
+/**
+ * PCM data buffer for one OPUS frame
+ */
+static float *pcm_buffer;
+
+/**
+ * Length of the pcm data needed for one OPUS frame
+ */
+static int pcm_length;
+
+/**
+ * Audio buffer
+ */
+static char *transmit_buffer;
+
+/**
+ * Length of audio buffer
+ */
+static size_t transmit_buffer_length;
+
+/**
+ * Read index for transmit buffer
+ */
+static size_t transmit_buffer_index;
+
+/**
+ * Audio message skeleton
+ */
+static struct AudioMessage *audio_message;
+
+/**
+ * Ogg muxer state
+ */
+static ogg_stream_state os;
+
+/**
+ * Ogg packet id
+ */
+static int32_t packet_id;
+
+/**
+ * Ogg granule for current packet
+ */
+static int64_t enc_granulepos;
+
+#ifdef DEBUG_RECORD_PURE_OGG
+/**
+ * 1 to not to write GNUnet message headers,
+ * producing pure playable ogg output
+ */
+static int dump_pure_ogg;
+#endif
+
+/**
+ * Pulseaudio shutdown task
+ */
+static void
+quit (int ret)
+{
+  mainloop_api->quit (mainloop_api,
+                      ret);
+  exit (ret);
+}
+
+
+static void
+write_data (const char *ptr,
+            size_t msg_size)
+{
+  ssize_t ret;
+  size_t off;
+
+  off = 0;
+  while (off < msg_size)
+  {
+    ret = write (STDOUT_FILENO,
+                 &ptr[off],
+                 msg_size - off);
+    if (0 >= ret)
+    {
+      if (-1 == ret)
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+                             "write");
+      quit (2);
+    }
+    off += ret;
+  }
+}
+
+
+static void
+write_page (ogg_page *og)
+{
+  static unsigned long long toff;
+  size_t msg_size;
+
+  msg_size = sizeof(struct AudioMessage) + og->header_len + og->body_len;
+  audio_message->header.size = htons ((uint16_t) msg_size);
+  GNUNET_memcpy (&audio_message[1], og->header, og->header_len);
+  GNUNET_memcpy (((char *) &audio_message[1]) + og->header_len, og->body,
+                 og->body_len);
+
+  toff += msg_size;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending %u bytes of audio data (total: %llu)\n",
+              (unsigned int) msg_size,
+              toff);
+#ifdef DEBUG_RECORD_PURE_OGG
+  if (dump_pure_ogg)
+    write_data ((const char *) &audio_message[1],
+                og->header_len + og->body_len);
+  else
+#endif
+  write_data ((const char *) audio_message,
+              msg_size);
+}
+
+
+/**
+ * Creates OPUS packets from PCM data
+ */
+static void
+packetizer ()
+{
+  char *nbuf;
+  size_t new_size;
+  int32_t len;
+  ogg_packet op;
+  ogg_page og;
+
+  while (transmit_buffer_length >= transmit_buffer_index + pcm_length)
+  {
+    GNUNET_memcpy (pcm_buffer,
+                   &transmit_buffer[transmit_buffer_index],
+                   pcm_length);
+    transmit_buffer_index += pcm_length;
+    len =
+      opus_encode_float (enc, pcm_buffer, FRAME_SIZE, opus_data,
+                         MAX_PAYLOAD_BYTES);
+
+    if (len < 0)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("opus_encode_float() failed: %s. Aborting\n"),
+                  opus_strerror (len));
+      quit (5);
+    }
+    if (((uint32_t) len) > UINT16_MAX - sizeof(struct AudioMessage))
+    {
+      GNUNET_break (0);
+      continue;
+    }
+
+    /* As per OggOpus spec, granule is calculated as if the audio
+       had 48kHz sampling rate. */
+    enc_granulepos += FRAME_SIZE * 48000 / SAMPLING_RATE;
+
+    op.packet = (unsigned char *) opus_data;
+    op.bytes = len;
+    op.b_o_s = 0;
+    op.e_o_s = 0;
+    op.granulepos = enc_granulepos;
+    op.packetno = packet_id++;
+    ogg_stream_packetin (&os, &op);
+
+    while (ogg_stream_flush_fill (&os, &og, PAGE_WATERLINE))
+    {
+      if (((unsigned long long) og.header_len)
+          + ((unsigned long long) og.body_len) >
+          UINT16_MAX - sizeof(struct AudioMessage))
+      {
+        GNUNET_assert (0);
+        continue;
+      }
+      write_page (&og);
+    }
+  }
+
+  new_size = transmit_buffer_length - transmit_buffer_index;
+  if (0 != new_size)
+  {
+    nbuf = pa_xmalloc (new_size);
+    memmove (nbuf,
+             &transmit_buffer[transmit_buffer_index],
+             new_size);
+    pa_xfree (transmit_buffer);
+    transmit_buffer = nbuf;
+  }
+  else
+  {
+    pa_xfree (transmit_buffer);
+    transmit_buffer = NULL;
+  }
+  transmit_buffer_index = 0;
+  transmit_buffer_length = new_size;
+}
+
+
+/**
+ * Pulseaudio callback when new data is available.
+ */
+static void
+stream_read_callback (pa_stream *s,
+                      size_t length,
+                      void *userdata)
+{
+  const void *data;
+
+  (void) userdata;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Got %u/%d bytes of PCM data\n",
+              (unsigned int) length,
+              pcm_length);
+
+  GNUNET_assert (NULL != s);
+  GNUNET_assert (length > 0);
+  if (stdio_event)
+    mainloop_api->io_enable (stdio_event, PA_IO_EVENT_OUTPUT);
+
+  if (pa_stream_peek (s, (const void **) &data, &length) < 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_stream_peek() failed: %s\n"),
+                pa_strerror (pa_context_errno (context)));
+    quit (1);
+    return;
+  }
+  GNUNET_assert (NULL != data);
+  GNUNET_assert (length > 0);
+  if (NULL != transmit_buffer)
+  {
+    transmit_buffer = pa_xrealloc (transmit_buffer,
+                                   transmit_buffer_length + length);
+    GNUNET_memcpy (&transmit_buffer[transmit_buffer_length],
+                   data,
+                   length);
+    transmit_buffer_length += length;
+  }
+  else
+  {
+    transmit_buffer = pa_xmalloc (length);
+    GNUNET_memcpy (transmit_buffer, data, length);
+    transmit_buffer_length = length;
+    transmit_buffer_index = 0;
+  }
+  pa_stream_drop (s);
+  packetizer ();
+}
+
+
+/**
+ * Exit callback for SIGTERM and SIGINT
+ */
+static void
+exit_signal_callback (pa_mainloop_api *m,
+                      pa_signal_event *e,
+                      int sig,
+                      void *userdata)
+{
+  (void) m;
+  (void) e;
+  (void) sig;
+  (void) userdata;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("Got signal, exiting.\n"));
+  quit (1);
+}
+
+
+/**
+ * Pulseaudio stream state callback
+ */
+static void
+stream_state_callback (pa_stream *s,
+                       void *userdata)
+{
+  (void) userdata;
+  GNUNET_assert (NULL != s);
+  switch (pa_stream_get_state (s))
+  {
+  case PA_STREAM_CREATING:
+  case PA_STREAM_TERMINATED:
+    break;
+
+  case PA_STREAM_READY:
+    {
+      const pa_buffer_attr *a;
+      char cmt[PA_CHANNEL_MAP_SNPRINT_MAX];
+      char sst[PA_SAMPLE_SPEC_SNPRINT_MAX];
+
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Stream successfully created.\n"));
+
+      if (! (a = pa_stream_get_buffer_attr (s)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("pa_stream_get_buffer_attr() failed: %s\n"),
+                    pa_strerror (pa_context_errno
+                                   (pa_stream_get_context (s))));
+      }
+      else
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    _ ("Buffer metrics: maxlength=%u, fragsize=%u\n"),
+                    a->maxlength, a->fragsize);
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Using sample spec '%s', channel map '%s'.\n"),
+                  pa_sample_spec_snprint (sst, sizeof(sst),
+                                          pa_stream_get_sample_spec (s)),
+                  pa_channel_map_snprint (cmt, sizeof(cmt),
+                                          pa_stream_get_channel_map (s)));
+
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Connected to device %s (%u, %ssuspended).\n"),
+                  pa_stream_get_device_name (s),
+                  pa_stream_get_device_index (s),
+                  pa_stream_is_suspended (s) ? "" : "not ");
+    }
+    break;
+
+  case PA_STREAM_FAILED:
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Stream error: %s\n"),
+                pa_strerror (pa_context_errno (pa_stream_get_context (s))));
+    quit (1);
+  }
+}
+
+
+/**
+ * Pulseaudio context state callback
+ */
+static void
+context_state_callback (pa_context *c,
+                        void *userdata)
+{
+  (void) userdata;
+  GNUNET_assert (c);
+
+  switch (pa_context_get_state (c))
+  {
+  case PA_CONTEXT_CONNECTING:
+  case PA_CONTEXT_AUTHORIZING:
+  case PA_CONTEXT_SETTING_NAME:
+    break;
+
+  case PA_CONTEXT_READY:
+    {
+      int r;
+      pa_buffer_attr na;
+
+      GNUNET_assert (! stream_in);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Connection established.\n"));
+      if (! (stream_in =
+               pa_stream_new (c, "GNUNET_VoIP recorder", &sample_spec, NULL)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("pa_stream_new() failed: %s\n"),
+                    pa_strerror (pa_context_errno (c)));
+        goto fail;
+      }
+      pa_stream_set_state_callback (stream_in, &stream_state_callback, NULL);
+      pa_stream_set_read_callback (stream_in, &stream_read_callback, NULL);
+      memset (&na, 0, sizeof(na));
+      na.maxlength = UINT32_MAX;
+      na.fragsize = pcm_length;
+      if ((r = pa_stream_connect_record (stream_in, NULL, &na,
+                                         PA_STREAM_ADJUST_LATENCY)) < 0)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("pa_stream_connect_record() failed: %s\n"),
+                    pa_strerror (pa_context_errno (c)));
+        goto fail;
+      }
+
+      break;
+    }
+
+  case PA_CONTEXT_TERMINATED:
+    quit (0);
+    break;
+
+  case PA_CONTEXT_FAILED:
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Connection failure: %s\n"),
+                pa_strerror (pa_context_errno (c)));
+    goto fail;
+  }
+  return;
+
+fail:
+  quit (1);
+}
+
+
+/**
+ * Pulsaudio init
+ */
+static void
+pa_init ()
+{
+  int r;
+  int i;
+
+  if (! pa_sample_spec_valid (&sample_spec))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Wrong Spec\n"));
+  }
+  /* set up main record loop */
+  if (! (m = pa_mainloop_new ()))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_mainloop_new() failed.\n"));
+  }
+  mainloop_api = pa_mainloop_get_api (m);
+
+  /* listen to signals */
+  r = pa_signal_init (mainloop_api);
+  GNUNET_assert (r == 0);
+  pa_signal_new (SIGINT, &exit_signal_callback, NULL);
+  pa_signal_new (SIGTERM, &exit_signal_callback, NULL);
+
+  /* connect to the main pulseaudio context */
+
+  if (! (context = pa_context_new (mainloop_api, "GNUNET VoIP")))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_context_new() failed.\n"));
+  }
+  pa_context_set_state_callback (context, &context_state_callback, NULL);
+  if (pa_context_connect (context, NULL, 0, NULL) < 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_context_connect() failed: %s\n"),
+                pa_strerror (pa_context_errno (context)));
+  }
+  if (pa_mainloop_run (m, &i) < 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_mainloop_run() failed.\n"));
+  }
+}
+
+
+/**
+ * OPUS init
+ */
+static void
+opus_init ()
+{
+  int err;
+
+  pcm_length = FRAME_SIZE * CHANNELS * sizeof(float);
+  pcm_buffer = pa_xmalloc (pcm_length);
+  opus_data = GNUNET_malloc (MAX_PAYLOAD_BYTES);
+  enc = opus_encoder_create (SAMPLING_RATE,
+                             CHANNELS,
+                             CONV_OPUS_APP_TYPE,
+                             &err);
+  opus_encoder_ctl (enc,
+                    OPUS_SET_PACKET_LOSS_PERC (
+                      CONV_OPUS_PACKET_LOSS_PERCENTAGE));
+  opus_encoder_ctl (enc,
+                    OPUS_SET_COMPLEXITY (CONV_OPUS_ENCODING_COMPLEXITY));
+  opus_encoder_ctl (enc,
+                    OPUS_SET_INBAND_FEC (CONV_OPUS_INBAND_FEC));
+  opus_encoder_ctl (enc,
+                    OPUS_SET_SIGNAL (CONV_OPUS_SIGNAL));
+}
+
+
+static void
+ogg_init ()
+{
+  int serialno;
+  struct OpusHeadPacket headpacket;
+  struct OpusCommentsPacket *commentspacket;
+  size_t commentspacket_len;
+
+  serialno = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG,
+                                       0x7FFFFFFF);
+  /*Initialize Ogg stream struct*/
+  if (-1 == ogg_stream_init (&os, serialno))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("ogg_stream_init() failed.\n"));
+    exit (3);
+  }
+
+  packet_id = 0;
+
+  /*Write header*/
+  {
+    ogg_packet op;
+    ogg_page og;
+    const char *opusver;
+    int vendor_length;
+
+    GNUNET_memcpy (headpacket.magic, "OpusHead", 8);
+    headpacket.version = 1;
+    headpacket.channels = CHANNELS;
+    headpacket.preskip = GNUNET_htole16 (0);
+    headpacket.sampling_rate = GNUNET_htole32 (SAMPLING_RATE);
+    headpacket.gain = GNUNET_htole16 (0);
+    headpacket.channel_mapping = 0; /* Mono or stereo */
+
+    op.packet = (unsigned char *) &headpacket;
+    op.bytes = sizeof(headpacket);
+    op.b_o_s = 1;
+    op.e_o_s = 0;
+    op.granulepos = 0;
+    op.packetno = packet_id++;
+    ogg_stream_packetin (&os, &op);
+
+    /* Head packet must be alone on its page */
+    while (ogg_stream_flush (&os, &og))
+    {
+      write_page (&og);
+    }
+
+    commentspacket_len = sizeof(*commentspacket);
+    opusver = opus_get_version_string ();
+    vendor_length = strlen (opusver);
+    commentspacket_len += vendor_length;
+    commentspacket_len += sizeof(uint32_t);
+
+    commentspacket = (struct OpusCommentsPacket *) malloc (commentspacket_len);
+    if (NULL == commentspacket)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("Failed to allocate %u bytes for second packet\n"),
+                  (unsigned int) commentspacket_len);
+      exit (5);
+    }
+
+    GNUNET_memcpy (commentspacket->magic, "OpusTags", 8);
+    commentspacket->vendor_length = GNUNET_htole32 (vendor_length);
+    GNUNET_memcpy (&commentspacket[1], opusver, vendor_length);
+    *(uint32_t *) &((char *) &commentspacket[1])[vendor_length] = \
+      GNUNET_htole32 (0);    /* no tags */
+
+    op.packet = (unsigned char *) commentspacket;
+    op.bytes = commentspacket_len;
+    op.b_o_s = 0;
+    op.e_o_s = 0;
+    op.granulepos = 0;
+    op.packetno = packet_id++;
+    ogg_stream_packetin (&os, &op);
+
+    /* Comment packets must not be mixed with audio packets on their pages */
+    while (ogg_stream_flush (&os, &og))
+    {
+      write_page (&og);
+    }
+
+    free (commentspacket);
+  }
+}
+
+
+/**
+ * The main function for the record helper.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc,
+      char *argv[])
+{
+  (void) argc;
+  (void) argv;
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_log_setup ("gnunet-helper-audio-record",
+                                   "WARNING",
+                                   NULL));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Audio source starts\n");
+  audio_message = GNUNET_malloc (UINT16_MAX);
+  audio_message->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+
+#ifdef DEBUG_RECORD_PURE_OGG
+  dump_pure_ogg = getenv ("GNUNET_RECORD_PURE_OGG") ? 1 : 0;
+#endif
+  ogg_init ();
+  opus_init ();
+  pa_init ();
+  return 0;
+}
diff --git a/src/contrib/service/conversation/gnunet-service-conversation.c b/src/contrib/service/conversation/gnunet-service-conversation.c
new file mode 100644
index 000000000..06721e535
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-service-conversation.c
@@ -0,0 +1,1461 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2013, 2016, 2017 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/gnunet-service-conversation.c
+ * @brief conversation service implementation
+ * @author Simon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_applications.h"
+#include "gnunet_constants.h"
+#include "gnunet_signatures.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_conversation_service.h"
+#include "conversation.h"
+
+
+/**
+ * How long is our signature on a call valid?  Needs to be long enough for time zone
+ * differences and network latency to not matter.  No strong need for it to be short,
+ * but we simply like all signatures to eventually expire.
+ */
+#define RING_TIMEOUT GNUNET_TIME_UNIT_DAYS
+
+
+/**
+ * A line connects a local client with a cadet channel (or, if it is an
+ * open line, is waiting for a cadet channel).
+ */
+struct Line;
+
+/**
+ * The possible connection status
+ */
+enum ChannelStatus
+{
+  /**
+   * We just got the connection, but no introduction yet.
+   */
+  CS_CALLEE_INIT,
+
+  /**
+   * Our phone is ringing, waiting for the client to pick up.
+   */
+  CS_CALLEE_RINGING,
+
+  /**
+   * We are talking!
+   */
+  CS_CALLEE_CONNECTED,
+
+  /**
+   * We're in shutdown, sending hangup messages before cleaning up.
+   */
+  CS_CALLEE_SHUTDOWN,
+
+  /**
+   * We are waiting for the phone to be picked up.
+   */
+  CS_CALLER_CALLING,
+
+  /**
+   * We are talking!
+   */
+  CS_CALLER_CONNECTED,
+
+  /**
+   * We're in shutdown, sending hangup messages before cleaning up.
+   */
+  CS_CALLER_SHUTDOWN
+};
+
+
+/**
+ * A `struct Channel` represents a cadet channel, which is a P2P
+ * connection to another conversation service.  Multiple channels can
+ * be attached the the same `struct Line`, which represents a local
+ * client.  We keep them in a linked list.
+ */
+struct Channel
+{
+  /**
+   * This is a DLL.
+   */
+  struct Channel *next;
+
+  /**
+   * This is a DLL.
+   */
+  struct Channel *prev;
+
+  /**
+   * Line associated with the channel.
+   */
+  struct Line *line;
+
+  /**
+   * Handle for the channel.
+   */
+  struct GNUNET_CADET_Channel *channel;
+
+  /**
+   * Message queue for control messages
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Temporary buffer for audio data in the @e mq.
+   */
+  struct GNUNET_MQ_Envelope *env;
+
+  /**
+   * Channel identifier we use for this call with the client.
+   */
+  uint32_t cid;
+
+  /**
+   * Current status of this line.
+   */
+  enum ChannelStatus status;
+
+  /**
+   * #GNUNET_YES if the channel was suspended by the other peer.
+   */
+  int8_t suspended_remote;
+
+  /**
+   * #GNUNET_YES if the channel was suspended by the local client.
+   */
+  int8_t suspended_local;
+};
+
+
+/**
+ * A `struct Line` connects a local client with cadet channels.
+ */
+struct Line
+{
+  /**
+   * This is a DLL.
+   */
+  struct Channel *channel_head;
+
+  /**
+   * This is a DLL.
+   */
+  struct Channel *channel_tail;
+
+  /**
+   * Handle to the line client.
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * Message queue for @e client.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Our open port.
+   */
+  struct GNUNET_CADET_Port *port;
+
+  /**
+   * Port number we are listening on (to verify signatures).
+   * Only valid if @e port is non-NULL.
+   */
+  struct GNUNET_HashCode line_port;
+
+  /**
+   * Generator for channel IDs.
+   */
+  uint32_t cid_gen;
+};
+
+
+/**
+ * Our configuration.
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Handle for cadet
+ */
+static struct GNUNET_CADET_Handle *cadet;
+
+/**
+ * Identity of this peer.
+ */
+static struct GNUNET_PeerIdentity my_identity;
+
+
+/**
+ * Given a @a cid, find the corresponding channel given
+ * a @a line.
+ *
+ * @param line a line to search
+ * @param cid what to search for
+ * @return NULL for not found
+ */
+static struct Channel *
+find_channel_by_line (struct Line *line, uint32_t cid)
+{
+  for (struct Channel *ch = line->channel_head; NULL != ch; ch = ch->next)
+    if (cid == ch->cid)
+      return ch;
+  return NULL;
+}
+
+
+/**
+ * Function to handle a pickup request message from the client
+ *
+ * @param cls the `struct Line` of the client from which the message is
+ * @param msg the message from the client
+ */
+static void
+handle_client_pickup_message (void *cls,
+                              const struct ClientPhonePickupMessage *msg)
+{
+  struct Line *line = cls;
+  struct CadetPhonePickupMessage *mppm;
+  struct GNUNET_MQ_Envelope *env;
+  struct Channel *ch;
+
+  if (NULL == line->port)
+  {
+    /* we never opened the port, bad client! */
+    GNUNET_break_op (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  for (ch = line->channel_head; NULL != ch; ch = ch->next)
+    if (msg->cid == ch->cid)
+      break;
+  if (NULL == ch)
+  {
+    /* could have been destroyed asynchronously, ignore message */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_RINGING:
+    ch->status = CS_CALLEE_CONNECTED;
+    break;
+
+  case CS_CALLEE_CONNECTED:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_SHUTDOWN:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Ignoring client's PICKUP message, line is in SHUTDOWN\n");
+    break;
+
+  case CS_CALLER_CALLING:
+  case CS_CALLER_CONNECTED:
+  case CS_CALLER_SHUTDOWN:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  GNUNET_break (CS_CALLEE_CONNECTED == ch->status);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending PICK_UP message to cadet\n");
+  env =
+    GNUNET_MQ_msg (mppm, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP);
+  GNUNET_MQ_send (ch->mq, env);
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+
+/**
+ * Channel went down, notify client and free data
+ * structure.
+ *
+ * @param ch channel that went down
+ */
+static void
+clean_up_channel (struct Channel *ch)
+{
+  struct Line *line = ch->line;
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientPhoneHangupMessage *hup;
+
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+  case CS_CALLEE_SHUTDOWN:
+  case CS_CALLER_SHUTDOWN:
+    break;
+
+  case CS_CALLEE_RINGING:
+  case CS_CALLEE_CONNECTED:
+  case CS_CALLER_CALLING:
+  case CS_CALLER_CONNECTED:
+    if (NULL != line)
+    {
+      env =
+        GNUNET_MQ_msg (hup, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);
+      hup->cid = ch->cid;
+      GNUNET_MQ_send (line->mq, env);
+    }
+    break;
+  }
+  if (NULL != line)
+    GNUNET_CONTAINER_DLL_remove (line->channel_head, line->channel_tail, ch);
+  GNUNET_free (ch);
+}
+
+
+/**
+ * Destroy a channel.
+ *
+ * @param ch channel to destroy.
+ */
+static void
+destroy_line_cadet_channels (struct Channel *ch)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Destroying cadet channels\n");
+  if (NULL != ch->channel)
+  {
+    GNUNET_CADET_channel_destroy (ch->channel);
+    ch->channel = NULL;
+  }
+  clean_up_channel (ch);
+}
+
+
+/**
+ * We are done signalling shutdown to the other peer.  Close down
+ * the channel.
+ *
+ * @param cls the `struct Channel` to reset/terminate
+ */
+static void
+mq_done_finish_caller_shutdown (void *cls)
+{
+  struct Channel *ch = cls;
+
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLEE_RINGING:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLEE_CONNECTED:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    destroy_line_cadet_channels (ch);
+    break;
+
+  case CS_CALLER_CALLING:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLER_CONNECTED:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    destroy_line_cadet_channels (ch);
+    break;
+  }
+}
+
+
+/**
+ * Function to handle a hangup request message from the client
+ *
+ * @param cls the `struct Line` the hangup is for
+ * @param msg the message from the client
+ */
+static void
+handle_client_hangup_message (void *cls,
+                              const struct ClientPhoneHangupMessage *msg)
+{
+  struct Line *line = cls;
+  struct GNUNET_MQ_Envelope *e;
+  struct CadetPhoneHangupMessage *mhum;
+  struct Channel *ch;
+
+  for (ch = line->channel_head; NULL != ch; ch = ch->next)
+    if (msg->cid == ch->cid)
+      break;
+  if (NULL == ch)
+  {
+    /* could have been destroyed asynchronously, ignore message */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received HANGUP for channel %u which is in state %d\n",
+              msg->cid,
+              ch->status);
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_RINGING:
+    ch->status = CS_CALLEE_SHUTDOWN;
+    break;
+
+  case CS_CALLEE_CONNECTED:
+    ch->status = CS_CALLEE_SHUTDOWN;
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    /* maybe the other peer closed asynchronously... */
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+
+  case CS_CALLER_CALLING:
+    ch->status = CS_CALLER_SHUTDOWN;
+    break;
+
+  case CS_CALLER_CONNECTED:
+    ch->status = CS_CALLER_SHUTDOWN;
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    /* maybe the other peer closed asynchronously... */
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending HANG_UP message via cadet\n");
+  e =
+    GNUNET_MQ_msg (mhum, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP);
+  GNUNET_MQ_notify_sent (e, &mq_done_finish_caller_shutdown, ch);
+  GNUNET_MQ_send (ch->mq, e);
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+
+/**
+ * Function to handle a suspend request message from the client
+ *
+ * @param cls the `struct Line` the message is about
+ * @param msg the message from the client
+ */
+static void
+handle_client_suspend_message (void *cls,
+                               const struct ClientPhoneSuspendMessage *msg)
+{
+  struct Line *line = cls;
+  struct GNUNET_MQ_Envelope *e;
+  struct CadetPhoneSuspendMessage *mhum;
+  struct Channel *ch;
+
+  for (ch = line->channel_head; NULL != ch; ch = ch->next)
+    if (msg->cid == ch->cid)
+      break;
+  if (NULL == ch)
+  {
+    /* could have been destroyed asynchronously, ignore message */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  if (GNUNET_YES == ch->suspended_local)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received SUSPEND for channel %u which is in state %d\n",
+              msg->cid,
+              ch->status);
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_RINGING:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_CONNECTED:
+    ch->suspended_local = GNUNET_YES;
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    /* maybe the other peer closed asynchronously... */
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+
+  case CS_CALLER_CALLING:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLER_CONNECTED:
+    ch->suspended_local = GNUNET_YES;
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    /* maybe the other peer closed asynchronously... */
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUSPEND message via cadet\n");
+  e =
+    GNUNET_MQ_msg (mhum, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND);
+  GNUNET_MQ_send (ch->mq, e);
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+
+/**
+ * Function to handle a resume request message from the client
+ *
+ * @param cls the `struct Line` the message is about
+ * @param msg the message from the client
+ */
+static void
+handle_client_resume_message (void *cls,
+                              const struct ClientPhoneResumeMessage *msg)
+{
+  struct Line *line = cls;
+  struct GNUNET_MQ_Envelope *e;
+  struct CadetPhoneResumeMessage *mhum;
+  struct Channel *ch;
+
+  for (ch = line->channel_head; NULL != ch; ch = ch->next)
+    if (msg->cid == ch->cid)
+      break;
+  if (NULL == ch)
+  {
+    /* could have been destroyed asynchronously, ignore message */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  if (GNUNET_YES != ch->suspended_local)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received RESUME for channel %u which is in state %d\n",
+              msg->cid,
+              ch->status);
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_RINGING:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_CONNECTED:
+    ch->suspended_local = GNUNET_NO;
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    /* maybe the other peer closed asynchronously... */
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+
+  case CS_CALLER_CALLING:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLER_CONNECTED:
+    ch->suspended_local = GNUNET_NO;
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    /* maybe the other peer closed asynchronously... */
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending RESUME message via cadet\n");
+  e = GNUNET_MQ_msg (mhum, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME);
+  GNUNET_MQ_send (ch->mq, e);
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+
+/**
+ * Transmission of audio data via cadet channel finished.
+ *
+ * @param cls the `struct Channel` we are transmitting for
+ */
+static void
+channel_audio_sent_notify (void *cls)
+{
+  struct Channel *ch = cls;
+
+  ch->env = NULL;
+}
+
+
+/**
+ * Function to check audio data from the client
+ *
+ * @param cls the `struct Line` the message is about
+ * @param msg the message from the client
+ * @return #GNUNET_OK (any data is ok)
+ */
+static int
+check_client_audio_message (void *cls, const struct ClientAudioMessage *msg)
+{
+  (void) cls;
+  (void) msg;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function to handle audio data from the client
+ *
+ * @param cls the `struct Line` the message is about
+ * @param msg the message from the client
+ */
+static void
+handle_client_audio_message (void *cls, const struct ClientAudioMessage *msg)
+{
+  struct Line *line = cls;
+  struct CadetAudioMessage *mam;
+  struct Channel *ch;
+  size_t size;
+
+  size = ntohs (msg->header.size) - sizeof(struct ClientAudioMessage);
+  ch = find_channel_by_line (line, msg->cid);
+  if (NULL == ch)
+  {
+    /* could have been destroyed asynchronously, ignore message */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+  case CS_CALLEE_RINGING:
+  case CS_CALLER_CALLING:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_CONNECTED:
+  case CS_CALLER_CONNECTED:
+    /* common case, handled below */
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+  case CS_CALLER_SHUTDOWN:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+                "Cadet audio channel in shutdown; audio data dropped\n");
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  if (GNUNET_YES == ch->suspended_local)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "This channel is suspended locally\n");
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  if (NULL != ch->env)
+  {
+    /* NOTE: we may want to not do this and instead combine the data */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Bandwidth insufficient; dropping previous audio data segment\n");
+    GNUNET_MQ_send_cancel (ch->env);
+    ch->env = NULL;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received %u bytes of AUDIO data from client CID %u\n",
+              (unsigned int) size,
+              msg->cid);
+  ch->env = GNUNET_MQ_msg_extra (mam,
+                                 size,
+                                 GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO);
+  GNUNET_memcpy (&mam[1], &msg[1], size);
+  /* FIXME: set options for unreliable transmission */
+  GNUNET_MQ_notify_sent (ch->env, &channel_audio_sent_notify, ch);
+  GNUNET_MQ_send (ch->mq, ch->env);
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+/**
+ * Function to handle a ring message incoming over cadet
+ *
+ * @param cls closure, NULL
+ * @param msg the incoming message
+ */
+static enum GNUNET_GenericReturnValue
+check_cadet_ring_message (void *cls, const struct CadetPhoneRingMessage *msg)
+{
+  // FIXME
+  return GNUNET_OK;
+}
+
+/**
+ * Function to handle a ring message incoming over cadet
+ *
+ * @param cls closure, NULL
+ * @param msg the incoming message
+ */
+static void
+handle_cadet_ring_message (void *cls, const struct CadetPhoneRingMessage *msg)
+{
+  struct Channel *ch = cls;
+  struct Line *line = ch->line;
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientPhoneRingMessage *cring;
+  struct CadetPhoneRingInfoPS rs;
+  struct GNUNET_CRYPTO_PublicKey identity;
+  struct GNUNET_CRYPTO_Signature sig;
+  size_t key_len;
+  size_t sig_len;
+  size_t read;
+
+  rs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING);
+  rs.purpose.size = htonl (sizeof(struct CadetPhoneRingInfoPS));
+  rs.line_port = line->line_port;
+  rs.target_peer = my_identity;
+  rs.expiration_time = msg->expiration_time;
+  key_len = ntohl (msg->key_len);
+  sig_len = ntohl (msg->sig_len);
+
+  if ((GNUNET_SYSERR ==
+       GNUNET_CRYPTO_read_public_key_from_buffer (&msg[1],
+                                                    key_len,
+                                                    &identity,
+                                                    &read)) ||
+      (read != key_len))
+  {
+    GNUNET_break_op (0);
+    destroy_line_cadet_channels (ch);
+    return;
+  }
+  GNUNET_CRYPTO_read_signature_from_buffer (&sig,
+                                              (char*) &msg[1] + read,
+                                              sig_len);
+  if (GNUNET_OK !=
+      GNUNET_CRYPTO_signature_verify (
+        GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING,
+        &rs,
+        &sig,
+        &identity))
+  {
+    GNUNET_break_op (0);
+    destroy_line_cadet_channels (ch);
+    return;
+  }
+  if (0 == GNUNET_TIME_absolute_get_remaining (
+        GNUNET_TIME_absolute_ntoh (msg->expiration_time))
+      .rel_value_us)
+  {
+    /* ancient call, replay? */
+    GNUNET_break_op (0);
+    /* Note that our reliance on time here is awkward; better would be
+       to use a more complex challenge-response protocol against
+       replay attacks.  Left for future work ;-). */
+    destroy_line_cadet_channels (ch);
+    return;
+  }
+  if (CS_CALLEE_INIT != ch->status)
+  {
+    GNUNET_break_op (0);
+    destroy_line_cadet_channels (ch);
+    return;
+  }
+  GNUNET_CADET_receive_done (ch->channel);
+  ch->status = CS_CALLEE_RINGING;
+  env = GNUNET_MQ_msg_extra (cring,
+                             key_len,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING);
+  cring->cid = ch->cid;
+  memcpy (&cring[1], &msg[1], key_len);
+  cring->key_len = msg->key_len;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending RING message to client. CID is %u\n",
+              (unsigned int) ch->cid);
+  GNUNET_MQ_send (line->mq, env);
+}
+
+
+/**
+ * Function to handle a hangup message incoming over cadet
+ *
+ * @param cls closure, our `struct Channel *`
+ * @param message the incoming message
+ */
+static void
+handle_cadet_hangup_message (void *cls,
+                             const struct CadetPhoneHangupMessage *message)
+{
+  struct Channel *ch = cls;
+  struct Line *line = ch->line;
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientPhoneHangupMessage *hup;
+  enum ChannelStatus status;
+  uint32_t cid;
+
+  (void) message;
+  GNUNET_CADET_receive_done (ch->channel);
+  cid = ch->cid;
+  status = ch->status;
+  destroy_line_cadet_channels (ch);
+  switch (status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break_op (0);
+    return;
+
+  case CS_CALLEE_RINGING:
+  case CS_CALLEE_CONNECTED:
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    return;
+
+  case CS_CALLER_CALLING:
+  case CS_CALLER_CONNECTED:
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending HANG UP message to client\n");
+  env = GNUNET_MQ_msg (hup, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);
+  hup->cid = cid;
+  GNUNET_MQ_send (line->mq, env);
+}
+
+
+/**
+ * Function to handle a pickup message incoming over cadet
+ *
+ * @param cls closure, our `struct Channel *`
+ * @param message the incoming message
+ */
+static void
+handle_cadet_pickup_message (void *cls,
+                             const struct CadetPhonePickupMessage *message)
+{
+  struct Channel *ch = cls;
+  struct Line *line = ch->line;
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientPhonePickedupMessage *pick;
+
+  (void) message;
+  GNUNET_CADET_receive_done (ch->channel);
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+  case CS_CALLEE_RINGING:
+  case CS_CALLEE_CONNECTED:
+    GNUNET_break_op (0);
+    destroy_line_cadet_channels (ch);
+    return;
+
+  case CS_CALLEE_SHUTDOWN:
+    GNUNET_break_op (0);
+    destroy_line_cadet_channels (ch);
+    return;
+
+  case CS_CALLER_CALLING:
+    ch->status = CS_CALLER_CONNECTED;
+    break;
+
+  case CS_CALLER_CONNECTED:
+    GNUNET_break_op (0);
+    return;
+
+  case CS_CALLER_SHUTDOWN:
+    GNUNET_break_op (0);
+    mq_done_finish_caller_shutdown (ch);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending PICKED UP message to client\n");
+  env =
+    GNUNET_MQ_msg (pick, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP);
+  pick->cid = ch->cid;
+  GNUNET_MQ_send (line->mq, env);
+}
+
+
+/**
+ * Function to handle a suspend message incoming over cadet
+ *
+ * @param cls closure, our `struct Channel *`
+ * @param message the incoming message
+ */
+static void
+handle_cadet_suspend_message (void *cls,
+                              const struct CadetPhoneSuspendMessage *message)
+{
+  struct Channel *ch = cls;
+  struct Line *line = ch->line;
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientPhoneSuspendMessage *suspend;
+
+  (void) message;
+  GNUNET_CADET_receive_done (ch->channel);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Suspending channel CID: %u\n", ch->cid);
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_CALLEE_RINGING:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_CALLEE_CONNECTED:
+    ch->suspended_remote = GNUNET_YES;
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    return;
+
+  case CS_CALLER_CALLING:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_CALLER_CONNECTED:
+    ch->suspended_remote = GNUNET_YES;
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    return;
+  }
+  env =
+    GNUNET_MQ_msg (suspend, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND);
+  suspend->cid = ch->cid;
+  GNUNET_MQ_send (line->mq, env);
+}
+
+
+/**
+ * Function to handle a resume message incoming over cadet
+ *
+ * @param cls closure, our `struct Channel *`
+ * @param msg the incoming message
+ */
+static void
+handle_cadet_resume_message (void *cls,
+                             const struct CadetPhoneResumeMessage *msg)
+{
+  struct Channel *ch = cls;
+  struct Line *line;
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientPhoneResumeMessage *resume;
+
+  (void) msg;
+  line = ch->line;
+  GNUNET_CADET_receive_done (ch->channel);
+  if (GNUNET_YES != ch->suspended_remote)
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_DEBUG,
+      "RESUME message received for non-suspended channel, dropping channel.\n");
+    destroy_line_cadet_channels (ch);
+    return;
+  }
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLEE_RINGING:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLEE_CONNECTED:
+    ch->suspended_remote = GNUNET_NO;
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    return;
+
+  case CS_CALLER_CALLING:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLER_CONNECTED:
+    ch->suspended_remote = GNUNET_NO;
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    return;
+  }
+  env =
+    GNUNET_MQ_msg (resume, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME);
+  resume->cid = ch->cid;
+  GNUNET_MQ_send (line->mq, env);
+}
+
+
+/**
+ * Function to check an audio message incoming over cadet
+ *
+ * @param cls closure, our `struct Channel *`
+ * @param msg the incoming message
+ * @return #GNUNET_OK (always)
+ */
+static int
+check_cadet_audio_message (void *cls, const struct CadetAudioMessage *msg)
+{
+  (void) cls;
+  (void) msg;
+  return GNUNET_OK; /* any payload is fine */
+}
+
+
+/**
+ * Function to handle an audio message incoming over cadet
+ *
+ * @param cls closure, our `struct Channel *`
+ * @param msg the incoming message
+ */
+static void
+handle_cadet_audio_message (void *cls, const struct CadetAudioMessage *msg)
+{
+  struct Channel *ch = cls;
+  size_t msize = ntohs (msg->header.size) - sizeof(struct CadetAudioMessage);
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientAudioMessage *cam;
+
+  GNUNET_CADET_receive_done (ch->channel);
+  if ((GNUNET_YES == ch->suspended_local) ||
+      (GNUNET_YES == ch->suspended_remote))
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_DEBUG,
+      "Received %u bytes of AUDIO data on suspended channel CID %u; dropping\n",
+      (unsigned int) msize,
+      ch->cid);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Forwarding %u bytes of AUDIO data to client CID %u\n",
+              (unsigned int) msize,
+              ch->cid);
+  env =
+    GNUNET_MQ_msg_extra (cam, msize, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO);
+  cam->cid = ch->cid;
+  GNUNET_memcpy (&cam[1], &msg[1], msize);
+  GNUNET_MQ_send (ch->line->mq, env);
+}
+
+
+/**
+ * Function called whenever an inbound channel is destroyed.  Should clean up
+ * any associated state.
+ *
+ * @param cls closure (set from #GNUNET_CADET_connect)
+ * @param channel connection to the other end (henceforth invalid)
+ */
+static void
+inbound_end (void *cls, const struct GNUNET_CADET_Channel *channel)
+{
+  struct Channel *ch = cls;
+
+  GNUNET_assert (channel == ch->channel);
+  ch->channel = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Channel destroyed by CADET in state %d\n",
+              ch->status);
+  clean_up_channel (ch);
+}
+
+/**
+ * Function to handle call request from the client
+ *
+ * @param cls the `struct Line` the message is about
+ * @param msg the message from the client
+ */
+static enum GNUNET_GenericReturnValue
+check_client_call_message (void *cls, const struct ClientCallMessage *msg)
+{
+  // FIXME
+  return GNUNET_OK;
+}
+
+/**
+ * Function to handle call request from the client
+ *
+ * @param cls the `struct Line` the message is about
+ * @param msg the message from the client
+ */
+static void
+handle_client_call_message (void *cls, const struct ClientCallMessage *msg)
+{
+  struct Line *line = cls;
+  struct Channel *ch = GNUNET_new (struct Channel);
+  struct GNUNET_MQ_MessageHandler cadet_handlers[] =
+  { GNUNET_MQ_hd_fixed_size (cadet_hangup_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP,
+                             struct CadetPhoneHangupMessage,
+                             ch),
+    GNUNET_MQ_hd_fixed_size (cadet_pickup_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP,
+                             struct CadetPhonePickupMessage,
+                             ch),
+    GNUNET_MQ_hd_fixed_size (cadet_suspend_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND,
+                             struct CadetPhoneSuspendMessage,
+                             ch),
+    GNUNET_MQ_hd_fixed_size (cadet_resume_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME,
+                             struct CadetPhoneResumeMessage,
+                             ch),
+    GNUNET_MQ_hd_var_size (cadet_audio_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO,
+                           struct CadetAudioMessage,
+                           ch),
+    GNUNET_MQ_handler_end () };
+  struct GNUNET_MQ_Envelope *e;
+  struct CadetPhoneRingMessage *ring;
+  struct CadetPhoneRingInfoPS rs;
+  struct GNUNET_CRYPTO_PrivateKey caller_id;
+  struct GNUNET_CRYPTO_PublicKey caller_id_pub;
+  struct GNUNET_CRYPTO_Signature sig;
+  ssize_t written;
+  size_t key_len;
+  size_t pkey_len;
+  size_t sig_len;
+  size_t read;
+
+  line->line_port = msg->line_port;
+  rs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING);
+  rs.purpose.size = htonl (sizeof(struct CadetPhoneRingInfoPS));
+  rs.line_port = line->line_port;
+  rs.target_peer = msg->target;
+  rs.expiration_time =
+    GNUNET_TIME_absolute_hton (GNUNET_TIME_relative_to_absolute (RING_TIMEOUT));
+  key_len = ntohl (msg->key_len);
+  if (GNUNET_SYSERR ==
+      GNUNET_CRYPTO_read_private_key_from_buffer (&msg[1],
+                                                    key_len,
+                                                    &caller_id,
+                                                    &read))
+  {
+    GNUNET_break_op (0);
+    GNUNET_free (ch);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  ch->line = line;
+  GNUNET_CONTAINER_DLL_insert (line->channel_head, line->channel_tail, ch);
+  ch->status = CS_CALLER_CALLING;
+  ch->channel = GNUNET_CADET_channel_create (cadet,
+                                             ch,
+                                             &msg->target,
+                                             &msg->line_port,
+                                             NULL,
+                                             &inbound_end,
+                                             cadet_handlers);
+  ch->mq = GNUNET_CADET_get_mq (ch->channel);
+  GNUNET_assert (read == key_len);
+  GNUNET_CRYPTO_sign (&caller_id, &rs, &sig);
+  sig_len = GNUNET_CRYPTO_signature_get_length (&sig);
+  GNUNET_CRYPTO_key_get_public (&caller_id, &caller_id_pub);
+  pkey_len = GNUNET_CRYPTO_public_key_get_length (&caller_id_pub);
+  e = GNUNET_MQ_msg_extra (ring, pkey_len + sig_len,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING);
+  written = GNUNET_CRYPTO_write_public_key_to_buffer (&caller_id_pub,
+                                                        &ring[1],
+                                                        pkey_len);
+  ring->expiration_time = rs.expiration_time;
+  ring->key_len = htonl (pkey_len);
+  ring->sig_len = htonl (sig_len);
+  GNUNET_CRYPTO_write_signature_to_buffer (&sig,
+                                             (char *) &ring[1] + written,
+                                             sig_len);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending RING message via CADET\n");
+  GNUNET_MQ_send (ch->mq, e);
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+
+/**
+ * Method called whenever another peer has added us to a channel
+ * the other peer initiated.
+ *
+ * @param cls the `struct Line` receiving a connection
+ * @param channel new handle to the channel
+ * @param initiator peer that started the channel
+ * @return initial channel context for the channel
+ */
+static void *
+inbound_channel (void *cls,
+                 struct GNUNET_CADET_Channel *channel,
+                 const struct GNUNET_PeerIdentity *initiator)
+{
+  struct Line *line = cls;
+  struct Channel *ch;
+
+  (void) initiator;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received incoming cadet channel on line %p\n",
+              line);
+  ch = GNUNET_new (struct Channel);
+  ch->status = CS_CALLEE_INIT;
+  ch->line = line;
+  ch->channel = channel;
+  ch->mq = GNUNET_CADET_get_mq (ch->channel);
+  ch->cid = line->cid_gen++;
+  GNUNET_CONTAINER_DLL_insert (line->channel_head, line->channel_tail, ch);
+  return ch;
+}
+
+
+/**
+ * A client connected.  Initialize the `struct Line` data structure.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param mq message queue for @a client
+ * @return the `struct Line` for the client
+ */
+static void *
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
+{
+  struct Line *line;
+
+  (void) cls;
+  line = GNUNET_new (struct Line);
+  line->client = client;
+  line->mq = mq;
+  return line;
+}
+
+
+/**
+ * A client disconnected.  Remove all of its data structure entries.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param app_ctx our `struct Line *` for @a client
+ */
+static void
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_ctx)
+{
+  struct Line *line = app_ctx;
+  struct Channel *chn;
+
+  (void) cls;
+  (void) client;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client disconnected, closing line\n");
+  if (NULL != line->port)
+  {
+    GNUNET_CADET_close_port (line->port);
+    line->port = NULL;
+  }
+  for (struct Channel *ch = line->channel_head; NULL != ch; ch = chn)
+  {
+    chn = ch->next;
+    ch->line = NULL;
+    destroy_line_cadet_channels (ch);
+  }
+  GNUNET_free (line);
+}
+
+
+/**
+ * Function to register a phone.
+ *
+ * @param cls the `struct Line` of the client from which the message is
+ * @param msg the message from the client
+ */
+static void
+handle_client_register_message (void *cls,
+                                const struct ClientPhoneRegisterMessage *msg)
+{
+  struct Line *line = cls;
+  struct GNUNET_MQ_MessageHandler cadet_handlers[] =
+  { GNUNET_MQ_hd_var_size (cadet_ring_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING,
+                           struct CadetPhoneRingMessage,
+                           NULL),
+    GNUNET_MQ_hd_fixed_size (cadet_hangup_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP,
+                             struct CadetPhoneHangupMessage,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (cadet_pickup_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP,
+                             struct CadetPhonePickupMessage,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (cadet_suspend_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND,
+                             struct CadetPhoneSuspendMessage,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (cadet_resume_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME,
+                             struct CadetPhoneResumeMessage,
+                             NULL),
+    GNUNET_MQ_hd_var_size (cadet_audio_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO,
+                           struct CadetAudioMessage,
+                           NULL),
+    GNUNET_MQ_handler_end () };
+
+  line->line_port = msg->line_port;
+  line->port = GNUNET_CADET_open_port (cadet,
+                                       &msg->line_port,
+                                       &inbound_channel,
+                                       line,
+                                       NULL,
+                                       &inbound_end,
+                                       cadet_handlers);
+  if (NULL == line->port)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Could not open line, port %s already in use!\n"),
+                GNUNET_h2s (&msg->line_port));
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+
+/**
+ * Shutdown nicely
+ *
+ * @param cls closure, NULL
+ */
+static void
+do_shutdown (void *cls)
+{
+  (void) cls;
+  if (NULL != cadet)
+  {
+    GNUNET_CADET_disconnect (cadet);
+    cadet = NULL;
+  }
+}
+
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure
+ * @param c configuration
+ * @param service service handle
+ */
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_SERVICE_Handle *service)
+{
+  (void) cls;
+  (void) service;
+  cfg = c;
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CRYPTO_get_peer_identity (cfg, &my_identity));
+  cadet = GNUNET_CADET_connect (cfg);
+  if (NULL == cadet)
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+}
+
+
+/**
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN (
+  "conversation",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_fixed_size (client_register_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER,
+                           struct ClientPhoneRegisterMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_pickup_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICK_UP,
+                           struct ClientPhonePickupMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_suspend_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND,
+                           struct ClientPhoneSuspendMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_resume_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME,
+                           struct ClientPhoneResumeMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_hangup_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP,
+                           struct ClientPhoneHangupMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (client_call_message,
+                         GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL,
+                         struct ClientCallMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (client_audio_message,
+                         GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO,
+                         struct ClientAudioMessage,
+                         NULL),
+  GNUNET_MQ_handler_end ());
+
+
+/* end of gnunet-service-conversation.c */
diff --git a/src/contrib/service/conversation/gnunet_gst.c b/src/contrib/service/conversation/gnunet_gst.c
new file mode 100644
index 000000000..48d41a457
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet_gst.c
@@ -0,0 +1,1154 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2016 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/gnunet_gst.c
+ * @brief FIXME
+ * @author Hark
+ */
+#include "platform.h"
+#include "gnunet_gst_def.h"
+
+/**
+ * Our configuration.
+ */
+static struct GNUNET_CONFIGURATION_Handle *cfg;
+
+
+void
+dump_buffer (unsigned n, const unsigned char*buf)
+{
+  const unsigned char *p, *end;
+  unsigned i, j;
+
+  end = buf + n;
+
+  for (i = 0;; i += 16)
+  {
+    p = buf + i;
+    for (j = 0; j < 16; j++)
+    {
+      fprintf (stderr, "%02X ", p[j]);
+      if (p + j >= end)
+        goto BREAKOUT;
+    }
+    fprintf (stderr, " ");
+    p = buf + i;
+    for (j = 0; j < 16; j++)
+    {
+      fprintf (stderr, "%c", isprint (p[j]) ? p[j] :
+               '.');
+      if (p + j >= end)
+        goto BREAKOUT;
+    }
+    fprintf (stderr, "\n");
+  }
+BREAKOUT:
+  return;
+}
+
+
+/***
+ * load gnunet configuration
+ */
+void
+gg_load_configuration (GNUNET_gstData *d)
+{
+  char *audiobackend_string;
+
+  cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_CONFIGURATION_load (cfg, "mediahelper.conf");
+
+  GNUNET_CONFIGURATION_get_value_string (cfg, "MEDIAHELPER", "JACK_PP_IN",
+                                         &d->jack_pp_in);
+  GNUNET_CONFIGURATION_get_value_string (cfg, "MEDIAHELPER", "JACK_PP_OUT",
+                                         &d->jack_pp_out);
+
+  GNUNET_CONFIGURATION_get_value_string (cfg, "MEDIAHELPER", "AUDIOBACKEND",
+                                         &audiobackend_string);
+
+  // printf("abstring: %s \n", audiobackend_string);
+
+  if (0 == strcasecmp (audiobackend_string, "AUTO"))
+  {
+    d->audiobackend = AUTO;
+  }
+  else if (0 == strcasecmp (audiobackend_string, "JACK"))
+  {
+    d->audiobackend = JACK;
+  }
+  else if (0 == strcasecmp (audiobackend_string, "ALSA"))
+  {
+    d->audiobackend = ALSA;
+  }
+  else if (0 == strcasecmp (audiobackend_string, "FAKE"))
+  {
+    d->audiobackend = FAKE;
+  }
+  else if (0 == strcasecmp (audiobackend_string, "TEST"))
+  {
+    d->audiobackend = TEST;
+  }
+  else
+  {
+    d->audiobackend = AUTO;
+  }
+
+  if (GNUNET_CONFIGURATION_get_value_yesno (cfg, "MEDIAHELPER",
+                                            "REMOVESILENCE") == GNUNET_YES)
+  {
+    d->dropsilence = TRUE;
+  }
+  else
+  {
+    d->dropsilence = FALSE;
+  }
+
+  if (GNUNET_CONFIGURATION_get_value_yesno (cfg, "MEDIAHELPER",
+                                            "NO_GN_HEADERS") == GNUNET_YES)
+  {
+    d->pure_ogg = TRUE;
+  }
+  else
+  {
+    d->pure_ogg = FALSE;
+  }
+
+
+  if (GNUNET_CONFIGURATION_get_value_yesno (cfg, "MEDIAHELPER", "USERTP") ==
+      GNUNET_YES)
+  {
+    d->usertp = TRUE;
+  }
+  else
+  {
+    d->usertp = FALSE;
+  }
+
+//  GNUNET_CONFIGURATION_write(cfg, "mediahelper.conf");
+}
+
+
+static void
+write_data (const char *ptr, size_t msg_size)
+{
+  ssize_t ret;
+  size_t off;
+
+  off = 0;
+  while (off < msg_size)
+  {
+    ret = write (1, &ptr[off], msg_size - off);
+    if (0 >= ret)
+    {
+      if (-1 == ret)
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "write");
+//      quit (2);
+    }
+    off += ret;
+  }
+}
+
+
+extern GstFlowReturn
+on_appsink_new_sample (GstElement *element, GNUNET_gstData *d)
+{
+  // size of message including gnunet header
+  size_t msg_size;
+
+  GstSample *s;
+  GstBuffer *b;
+  GstMapInfo map;
+
+/*
+   const GstStructure *si;
+   char *si_str;
+   GstCaps *s_caps;
+   char *caps_str;
+ */if (gst_app_sink_is_eos (GST_APP_SINK (element)))
+    return GST_FLOW_OK;
+
+  // pull sample from appsink
+  s = gst_app_sink_pull_sample (GST_APP_SINK (element));
+
+  if (s == NULL)
+    return GST_FLOW_OK;
+
+  if (! GST_IS_SAMPLE (s))
+    return GST_FLOW_OK;
+
+  b = gst_sample_get_buffer (s);
+
+  GST_WARNING ("caps are %" GST_PTR_FORMAT, gst_sample_get_caps (s));
+
+
+  gst_buffer_map (b, &map, GST_MAP_READ);
+
+  size_t len;
+  len = map.size;
+  if (len > UINT16_MAX - sizeof(struct AudioMessage))
+  {
+    // this should never happen?
+    printf ("GSTREAMER sample too big! \n");
+    exit (20);
+    len = UINT16_MAX - sizeof(struct AudioMessage);
+  }
+
+  msg_size = sizeof(struct AudioMessage) + len;
+
+  // copy the data into audio_message
+  GNUNET_memcpy (((char *) &(d->audio_message)[1]), map.data, len);
+  (d->audio_message)->header.size = htons ((uint16_t) msg_size);
+  if (d->pure_ogg)
+    // write the audio_message without the gnunet headers
+    write_data ((const char *) &(d->audio_message)[1], len);
+  else
+    write_data ((const char *) d->audio_message, msg_size);
+
+  gst_sample_unref (s);
+  return GST_FLOW_OK;
+}
+
+
+/***
+ * Dump a pipeline graph
+ */
+extern void
+pl_graph (GstElement *pipeline)
+{
+#ifdef IS_SPEAKER
+  gst_debug_bin_to_dot_file_with_ts (GST_BIN (pipeline),
+                                     GST_DEBUG_GRAPH_SHOW_ALL,
+                                     "playback_helper.dot");
+#endif
+#ifdef IS_MIC
+  gst_debug_bin_to_dot_file_with_ts (GST_BIN (pipeline),
+                                     GST_DEBUG_GRAPH_SHOW_ALL,
+                                     "record_helper.dot");
+#endif
+
+
+  //  load_configuration();
+}
+
+
+extern gboolean
+gnunet_gst_bus_call (GstBus *bus, GstMessage *msg, gpointer data)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Bus message\n");
+  switch (GST_MESSAGE_TYPE (msg))
+  {
+  case GST_MESSAGE_EOS:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "End of stream\n");
+    exit (10);
+    break;
+
+  case GST_MESSAGE_ERROR:
+    {
+      gchar  *debug;
+      GError *error;
+
+      gst_message_parse_error (msg, &error, &debug);
+      g_free (debug);
+
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Error: %s\n",
+                  error->message);
+      g_error_free (error);
+
+      exit (10);
+      break;
+    }
+
+  default:
+    break;
+  }
+
+  return TRUE;
+}
+
+
+/* called when pipeline changes state */
+extern void
+state_changed_cb (GstBus *bus, GstMessage *msg, GNUNET_gstData *d)
+{
+  GstState old_state, new_state, pending_state;
+
+  gst_message_parse_state_changed (msg, &old_state, &new_state,
+                                   &pending_state);
+  switch (new_state)
+  {
+  case GST_STATE_READY:
+//      printf("ready.... \n");
+    // pl_graph(GST_ELEMENT(d->pipeline));
+    break;
+
+  case GST_STATE_PLAYING:
+
+    // GST_LOG ("caps are %" GST_PTR_FORMAT, caps);
+
+    //     printf("Playing.... \n");
+    pl_graph (GST_ELEMENT (d->pipeline));
+    break;
+
+  case GST_STATE_VOID_PENDING:
+    //   printf("void_pending.... \n");
+    // pl_graph(GST_ELEMENT(d->pipeline));
+    break;
+
+  case GST_STATE_NULL:
+    //  printf("null.... \n");
+    // pl_graph(GST_ELEMENT(d->pipeline));
+    break;
+
+  case GST_STATE_PAUSED:
+    //     printf("paused.... \n");
+    // pl_graph(GST_ELEMENT(d->pipeline));
+    break;
+  }
+}
+
+
+static void
+application_cb (GstBus *bus, GstMessage *msg, GNUNET_gstData *data)
+{
+  // printf("application cb");
+  return;
+}
+
+
+static void
+error_cb (GstBus *bus, GstMessage *msg, GNUNET_gstData *data)
+{
+  // printf("error cb");
+  return;
+}
+
+
+static void
+eos_cb (GstBus *bus, GstMessage *msg, GNUNET_gstData *data)
+{
+  // printf("eos cb");
+  return;
+}
+
+
+extern void
+gg_setup_gst_bus (GNUNET_gstData *d)
+{
+  GstBus *bus;
+
+  bus = gst_element_get_bus (GST_ELEMENT (d->pipeline));
+  gst_bus_add_signal_watch (bus);
+  g_signal_connect (G_OBJECT (bus), "message::error", (GCallback) error_cb,
+                    d);
+  g_signal_connect (G_OBJECT (bus), "message::eos", (GCallback) eos_cb,
+                    d);
+  g_signal_connect (G_OBJECT (bus), "message::state-changed",
+                    (GCallback) state_changed_cb, d);
+  g_signal_connect (G_OBJECT (bus), "message::application",
+                    (GCallback) application_cb, d);
+  g_signal_connect (G_OBJECT (bus), "message::about-to-finish",
+                    (GCallback) application_cb, d);
+  gst_object_unref (bus);
+}
+
+
+/*
+ * take buffer from gstreamer and feed it to gnunet
+ */
+/*
+   extern int
+   feed_buffer_to_gnunet (GNUNET_gstData * d)
+   {
+   GstSample *s;
+   GstBuffer *b;
+   GstMapInfo m;
+   size_t len, msg_size;
+   const char *ptr;
+   int phase;
+
+   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "pulling...\n");
+   s = gst_app_sink_pull_sample (GST_APP_SINK(d->appsink));
+   if (NULL == s)
+   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "pulled NULL\n");
+    return OK;
+   }
+   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "...pulled!\n");
+
+    const GstStructure *si;
+    char *si_str;
+    GstCaps *s_caps;
+    char *caps_str;
+    si = gst_sample_get_info (s);
+    if (si)
+    {
+      si_str = gst_structure_to_string (si);
+      if (si_str)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample %s\n", si_str);
+        g_free (si_str);
+      }
+    }
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample with no info\n");
+    s_caps = gst_sample_get_caps (s);
+    if (s_caps)
+    {
+      caps_str = gst_caps_to_string (s_caps);
+      if (caps_str)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample with caps %s\n", caps_str);
+        g_free (caps_str);
+      }
+    }
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample with no caps\n");
+
+   b = gst_sample_get_buffer (s);
+   if (NULL == b || !gst_buffer_map (b, &m, GST_MAP_READ))
+   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got NULL buffer %p or failed to map the buffer\n", b);
+    gst_sample_unref (s);
+    return FAIL;
+   }
+
+   len = m.size;
+   if (len > UINT16_MAX - sizeof (struct AudioMessage))
+   {
+    GNUNET_break (0);
+    len = UINT16_MAX - sizeof (struct AudioMessage);
+   }
+   msg_size = sizeof (struct AudioMessage) + len;
+   audio_message.header.size = htons ((uint16_t) msg_size);
+
+
+   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+      "Sending %u bytes of audio data\n", (unsigned int) msg_size);
+   for (phase = 0; phase < 2; phase++)
+   {
+    size_t offset;
+    size_t to_send;
+    ssize_t ret;
+    if (0 == phase && !d->pure_ogg)
+    {
+   //#ifdef DEBUG_RECORD_PURE_OGG
+
+   //      if (d->pure_ogg)
+   //        break;
+
+   //#endif
+      ptr = (const char *) &audio_message;
+      to_send = sizeof (audio_message);
+    }
+    else
+    {
+      ptr = (const char *) m.data;
+      to_send = len;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+        "Sending %u bytes on phase %d\n", (unsigned int) to_send, phase);
+    for (offset = 0; offset < to_send; offset += ret)
+    {
+      ret = write (1, &ptr[offset], to_send - offset);
+      if (0 >= ret)
+      {
+        if (-1 == ret)
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Failed to write %u bytes at offset %u (total %u) in phase %d: %s\n",
+              (unsigned int) to_send - offset, (unsigned int) offset,
+              (unsigned int) (to_send + offset), phase, strerror (errno));
+     //   abort_send = 1;
+        return FAIL;
+      }
+    }
+
+   //   if (abort_send)
+   //   break;
+
+   }
+   gst_buffer_unmap (b, &m);
+   gst_sample_unref (s);
+   }
+ */
+
+
+extern int
+feed_buffer_to_gst (const char *audio, size_t b_len, GNUNET_gstData *d)
+{
+  GstBuffer *b;
+  gchar *bufspace;
+  GstFlowReturn flow;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Feeding %u bytes to GStreamer\n",
+              (unsigned int) b_len);
+
+  bufspace = g_memdup (audio, b_len);
+  b = gst_buffer_new_wrapped (bufspace, b_len);
+  if (NULL == b)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Failed to wrap a buffer\n");
+    g_free (bufspace);
+    return GNUNET_SYSERR;
+  }
+  if (GST_APP_SRC (d->appsrc) == NULL)
+    exit (10);
+  flow = gst_app_src_push_buffer (GST_APP_SRC (d->appsrc), b);
+  /* They all return GNUNET_OK, because currently player stops when
+   * data stops coming. This might need to be changed for the player
+   * to also stop when pipeline breaks.
+   */
+  switch (flow)
+  {
+  case GST_FLOW_OK:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Fed %u bytes to the pipeline\n",
+                (unsigned int) b_len);
+    break;
+
+  case GST_FLOW_FLUSHING:
+    /* buffer was dropped, because pipeline state is not PAUSED or PLAYING */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Dropped a buffer\n");
+    break;
+
+  case GST_FLOW_EOS:
+    /* end of stream */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "EOS\n");
+    break;
+
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Unexpected push result\n");
+    break;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * debug making elements
+ */
+extern GstElement *
+gst_element_factory_make_debug (gchar *factoryname, gchar *name)
+{
+  GstElement *element;
+
+  element = gst_element_factory_make (factoryname, name);
+
+  if (element == NULL)
+  {
+    printf ("\n Failed to create element - type: %s name: %s \n", factoryname,
+            name);
+    exit (10);
+    return element;
+  }
+  else
+  {
+    return element;
+  }
+}
+
+
+/*
+   static gboolean
+   gst_element_link_many_debug(...)
+   {
+   va_list arguments;
+   gst_element_link_many(argptr);
+   }
+
+ #define gst_element_link_many(...) \
+           gst_element_link_many_debug(__VA_ARGS__)
+ */
+extern void
+lf (char *msg)
+{
+  printf ("linking elements failed: %s", msg);
+  exit (10);
+}
+
+
+/***
+ * used to set properties on autoaudiosink's chosen sink
+ */
+static void
+autoaudiosink_child_added (GstChildProxy *child_proxy,
+                           GObject *object,
+                           gchar *name,
+                           gpointer user_data)
+{
+  if (GST_IS_AUDIO_BASE_SRC (object))
+    g_object_set (object,
+                  "buffer-time", (gint64) BUFFER_TIME,
+                  "latency-time", (gint64) LATENCY_TIME,
+                  NULL);
+}
+
+
+/***
+ * used to set properties on autoaudiosource's chosen sink
+ */
+static void
+autoaudiosource_child_added (GstChildProxy *child_proxy, GObject *object,
+                             gchar *name, gpointer user_data)
+{
+  if (GST_IS_AUDIO_BASE_SRC (object))
+    g_object_set (object, "buffer-time", (gint64) BUFFER_TIME, "latency-time",
+                  (gint64) LATENCY_TIME, NULL);
+}
+
+
+GstElement *
+get_pipeline (GstElement *element)
+{
+  GstPipeline *p;
+
+  p = GST_PIPELINE (gst_object_get_parent (GST_OBJECT (element)));
+
+  return GST_ELEMENT (p);
+}
+
+
+static void
+decoder_ogg_pad_added (GstElement *element,
+                       GstPad *pad,
+                       gpointer data)
+{
+  GstPad *sinkpad;
+  GstElement *decoder = (GstElement *) data;
+
+  printf ("==== ogg pad added callback \n");
+  /* We can now link this pad with the opus-decoder sink pad */
+//  pl_graph(get_pipeline(element));
+  sinkpad = gst_element_get_static_pad (decoder, "sink");
+
+  gst_pad_link (pad, sinkpad);
+  gst_element_link_many (element, decoder, NULL);
+  gst_object_unref (sinkpad);
+}
+
+
+int
+gnunet_read (GNUNET_gstData *d)
+{
+  char readbuf[MAXLINE];
+  int ret;
+
+  printf ("read \n");
+  ret = read (0, readbuf, sizeof(readbuf));
+  if (0 > ret)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Read error from STDIN: %d %s\n"),
+                ret, strerror (errno));
+    return FAIL;
+  }
+  // toff += ret;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received %d bytes of audio data\n",
+              (int) ret);
+  if (0 == ret)
+    return FAIL;
+  // #ifdef DEBUG_READ_PURE_OGG
+
+  if (d->pure_ogg)
+  {
+    feed_buffer_to_gst (readbuf, ret, d);
+  }
+  else
+  {
+    // #endif
+    GNUNET_MST_from_buffer (d->stdin_mst,
+                            readbuf,
+                            ret,
+                            GNUNET_NO,
+                            GNUNET_NO);
+  }
+  return 0;
+}
+
+
+/**
+ * Message callback
+ *
+ * @param msg message we received.
+ * @return #GNUNET_OK on success,
+ *     #GNUNET_NO to stop further processing due to disconnect (no error)
+ *     #GNUNET_SYSERR to stop further processing due to error
+ */
+static int
+stdin_receiver (void *cls,
+                const struct GNUNET_MessageHeader *msg)
+{
+  struct AudioMessage *audio;
+  size_t b_len;
+
+  printf ("stdin receiver \n ");
+  dump_buffer (sizeof(msg),
+               (const unsigned char *) msg);
+
+  switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO:
+    audio = (struct AudioMessage *) msg;
+
+    b_len = ntohs (audio->header.size) - sizeof(struct AudioMessage);
+    printf ("feeding buffer to gst \n ");
+    feed_buffer_to_gst ((const char *) &audio[1], b_len, cls);
+    break;
+
+  default:
+    printf ("No audio message: %u \n ", ntohs (msg->type));
+    break;
+  }
+  return GNUNET_OK;
+}
+
+
+GstBin *
+get_app (GNUNET_gstData *d, int type)
+{
+  GstBin *bin;
+  GstPad *pad, *ghostpad;
+
+  if (type == SOURCE)
+  {
+    bin = GST_BIN (gst_bin_new ("Gnunet appsrc"));
+
+
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_log_setup ("gnunet-helper-audio-playback",
+                                     "WARNING",
+                                     NULL));
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Audio playback starts\n");
+    printf (" creating appsrc \n ");
+    // d->audio_message.header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+
+// d->audio_message = GNUNET_malloc (UINT16_MAX);
+//  d->audio_message = (AudioMessage*)malloc(sizeof(struct AudioMessage));
+//  d->audio_message = GNUNET_malloc(sizeof(struct AudioMessage));
+
+
+    // d->audio_message.header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+
+
+    d->stdin_mst = GNUNET_MST_create (&stdin_receiver, d);
+
+    if (d->stdin_mst == NULL)
+      printf ("stdin_mst = NULL");
+
+    d->appsrc = gst_element_factory_make ("appsrc", "appsrc");
+
+    gst_bin_add_many (bin, d->appsrc, NULL);
+//    gst_element_link_many ( encoder, muxer, NULL);
+
+    pad = gst_element_get_static_pad (d->appsrc, "src");
+    ghostpad = gst_ghost_pad_new ("src", pad);
+  }
+  if (type == SINK)
+  {
+    bin = GST_BIN (gst_bin_new ("Gnunet appsink"));
+
+
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_log_setup ("gnunet-helper-audio-record",
+                                     "WARNING",
+                                     NULL));
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Audio source starts\n");
+
+    d->appsink = gst_element_factory_make ("appsink", "appsink");
+
+    // Move this out of here!
+    d->audio_message = GNUNET_malloc (UINT16_MAX);
+    (d->audio_message)->header.type = htons (
+      GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+    g_object_set (G_OBJECT (d->appsink), "emit-signals", TRUE, "sync", TRUE,
+                  NULL);
+
+    g_signal_connect (d->appsink, "new-sample",
+                      G_CALLBACK (on_appsink_new_sample), &d);
+
+    gst_bin_add_many (bin, d->appsink, NULL);
+//    gst_element_link_many ( encoder, muxer, NULL);
+
+    pad = gst_element_get_static_pad (d->appsink, "sink");
+    ghostpad = gst_ghost_pad_new ("sink", pad);
+  }
+
+  /* set the bin pads */
+  gst_pad_set_active (ghostpad, TRUE);
+  gst_element_add_pad (GST_ELEMENT (bin), ghostpad);
+
+  gst_object_unref (pad);
+
+  return bin;
+}
+
+
+extern GstBin *
+get_coder (GNUNET_gstData *d, int type)
+{
+  GstBin *bin;
+  GstPad *srcpad, *sinkpad, *srcghostpad, *sinkghostpad;
+  GstCaps *rtpcaps;
+  GstElement *encoder, *muxer, *decoder, *demuxer, *jitterbuffer,
+             *rtpcapsfilter;
+
+  if (d->usertp == TRUE)
+  {
+    /*
+     * application/x-rtp, media=(string)audio, clock-rate=(int)48000, encoding-name=(string)OPUS, sprop-maxcapturerate=(string)48000, sprop-stereo=(string)0, payload=(int)96, encoding-params=(string)2, ssrc=(uint)630297634, timestamp-offset=(uint)678334141, seqnum-offset=(uint)16938 */
+/*
+    rtpcaps = gst_caps_new_simple ("application/x-rtp",
+          "media", G_TYPE_STRING, "audio",
+          "clock-rate", G_TYPE_INT, SAMPLING_RATE,
+          "encoding-name", G_TYPE_STRING, "OPUS",
+          "payload", G_TYPE_INT, 96,
+          "sprop-stereo", G_TYPE_STRING, "0",
+          "encoding-params", G_TYPE_STRING, "2",
+          NULL);
+ */ rtpcaps = gst_caps_new_simple ("application/x-rtp",
+                                   "media", G_TYPE_STRING, "audio",
+                                   "clock-rate", G_TYPE_INT, SAMPLING_RATE,
+                                   "encoding-name", G_TYPE_STRING, "OPUS",
+                                   "payload", G_TYPE_INT, 96,
+                                   "sprop-stereo", G_TYPE_STRING, "0",
+                                   "encoding-params", G_TYPE_STRING, "2",
+                                   NULL);
+
+
+    rtpcapsfilter = gst_element_factory_make ("capsfilter", "rtpcapsfilter");
+
+    g_object_set (G_OBJECT (rtpcapsfilter),
+                  "caps", rtpcaps,
+                  NULL);
+    gst_caps_unref (rtpcaps);
+  }
+
+
+  if (type == ENCODER)
+  {
+    bin = GST_BIN (gst_bin_new ("Gnunet audioencoder"));
+
+    encoder = gst_element_factory_make ("opusenc", "opus-encoder");
+    if (d->usertp == TRUE)
+    {
+      muxer = gst_element_factory_make ("rtpopuspay", "rtp-payloader");
+    }
+    else
+    {
+      muxer = gst_element_factory_make ("oggmux", "ogg-muxer");
+    }
+    g_object_set (G_OBJECT (encoder),
+                  /*      "bitrate", 64000, */
+                  /*      "bandwidth", OPUS_BANDWIDTH_FULLBAND, */
+                  "inband-fec", INBAND_FEC_MODE,
+                  "packet-loss-percentage", PACKET_LOSS_PERCENTAGE,
+                  "max-payload-size", MAX_PAYLOAD_SIZE,
+                  "audio", TRUE,  /* VoIP, not audio */
+                  "frame-size", OPUS_FRAME_SIZE,
+                  NULL);
+
+    if (d->usertp != TRUE)
+    {
+      g_object_set (G_OBJECT (muxer),
+                    "max-delay", OGG_MAX_DELAY,
+                    "max-page-delay", OGG_MAX_PAGE_DELAY,
+                    NULL);
+    }
+
+    gst_bin_add_many (bin, encoder, muxer, NULL);
+    gst_element_link_many (encoder, muxer, NULL);
+    sinkpad = gst_element_get_static_pad (encoder, "sink");
+    sinkghostpad = gst_ghost_pad_new ("sink", sinkpad);
+
+    srcpad = gst_element_get_static_pad (muxer, "src");
+    srcghostpad = gst_ghost_pad_new ("src", srcpad);
+  }
+  if (type == DECODER)
+  {
+    bin = GST_BIN (gst_bin_new ("Gnunet audiodecoder"));
+
+    // decoder
+    if (d->usertp == TRUE)
+    {
+      demuxer = gst_element_factory_make ("rtpopusdepay", "ogg-demuxer");
+      jitterbuffer = gst_element_factory_make ("rtpjitterbuffer",
+                                               "rtpjitterbuffer");
+    }
+    else
+    {
+      demuxer = gst_element_factory_make ("oggdemux", "ogg-demuxer");
+    }
+    decoder = gst_element_factory_make ("opusdec", "opus-decoder");
+
+    if (d->usertp == TRUE)
+    {
+      gst_bin_add_many (bin, rtpcapsfilter, jitterbuffer, demuxer, decoder,
+                        NULL);
+      gst_element_link_many (rtpcapsfilter, jitterbuffer, demuxer, decoder,
+                             NULL);
+      sinkpad = gst_element_get_static_pad (rtpcapsfilter, "sink");
+    }
+    else
+    {
+      gst_bin_add_many (bin, demuxer, decoder, NULL);
+
+      g_signal_connect (demuxer,
+                        "pad-added",
+                        G_CALLBACK (decoder_ogg_pad_added),
+                        decoder);
+
+      sinkpad = gst_element_get_static_pad (demuxer, "sink");
+    }
+    sinkghostpad = gst_ghost_pad_new ("sink", sinkpad);
+
+    srcpad = gst_element_get_static_pad (decoder, "src");
+    srcghostpad = gst_ghost_pad_new ("src", srcpad);
+  }
+
+  // add pads to the bin
+  gst_pad_set_active (sinkghostpad, TRUE);
+  gst_element_add_pad (GST_ELEMENT (bin), sinkghostpad);
+
+  gst_pad_set_active (srcghostpad, TRUE);
+  gst_element_add_pad (GST_ELEMENT (bin), srcghostpad);
+
+
+  return bin;
+}
+
+
+extern GstBin *
+get_audiobin (GNUNET_gstData *d, int type)
+{
+  GstBin *bin;
+  GstElement *sink, *source, *queue, *conv, *resampler, *removesilence, *filter;
+  GstPad *pad, *ghostpad;
+  GstCaps *caps;
+
+  if (type == SINK)
+  {
+    bin = GST_BIN (gst_bin_new ("Gnunet audiosink"));
+
+    /* Create all the elements */
+    if (d->dropsilence == TRUE)
+    {
+      queue = gst_element_factory_make ("queue", "queue");
+      removesilence = gst_element_factory_make ("removesilence",
+                                                "removesilence");
+    }
+
+    conv = gst_element_factory_make ("audioconvert", "converter");
+    resampler = gst_element_factory_make ("audioresample", "resampler");
+
+    if (d->audiobackend == AUTO)
+    {
+      sink = gst_element_factory_make ("autoaudiosink", "audiosink");
+      g_signal_connect (sink, "child-added", G_CALLBACK (
+                          autoaudiosink_child_added), NULL);
+    }
+
+    if (d->audiobackend == ALSA)
+    {
+      sink = gst_element_factory_make ("alsaaudiosink", "audiosink");
+    }
+
+    if (d->audiobackend == JACK)
+    {
+      sink = gst_element_factory_make ("jackaudiosink", "audiosink");
+
+      g_object_set (G_OBJECT (sink), "client-name", "gnunet", NULL);
+
+      if (g_object_class_find_property
+            (G_OBJECT_GET_CLASS (sink), "port-pattern"))
+      {
+//        char *portpattern = "system";
+
+        g_object_set (G_OBJECT (sink), "port-pattern", d->jack_pp_out,
+                      NULL);
+      }
+    }
+
+    if (d->audiobackend == FAKE)
+    {
+      sink = gst_element_factory_make ("fakesink", "audiosink");
+    }
+
+    g_object_set (sink,
+                  "buffer-time", (gint64) BUFFER_TIME,
+                  "latency-time", (gint64) LATENCY_TIME,
+                  NULL);
+
+    if (d->dropsilence == TRUE)
+    {
+      // Do not remove silence by default
+      g_object_set (removesilence, "remove", FALSE, NULL);
+      g_object_set (queue, "max-size-buffers", 12, NULL);
+      /*
+         g_signal_connect (source,
+         "need-data",
+         G_CALLBACK(appsrc_need_data),
+         NULL);
+
+         g_signal_connect (source,
+         "enough-data",
+         G_CALLBACK(appsrc_enough_data),
+         NULL);
+       *//*
+      g_signal_connect (queue,
+          "notify::current-level-bytes",
+          G_CALLBACK(queue_current_level),
+          NULL);
+
+      g_signal_connect (queue,
+          "underrun",
+          G_CALLBACK(queue_underrun),
+          NULL);
+
+      g_signal_connect (queue,
+          "running",
+          G_CALLBACK(queue_running),
+          NULL);
+
+      g_signal_connect (queue,
+          "overrun",
+          G_CALLBACK(queue_overrun),
+          NULL);
+
+      g_signal_connect (queue,
+          "pushing",
+          G_CALLBACK(queue_pushing),
+          NULL);
+ */ }
+
+
+    gst_bin_add_many (bin, conv, resampler, sink, NULL);
+    gst_element_link_many (conv, resampler, sink, NULL);
+
+    if (d->dropsilence == TRUE)
+    {
+      gst_bin_add_many (bin, queue, removesilence, NULL);
+
+      if (! gst_element_link_many (queue, removesilence, conv, NULL))
+        lf ("queue, removesilence, conv ");
+
+      pad = gst_element_get_static_pad (queue, "sink");
+    }
+    else
+    {
+      pad = gst_element_get_static_pad (conv, "sink");
+    }
+
+    ghostpad = gst_ghost_pad_new ("sink", pad);
+  }
+  else
+  {
+    // SOURCE
+
+    bin = GST_BIN (gst_bin_new ("Gnunet audiosource"));
+
+    //    source = gst_element_factory_make("audiotestsrc", "audiotestsrcbla");
+
+    if (d->audiobackend == AUTO)
+    {
+      source = gst_element_factory_make ("autoaudiosrc", "audiosource");
+    }
+    if (d->audiobackend == ALSA)
+    {
+      source = gst_element_factory_make ("alsasrc", "audiosource");
+    }
+    if (d->audiobackend == JACK)
+    {
+      source = gst_element_factory_make ("jackaudiosrc", "audiosource");
+    }
+    if (d->audiobackend == TEST)
+    {
+      source = gst_element_factory_make ("audiotestsrc", "audiosource");
+    }
+
+    filter = gst_element_factory_make ("capsfilter", "filter");
+    conv = gst_element_factory_make ("audioconvert", "converter");
+    resampler = gst_element_factory_make ("audioresample", "resampler");
+
+    if (d->audiobackend == AUTO)
+    {
+      g_signal_connect (source, "child-added", G_CALLBACK (
+                          autoaudiosource_child_added), NULL);
+    }
+    else
+    {
+      if (GST_IS_AUDIO_BASE_SRC (source))
+        g_object_set (source, "buffer-time", (gint64) BUFFER_TIME,
+                      "latency-time", (gint64) LATENCY_TIME, NULL);
+      if (d->audiobackend == JACK)
+      {
+        g_object_set (G_OBJECT (source), "client-name", "gnunet", NULL);
+        if (g_object_class_find_property
+              (G_OBJECT_GET_CLASS (source), "port-pattern"))
+        {
+          char *portpattern = "moc";
+
+          g_object_set (G_OBJECT (source), "port-pattern", portpattern,
+                        NULL);
+        }
+      }
+    }
+
+    caps = gst_caps_new_simple ("audio/x-raw",
+                                /*  "format", G_TYPE_STRING, "S16LE", */
+                                /*    "rate", G_TYPE_INT, SAMPLING_RATE,*/
+                                "channels", G_TYPE_INT, OPUS_CHANNELS,
+                                /*    "layout", G_TYPE_STRING, "interleaved",*/
+                                NULL);
+
+    g_object_set (G_OBJECT (filter),
+                  "caps", caps,
+                  NULL);
+    gst_caps_unref (caps);
+
+    gst_bin_add_many (bin, source, filter, conv, resampler, NULL);
+    gst_element_link_many (source, filter, conv, resampler, NULL);
+
+    pad = gst_element_get_static_pad (resampler, "src");
+
+
+    /* pads */
+    ghostpad = gst_ghost_pad_new ("src", pad);
+  }
+
+  /* set the bin pads */
+  gst_pad_set_active (ghostpad, TRUE);
+  gst_element_add_pad (GST_ELEMENT (bin), ghostpad);
+
+  gst_object_unref (pad);
+
+  return bin;
+}
diff --git a/src/contrib/service/conversation/gnunet_gst.h b/src/contrib/service/conversation/gnunet_gst.h
new file mode 100644
index 000000000..479ae14b3
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet_gst.h
@@ -0,0 +1,62 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2016 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/gnunet_gst.c
+ * @brief FIXME
+ * @author Hark
+ */
+
+// which audiobackend we use
+//
+
+/*
+   int audiobackend = JACK;
+   int dropsilence = TRUE;
+   int enough = 0;
+   int usertp = TRUE;
+ */
+
+#define gst_element_factory_make(element, name) gst_element_factory_make_debug ( \
+    element, name);
+
+extern void pl_graph ();
+
+
+extern GstElement *
+gst_element_factory_make_debug (gchar *, gchar *);
+
+extern GstBin *
+get_audiobin (GNUNET_gstData *, int);
+
+extern GstBin *
+get_coder (GNUNET_gstData *, int);
+
+
+extern gboolean
+gnunet_gst_bus_call (GstBus *bus, GstMessage *msg, gpointer data);
+
+extern void
+gg_setup_gst_bus (GNUNET_gstData *d);
+
+extern void
+gg_load_configuration (GNUNET_gstData *d);
+
+extern GstFlowReturn
+on_appsink_new_sample (GstElement *, GNUNET_gstData *);
diff --git a/src/contrib/service/conversation/gnunet_gst_def.h b/src/contrib/service/conversation/gnunet_gst_def.h
new file mode 100644
index 000000000..7bfcc5e53
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet_gst_def.h
@@ -0,0 +1,219 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2016 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/gnunet_gst_def.h
+ * @brief FIXME
+ * @author Hark
+ */
+
+#include <getopt.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <regex.h>
+
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+// #include "gnunet/conversation.h" doesn't get installed
+#include "conversation.h"
+#include "gnunet_constants.h"
+#include "gnunet_core_service.h"
+#include "gnunet_common.h"
+
+/*
+ #include <gst/gst.h>
+ #include <gst/audio/gstaudiobasesrc.h>
+ #include <gst/app/gstappsrc.h>
+ */
+
+/* huh
+ #include <glib-2.0/glib.h>
+
+ #include <gstreamer-1.0/gst/gst.h>
+ #include <gstreamer-1.0/gst/pbutils/pbutils.h>
+ #include <gstreamer-1.0/gst/video/videooverlay.h>
+ #include <gstreamer-1.0/gst/audio/gstaudiobasesrc.h>
+ #include <gstreamer-1.0/gst/app/gstappsrc.h>
+ */
+
+#include <gst/gst.h>
+#include <gst/audio/gstaudiobasesrc.h>
+#include <gst/app/gstappsrc.h>
+#include <glib.h>
+#include <gst/app/gstappsink.h>
+
+// sockets
+#if HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include <sys/types.h>
+#include <fcntl.h>
+
+
+// glib stuff
+// #include <glib.h>
+#include <glib-2.0/glib/gprintf.h>
+// #include <glib-unix.h>
+
+// static struct AudioMessage *audio_message;
+
+
+typedef struct GNUNET_gstData GNUNET_gstData;
+struct GNUNET_gstData
+{
+  // general
+  GstPipeline *pipeline;
+
+  // things
+  struct AudioMessage *audio_message;
+  struct GNUNET_MessageStreamTokenizer *stdin_mst;
+  GstElement *appsrc;
+  GstElement *appsink;
+  // settings
+  int audiobackend;
+  int dropsilence;
+  int usertp;
+  int pure_ogg;
+  char *jack_pp_in;
+  char *jack_pp_out;
+};
+
+
+#define DEBUG_READ_PURE_OGG 1
+#define DEBUG_RECORD_PURE_OGG 1
+
+
+/**
+ * How much data to read in one go
+ */
+#define MAXLINE 4096
+
+/**
+ * Max number of microseconds to buffer in audiosink.
+ * Default is 1000
+ */
+#define BUFFER_TIME 1000
+
+/**
+ * Min number of microseconds to buffer in audiosink.
+ * Default is 1000
+ */
+#define LATENCY_TIME 1000
+
+
+/**
+ * Number of channels.
+ * Must be one of the following (from libopusenc documentation):
+ * 1, 2
+ */
+#define OPUS_CHANNELS 1
+
+/**
+ * Maximal size of a single opus packet.
+ */
+#define MAX_PAYLOAD_SIZE (1024 / OPUS_CHANNELS)
+
+/**
+ * Size of a single frame fed to the encoder, in ms.
+ * Must be one of the following (from libopus documentation):
+ * 2.5, 5, 10, 20, 40 or 60
+ */
+#define OPUS_FRAME_SIZE 40
+
+/**
+ * Expected packet loss to prepare for, in percents.
+ */
+#define PACKET_LOSS_PERCENTAGE 1
+
+/**
+ * Set to 1 to enable forward error correction.
+ * Set to 0 to disable.
+ */
+#define INBAND_FEC_MODE 1
+
+/**
+ * Max number of microseconds to buffer in audiosource.
+ * Default is 200000
+ */
+#define BUFFER_TIME 1000 /* 1ms */
+
+/**
+ * Min number of microseconds to buffer in audiosource.
+ * Default is 10000
+ */
+#define LATENCY_TIME 1000 /* 1ms */
+
+/**
+ * Maximum delay in multiplexing streams, in ns.
+ * Setting this to 0 forces page flushing, which
+ * decreases delay, but increases overhead.
+ */
+#define OGG_MAX_DELAY 0
+
+/**
+ * Maximum delay for sending out a page, in ns.
+ * Setting this to 0 forces page flushing, which
+ * decreases delay, but increases overhead.
+ */
+#define OGG_MAX_PAGE_DELAY 0
+
+#define SAMPLING_RATE 48000
+
+enum
+{
+  AUTO,
+  JACK,
+  ALSA,
+  FAKE,
+  TEST
+};
+
+enum
+{
+  SOURCE,
+  SINK
+};
+
+enum
+{
+  ENCODER,
+  DECODER
+};
+
+enum
+{
+  FAIL,
+  OK
+};
+
+enum
+{
+  SPEAKER,
+  MICROPHONE
+};
diff --git a/src/contrib/service/conversation/gnunet_gst_test.c b/src/contrib/service/conversation/gnunet_gst_test.c
new file mode 100644
index 000000000..dd2ef5a38
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet_gst_test.c
@@ -0,0 +1,135 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2016 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/gnunet_gst_test.c
+ * @brief FIXME
+ * @author Hark
+ */
+
+#include "platform.h"
+#include "gnunet_gst_def.h"
+#include "gnunet_gst.h"
+
+int
+main (int argc, char *argv[])
+{
+  struct GNUNET_gstData *gst;
+  // GstBus *bus;
+  GstElement *gnunetsrc, *gnunetsink, *source, *sink, *encoder, *decoder;
+
+
+  // audio_message = GNUNET_malloc (UINT16_MAX);
+  // audio_message->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+
+
+  // GstPipeline *pipeline;
+
+  gst = (GNUNET_gstData *) malloc (sizeof(struct GNUNET_gstData));
+
+  // gst->audio_message.header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+
+
+  gg_load_configuration (gst);
+/*
+   gst->audiobackend = JACK;
+   gst->dropsilence = TRUE;
+   gst->usertp = FALSE;
+ *//* Initialize GStreamer */gst_init (&argc, &argv);
+
+  gst->pipeline = GST_PIPELINE (gst_pipeline_new ("gnunet-media-helper"));
+
+#ifdef IS_SPEAKER
+  int type = SPEAKER;
+  printf ("this is the speaker \n");
+#endif
+#ifdef IS_MIC
+  int type = MICROPHONE;
+  printf ("this is the microphone \n");
+#endif
+  if (type == SPEAKER)
+  {
+    gnunetsrc = GST_ELEMENT (get_app (gst, SOURCE));
+
+    sink = GST_ELEMENT (get_audiobin (gst, SINK));
+    decoder = GST_ELEMENT (get_coder (gst, DECODER));
+    gst_bin_add_many (GST_BIN (gst->pipeline), gnunetsrc, decoder, sink, NULL);
+    gst_element_link_many (gnunetsrc, decoder, sink, NULL);
+  }
+  if (type == MICROPHONE)
+  {
+    source = GST_ELEMENT (get_audiobin (gst, SOURCE));
+
+    encoder = GST_ELEMENT (get_coder (gst, ENCODER));
+
+    gnunetsink = GST_ELEMENT (get_app (gst, SINK));
+
+    gst_bin_add_many (GST_BIN (gst->pipeline), source, encoder, gnunetsink,
+                      NULL);
+    gst_element_link_many (source, encoder, gnunetsink, NULL);
+  }
+  /*
+     gst_bin_add_many( GST_BIN(gst->pipeline), appsource, appsink, source, encoder, decoder, sink, NULL);
+     gst_element_link_many( source, encoder, decoder, sink , NULL);
+   */
+  pl_graph (gst->pipeline);
+  /* Start playing */
+  gst_element_set_state (GST_ELEMENT (gst->pipeline), GST_STATE_PLAYING);
+
+  // pl_graph(gst->pipeline);
+
+  /* Wait until error or EOS */
+  // bus = gst_element_get_bus (GST_ELEMENT(gst->pipeline));
+  // bus_watch_id = gst_bus_add_watch (bus, gnunet_gst_bus_call, pipeline);
+
+  gg_setup_gst_bus (gst);
+// g_print ("Running...\n");
+
+
+  // start pushing buffers
+  if (type == MICROPHONE)
+  {
+    GMainLoop *loop;
+    loop = g_main_loop_new (NULL, FALSE);
+
+    g_main_loop_run (loop);
+
+/*
+   while ( 1 )
+     {
+         GstFlowReturn flow;
+         flow = on_appsink_new_sample (gst->appsink, gst);
+    }
+ */}
+  if (type == SPEAKER)
+  {
+    while (1)
+    {
+//      printf("read.. \n");
+      gnunet_read (gst);
+    }
+  }
+  g_print ("Returned, stopping playback\n");
+
+  // gst_object_unref (bus);
+  gst_element_set_state (GST_ELEMENT (gst->pipeline), GST_STATE_NULL);
+  gst_object_unref (gst->pipeline);
+
+  return 0;
+}
diff --git a/src/contrib/service/conversation/mediahelper.conf b/src/contrib/service/conversation/mediahelper.conf
new file mode 100644
index 000000000..85c051107
--- /dev/null
+++ b/src/contrib/service/conversation/mediahelper.conf
@@ -0,0 +1,7 @@
+[MEDIAHELPER]
+AUDIOBACKEND = JACK
+REMOVESILENCE = NO
+USERTP  = NO
+NO_GN_HEADERS = NO
+JACK_PP_IN = mocp
+JACK_PP_OUT = system
diff --git a/src/contrib/service/conversation/meson.build b/src/contrib/service/conversation/meson.build
new file mode 100644
index 000000000..4ecc0fc93
--- /dev/null
+++ b/src/contrib/service/conversation/meson.build
@@ -0,0 +1,203 @@
+libgnunetconversation_src = ['conversation_api.c', 'conversation_api_call.c']
+
+gnunetserviceconversation_src = ['gnunet-service-conversation.c']
+
+gnunetconversationproxy_src = ['gnunet-conversation-proxy.c']
+
+configure_file(input : 'conversation.conf.in',
+               output : 'conversation.conf',
+               configuration : cdata,
+               install: true,
+               install_dir: pkgcfgdir)
+
+
+if get_option('monolith')
+  foreach p : libgnunetconversation_src + gnunetserviceconversation_src
+    gnunet_src += 'conversation/' + p
+  endforeach
+endif
+
+libgnunetmicrophone = library('gnunetmicrophone',
+        ['microphone.c'],
+        soversion: '0',
+        version: '0.0.0',
+        dependencies: [libgnunetutil_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+libgnunetmicrophone_dep = declare_dependency(link_with : libgnunetmicrophone)
+pkg.generate(libgnunetmicrophone, url: 'https://www.gnunet.org',
+             description : 'Provides API to access to microphone')
+
+libgnunetspeaker = library('gnunetspeaker',
+        ['speaker.c'],
+        soversion: '0',
+        version: '0.0.0',
+        dependencies: [libgnunetutil_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+libgnunetspeaker_dep = declare_dependency(link_with : libgnunetspeaker)
+pkg.generate(libgnunetspeaker, url: 'https://www.gnunet.org',
+             description : 'Provides API to access to speaker')
+
+libgnunetconversation = library('gnunetconversation',
+        libgnunetconversation_src,
+        soversion: '0',
+        version: '0.0.0',
+        dependencies: [libgnunetutil_dep,
+                       libgnunetgnsrecord_dep,
+                       libgnunetgns_dep,
+                       libgnunetnamestore_dep,
+                       libgnunetidentity_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+libgnunetconversation_dep = declare_dependency(link_with : libgnunetconversation)
+pkg.generate(libgnunetconversation, url: 'https://www.gnunet.org',
+             description : 'Provides API to access to conversation')
+
+shared_module('gnunet_plugin_gnsrecord_conversation',
+        ['plugin_gnsrecord_conversation.c'],
+        dependencies: [libgnunetutil_dep,
+                       libgnunetconversation_dep,
+                       libgnunetgns_dep,
+                       libgnunetgnsrecord_dep,
+                       libgnunetidentity_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir')/'gnunet')
+
+executable ('gnunet-conversation',
+            'gnunet-conversation.c',
+            dependencies: [libgnunetconversation_dep,
+                           libgnunetgns_dep,
+                           libgnunetgnsrecord_dep,
+                           libgnunetnamestore_dep,
+                           libgnunetspeaker_dep,
+                           libgnunetmicrophone_dep,
+                           libgnunetidentity_dep,
+                           libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('bindir'))
+
+executable ('gnunet-conversation-test',
+            'gnunet-conversation-test.c',
+            dependencies: [libgnunetconversation_dep,
+                           libgnunetspeaker_dep,
+                           libgnunetmicrophone_dep,
+                           libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('bindir'))
+
+executable ('gnunet-service-conversation',
+            gnunetserviceconversation_src,
+            dependencies: [libgnunetconversation_dep,
+                           libgnunetutil_dep,
+                           libgnunetspeaker_dep,
+                           libgnunetmicrophone_dep,
+                           libgnunetidentity_dep,
+                           libgnunetcadet_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+
+helperrecord_src = ['gnunet-helper-audio-record.c']
+helperplayback_src = ['gnunet-helper-audio-record.c']
+if conversation_backend == 'gst'
+  helperrecord_src = ['gnunet-helper-audio-record-gst.c']
+  helperplayback_src = ['gnunet-helper-audio-playback-gst.c']
+endif
+
+executable ('gnunet-helper-audio-record',
+            helperrecord_src,
+            dependencies: [libgnunetconversation_dep,
+                           libgnunetutil_dep,
+                           libgnunetspeaker_dep,
+                           libgnunetmicrophone_dep,
+                           gst_dep,
+                           gst_app_dep,
+                           gst_audio_dep,
+                           ogg_dep,
+                           pulse_dep,
+                           opus_dep
+                           ],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+
+executable ('gnunet-helper-audio-playback',
+         helperplayback_src,
+          dependencies: [libgnunetconversation_dep,
+                         libgnunetutil_dep,
+                         libgnunetspeaker_dep,
+                         libgnunetmicrophone_dep,
+                         gst_dep,
+                         gst_app_dep,
+                         gst_audio_dep,
+                         ogg_dep,
+                         pulse_dep,
+                         opus_dep
+                         ],
+          include_directories: [incdir, configuration_inc],
+          install: true,
+          install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+
+testconvapi = executable ('test_conversation_api',
+         ['test_conversation_api.c'],
+          dependencies: [libgnunetconversation_dep,
+                         libgnunetutil_dep,
+                         libgnunetidentity_dep,
+                         libgnunettesting_dep,
+                         libgnunetgnsrecord_dep,
+                         libgnunetnamestore_dep,
+                         libgnunetspeaker_dep,
+                         libgnunetmicrophone_dep,
+                         ],
+          include_directories: [incdir, configuration_inc],
+          install: false)
+
+testconvapitwo = executable ('test_conversation_api_twocalls',
+         ['test_conversation_api_twocalls.c'],
+          dependencies: [libgnunetconversation_dep,
+                         libgnunetutil_dep,
+                         libgnunetidentity_dep,
+                         libgnunettesting_dep,
+                         libgnunetgnsrecord_dep,
+                         libgnunetnamestore_dep,
+                         libgnunetspeaker_dep,
+                         libgnunetmicrophone_dep,
+                         ],
+          include_directories: [incdir, configuration_inc],
+          install: false)
+
+testconvapireject = executable ('test_conversation_api_reject',
+         ['test_conversation_api_reject.c'],
+          dependencies: [libgnunetconversation_dep,
+                         libgnunetutil_dep,
+                         libgnunetidentity_dep,
+                         libgnunettesting_dep,
+                         libgnunetgnsrecord_dep,
+                         libgnunetnamestore_dep,
+                         libgnunetspeaker_dep,
+                         libgnunetmicrophone_dep,
+                         ],
+          include_directories: [incdir, configuration_inc],
+          install: false)
+
+configure_file(input : 'test_conversation.conf',
+               output : 'test_conversation.conf',
+               copy: true,
+               install: false)
+
+test('test_conversation_api', testconvapi, workdir: meson.current_build_dir(),
+     suite: ['conversation', 'contrib'])
+
+test('test_conversation_api_twocalls', testconvapitwo, workdir: meson.current_build_dir(),
+     suite: ['conversation', 'contrib'])
+
+test('test_conversation_api_reject', testconvapireject, workdir: meson.current_build_dir(),
+     suite: ['conversation', 'contrib'])
+
diff --git a/src/contrib/service/conversation/microphone.c b/src/contrib/service/conversation/microphone.c
new file mode 100644
index 000000000..a4a40796f
--- /dev/null
+++ b/src/contrib/service/conversation/microphone.c
@@ -0,0 +1,200 @@
+/*
+   This file is part of GNUnet
+   Copyright (C) 2013 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file conversation/microphone.c
+ * @brief API to access an audio microphone; provides access to hardware microphones;
+ *        actually just wraps the gnunet-helper-audio-record
+ * @author Simon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_microphone_lib.h"
+#include "conversation.h"
+
+
+/**
+ * Internal data structures for the microphone.
+ */
+struct Microphone
+{
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Handle for the record helper
+   */
+  struct GNUNET_HELPER_Handle *record_helper;
+
+  /**
+   * Function to call with audio data (if we are enabled).
+   */
+  GNUNET_MICROPHONE_RecordedDataCallback rdc;
+
+  /**
+   * Closure for @e rdc.
+   */
+  void *rdc_cls;
+};
+
+
+/**
+ * Function to process the audio from the record helper
+ *
+ * @param cls clsoure with our `struct Microphone`
+ * @param msg the message from the helper
+ * @return #GNUNET_OK on success,
+ *    #GNUNET_NO to stop further processing (no error)
+ *    #GNUNET_SYSERR to stop further processing with error
+ */
+static int
+process_record_messages (void *cls,
+                         const struct GNUNET_MessageHeader *msg)
+{
+  struct Microphone *mic = cls;
+  const struct AudioMessage *am;
+
+  if (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  am = (const struct AudioMessage *) msg;
+  mic->rdc (mic->rdc_cls,
+            ntohs (msg->size) - sizeof(struct AudioMessage),
+            &am[1]);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Enable a microphone.
+ *
+ * @param cls clsoure with our `struct Microphone`
+ * @param rdc function to call with recorded data
+ * @param rdc_cls closure for @a dc
+ */
+static int
+enable (void *cls,
+        GNUNET_MICROPHONE_RecordedDataCallback rdc,
+        void *rdc_cls)
+{
+  struct Microphone *mic = cls;
+  static char *const record_helper_argv[] = {
+    "gnunet-helper-audio-record",
+    NULL
+  };
+
+  mic->rdc = rdc;
+  mic->rdc_cls = rdc_cls;
+  mic->record_helper = GNUNET_HELPER_start (GNUNET_NO,
+                                            "gnunet-helper-audio-record",
+                                            record_helper_argv,
+                                            &process_record_messages,
+                                            NULL, mic);
+  if (NULL == mic->record_helper)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Could not start record audio helper\n"));
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function that disables a microphone.
+ *
+ * @param cls clsoure
+ */
+static void
+disable (void *cls)
+{
+  struct Microphone *mic = cls;
+
+  if (NULL == mic->record_helper)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_HELPER_kill (mic->record_helper, GNUNET_NO));
+  GNUNET_HELPER_destroy (mic->record_helper);
+  mic->record_helper = NULL;
+}
+
+
+/**
+ * Function to destroy a microphone.
+ *
+ * @param cls clsoure
+ */
+static void
+destroy (void *cls)
+{
+  struct Microphone *mic = cls;
+
+  if (NULL != mic->record_helper)
+    disable (mic);
+}
+
+
+/**
+ * Create a microphone that corresponds to the microphone hardware
+ * of our system.
+ *
+ * @param cfg configuration to use
+ * @return NULL on error
+ */
+struct GNUNET_MICROPHONE_Handle *
+GNUNET_MICROPHONE_create_from_hardware (const struct
+                                        GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_MICROPHONE_Handle *microphone;
+  struct Microphone *mic;
+
+  mic = GNUNET_new (struct Microphone);
+  mic->cfg = cfg;
+  microphone = GNUNET_new (struct GNUNET_MICROPHONE_Handle);
+  microphone->cls = mic;
+  microphone->enable_microphone = &enable;
+  microphone->disable_microphone = &disable;
+  microphone->destroy_microphone = &destroy;
+  return microphone;
+}
+
+
+/**
+ * Destroy a microphone.
+ *
+ * @param microphone microphone to destroy
+ */
+void
+GNUNET_MICROPHONE_destroy (struct GNUNET_MICROPHONE_Handle *microphone)
+{
+  microphone->destroy_microphone (microphone->cls);
+  GNUNET_free (microphone);
+}
+
+
+/* end of microphone.c */
diff --git a/src/contrib/service/conversation/plugin_gnsrecord_conversation.c b/src/contrib/service/conversation/plugin_gnsrecord_conversation.c
new file mode 100644
index 000000000..802732cfe
--- /dev/null
+++ b/src/contrib/service/conversation/plugin_gnsrecord_conversation.c
@@ -0,0 +1,262 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2013 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file conversation/plugin_gnsrecord_conversation.c
+ * @brief gnsrecord plugin to provide the API for fundamental GNS records
+ *                  This includes the VPN record because GNS resolution
+ *                  is expected to understand VPN records and (if needed)
+ *                  map the result to A/AAAA.
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_conversation_service.h"
+#include "gnunet_gnsrecord_plugin.h"
+
+
+/**
+ * Convert the 'value' of a record to a string.
+ *
+ * @param cls closure, unused
+ * @param type type of the record
+ * @param data value in binary encoding
+ * @param data_size number of bytes in @a data
+ * @return NULL on error, otherwise human-readable representation of the value
+ */
+static char *
+conversation_value_to_string (void *cls,
+                              uint32_t type,
+                              const void *data,
+                              size_t data_size)
+{
+  char *s;
+
+  (void) cls;
+  switch (type)
+  {
+  case GNUNET_GNSRECORD_TYPE_PHONE:
+    {
+      const struct GNUNET_CONVERSATION_PhoneRecord *pr;
+      char *ret;
+      char *pkey;
+
+      if (data_size != sizeof(struct GNUNET_CONVERSATION_PhoneRecord))
+      {
+        GNUNET_break_op (0);
+        return NULL;
+      }
+      pr = data;
+      if (1 != ntohl (pr->version))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("PHONE version %u not supported\n"),
+                    ntohl (pr->version));
+        return NULL;
+      }
+      pkey = GNUNET_CRYPTO_eddsa_public_key_to_string (&pr->peer.public_key);
+      s = GNUNET_STRINGS_data_to_string_alloc (&pr->line_port,
+                                               sizeof(struct GNUNET_HashCode));
+
+      GNUNET_asprintf (&ret,
+                       "%s-%s",
+                       s,
+                       pkey);
+      GNUNET_free (s);
+      GNUNET_free (pkey);
+      return ret;
+    }
+
+  default:
+    return NULL;
+  }
+}
+
+
+/**
+ * Convert human-readable version of a 'value' of a record to the binary
+ * representation.
+ *
+ * @param cls closure, unused
+ * @param type type of the record
+ * @param s human-readable string
+ * @param data set to value in binary encoding (will be allocated)
+ * @param data_size set to number of bytes in @a data
+ * @return #GNUNET_OK on success
+ */
+static int
+conversation_string_to_value (void *cls,
+                              uint32_t type,
+                              const char *s,
+                              void **data,
+                              size_t *data_size)
+{
+  (void) cls;
+  if (NULL == s)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  switch (type)
+  {
+  case GNUNET_GNSRECORD_TYPE_PHONE:
+    {
+      struct GNUNET_CONVERSATION_PhoneRecord *pr;
+      char line_port[104];
+      const char *dash;
+      struct GNUNET_PeerIdentity peer;
+
+      if ((NULL == (dash = strchr (s, '-'))) ||
+          (1 != sscanf (s, "%103s-", line_port)) ||
+          (GNUNET_OK !=
+           GNUNET_CRYPTO_eddsa_public_key_from_string (dash + 1,
+                                                       strlen (dash + 1),
+                                                       &peer.public_key)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("Unable to parse PHONE record `%s'\n"),
+                    s);
+        return GNUNET_SYSERR;
+      }
+      pr = GNUNET_new (struct GNUNET_CONVERSATION_PhoneRecord);
+      pr->version = htonl (1);
+      pr->reserved = htonl (0);
+      if (GNUNET_OK !=
+          GNUNET_STRINGS_string_to_data (line_port,
+                                         strlen (line_port),
+                                         &pr->line_port,
+                                         sizeof(struct GNUNET_HashCode)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("Unable to parse PHONE record `%s'\n"),
+                    s);
+        GNUNET_free (pr);
+        return GNUNET_SYSERR;
+      }
+      pr->peer = peer;
+      *data = pr;
+      *data_size = sizeof(struct GNUNET_CONVERSATION_PhoneRecord);
+      return GNUNET_OK;
+    }
+
+  default:
+    return GNUNET_SYSERR;
+  }
+}
+
+
+/**
+ * Mapping of record type numbers to human-readable
+ * record type names.
+ */
+static struct
+{
+  const char *name;
+  uint32_t number;
+} name_map[] = {
+  { "PHONE", GNUNET_GNSRECORD_TYPE_PHONE },
+  { NULL, UINT32_MAX }
+};
+
+
+/**
+ * Convert a type name (e.g. "AAAA") to the corresponding number.
+ *
+ * @param cls closure, unused
+ * @param gns_typename name to convert
+ * @return corresponding number, UINT32_MAX on error
+ */
+static uint32_t
+conversation_typename_to_number (void *cls,
+                                 const char *gns_typename)
+{
+  unsigned int i;
+
+  (void) cls;
+  i = 0;
+  while ((name_map[i].name != NULL) &&
+         (0 != strcasecmp (gns_typename, name_map[i].name)))
+    i++;
+  return name_map[i].number;
+}
+
+
+/**
+ * Convert a type number to the corresponding type string (e.g. 1 to "A")
+ *
+ * @param cls closure, unused
+ * @param type number of a type to convert
+ * @return corresponding typestring, NULL on error
+ */
+static const char *
+conversation_number_to_typename (void *cls,
+                                 uint32_t type)
+{
+  unsigned int i;
+
+  (void) cls;
+  i = 0;
+  while ((name_map[i].name != NULL) &&
+         (type != name_map[i].number))
+    i++;
+  return name_map[i].name;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls NULL
+ * @return the exported block API
+ */
+void *
+libgnunet_plugin_gnsrecord_conversation_init (void *cls)
+{
+  struct GNUNET_GNSRECORD_PluginFunctions *api;
+
+  (void) cls;
+  api = GNUNET_new (struct GNUNET_GNSRECORD_PluginFunctions);
+  api->value_to_string = &conversation_value_to_string;
+  api->string_to_value = &conversation_string_to_value;
+  api->typename_to_number = &conversation_typename_to_number;
+  api->number_to_typename = &conversation_number_to_typename;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls the return value from #libgnunet_plugin_block_test_init
+ * @return NULL
+ */
+void *
+libgnunet_plugin_gnsrecord_conversation_done (void *cls)
+{
+  struct GNUNET_GNSRECORD_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_gnsrecord_conversation.c */
diff --git a/src/contrib/service/conversation/speaker.c b/src/contrib/service/conversation/speaker.c
new file mode 100644
index 000000000..38eb1159c
--- /dev/null
+++ b/src/contrib/service/conversation/speaker.c
@@ -0,0 +1,189 @@
+/*
+   This file is part of GNUnet
+   Copyright (C) 2013 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file conversation/speaker.c
+ * @brief API to access an audio speaker; provides access to hardware speakers
+ * @author Simon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_speaker_lib.h"
+#include "conversation.h"
+
+
+/**
+ * Internal data structures for the speaker.
+ */
+struct Speaker
+{
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Handle for the playback helper
+   */
+  struct GNUNET_HELPER_Handle *playback_helper;
+};
+
+
+/**
+ * Function that enables a speaker.
+ *
+ * @param cls closure with the `struct Speaker`
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+static int
+enable (void *cls)
+{
+  struct Speaker *spe = cls;
+  static char *playback_helper_argv[] = {
+    "gnunet-helper-audio-playback",
+    NULL
+  };
+
+  spe->playback_helper = GNUNET_HELPER_start (GNUNET_NO,
+                                              "gnunet-helper-audio-playback",
+                                              playback_helper_argv,
+                                              NULL,
+                                              NULL, spe);
+  if (NULL == spe->playback_helper)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Could not start playback audio helper.\n"));
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function that disables a speaker.
+ *
+ * @param cls closure with the `struct Speaker`
+ */
+static void
+disable (void *cls)
+{
+  struct Speaker *spe = cls;
+
+  if (NULL == spe->playback_helper)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_HELPER_kill (spe->playback_helper, GNUNET_NO));
+  GNUNET_HELPER_destroy (spe->playback_helper);
+  spe->playback_helper = NULL;
+}
+
+
+/**
+ * Function to destroy a speaker.
+ *
+ * @param cls closure with the `struct Speaker`
+ */
+static void
+destroy (void *cls)
+{
+  struct Speaker *spe = cls;
+
+  if (NULL != spe->playback_helper)
+    disable (spe);
+}
+
+
+/**
+ * Function to cause a speaker to play audio data.
+ *
+ * @param cls clsoure with the `struct Speaker`
+ * @param data_size number of bytes in @a data
+ * @param data audio data to play, format is
+ *        opaque to the API but should be OPUS.
+ */
+static void
+play (void *cls,
+      size_t data_size,
+      const void *data)
+{
+  struct Speaker *spe = cls;
+  char buf[sizeof(struct AudioMessage) + data_size];
+  struct AudioMessage *am;
+
+  if (NULL == spe->playback_helper)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  am = (struct AudioMessage *) buf;
+  am->header.size = htons (sizeof(struct AudioMessage) + data_size);
+  am->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+  GNUNET_memcpy (&am[1], data, data_size);
+  (void) GNUNET_HELPER_send (spe->playback_helper,
+                             &am->header,
+                             GNUNET_NO,
+                             NULL, NULL);
+}
+
+
+/**
+ * Create a speaker that corresponds to the speaker hardware
+ * of our system.
+ *
+ * @param cfg configuration to use
+ * @return NULL on error
+ */
+struct GNUNET_SPEAKER_Handle *
+GNUNET_SPEAKER_create_from_hardware (const struct
+                                     GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_SPEAKER_Handle *speaker;
+  struct Speaker *spe;
+
+  spe = GNUNET_new (struct Speaker);
+  spe->cfg = cfg;
+  speaker = GNUNET_new (struct GNUNET_SPEAKER_Handle);
+  speaker->cls = spe;
+  speaker->enable_speaker = &enable;
+  speaker->play = &play;
+  speaker->disable_speaker = &disable;
+  speaker->destroy_speaker = &destroy;
+  return speaker;
+}
+
+
+/**
+ * Destroy a speaker.
+ *
+ * @param speaker speaker to destroy
+ */
+void
+GNUNET_SPEAKER_destroy (struct GNUNET_SPEAKER_Handle *speaker)
+{
+  speaker->destroy_speaker (speaker->cls);
+  GNUNET_free (speaker);
+}
+
+
+/* end of speaker.c */
diff --git a/src/contrib/service/conversation/test.sh b/src/contrib/service/conversation/test.sh
new file mode 100644
index 000000000..20e82bc88
--- /dev/null
+++ b/src/contrib/service/conversation/test.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+export GST_DEBUG_DUMP_DOT_DIR=/tmp/ 
+GST_DEBUG_DUMP_DOT_DIR=/tmp/ ./gnunet-helper-audio-record |GST_DEBUG_DUMP_DOT_DIR=/tmp/ ./gnunet-helper-audio-playback
diff --git a/src/contrib/service/conversation/test_conversation.conf b/src/contrib/service/conversation/test_conversation.conf
new file mode 100644
index 000000000..097aed592
--- /dev/null
+++ b/src/contrib/service/conversation/test_conversation.conf
@@ -0,0 +1,12 @@
+@INLINE@ ../../../../contrib/conf/gnunet/no_forcestart.conf
+
+[conversation]
+LINE=1
+#PREFIX = valgrind
+
+[zonemaster]
+IMMEDIATE_START = YES
+START_ON_DEMAND = YES
+
+[nse]
+WORKBITS = 0
diff --git a/src/contrib/service/conversation/test_conversation_api.c b/src/contrib/service/conversation/test_conversation_api.c
new file mode 100644
index 000000000..decc40b64
--- /dev/null
+++ b/src/contrib/service/conversation/test_conversation_api.c
@@ -0,0 +1,510 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013, 2014, 2018 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/test_conversation_api.c
+ * @brief testcase for conversation_api.c
+ *
+ * This test performs the operations of a call to a phone
+ * where the phone user picks up and then the call is
+ * terminated by the party that initiated the call.
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_conversation_service.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_namestore_service.h"
+
+#define FREQ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 25)
+
+static int ok = 1;
+
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static struct GNUNET_IDENTITY_Handle *id;
+
+static struct GNUNET_IDENTITY_Operation *op;
+
+static struct GNUNET_CONVERSATION_Phone *phone;
+
+static struct GNUNET_NAMESTORE_Handle *ns;
+
+static struct GNUNET_CONVERSATION_Call *call;
+
+static struct GNUNET_NAMESTORE_QueueEntry *qe;
+
+static struct GNUNET_CONVERSATION_Caller *active_caller;
+
+static char *gns_name;
+
+static char *gns_caller_id;
+
+static GNUNET_MICROPHONE_RecordedDataCallback phone_rdc;
+
+static void *phone_rdc_cls;
+
+static GNUNET_MICROPHONE_RecordedDataCallback call_rdc;
+
+static void *call_rdc_cls;
+
+static struct GNUNET_SCHEDULER_Task *phone_task;
+
+static struct GNUNET_SCHEDULER_Task *call_task;
+
+
+static void
+phone_send (void *cls)
+{
+  static unsigned int i;
+  char buf[32];
+
+  (void) cls;
+  GNUNET_assert (NULL != phone_rdc);
+  GNUNET_snprintf (buf, sizeof(buf), "phone-%u", i++);
+  phone_rdc (phone_rdc_cls, strlen (buf) + 1, buf);
+  phone_task = GNUNET_SCHEDULER_add_delayed (FREQ, &phone_send, NULL);
+}
+
+
+static void
+call_send (void *cls)
+{
+  static unsigned int i;
+  char buf[32];
+
+  (void) cls;
+  GNUNET_assert (NULL != call_rdc);
+  GNUNET_snprintf (buf, sizeof(buf), "call-%u", i++);
+  call_rdc (call_rdc_cls, strlen (buf) + 1, buf);
+  call_task = GNUNET_SCHEDULER_add_delayed (FREQ, &call_send, NULL);
+}
+
+
+static int
+enable_speaker (void *cls)
+{
+  const char *origin = cls;
+
+  fprintf (stderr, "Speaker %s enabled\n", origin);
+  return GNUNET_OK;
+}
+
+
+static void
+disable_speaker (void *cls)
+{
+  const char *origin = cls;
+
+  fprintf (stderr, "Speaker %s disabled\n", origin);
+}
+
+
+static void
+play (void *cls, size_t data_size, const void *data)
+{
+  const char *origin = cls;
+  static unsigned int phone_i = 1;
+  static unsigned int call_i;
+  char buf[32];
+
+  if (0 == strcmp (origin, "phone"))
+    GNUNET_snprintf (buf, sizeof(buf), "call-%u", call_i++);
+  else
+    GNUNET_snprintf (buf, sizeof(buf), "phone-%u", phone_i++);
+  if ((data_size != strlen (buf) + 1) || (0 != strncmp (buf, data, data_size)))
+  {
+    fprintf (stderr,
+             "Expected %s, received %.*s\n",
+             buf,
+             (int) data_size,
+             (const char *) data);
+  }
+  else
+  {
+    fprintf (stderr, ".");
+  }
+  if ((20 < call_i) && (20 < phone_i) && (NULL != call))
+  {
+    /* time to hang up ... */
+    GNUNET_CONVERSATION_call_stop (call);
+    call = NULL;
+  }
+}
+
+
+static void
+destroy_speaker (void *cls)
+{
+  const char *origin = cls;
+
+  fprintf (stderr, "Speaker %s destroyed\n", origin);
+}
+
+
+static struct GNUNET_SPEAKER_Handle call_speaker = { &enable_speaker,
+                                                     &play,
+                                                     &disable_speaker,
+                                                     &destroy_speaker,
+                                                     "caller" };
+
+
+static struct GNUNET_SPEAKER_Handle phone_speaker = { &enable_speaker,
+                                                      &play,
+                                                      &disable_speaker,
+                                                      &destroy_speaker,
+                                                      "phone" };
+
+
+static int
+enable_mic (void *cls,
+            GNUNET_MICROPHONE_RecordedDataCallback rdc,
+            void *rdc_cls)
+{
+  const char *origin = cls;
+
+  fprintf (stderr, "Mic %s enabled\n", origin);
+  if (0 == strcmp (origin, "phone"))
+  {
+    phone_rdc = rdc;
+    phone_rdc_cls = rdc_cls;
+    phone_task = GNUNET_SCHEDULER_add_now (&phone_send, NULL);
+  }
+  else
+  {
+    call_rdc = rdc;
+    call_rdc_cls = rdc_cls;
+    call_task = GNUNET_SCHEDULER_add_now (&call_send, NULL);
+  }
+  return GNUNET_OK;
+}
+
+
+static void
+disable_mic (void *cls)
+{
+  const char *origin = cls;
+
+  fprintf (stderr, "Mic %s disabled\n", origin);
+  if (0 == strcmp (origin, "phone"))
+  {
+    phone_rdc = NULL;
+    phone_rdc_cls = NULL;
+    GNUNET_SCHEDULER_cancel (phone_task);
+    phone_task = NULL;
+  }
+  else
+  {
+    call_rdc = NULL;
+    call_rdc_cls = NULL;
+    GNUNET_SCHEDULER_cancel (call_task);
+    call_task = NULL;
+  }
+}
+
+
+static void
+destroy_mic (void *cls)
+{
+  const char *origin = cls;
+
+  fprintf (stderr, "Mic %s destroyed\n", origin);
+}
+
+
+static struct GNUNET_MICROPHONE_Handle call_mic = { &enable_mic,
+                                                    &disable_mic,
+                                                    &destroy_mic,
+                                                    "caller" };
+
+
+static struct GNUNET_MICROPHONE_Handle phone_mic = { &enable_mic,
+                                                     &disable_mic,
+                                                     &destroy_mic,
+                                                     "phone" };
+
+
+/**
+ * Signature of the main function of a task.
+ *
+ * @param cls closure
+ */
+static void
+end_test (void *cls)
+{
+  (void) cls;
+  GNUNET_SCHEDULER_shutdown ();
+  if (NULL != op)
+  {
+    GNUNET_IDENTITY_cancel (op);
+    op = NULL;
+  }
+  if (NULL != call)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    call = NULL;
+  }
+  if (NULL != phone)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from PHONE service.\n");
+    GNUNET_CONVERSATION_phone_destroy (phone);
+    phone = NULL;
+  }
+  if (NULL != id)
+  {
+    GNUNET_IDENTITY_disconnect (id);
+    id = NULL;
+  }
+  if (NULL != qe)
+  {
+    GNUNET_NAMESTORE_cancel (qe);
+    qe = NULL;
+  }
+  if (NULL != ns)
+  {
+    GNUNET_NAMESTORE_disconnect (ns);
+    ns = NULL;
+  }
+}
+
+
+static void
+caller_event_handler (void *cls, enum GNUNET_CONVERSATION_CallerEventCode code)
+{
+  (void) cls;
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALLER_SUSPEND:
+  case GNUNET_CONVERSATION_EC_CALLER_RESUME:
+    fprintf (stderr, "Unexpected caller code: %d\n", code);
+    break;
+  }
+}
+
+
+static void
+phone_event_handler (void *cls,
+                     enum GNUNET_CONVERSATION_PhoneEventCode code,
+                     struct GNUNET_CONVERSATION_Caller *caller,
+                     const struct GNUNET_CRYPTO_PublicKey *caller_id)
+{
+  static enum GNUNET_CONVERSATION_PhoneEventCode expect =
+    GNUNET_CONVERSATION_EC_PHONE_RING;
+
+  (void) cls;
+  (void) caller_id;
+  GNUNET_break (code == expect);
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_PHONE_RING:
+    active_caller = caller;
+    GNUNET_CONVERSATION_caller_pick_up (caller,
+                                        &caller_event_handler,
+                                        NULL,
+                                        &phone_speaker,
+                                        &phone_mic);
+    expect = GNUNET_CONVERSATION_EC_PHONE_HUNG_UP;
+    break;
+
+  case GNUNET_CONVERSATION_EC_PHONE_HUNG_UP:
+    GNUNET_break (caller == active_caller);
+    active_caller = NULL;
+    if (1 == ok)
+      ok = 0;
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  default:
+    fprintf (stderr, "Unexpected phone code: %d\n", code);
+    break;
+  }
+}
+
+
+static void
+call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
+{
+  static enum GNUNET_CONVERSATION_CallEventCode expect =
+    GNUNET_CONVERSATION_EC_CALL_RINGING;
+
+  (void) cls;
+  GNUNET_break (code == expect);
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALL_RINGING:
+    expect = GNUNET_CONVERSATION_EC_CALL_PICKED_UP;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
+    expect = -1;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
+  case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
+    call = NULL;
+    ok = 2;
+    GNUNET_break (0);
+    fprintf (stderr, "Unexpected call code: %d\n", code);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
+  case GNUNET_CONVERSATION_EC_CALL_RESUMED:
+    GNUNET_break (0);
+    fprintf (stderr, "Unexpected call code: %d\n", code);
+    ok = 2;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_ERROR:
+    GNUNET_break (0);
+    fprintf (stderr, "Unexpected call code: %d\n", code);
+    call = NULL;
+    ok = 2;
+    break;
+  }
+}
+
+
+static void
+caller_ego_create_cont (void *cls,
+                        const struct GNUNET_CRYPTO_PrivateKey *pk,
+                        enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  op = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+}
+
+
+static void
+namestore_put_cont (void *cls, enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  qe = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+  GNUNET_assert (NULL == op);
+  op = GNUNET_IDENTITY_create (id, "caller-ego", NULL,
+                               GNUNET_PUBLIC_KEY_TYPE_ECDSA,
+                               &caller_ego_create_cont,
+                               NULL);
+}
+
+
+static void
+identity_cb (void *cls,
+             struct GNUNET_IDENTITY_Ego *ego,
+             void **ctx,
+             const char *name)
+{
+  struct GNUNET_GNSRECORD_Data rd;
+  struct GNUNET_CRYPTO_PublicKey pub;
+
+  (void) cls;
+  (void) ctx;
+  if (NULL == name)
+    return;
+  if (NULL == ego)
+    return;
+  if (0 == strcmp (name, "phone-ego"))
+  {
+    GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
+    GNUNET_asprintf (&gns_name,
+                     "phone.%s",
+                     GNUNET_GNSRECORD_pkey_to_zkey (&pub));
+    phone =
+      GNUNET_CONVERSATION_phone_create (cfg, ego, &phone_event_handler, NULL);
+    GNUNET_assert (NULL != phone);
+    memset (&rd, 0, sizeof(rd));
+    GNUNET_CONVERSATION_phone_get_record (phone, &rd);
+    GNUNET_assert (rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE);
+    rd.expiration_time = UINT64_MAX;
+    qe =
+      GNUNET_NAMESTORE_record_set_store (ns,
+                                      GNUNET_IDENTITY_ego_get_private_key (ego),
+                                      "phone" /* GNS label */,
+                                      1,
+                                      &rd,
+                                      &namestore_put_cont,
+                                      NULL);
+    return;
+  }
+  if (0 == strcmp (name, "caller-ego"))
+  {
+    GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
+    GNUNET_asprintf (&gns_caller_id,
+                     "%s",
+                     GNUNET_GNSRECORD_pkey_to_zkey (&pub));
+    call = GNUNET_CONVERSATION_call_start (cfg,
+                                           ego,
+                                           gns_name,
+                                           &call_speaker,
+                                           &call_mic,
+                                           &call_event_handler,
+                                           NULL);
+    return;
+  }
+}
+
+
+static void
+phone_ego_create_cont (void *cls,
+                       const struct GNUNET_CRYPTO_PrivateKey *pk,
+                       enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  op = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+}
+
+
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_TESTING_Peer *peer)
+{
+  (void) cls;
+  (void) peer;
+  cfg = c;
+  GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_test, NULL);
+  id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
+  op = GNUNET_IDENTITY_create (id, "phone-ego", NULL,
+                               GNUNET_PUBLIC_KEY_TYPE_ECDSA,
+                               &phone_ego_create_cont,
+                               NULL);
+  ns = GNUNET_NAMESTORE_connect (cfg);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  (void) argc;
+  (void) argv;
+  if (0 != GNUNET_TESTING_peer_run ("test_conversation_api",
+                                    "test_conversation.conf",
+                                    &run,
+                                    NULL))
+    return 1;
+  return ok;
+}
+
+
+/* end of test_conversation_api.c */
diff --git a/src/contrib/service/conversation/test_conversation_api_reject.c b/src/contrib/service/conversation/test_conversation_api_reject.c
new file mode 100644
index 000000000..248c7835d
--- /dev/null
+++ b/src/contrib/service/conversation/test_conversation_api_reject.c
@@ -0,0 +1,363 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013, 2014, 2018 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/test_conversation_api_reject.c
+ * @brief testcase for conversation_api.c
+ *
+ * This test performs the operations of a call to a phone
+ * where the phone user immediately hangs up (rejecting the
+ * call).
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_conversation_service.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_namestore_service.h"
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 25)
+
+static int ok = 1;
+
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static struct GNUNET_IDENTITY_Handle *id;
+
+static struct GNUNET_IDENTITY_Operation *op;
+
+static struct GNUNET_CONVERSATION_Phone *phone;
+
+static struct GNUNET_NAMESTORE_Handle *ns;
+
+static struct GNUNET_CONVERSATION_Call *call;
+
+static struct GNUNET_NAMESTORE_QueueEntry *qe;
+
+static char *gns_name;
+
+static char *gns_caller_id;
+
+
+static int
+enable_speaker (void *cls)
+{
+  (void) cls;
+  GNUNET_break (0);
+  return GNUNET_SYSERR;
+}
+
+
+static void
+disable_speaker (void *cls)
+{
+  (void) cls;
+  GNUNET_break (0);
+}
+
+
+static void
+play (void *cls, size_t data_size, const void *data)
+{
+  (void) cls;
+  (void) data_size;
+  (void) data;
+  GNUNET_break (0);
+}
+
+
+static void
+destroy_speaker (void *cls)
+{
+  (void) cls;
+}
+
+
+static struct GNUNET_SPEAKER_Handle call_speaker = { &enable_speaker,
+                                                     &play,
+                                                     &disable_speaker,
+                                                     &destroy_speaker,
+                                                     "caller" };
+
+
+static int
+enable_mic (void *cls,
+            GNUNET_MICROPHONE_RecordedDataCallback rdc,
+            void *rdc_cls)
+{
+  (void) cls;
+  (void) rdc;
+  (void) rdc_cls;
+  GNUNET_break (0);
+  return GNUNET_SYSERR;
+}
+
+
+static void
+disable_mic (void *cls)
+{
+  (void) cls;
+  GNUNET_break (0);
+}
+
+
+static void
+destroy_mic (void *cls)
+{
+  (void) cls;
+}
+
+
+static struct GNUNET_MICROPHONE_Handle call_mic = { &enable_mic,
+                                                    &disable_mic,
+                                                    &destroy_mic,
+                                                    "caller" };
+
+
+/**
+ * Signature of the main function of a task.
+ *
+ * @param cls closure
+ */
+static void
+end_test (void *cls)
+{
+  (void) cls;
+  GNUNET_SCHEDULER_shutdown ();
+  if (NULL != op)
+  {
+    GNUNET_IDENTITY_cancel (op);
+    op = NULL;
+  }
+  if (NULL != call)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    call = NULL;
+  }
+  if (NULL != phone)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from PHONE service.\n");
+    GNUNET_CONVERSATION_phone_destroy (phone);
+    phone = NULL;
+  }
+  if (NULL != id)
+  {
+    GNUNET_IDENTITY_disconnect (id);
+    id = NULL;
+  }
+  if (NULL != qe)
+  {
+    GNUNET_NAMESTORE_cancel (qe);
+    qe = NULL;
+  }
+  if (NULL != ns)
+  {
+    GNUNET_NAMESTORE_disconnect (ns);
+    ns = NULL;
+  }
+}
+
+
+static void
+phone_event_handler (void *cls,
+                     enum GNUNET_CONVERSATION_PhoneEventCode code,
+                     struct GNUNET_CONVERSATION_Caller *caller,
+                     const struct GNUNET_CRYPTO_PublicKey *caller_id)
+{
+  static enum GNUNET_CONVERSATION_PhoneEventCode expect =
+    GNUNET_CONVERSATION_EC_PHONE_RING;
+
+  (void) cls;
+  (void) caller_id;
+  GNUNET_break (code == expect);
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_PHONE_RING:
+    GNUNET_CONVERSATION_caller_hang_up (caller);
+    break;
+
+  default:
+    fprintf (stderr, "Unexpected phone code: %d\n", code);
+    break;
+  }
+}
+
+
+static void
+call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
+{
+  static enum GNUNET_CONVERSATION_CallEventCode expect =
+    GNUNET_CONVERSATION_EC_CALL_RINGING;
+
+  (void) cls;
+  GNUNET_break (code == expect);
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALL_RINGING:
+    expect = GNUNET_CONVERSATION_EC_CALL_HUNG_UP;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
+    call = NULL;
+    ok = 0;
+    GNUNET_SCHEDULER_shutdown ();
+    expect = -1;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
+  case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
+  case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
+  case GNUNET_CONVERSATION_EC_CALL_RESUMED:
+    fprintf (stderr, "Unexpected call code: %d\n", code);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_ERROR:
+    fprintf (stderr, "Unexpected call code: %d\n", code);
+    call = NULL;
+    break;
+  }
+}
+
+
+static void
+caller_ego_create_cont (void *cls,
+                        const struct GNUNET_CRYPTO_PrivateKey *pk,
+                        enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  op = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+}
+
+
+static void
+namestore_put_cont (void *cls, enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  qe = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+  GNUNET_assert (NULL == op);
+  op = GNUNET_IDENTITY_create (id, "caller-ego", NULL,
+                               GNUNET_PUBLIC_KEY_TYPE_ECDSA,
+                               &caller_ego_create_cont,
+                               NULL);
+}
+
+
+static void
+identity_cb (void *cls,
+             struct GNUNET_IDENTITY_Ego *ego,
+             void **ctx,
+             const char *name)
+{
+  struct GNUNET_GNSRECORD_Data rd;
+  struct GNUNET_CRYPTO_PublicKey pub;
+
+  (void) cls;
+  (void) ctx;
+  if (NULL == name)
+    return;
+  if (NULL == ego)
+    return;
+  if (0 == strcmp (name, "phone-ego"))
+  {
+    GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
+    GNUNET_asprintf (&gns_name,
+                     "phone.%s",
+                     GNUNET_GNSRECORD_pkey_to_zkey (&pub));
+    phone =
+      GNUNET_CONVERSATION_phone_create (cfg, ego, &phone_event_handler, NULL);
+    GNUNET_assert (NULL != phone);
+    memset (&rd, 0, sizeof(rd));
+    GNUNET_CONVERSATION_phone_get_record (phone, &rd);
+    GNUNET_assert (rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE);
+    rd.expiration_time = UINT64_MAX;
+    qe =
+      GNUNET_NAMESTORE_record_set_store (ns,
+                                      GNUNET_IDENTITY_ego_get_private_key (ego),
+                                      "phone" /* GNS label */,
+                                      1,
+                                      &rd,
+                                      &namestore_put_cont,
+                                      NULL);
+    return;
+  }
+  if (0 == strcmp (name, "caller-ego"))
+  {
+    GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
+    GNUNET_asprintf (&gns_caller_id,
+                     "%s",
+                     GNUNET_GNSRECORD_pkey_to_zkey (&pub));
+    call = GNUNET_CONVERSATION_call_start (cfg,
+                                           ego,
+                                           gns_name,
+                                           &call_speaker,
+                                           &call_mic,
+                                           &call_event_handler,
+                                           NULL);
+    return;
+  }
+}
+
+
+static void
+phone_ego_create_cont (void *cls,
+                       const struct GNUNET_CRYPTO_PrivateKey *pk,
+                       enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  op = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+}
+
+
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_TESTING_Peer *peer)
+{
+  (void) cls;
+  (void) peer;
+  cfg = c;
+  GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_test, NULL);
+  id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
+  op = GNUNET_IDENTITY_create (id, "phone-ego", NULL,
+                               GNUNET_PUBLIC_KEY_TYPE_ECDSA,
+                               &phone_ego_create_cont,
+                               NULL);
+  ns = GNUNET_NAMESTORE_connect (cfg);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  (void) argc;
+  (void) argv;
+  if (0 != GNUNET_TESTING_peer_run ("test_conversation_api",
+                                    "test_conversation.conf",
+                                    &run,
+                                    NULL))
+    return 1;
+  return ok;
+}
+
+
+/* end of test_conversation_api_reject.c */
diff --git a/src/contrib/service/conversation/test_conversation_api_twocalls.c b/src/contrib/service/conversation/test_conversation_api_twocalls.c
new file mode 100644
index 000000000..cc4969e09
--- /dev/null
+++ b/src/contrib/service/conversation/test_conversation_api_twocalls.c
@@ -0,0 +1,642 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013, 2018x GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/test_conversation_api_twocalls.c
+ * @brief testcase for conversation_api.c
+ *
+ * This test performs the operations of TWO calls made to a phone
+ * where the phone user picks up one, suspends it, picks up the
+ * second one; eventually, the initiator hangs up, the callee
+ * resumes the first call, and then the initiator hangs up the
+ * second call.
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_conversation_service.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_namestore_service.h"
+
+#define FREQ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 25)
+
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+#define LOG_DEBUG(...) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
+
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static struct GNUNET_IDENTITY_Handle *id;
+
+static struct GNUNET_IDENTITY_Operation *op;
+
+static struct GNUNET_CONVERSATION_Phone *phone;
+
+static struct GNUNET_NAMESTORE_Handle *ns;
+
+static struct GNUNET_CONVERSATION_Call *call1;
+
+static struct GNUNET_CONVERSATION_Call *call2;
+
+static struct GNUNET_NAMESTORE_QueueEntry *qe;
+
+static struct GNUNET_CONVERSATION_Caller *active_caller1;
+
+static struct GNUNET_CONVERSATION_Caller *active_caller2;
+
+static char *gns_name;
+
+static char *gns_caller_id;
+
+static GNUNET_MICROPHONE_RecordedDataCallback phone_rdc;
+
+static void *phone_rdc_cls;
+
+static struct GNUNET_SCHEDULER_Task *phone_task;
+
+static struct GNUNET_SCHEDULER_Task *timeout_task;
+
+/**
+ * Variable for recognizing caller1
+ */
+static const char *caller1 = "caller1";
+
+/**
+ * Variable for recognizing caller2
+ */
+static const char *caller2 = "caller2";
+
+/**
+ * Variable for recognizing callee
+ */
+static const char *phone0 = "phone";
+
+
+#define CALLER1 &caller1
+#define CALLER2 &caller2
+#define PHONE0 &phone0
+
+#define CLS_STR(caller) (*((char **) caller))
+
+
+/**
+ * Did caller1 call finish successfully
+ */
+static int call1_finished;
+
+/**
+ * Did caller2 call finish successfully
+ */
+static int call2_finished;
+
+struct MicContext
+{
+  GNUNET_MICROPHONE_RecordedDataCallback rdc;
+
+  void *rdc_cls;
+
+  struct GNUNET_SCHEDULER_Task *call_task;
+};
+
+static struct MicContext call1_mic_ctx;
+static struct MicContext call2_mic_ctx;
+// static struct MicContext phone_mic_ctx;
+
+
+static void
+phone_send (void *cls)
+{
+  char buf[32];
+
+  (void) cls;
+  GNUNET_assert (NULL != phone_rdc);
+  GNUNET_snprintf (buf, sizeof(buf), "phone");
+  phone_rdc (phone_rdc_cls, strlen (buf) + 1, buf);
+  phone_task = GNUNET_SCHEDULER_add_delayed (FREQ, &phone_send, NULL);
+}
+
+
+static void
+call_send (void *cls)
+{
+  struct MicContext *mc = cls;
+  char buf[32];
+
+  (void) cls;
+  GNUNET_assert (NULL != mc->rdc);
+  GNUNET_snprintf (buf, sizeof(buf), "call");
+  mc->rdc (mc->rdc_cls, strlen (buf) + 1, buf);
+  mc->call_task = GNUNET_SCHEDULER_add_delayed (FREQ, &call_send, mc);
+}
+
+
+static int
+enable_speaker (void *cls)
+{
+  const char *origin = CLS_STR (cls);
+
+  (void) cls;
+  LOG_DEBUG ("Speaker %s enabled\n", origin);
+  return GNUNET_OK;
+}
+
+
+static void
+disable_speaker (void *cls)
+{
+  const char *origin = CLS_STR (cls);
+
+  (void) cls;
+  LOG_DEBUG ("Speaker %s disabled\n", origin);
+}
+
+
+static void
+play (void *cls, size_t data_size, const void *data)
+{
+  static unsigned int phone_i;
+  static unsigned int call_i;
+
+  (void) cls;
+  if (0 == strncmp ("call", data, data_size))
+    call_i++;
+  else if (0 == strncmp ("phone", data, data_size))
+    phone_i++;
+  else
+  {
+    LOG_DEBUG ("Received %u bytes of unexpected data `%.*s'\n",
+               (unsigned int) data_size,
+               (int) data_size,
+               (const char *) data);
+  }
+
+  if ((20 < call_i) && (20 < phone_i) && (CALLER2 == cls))
+  {
+    /* time to hang up ... */
+    GNUNET_CONVERSATION_call_stop (call2);
+    call2 = NULL;
+    /* reset counters */
+    call_i = 0;
+    phone_i = 0;
+    call2_finished = GNUNET_YES;
+  }
+  if ((20 < call_i) && (20 < phone_i) && (CALLER1 == cls))
+  {
+    /* time to hang up ... */
+    GNUNET_CONVERSATION_call_stop (call1);
+    call1 = NULL;
+    call_i = 0;
+    phone_i = 0;
+    call1_finished = GNUNET_YES;
+  }
+}
+
+
+static void
+destroy_speaker (void *cls)
+{
+  const char *origin = CLS_STR (cls);
+
+  LOG_DEBUG ("Speaker %s destroyed\n", origin);
+}
+
+
+static struct GNUNET_SPEAKER_Handle call1_speaker = { &enable_speaker,
+                                                      &play,
+                                                      &disable_speaker,
+                                                      &destroy_speaker,
+                                                      CALLER1 };
+
+
+static struct GNUNET_SPEAKER_Handle call2_speaker = { &enable_speaker,
+                                                      &play,
+                                                      &disable_speaker,
+                                                      &destroy_speaker,
+                                                      CALLER2 };
+
+
+static struct GNUNET_SPEAKER_Handle phone_speaker = { &enable_speaker,
+                                                      &play,
+                                                      &disable_speaker,
+                                                      &destroy_speaker,
+                                                      PHONE0 };
+
+
+static int
+enable_mic (void *cls,
+            GNUNET_MICROPHONE_RecordedDataCallback rdc,
+            void *rdc_cls)
+{
+  const char *origin = CLS_STR (cls);
+  struct MicContext *mc;
+
+  LOG_DEBUG ("Mic %s enabled\n", origin);
+  if (PHONE0 == cls)
+  {
+    phone_rdc = rdc;
+    phone_rdc_cls = rdc_cls;
+    GNUNET_break (NULL == phone_task);
+    phone_task = GNUNET_SCHEDULER_add_now (&phone_send, NULL);
+    return GNUNET_OK;
+  }
+  mc = (CALLER1 == cls) ? &call1_mic_ctx : &call2_mic_ctx;
+  mc->rdc = rdc;
+  mc->rdc_cls = rdc_cls;
+  GNUNET_break (NULL == mc->call_task);
+  mc->call_task = GNUNET_SCHEDULER_add_now (&call_send, mc);
+  return GNUNET_OK;
+}
+
+
+static void
+disable_mic (void *cls)
+{
+  const char *origin = CLS_STR (cls);
+  struct MicContext *mc;
+
+  LOG_DEBUG ("Mic %s disabled\n", origin);
+  if (PHONE0 == cls)
+  {
+    phone_rdc = NULL;
+    phone_rdc_cls = NULL;
+    GNUNET_SCHEDULER_cancel (phone_task);
+    phone_task = NULL;
+    return;
+  }
+  mc = (CALLER1 == cls) ? &call1_mic_ctx : &call2_mic_ctx;
+  mc->rdc = NULL;
+  mc->rdc_cls = NULL;
+  GNUNET_SCHEDULER_cancel (mc->call_task);
+  mc->call_task = NULL;
+}
+
+
+static void
+destroy_mic (void *cls)
+{
+  const char *origin = CLS_STR (cls);
+
+  LOG_DEBUG ("Mic %s destroyed\n", origin);
+}
+
+
+static struct GNUNET_MICROPHONE_Handle call1_mic = { &enable_mic,
+                                                     &disable_mic,
+                                                     &destroy_mic,
+                                                     CALLER1 };
+
+
+static struct GNUNET_MICROPHONE_Handle call2_mic = { &enable_mic,
+                                                     &disable_mic,
+                                                     &destroy_mic,
+                                                     CALLER2 };
+
+
+static struct GNUNET_MICROPHONE_Handle phone_mic = { &enable_mic,
+                                                     &disable_mic,
+                                                     &destroy_mic,
+                                                     PHONE0 };
+
+
+/**
+ * Function run on timeout.
+ *
+ * @param cls closure
+ */
+static void
+end_test (void *cls)
+{
+  (void) cls;
+  timeout_task = NULL;
+  fprintf (stderr, "Timeout!\n");
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Function run on shutdown.
+ *
+ * @param cls closure
+ */
+static void
+do_shutdown (void *cls)
+{
+  (void) cls;
+  if (NULL != timeout_task)
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
+  if (NULL != op)
+  {
+    GNUNET_IDENTITY_cancel (op);
+    op = NULL;
+  }
+  if (NULL != call1)
+  {
+    GNUNET_CONVERSATION_call_stop (call1);
+    call1 = NULL;
+  }
+  if (NULL != call2)
+  {
+    GNUNET_CONVERSATION_call_stop (call2);
+    call2 = NULL;
+  }
+  if (NULL != phone)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from PHONE service.\n");
+    GNUNET_CONVERSATION_phone_destroy (phone);
+    phone = NULL;
+  }
+  if (NULL != id)
+  {
+    GNUNET_IDENTITY_disconnect (id);
+    id = NULL;
+  }
+  if (NULL != qe)
+  {
+    GNUNET_NAMESTORE_cancel (qe);
+    qe = NULL;
+  }
+  if (NULL != ns)
+  {
+    GNUNET_NAMESTORE_disconnect (ns);
+    ns = NULL;
+  }
+}
+
+
+static void
+caller_event_handler (void *cls, enum GNUNET_CONVERSATION_CallerEventCode code)
+{
+  (void) cls;
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALLER_SUSPEND:
+  case GNUNET_CONVERSATION_EC_CALLER_RESUME:
+    LOG (GNUNET_ERROR_TYPE_WARNING, "Unexpected caller code: %d\n", code);
+    break;
+  }
+}
+
+
+static void
+phone_event_handler (void *cls,
+                     enum GNUNET_CONVERSATION_PhoneEventCode code,
+                     struct GNUNET_CONVERSATION_Caller *caller,
+                     const struct GNUNET_CRYPTO_PublicKey *caller_id)
+{
+  const char *cid;
+
+  (void) cls;
+  (void) caller_id;
+
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_PHONE_RING:
+    if (NULL == active_caller1)
+    {
+      active_caller1 = caller;
+      cid = "caller1";
+      GNUNET_CONVERSATION_caller_pick_up (caller,
+                                          &caller_event_handler,
+                                          (void *) cid,
+                                          &phone_speaker,
+                                          &phone_mic);
+    }
+    else
+    {
+      GNUNET_CONVERSATION_caller_suspend (active_caller1);
+      active_caller2 = caller;
+      cid = "caller2";
+      GNUNET_CONVERSATION_caller_pick_up (caller,
+                                          &caller_event_handler,
+                                          (void *) cid,
+                                          &phone_speaker,
+                                          &phone_mic);
+    }
+    break;
+
+  case GNUNET_CONVERSATION_EC_PHONE_HUNG_UP:
+    if (caller == active_caller2)
+    {
+      active_caller2 = NULL;
+      GNUNET_CONVERSATION_caller_resume (active_caller1,
+                                         &phone_speaker,
+                                         &phone_mic);
+    }
+    else if (caller == active_caller1)
+    {
+      active_caller1 = NULL;
+      GNUNET_break (NULL == active_caller2);
+      GNUNET_SCHEDULER_shutdown ();
+    }
+    break;
+
+  default:
+    LOG (GNUNET_ERROR_TYPE_WARNING, "Unexpected phone code: %d\n", code);
+    break;
+  }
+}
+
+
+static void
+call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
+{
+  const char *cid = cls;
+
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALL_RINGING:
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
+    LOG_DEBUG ("Call %s picked\n", cid);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
+    LOG_DEBUG ("Call %s GNS lookup failed \n", cid);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
+    LOG_DEBUG ("Call %s hungup\n", cid);
+    if (0 == strcmp (cid, "call1"))
+      call1 = NULL;
+    else
+      call2 = NULL;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
+    LOG_DEBUG ("Call %s suspended\n", cid);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_RESUMED:
+    LOG_DEBUG ("Call %s resumed\n", cid);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_ERROR:
+    GNUNET_break (0);
+    if (0 == strcmp (cid, "call1"))
+      call1 = NULL;
+    else
+      call2 = NULL;
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+  }
+}
+
+
+static void
+caller_ego_create_cont (void *cls,
+                        const struct GNUNET_CRYPTO_PrivateKey *pk,
+                        enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  op = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+}
+
+
+static void
+namestore_put_cont (void *cls, enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  qe = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+  GNUNET_assert (NULL == op);
+  op = GNUNET_IDENTITY_create (id, "caller-ego", NULL,
+                               GNUNET_PUBLIC_KEY_TYPE_ECDSA,
+                               &caller_ego_create_cont,
+                               NULL);
+}
+
+
+static void
+identity_cb (void *cls,
+             struct GNUNET_IDENTITY_Ego *ego,
+             void **ctx,
+             const char *name)
+{
+  struct GNUNET_GNSRECORD_Data rd;
+  struct GNUNET_CRYPTO_PublicKey pub;
+
+  (void) cls;
+  (void) ctx;
+  if (NULL == name)
+    return;
+  if (NULL == ego)
+    return;
+  if (0 == strcmp (name, "phone-ego"))
+  {
+    GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
+    GNUNET_asprintf (&gns_name,
+                     "phone.%s",
+                     GNUNET_GNSRECORD_pkey_to_zkey (&pub));
+    phone =
+      GNUNET_CONVERSATION_phone_create (cfg, ego, &phone_event_handler, NULL);
+    GNUNET_assert (NULL != phone);
+    memset (&rd, 0, sizeof(rd));
+    GNUNET_CONVERSATION_phone_get_record (phone, &rd);
+    GNUNET_assert (rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE);
+    rd.expiration_time = UINT64_MAX;
+    qe =
+      GNUNET_NAMESTORE_record_set_store (ns,
+                                      GNUNET_IDENTITY_ego_get_private_key (ego),
+                                      "phone" /* GNS label */,
+                                      1,
+                                      &rd,
+                                      &namestore_put_cont,
+                                      NULL);
+    return;
+  }
+  if (0 == strcmp (name, "caller-ego"))
+  {
+    GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
+    GNUNET_asprintf (&gns_caller_id,
+                     "%s",
+                     GNUNET_GNSRECORD_pkey_to_zkey (&pub));
+    call1 = GNUNET_CONVERSATION_call_start (cfg,
+                                            ego,
+                                            gns_name,
+                                            &call1_speaker,
+                                            &call1_mic,
+                                            &call_event_handler,
+                                            (void *) "call1");
+    call2 = GNUNET_CONVERSATION_call_start (cfg,
+                                            ego,
+                                            gns_name,
+                                            &call2_speaker,
+                                            &call2_mic,
+                                            &call_event_handler,
+                                            (void *) "call2");
+    return;
+  }
+}
+
+
+static void
+phone_ego_create_cont (void *cls,
+                       const struct GNUNET_CRYPTO_PrivateKey *pk,
+                       enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  op = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+}
+
+
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_TESTING_Peer *peer)
+{
+  (void) cls;
+  (void) peer;
+  cfg = c;
+  timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_test, NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+  id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
+  op = GNUNET_IDENTITY_create (id, "phone-ego", NULL,
+                               GNUNET_PUBLIC_KEY_TYPE_ECDSA,
+                               &phone_ego_create_cont,
+                               NULL);
+  ns = GNUNET_NAMESTORE_connect (cfg);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  (void) argc;
+  (void) argv;
+  if (0 != GNUNET_TESTING_peer_run ("test_conversation_api_twocalls",
+                                    "test_conversation.conf",
+                                    &run,
+                                    NULL))
+    return 1;
+  if (call1_finished && call2_finished)
+    return 0;
+  return 1;
+}
+
+
+/* end of test_conversation_api_twocalls.c */