Import libwfd from OpenWFD

Initial import of most generic WFD stuff from OpenWFD. The libwfd library
will be independent of any Miracast implementation so it can be shared
across projects. It will not provide any fancy integration or policy, but
only the most basic protocol parsers and handling.

Signed-off-by: David Herrmann <dh.herrmann@gmail.com>

20 files changed, 4376 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..53d0475
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,27 @@
+*.la
+*.lo
+*.log
+*.o
+*.swp
+*.tar.xz
+*.trs
+.deps/
+.dirstamp
+.libs/
+Makefile
+Makefile.in
+aclocal.m4
+autom4te.cache/
+build-aux/
+config.h
+config.h.in
+config.h.in~
+config.log
+config.status
+configure
+docs/libwfd.pc
+libtool
+m4/
+stamp-h1
+test-suite.log
+test_rtsp
diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..00a0ce5
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,37 @@
+= Authors =
+
+This software was written by:
+	David Herrmann <dh.herrmann@gmail.com>
+
+= Copyright Notice =
+
+This software is licensed under the terms of the MIT license. Please see each
+source file for the related copyright notice and license.
+
+If a file does not contain a copright notice, the following license shall
+apply:
+
+	Copyright (c) 2013-2014 David Herrmann <dh.herrmann@gmail.com>
+
+	Permission is hereby granted, free of charge, to any person obtaining
+	a copy of this software and associated documentation files
+	(the "Software"), to deal in the Software without restriction, including
+	without limitation the rights to use, copy, modify, merge, publish,
+	distribute, sublicense, and/or sell copies of the Software, and to
+	permit persons to whom the Software is furnished to do so, subject to
+	the following conditions:
+
+	The above copyright notice and this permission notice shall be included
+	in all copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+	IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+	CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+	TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+	SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+== Third-Party Source ==
+
+ - none so far -
diff --git a/Makefile.am b/Makefile.am
new file mode 100644
index 0000000..f2a1b82
--- /dev/null
+++ b/Makefile.am
@@ -0,0 +1,150 @@
+#
+# libwfd - Global Makefile
+# Copyright (c) 2013-2014 David Herrmann <dh.herrmann@gmail.com>
+#
+
+#
+# Library Version Numbers
+#
+
+LIBWFD_CURRENT = 0
+LIBWFD_REVISION = 0
+LIBWFD_AGE = 0
+
+#
+# Global Configurations and Initializations
+#
+
+ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}
+AM_MAKEFLAGS = --no-print-directory
+AUTOMAKE_OPTIONS = color-tests
+
+SUBDIRS = .
+
+.DELETE_ON_ERROR:
+
+include_HEADERS =
+EXTRA_DIST = \
+	README \
+	COPYING \
+	NEWS \
+	docs/libwfd.pc.in \
+	docs/libwfd.sym
+CLEANFILES =
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA =
+TPHONY =
+
+TESTS =
+MEMTESTS =
+check_PROGRAMS =
+lib_LTLIBRARIES =
+noinst_LTLIBRARIES =
+
+#
+# Default CFlags
+# Make all files include "config.h" by default. This shouldn't cause any
+# problems and we cannot forget to include it anymore.
+# Also make the linker discard all unused symbols.
+#
+
+AM_CFLAGS = \
+	-Wall \
+	-pipe \
+	-fno-common \
+	-ffast-math \
+	-fdiagnostics-show-option \
+	-fno-strict-aliasing \
+	-fvisibility=hidden \
+	-ffunction-sections \
+	-fdata-sections
+AM_CPPFLAGS = \
+	-include $(top_builddir)/config.h \
+	-I $(srcdir)/src
+AM_LDFLAGS = \
+	-Wl,--as-needed \
+	-Wl,--gc-sections \
+	-Wl,-z,relro \
+	-Wl,-z,now
+
+#
+# SHL - Static Helper Library
+# The SHL subsystem contains several small code pieces used all over libwfd and
+# other applications.
+#
+
+noinst_LTLIBRARIES += libshl.la
+
+libshl_la_SOURCES = \
+	src/shl_llog.h \
+	src/shl_macro.h \
+	src/shl_ring.h \
+	src/shl_ring.c \
+	src/shl_util.h \
+	src/shl_util.c
+libshl_la_CPPFLAGS = $(AM_CPPFLAGS)
+libshl_la_LDFLAGS = $(AM_LDFLAGS)
+libshl_la_LIBADD = $(AM_LIBADD)
+
+#
+# libwfd
+# Main library build instructions
+#
+
+lib_LTLIBRARIES += libwfd.la
+include_HEADERS += src/libwfd.h
+pkgconfig_DATA += docs/libwfd.pc
+
+libwfd_la_SOURCES = \
+	src/libwfd.h \
+	src/rtsp_decoder.c \
+	src/rtsp_tokenizer.c
+libwfd_la_CPPFLAGS = $(AM_CPPFLAGS)
+libwfd_la_LIBADD = libshl.la
+EXTRA_libwfd_la_DEPENDENCIES = $(top_srcdir)/docs/libwfd.sym
+libwfd_la_LDFLAGS = \
+	$(AM_LDFLAGS) \
+	-version-info $(LIBWFD_CURRENT):$(LIBWFD_REVISION):$(LIBWFD_AGE) \
+	-Wl,--version-script="$(top_srcdir)/docs/libwfd.sym"
+
+#
+# Tests
+#
+
+tests = \
+	test_rtsp
+
+if BUILD_HAVE_CHECK
+check_PROGRAMS += $(tests)
+TESTS += $(tests)
+endif
+
+test_sources = \
+	test/test_common.h
+test_libs = \
+	libwfd.la \
+	libshl.la \
+	$(CHECK_LIBS)
+test_cflags = \
+	$(AM_CPPFLAGS) \
+	$(CHECK_CFLAGS)
+test_lflags = \
+	$(AM_LDFLAGS)
+
+test_rtsp_SOURCES = test/test_rtsp.c $(test_sources)
+test_rtsp_CPPFLAGS = $(test_cflags)
+test_rtsp_LDADD = $(test_libs)
+test_rtsp_LDFLAGS = $(test_lflags)
+
+#
+# Phony targets
+#
+
+.PHONY: $(TPHONY)
+
+#
+# Empty .SECONDARY target causes alle intermediate files to be treated as
+# secondary files. That is, they don't get deleted after make finished.
+#
+
+.SECONDARY:
diff --git a/NEWS b/NEWS
new file mode 100644
index 0000000..a34083d
--- /dev/null
+++ b/NEWS
@@ -0,0 +1,4 @@
+= libwfd Release News =
+
+CHANGES WITH 1:
+	* TODO
diff --git a/README b/README
new file mode 100644
index 0000000..4c184a2
--- /dev/null
+++ b/README
@@ -0,0 +1,40 @@
+= libwfd - Wifi-Display/Miracast Protocol Implementation =
+
+TODO
+
+Website:
+  http://www.freedesktop.org/wiki/Software/miraclecast
+
+== Requirements ==
+
+  libwfd has no runtime requirements other than a ISO-C compatible C library.
+
+== Download ==
+
+Released tarballs can be found at:
+  http://www.freedesktop.org/software/miraclecast/releases
+
+== Install ==
+
+  To compile libwfd, run the standard autotools commands:
+    $ test -f ./configure || NOCONFIGURE=1 ./autogen.sh
+    $ ./configure --prefix=/usr
+    $ make
+    $ sudo make install
+  To compile and run the test applications, use:
+    $ make check
+
+== Documentation ==
+
+WIP
+
+== License ==
+
+  This software is licensed under the terms of an MIT-like license. Please see
+  ./COPYING for further information.
+
+== Contact ==
+
+  This software is maintained by:
+    David Herrmann <dh.herrmann@gmail.com>
+  If you have any questions, do not hesitate to contact one of the maintainers.
diff --git a/autogen.sh b/autogen.sh
new file mode 100755
index 0000000..65a6fe1
--- /dev/null
+++ b/autogen.sh
@@ -0,0 +1,17 @@
+#!/bin/sh
+set -e
+
+srcdir=`dirname $0`
+test -z "$srcdir" && srcdir=.
+
+origdir=`pwd`
+cd $srcdir
+
+mkdir -p m4
+autoreconf -is --force
+
+cd $origdir
+
+if test -z "$NOCONFIGURE" ; then
+    exec $srcdir/configure "$@"
+fi
diff --git a/configure.ac b/configure.ac
new file mode 100644
index 0000000..b92d6d7
--- /dev/null
+++ b/configure.ac
@@ -0,0 +1,75 @@
+#
+# libwfd - build configuration script
+# Copyright (c) 2013-2014 David Herrmann <dh.herrmann@gmail.com>
+#
+
+AC_PREREQ(2.68)
+
+AC_INIT([libwfd],
+        [3],
+        [http://www.freedesktop.org/wiki/Software/miraclecast],
+        [libwfd],
+        [http://www.freedesktop.org/wiki/Software/miraclecast])
+AC_CONFIG_SRCDIR([src/libwfd.h])
+AC_CONFIG_AUX_DIR([build-aux])
+AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_HEADER(config.h)
+AC_USE_SYSTEM_EXTENSIONS
+AC_SYS_LARGEFILE
+AC_CANONICAL_HOST
+
+AM_INIT_AUTOMAKE([foreign 1.11 subdir-objects dist-xz no-dist-gzip tar-pax -Wall -Werror -Wno-portability])
+AM_SILENT_RULES([yes])
+
+AC_SUBST(PACKAGE_DESCRIPTION, ["Wifi-Display/Miracast Protocol Implementation"])
+
+AC_PROG_CC
+AC_PROG_CC_C99
+AM_PROG_CC_C_O
+m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
+AC_PROG_SED
+AC_PROG_MKDIR_P
+AC_PROG_LN_S
+AC_PROG_GREP
+AC_PROG_AWK
+
+LT_PREREQ(2.2)
+LT_INIT
+
+#
+# Test for "check" which we use for our test-suite. If not found, we disable
+# all tests.
+#
+
+PKG_CHECK_MODULES([CHECK], [check],
+                  [have_check=yes], [have_check=no])
+AC_SUBST(CHECK_CFLAGS)
+AC_SUBST(CHECK_LIBS)
+AM_CONDITIONAL([BUILD_HAVE_CHECK], [test "x$have_check" = "xyes"])
+
+#
+# Makefile vars
+# After everything is configured, we create all makefiles.
+#
+
+AC_CONFIG_FILES([Makefile
+                 docs/libwfd.pc])
+AC_OUTPUT
+
+#
+# Configuration output
+# Show configuration to the user so they can check whether everything was
+# configured as expected.
+#
+
+AC_MSG_NOTICE([Build configuration:
+
+               prefix: $prefix
+          exec-prefix: $exec_prefix
+               libdir: $libdir
+           includedir: $includedir
+
+  Miscellaneous Options:
+       building tests: $have_check
+
+        Run "${MAKE-make}" to start compilation process])
diff --git a/docs/libwfd.pc.in b/docs/libwfd.pc.in
new file mode 100644
index 0000000..a3447b9
--- /dev/null
+++ b/docs/libwfd.pc.in
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libwfd
+Description: @PACKAGE_DESCRIPTION@
+URL: @PACKAGE_URL@
+Version: @PACKAGE_VERSION@
+Libs: -L${libdir} -lwfd
+Cflags: -I${includedir}
diff --git a/docs/libwfd.sym b/docs/libwfd.sym
new file mode 100644
index 0000000..a29cda1
--- /dev/null
+++ b/docs/libwfd.sym
@@ -0,0 +1,22 @@
+LIBWFD_1 {
+global:
+	wfd_rtsp_tokenize;
+
+	wfd_rtsp_method_get_name;
+	wfd_rtsp_method_from_name;
+	wfd_rtsp_status_is_valid;
+	wfd_rtsp_status_get_base;
+	wfd_rtsp_status_get_description;
+	wfd_rtsp_header_get_name;
+	wfd_rtsp_header_from_name;
+	wfd_rtsp_header_from_name_n;
+
+	wfd_rtsp_decoder_new;
+	wfd_rtsp_decoder_free;
+	wfd_rtsp_decoder_reset;
+	wfd_rtsp_decoder_set_data;
+	wfd_rtsp_decoder_get_data;
+	wfd_rtsp_decoder_feed;
+local:
+	*;
+};
diff --git a/src/libwfd.h b/src/libwfd.h
new file mode 100644
index 0000000..a43dd66
--- /dev/null
+++ b/src/libwfd.h
@@ -0,0 +1,816 @@
+/*
+ * libwfd - Wifi-Display/Miracast Protocol Implementation
+ *
+ * Copyright (c) 2013-2014 David Herrmann <dh.herrmann@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef WFD_LIBWFD_H
+#define WFD_LIBWFD_H
+
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WFD__PACKED __attribute__((__packed__))
+
+/**
+ * @defgroup wfd_p2p Wifi-Display Definitions for wifi-p2p
+ * Definitions from the Wifi-Display specification for Wifi-P2P
+ *
+ * This section contains definitions and constants from the Wifi-Display
+ * specification regarding Wifi-P2P. 
+ *
+ * @{
+ */
+
+/*
+ * TODO: WFD 5.2.7 defines service-discovery frames. wpa-supplicant currently
+ * does not support custom OUI fields. Fix this and then add support for
+ * WFD service discovery.
+ */
+
+/*
+ * IE elements
+ */
+
+#define WFD_IE_ID 0xdd
+#define WFD_IE_OUI_1_0 0x506f9a0a
+#define WFD_IE_DATA_MAX 251
+
+struct wfd_ie {
+	uint8_t element_id;
+	uint8_t length;
+	uint32_t oui;
+	uint8_t data[];
+} WFD__PACKED;
+
+/*
+ * IE subelements
+ */
+
+enum wfd_ie_sub_type {
+	WFD_IE_SUB_DEV_INFO			= 0,
+	WFD_IE_SUB_ASSOC_BSSID			= 1,
+	WFD_IE_SUB_AUDIO_FORMATS		= 2,
+	WFD_IE_SUB_VIDEO_FORMATS		= 3,
+	WFD_IE_SUB_3D_FORMATS			= 4,
+	WFD_IE_SUB_CONTENT_PROTECT		= 5,
+	WFD_IE_SUB_COUPLED_SINK			= 6,
+	WFD_IE_SUB_EXT_CAP			= 7,
+	WFD_IE_SUB_LOCAL_IP			= 8,
+	WFD_IE_SUB_SESSION_INFO			= 9,
+	WFD_IE_SUB_ALT_MAC			= 10,
+	WFD_IE_SUB_NUM
+};
+
+struct wfd_ie_sub {
+	uint8_t subelement_id;
+	uint16_t length;
+	uint8_t data[];
+} WFD__PACKED;
+
+/*
+ * IE subelement device information
+ */
+
+/* role */
+#define WFD_IE_SUB_DEV_INFO_ROLE_MASK			0x0003
+#define WFD_IE_SUB_DEV_INFO_SOURCE			0x0000
+#define WFD_IE_SUB_DEV_INFO_PRIMARY_SINK		0x0001
+#define WFD_IE_SUB_DEV_INFO_SECONDARY_SINK		0x0002
+#define WFD_IE_SUB_DEV_INFO_DUAL_ROLE			0x0003
+
+/* coupled sink as source */
+#define WFD_IE_SUB_DEV_INFO_SRC_COUPLED_SINK_MASK	0x0004
+#define WFD_IE_SUB_DEV_INFO_SRC_NO_COUPLED_SINK		0x0000
+#define WFD_IE_SUB_DEV_INFO_SRC_CAN_COUPLED_SINK	0x0004
+
+/* coupled sink as sink */
+#define WFD_IE_SUB_DEV_INFO_SINK_COUPLED_SINK_MASK	0x0008
+#define WFD_IE_SUB_DEV_INFO_SINK_NO_COUPLED_SINK	0x0000
+#define WFD_IE_SUB_DEV_INFO_SINK_CAN_COUPLED_SINK	0x0008
+
+/* availability for session establishment */
+#define WFD_IE_SUB_DEV_INFO_AVAILABLE_MASK		0x0030
+#define WFD_IE_SUB_DEV_INFO_NOT_AVAILABLE		0x0000
+#define WFD_IE_SUB_DEV_INFO_AVAILABLE			0x0010
+
+/* WFD service discovery */
+#define WFD_IE_SUB_DEV_INFO_WSD_MASK			0x0040
+#define WFD_IE_SUB_DEV_INFO_NO_WSD			0x0000
+#define WFD_IE_SUB_DEV_INFO_CAN_WSD			0x0040
+
+/* preferred connectivity */
+#define WFD_IE_SUB_DEV_INFO_PC_MASK			0x0080
+#define WFD_IE_SUB_DEV_INFO_PREFER_P2P			0x0000
+#define WFD_IE_SUB_DEV_INFO_PREFER_TDLS			0x0080
+
+/* content protection */
+#define WFD_IE_SUB_DEV_INFO_CP_MASK			0x0100
+#define WFD_IE_SUB_DEV_INFO_NO_CP			0x0000
+#define WFD_IE_SUB_DEV_INFO_CAN_CP			0x0100
+
+/* separate time-sync */
+#define WFD_IE_SUB_DEV_INFO_TIME_SYNC_MASK		0x0200
+#define WFD_IE_SUB_DEV_INFO_NO_TIME_SYNC		0x0000
+#define WFD_IE_SUB_DEV_INFO_CAN_TIME_SYNC		0x0200
+
+/* no audio */
+#define WFD_IE_SUB_DEV_INFO_NO_AUDIO_MASK		0x0400
+#define WFD_IE_SUB_DEV_INFO_CAN_AUDIO			0x0000
+#define WFD_IE_SUB_DEV_INFO_NO_AUDIO			0x0400
+
+/* audio only */
+#define WFD_IE_SUB_DEV_INFO_AUDIO_ONLY_MASK		0x0800
+#define WFD_IE_SUB_DEV_INFO_NO_AUDIO_ONLY		0x0000
+#define WFD_IE_SUB_DEV_INFO_AUDIO_ONLY			0x0800
+
+/* persistent TLDS */
+#define WFD_IE_SUB_DEV_INFO_PERSIST_TLDS_MASK		0x1000
+#define WFD_IE_SUB_DEV_INFO_NO_PERSIST_TLDS		0x0000
+#define WFD_IE_SUB_DEV_INFO_PERSIST_TLDS		0x1000
+
+/* persistent TLDS group re-invoke */
+#define WFD_IE_SUB_DEV_INFO_TLDS_REINVOKE_MASK		0x2000
+#define WFD_IE_SUB_DEV_INFO_NO_TLDS_REINVOKE		0x0000
+#define WFD_IE_SUB_DEV_INFO_TLDS_REINVOKE		0x2000
+
+#define WFD_IE_SUB_DEV_INFO_DEFAULT_PORT 7236
+
+struct wfd_ie_sub_dev_info {
+	uint16_t dev_info;
+	uint16_t ctrl_port;
+	uint16_t max_throughput;
+} WFD__PACKED;
+
+/*
+ * IE subelement associated BSSID
+ */
+
+struct wfd_ie_sub_assoc_bssid {
+	uint8_t bssid[6];
+} WFD__PACKED;
+
+/*
+ * IE subelement audio formats
+ */
+
+/* lpcm modes; 2C_16_48000 is mandatory */
+#define WFD_IE_SUB_AUDIO_FORMATS_LPCM_2C_16_44100	0x00000001
+#define WFD_IE_SUB_AUDIO_FORMATS_LPCM_2C_16_48000	0x00000002
+
+/* aac modes */
+#define WFD_IE_SUB_AUDIO_FORMATS_AAC_2C_16_48000	0x00000001
+#define WFD_IE_SUB_AUDIO_FORMATS_AAC_4C_16_48000	0x00000002
+#define WFD_IE_SUB_AUDIO_FORMATS_AAC_6C_16_48000	0x00000004
+#define WFD_IE_SUB_AUDIO_FORMATS_AAC_8C_16_48000	0x00000008
+
+/* ac3 modes */
+#define WFD_IE_SUB_AUDIO_FORMATS_AC3_2C_16_48000	0x00000001
+#define WFD_IE_SUB_AUDIO_FORMATS_AC3_4C_16_48000	0x00000002
+#define WFD_IE_SUB_AUDIO_FORMATS_AC3_6C_16_48000	0x00000004
+
+/* audio latency; encoded in multiples of 5ms */
+#define WFD_IE_SUB_AUDIO_FORMATS_UNKNOWN_LATENCY	0x00
+#define WFD_IE_SUB_AUDIO_FORMATS_LATENCY_FROM_MS(_ms) \
+							(((_ms) + 4ULL) / 5ULL)
+
+struct wfd_ie_sub_audio_formats {
+	uint32_t lpcm_modes;
+	uint8_t lpcm_latency;
+	uint32_t aac_modes;
+	uint8_t aac_latency;
+	uint32_t ac3_modes;
+	uint8_t ac3_latency;
+} WFD__PACKED;
+
+/*
+ * IE subelement video formats
+ * Multiple video-subelements are allowed, one for each supported 264 profile.
+ */
+
+/* cea modes; required cea modes; 640x480@p60 is always required; if you
+ * support higher resolutions at p60 or p50, you also must support 720x480@p60
+ * or 720x576@p50 respectively */
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_640_480_P60	0x00000001
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_720_480_P60	0x00000002
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_720_480_I60	0x00000004
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_720_576_P50	0x00000008
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_720_576_I50	0x00000010
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_1280_720_P30	0x00000020
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_1280_720_P60	0x00000040
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_1920_1080_P30	0x00000080
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_1920_1080_P60	0x00000100
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_1920_1080_I60	0x00000200
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_1280_720_P25	0x00000400
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_1280_720_P50	0x00000800
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_1920_1080_P25	0x00001000
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_1920_1080_P50	0x00002000
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_1920_1080_I50	0x00004000
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_1280_720_P24	0x00008000
+#define WFD_IE_SUB_VIDEO_FORMATS_CEA_1920_1080_P24	0x00010000
+
+/* vesa modes; if you support higher refresh-rates, you must also support
+ * *all* lower rates of the same mode */
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_800_600_P30	0x00000001
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_800_600_P60	0x00000002
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1024_768_P30	0x00000004
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1024_768_P60	0x00000008
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1152_864_P30	0x00000010
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1152_864_P60	0x00000020
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1280_768_P30	0x00000040
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1280_768_P60	0x00000080
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1280_800_P30	0x00000100
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1280_800_P60	0x00000200
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1360_768_P30	0x00000400
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1360_768_P60	0x00000800
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1366_768_P30	0x00001000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1366_768_P60	0x00002000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1280_1024_P30	0x00004000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1280_1024_P60	0x00008000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1400_1050_P30	0x00010000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1400_1050_P60	0x00020000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1440_900_P30	0x00040000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1440_900_P60	0x00080000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1600_900_P30	0x00100000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1600_900_P60	0x00200000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1600_1200_P30	0x00400000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1600_1200_P60	0x00800000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1680_1024_P30	0x01000000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1680_1024_P60	0x02000000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1680_1050_P30	0x04000000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1680_1050_P60	0x08000000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1920_1200_P30	0x10000000
+#define WFD_IE_SUB_VIDEO_FORMATS_VESA_1920_1200_P60	0x20000000
+
+/* hh modes (handheld devices) */
+#define WFD_IE_SUB_VIDEO_FORMATS_HH_800_480_P30		0x00000000
+#define WFD_IE_SUB_VIDEO_FORMATS_HH_800_480_P60		0x00000000
+#define WFD_IE_SUB_VIDEO_FORMATS_HH_854_480_P30		0x00000000
+#define WFD_IE_SUB_VIDEO_FORMATS_HH_854_480_P60		0x00000000
+#define WFD_IE_SUB_VIDEO_FORMATS_HH_864_480_P30		0x00000000
+#define WFD_IE_SUB_VIDEO_FORMATS_HH_864_480_P60		0x00000000
+#define WFD_IE_SUB_VIDEO_FORMATS_HH_640_360_P30		0x00000000
+#define WFD_IE_SUB_VIDEO_FORMATS_HH_640_360_P60		0x00000000
+#define WFD_IE_SUB_VIDEO_FORMATS_HH_960_540_P30		0x00000000
+#define WFD_IE_SUB_VIDEO_FORMATS_HH_960_540_P60		0x00000000
+#define WFD_IE_SUB_VIDEO_FORMATS_HH_848_480_P30		0x00000000
+#define WFD_IE_SUB_VIDEO_FORMATS_HH_848_480_P60		0x00000000
+
+/* native mode; table */
+#define WFD_IE_SUB_VIDEO_FORMATS_NATIVE_MODE_TABLE_MASK	0x03
+#define WFD_IE_SUB_VIDEO_FORMATS_NATIVE_MODE_CEA_TABLE	0x00
+#define WFD_IE_SUB_VIDEO_FORMATS_NATIVE_MODE_VESA_TABLE	0x01
+#define WFD_IE_SUB_VIDEO_FORMATS_NATIVE_MODE_HH_TABLE	0x02
+
+/* native mode; index */
+#define WFD_IE_SUB_VIDEO_FORMATS_NATIVE_MODE_IDX_MASK	0xfc
+#define WFD_IE_SUB_VIDEO_FORMATS_NATIVE_MODE_IDX_SHIFT	3
+
+/* h264 profiles; base-profile / high-profile; mostly only one bit allowed */
+#define WFD_IE_SUB_VIDEO_FORMATS_PROFILE_CBP		0x01
+#define WFD_IE_SUB_VIDEO_FORMATS_PROFILE_CHP		0x02
+
+/* max h264 level; mostly only one bit allowed */
+#define WFD_IE_SUB_VIDEO_FORMATS_H264_LEVEL_3_1		0x01
+#define WFD_IE_SUB_VIDEO_FORMATS_H264_LEVEL_3_2		0x02
+#define WFD_IE_SUB_VIDEO_FORMATS_H264_LEVEL_4_0		0x04
+#define WFD_IE_SUB_VIDEO_FORMATS_H264_LEVEL_4_1		0x08
+#define WFD_IE_SUB_VIDEO_FORMATS_H264_LEVEL_4_2		0x10
+
+/* display latency; encoded in multiples of 5ms */
+#define WFD_IE_SUB_VIDEO_FORMATS_UNKNOWN_LATENCY	0x00
+#define WFD_IE_SUB_VIDEO_FORMATS_LATENCY_FROM_MS(_ms) \
+							(((_ms) + 4ULL) / 5ULL)
+
+/* smallest slice size expressed in number of macro-blocks or 0x0 */
+#define WFD_IE_SUB_VIDEO_FORMATS_NO_SLICES		0x0000
+
+/* if no slices allowed, this can be set on slice_env */
+#define WFD_IE_SUB_VIDEO_FORMATS_NO_SLICE_ENC		0x0000
+
+/* max number of slices per picture MINUS 1 (0 not allowed) */
+#define WFD_IE_SUB_VIDEO_FORMATS_SLICE_ENC_MAX_MASK	0x03ff
+#define WFD_IE_SUB_VIDEO_FORMATS_SLICE_ENC_MAX_SHIFT	0
+
+/* ratio of max-slice-size to be used and slice_min field (0 not allowed) */
+#define WFD_IE_SUB_VIDEO_FORMATS_SLICE_ENC_RATIO_MASK	0x0c00
+#define WFD_IE_SUB_VIDEO_FORMATS_SLICE_ENC_RATIO_SHIFT	10
+
+/* frame skipping */
+#define WFD_IE_SUB_VIDEO_FORMATS_NO_FRAME_SKIP		0x00
+#define WFD_IE_SUB_VIDEO_FORMATS_CAN_FRAME_SKIP		0x01
+
+#define WFD_IE_SUB_VIDEO_FORMATS_FRAME_SKIP_MAX_I_MASK	0x0e
+#define WFD_IE_SUB_VIDEO_FORMATS_FRAME_SKIP_MAX_I_SHIFT	1
+#define WFD_IE_SUB_VIDEO_FORMATS_FRAME_SKIP_MAX_I_ANY	0x00
+
+#define WFD_IE_SUB_VIDEO_FORMATS_FRAME_SKIP_NO_DYN	0x00
+#define WFD_IE_SUB_VIDEO_FORMATS_FRAME_SKIP_CAN_DYN	0x10
+
+struct wfd_ie_sub_video_formats {
+	uint32_t cea_modes;
+	uint32_t vesa_modes;
+	uint32_t hh_modes;
+	uint8_t native_mode;
+	uint8_t h264_profile;
+	uint8_t h264_max_level;
+	uint8_t latency;
+	uint16_t slice_min;
+	uint16_t slice_enc;
+	uint8_t frame_skip;
+} WFD__PACKED;
+
+/*
+ * IE subelement 3d formats
+ * Multiple 3d-subelements are allowed, one for each supported h264 profile.
+ */
+
+/* 3d cpabilities; required modes; 1920x540/540@p24 is always required; if you
+ * support higher resolutions at p60 or p50, you also must support
+ * 1280x360/360@p60 or 1280x360/360@p50 respectively */
+#define WFD_IE_SUB_3D_FORMATS_CAP_1920_X_540_540_P24		0x0000000000000001
+#define WFD_IE_SUB_3D_FORMATS_CAP_1280_X_360_360_P60		0x0000000000000002
+#define WFD_IE_SUB_3D_FORMATS_CAP_1280_X_360_360_P50		0x0000000000000004
+#define WFD_IE_SUB_3D_FORMATS_CAP_1920_X_1080_P24_P24		0x0000000000000008
+#define WFD_IE_SUB_3D_FORMATS_CAP_1280_X_720_P60_P60		0x0000000000000010
+#define WFD_IE_SUB_3D_FORMATS_CAP_1280_X_720_P30_P30		0x0000000000000020
+#define WFD_IE_SUB_3D_FORMATS_CAP_1280_X_720_P50_P50		0x0000000000000040
+#define WFD_IE_SUB_3D_FORMATS_CAP_1280_X_720_P25_P25		0x0000000000000080
+#define WFD_IE_SUB_3D_FORMATS_CAP_1920_X_1080_45_1080_P24	0x0000000000000100
+#define WFD_IE_SUB_3D_FORMATS_CAP_1280_X_720_30_720_P60		0x0000000000000200
+#define WFD_IE_SUB_3D_FORMATS_CAP_1280_X_720_30_720_P30		0x0000000000000400
+#define WFD_IE_SUB_3D_FORMATS_CAP_1280_X_720_30_720_P50		0x0000000000000800
+#define WFD_IE_SUB_3D_FORMATS_CAP_1280_X_720_30_720_P25		0x0000000000001000
+#define WFD_IE_SUB_3D_FORMATS_CAP_960_960_X_1080_I60		0x0000000000002000
+#define WFD_IE_SUB_3D_FORMATS_CAP_960_960_X_1080_I50		0x0000000000004000
+#define WFD_IE_SUB_3D_FORMATS_CAP_640_X_240_240_P60		0x0000000000008000
+#define WFD_IE_SUB_3D_FORMATS_CAP_320_320_X_480_P60		0x0000000000010000
+#define WFD_IE_SUB_3D_FORMATS_CAP_720_X_240_240_P60		0x0000000000020000
+#define WFD_IE_SUB_3D_FORMATS_CAP_360_360_X_480_P60		0x0000000000040000
+#define WFD_IE_SUB_3D_FORMATS_CAP_720_X_288_288_P50		0x0000000000080000
+#define WFD_IE_SUB_3D_FORMATS_CAP_360_360_X_576_P50		0x0000000000100000
+#define WFD_IE_SUB_3D_FORMATS_CAP_1280_X_360_360_P24		0x0000000000200000
+#define WFD_IE_SUB_3D_FORMATS_CAP_640_640_X_720_P24		0x0000000000400000
+#define WFD_IE_SUB_3D_FORMATS_CAP_1280_X_360_360_P25		0x0000000000800000
+#define WFD_IE_SUB_3D_FORMATS_CAP_640_640_X_720_P25		0x0000000001000000
+#define WFD_IE_SUB_3D_FORMATS_CAP_1280_X_360_360_P30		0x0000000002000000
+#define WFD_IE_SUB_3D_FORMATS_CAP_640_640_X_720_P30		0x0000000004000000
+#define WFD_IE_SUB_3D_FORMATS_CAP_1920_X_540_540_P30		0x0000000008000000
+#define WFD_IE_SUB_3D_FORMATS_CAP_1920_X_540_540_P50		0x0000000010000000
+#define WFD_IE_SUB_3D_FORMATS_CAP_1920_X_540_540_P60		0x0000000020000000
+#define WFD_IE_SUB_3D_FORMATS_CAP_640_640_X_720_P50		0x0000000040000000
+#define WFD_IE_SUB_3D_FORMATS_CAP_640_640_X_720_P60		0x0000000080000000
+#define WFD_IE_SUB_3D_FORMATS_CAP_960_960_X_1080_P24		0x0000000100000000
+#define WFD_IE_SUB_3D_FORMATS_CAP_960_960_X_1080_P50		0x0000000200000000
+#define WFD_IE_SUB_3D_FORMATS_CAP_960_960_X_1080_P60		0x0000000400000000
+#define WFD_IE_SUB_3D_FORMATS_CAP_1920_X_1080_45_1080_P30	0x0000000800000000
+#define WFD_IE_SUB_3D_FORMATS_CAP_1920_X_1080_45_1080_I50	0x0000001000000000
+#define WFD_IE_SUB_3D_FORMATS_CAP_1920_X_1080_45_1080_I60	0x0000002000000000
+
+struct wfd_ie_sub_3d_formats {
+	uint64_t capabilities;
+	uint8_t native_mode;	/* same as video_formats.native_mode */
+	uint8_t h264_profile;	/* same as video_formats.h264_profile */
+	uint8_t h264_max_level;	/* same as video_formats.h264_max_level */
+	uint8_t latency;	/* same as video_formats.latency */
+	uint16_t slice_min;	/* same as video_formats.slice_min */
+	uint16_t slice_enc;	/* same as video_formats.slice_enc */
+	uint8_t frame_skip;	/* same as video_formats.frame_skip */
+} WFD__PACKED;
+
+/*
+ * IE subelement content protection
+ */
+
+/* HDCP 2.0 */
+#define WFD_IE_SUB_CONTENT_PROTECT_HDCP_2_0_MASK	0x01
+#define WFD_IE_SUB_CONTENT_PROTECT_NO_HDCP_2_0		0x00
+#define WFD_IE_SUB_CONTENT_PROTECT_CAN_HDCP_2_0		0x01
+
+/* HDCP 2.1; if set, you must also set HDCP 2.0 */
+#define WFD_IE_SUB_CONTENT_PROTECT_HDCP_2_1_MASK	0x02
+#define WFD_IE_SUB_CONTENT_PROTECT_NO_HDCP_2_1		0x00
+#define WFD_IE_SUB_CONTENT_PROTECT_CAN_HDCP_2_1		0x02
+
+struct wfd_ie_sub_content_protect {
+	uint8_t flags;
+} WFD__PACKED;
+
+/*
+ * IE subelement coupled sink information
+ */
+
+/* status */
+#define WFD_IE_SUB_COUPLED_SINK_STATUS_MASK		0x03
+#define WFD_IE_SUB_COUPLED_SINK_NOT_COUPLED		0x00
+#define WFD_IE_SUB_COUPLED_SINK_COUPLED			0x01
+#define WFD_IE_SUB_COUPLED_SINK_COUPLE_TEARDOWN		0x02
+
+struct wfd_ie_sub_coupled_sink {
+	uint8_t status;
+	uint8_t mac[6];
+} WFD__PACKED;
+
+/*
+ * IE subelement extended capabilities
+ */
+
+/* UIBC */
+#define WFD_IE_SUB_EXT_CAP_UIBC_MASK			0x01
+#define WFD_IE_SUB_EXT_CAP_NO_UIBC			0x00
+#define WFD_IE_SUB_EXT_CAP_CAN_UIBC			0x01
+
+/* I2C */
+#define WFD_IE_SUB_EXT_CAP_I2C_MASK			0x02
+#define WFD_IE_SUB_EXT_CAP_NO_I2C			0x00
+#define WFD_IE_SUB_EXT_CAP_CAN_I2C			0x02
+
+/* Preferred Mode */
+#define WFD_IE_SUB_EXT_CAP_PREFER_MODE_MASK		0x04
+#define WFD_IE_SUB_EXT_CAP_NO_PREFER_MODE		0x00
+#define WFD_IE_SUB_EXT_CAP_CAN_PREFER_MODE		0x04
+
+/* Standby */
+#define WFD_IE_SUB_EXT_CAP_STANDBY_MASK			0x08
+#define WFD_IE_SUB_EXT_CAP_NO_STANDBY			0x00
+#define WFD_IE_SUB_EXT_CAP_CAN_STANDBY			0x08
+
+/* Persistend TDLS */
+#define WFD_IE_SUB_EXT_CAP_PERSIST_TDLS_MASK		0x10
+#define WFD_IE_SUB_EXT_CAP_NO_PERSIST_TDLS		0x00
+#define WFD_IE_SUB_EXT_CAP_CAN_PERSIST_TDLS		0x10
+
+/* Persistend TDLS BSSID */
+#define WFD_IE_SUB_EXT_CAP_PERSIST_TDLS_BSSID_MASK	0x20
+#define WFD_IE_SUB_EXT_CAP_NO_PERSIST_TDLS_BSSID	0x00
+#define WFD_IE_SUB_EXT_CAP_CAN_PERSIST_TDLS_BSSID	0x20
+
+struct wfd_ie_sub_ext_cap {
+	uint16_t flags;
+} WFD__PACKED;
+
+/*
+ * IE subelement local ip
+ */
+
+#define WFD_IE_SUB_LOCAL_IP_IPV4			0x01
+
+struct wfd_ie_sub_local_ip {
+	uint8_t version;
+	uint8_t ip[4];
+} WFD__PACKED;
+
+/*
+ * IE subelement session information
+ */
+
+/* real payload is actually an array of this object for each device */
+struct wfd_ie_sub_session_info {
+	uint8_t length;			/* fixed: 23 == (sizeof(this) - 1) */
+	uint8_t mac[6];
+	uint8_t bssid[6];
+	uint16_t dev_info;		/* same as dev_info.dev_info */
+	uint16_t max_throughput;	/* same as dev_info.max_throughput */
+	uint8_t coupled_status;		/* same as coupled_sink.status */
+	uint8_t coupled_mac[6];		/* same as coupled_sink.mac */
+} WFD__PACKED;
+
+/*
+ * IE subelement alternative mac
+ */
+
+struct wfd_ie_sub_alt_mac {
+	uint8_t mac[6];
+} WFD__PACKED;
+
+/** @} */
+
+/**
+ * @defgroup wfd_rtsp Wifi-Display API for RTSP
+ * API for the Wifi-Display specification regarding RTSP
+ *
+ * This section contains definitions and constants from the Wifi-Display
+ * specification regarding RTSP and provides a basic API to parse and handle
+ * WFD-RTSP messages.
+ *
+ * Note that this parser is neither fast nor optimized for memory-usage. RTSP is
+ * not a high-throughput protocol, therefore, this API is made for easy use, not
+ * low-latency and high-throughput. This shouldn't hurt at all. If you use RTSP
+ * for huge payloads, you're doing it wrong. Note that this does *NOT* apply to
+ * RTSP data messages, which allow combining RTP streams with RTSP. These
+ * messages are handled properly and in a fast manner by this decoder.
+ *
+ * This decoder tries to provide a very convenient API that parses basic types
+ * but still allows the caller to get access to any unknown lines. This way,
+ * standard-conformant parsers can be easily written, while extensions are still
+ * allowed.
+ *
+ * @{
+ */
+
+/**
+ * wfd_rtsp_tokenize - Tokenize an RTSP line
+ * @line: input line
+ * @len: length of the line or -1 if zero-terminated
+ * @out: storage pointer for tokens
+ *
+ * This tokenizes a single RTSP line. It splits the given input-line by RTSP
+ * tokens and does some very basic line-parsing. A pointer to the tokenized
+ * string is stored in @out and must be freed by the caller. The tokenized
+ * string is separated by binary-0 and you can use wfd_rtsp_next_token() to jump
+ * to the next token. Binary-0 is not allowed in RTSP lines so this is safe.
+ *
+ * This function returns the number of tokens parsed. On error, a negative errno
+ * code is returned and @out is left untouched.
+ */
+ssize_t wfd_rtsp_tokenize(const char *line, ssize_t len, char **out);
+
+/**
+ * wfd_rtsp_next_token - Return next RTSP token
+ * @tokens: toknized RTSP line
+ *
+ * This can only be used in combination with wfd_rtsp_tokenize. It returns the next
+ * token from the tokenized line.
+ */
+static inline char *wfd_rtsp_next_token(char *tokens)
+{
+	return tokens + strlen(tokens) + 1;
+}
+
+/* RTSP messages */
+
+typedef void (*wfd_rtsp_log_t) (void *data,
+				const char *file,
+				int line,
+				const char *func,
+				const char *subs,
+				unsigned int sev,
+				const char *format,
+				va_list args);
+
+enum wfd_rtsp_msg_type {
+	WFD_RTSP_MSG_UNKNOWN,
+
+	WFD_RTSP_MSG_REQUEST,
+	WFD_RTSP_MSG_RESPONSE,
+
+	WFD_RTSP_MSG_CNT
+};
+
+enum wfd_rtsp_method_type {
+	WFD_RTSP_METHOD_UNKNOWN,
+
+	WFD_RTSP_METHOD_ANNOUNCE,
+	WFD_RTSP_METHOD_DESCRIBE,
+	WFD_RTSP_METHOD_GET_PARAMETER,
+	WFD_RTSP_METHOD_OPTIONS,
+	WFD_RTSP_METHOD_PAUSE,
+	WFD_RTSP_METHOD_PLAY,
+	WFD_RTSP_METHOD_RECORD,
+	WFD_RTSP_METHOD_REDIRECT,
+	WFD_RTSP_METHOD_SETUP,
+	WFD_RTSP_METHOD_SET_PARAMETER,
+	WFD_RTSP_METHOD_TEARDOWN,
+
+	WFD_RTSP_METHOD_CNT
+};
+
+const char *wfd_rtsp_method_get_name(unsigned int method);
+unsigned int wfd_rtsp_method_from_name(const char *method);
+
+enum wfd_rtsp_status_code {
+	WFD_RTSP_STATUS_CONTINUE = 100,
+
+	WFD_RTSP_STATUS_OK = 200,
+	WFD_RTSP_STATUS_CREATED,
+
+	WFD_RTSP_STATUS_LOW_ON_STORAGE_SPACE = 250,
+
+	WFD_RTSP_STATUS_MULTIPLE_CHOICES = 300,
+	WFD_RTSP_STATUS_MOVED_PERMANENTLY,
+	WFD_RTSP_STATUS_MOVED_TEMPORARILY,
+	WFD_RTSP_STATUS_SEE_OTHER,
+	WFD_RTSP_STATUS_NOT_MODIFIED,
+	WFD_RTSP_STATUS_USE_PROXY,
+
+	WFD_RTSP_STATUS_BAD_REQUEST = 400,
+	WFD_RTSP_STATUS_UNAUTHORIZED,
+	WFD_RTSP_STATUS_PAYMENT_REQUIRED,
+	WFD_RTSP_STATUS_FORBIDDEN,
+	WFD_RTSP_STATUS_NOT_FOUND,
+	WFD_RTSP_STATUS_METHOD_NOT_ALLOWED,
+	WFD_RTSP_STATUS_NOT_ACCEPTABLE,
+	WFD_RTSP_STATUS_PROXY_AUTHENTICATION_REQUIRED,
+	WFD_RTSP_STATUS_REQUEST_TIMEOUT,
+	WFD_RTSP_STATUS__PLACEHOLDER__1,
+	WFD_RTSP_STATUS_GONE,
+	WFD_RTSP_STATUS_LENGTH_REQUIRED,
+	WFD_RTSP_STATUS_PRECONDITION_FAILED,
+	WFD_RTSP_STATUS_REQUEST_ENTITY_TOO_LARGE,
+	WFD_RTSP_STATUS_REQUEST_URI_TOO_LARGE,
+	WFD_RTSP_STATUS_UNSUPPORTED_MEDIA_TYPE,
+
+	WFD_RTSP_STATUS_PARAMETER_NOT_UNDERSTOOD = 451,
+	WFD_RTSP_STATUS_CONFERENCE_NOT_FOUND,
+	WFD_RTSP_STATUS_NOT_ENOUGH_BANDWIDTH,
+	WFD_RTSP_STATUS_SESSION_NOT_FOUND,
+	WFD_RTSP_STATUS_METHOD_NOT_VALID_IN_THIS_STATE,
+	WFD_RTSP_STATUS_HEADER_FIELD_NOT_VALID_FOR_RESOURCE,
+	WFD_RTSP_STATUS_INVALID_RANGE,
+	WFD_RTSP_STATUS_PARAMETER_IS_READ_ONLY,
+	WFD_RTSP_STATUS_AGGREGATE_OPERATION_NOT_ALLOWED,
+	WFD_RTSP_STATUS_ONLY_AGGREGATE_OPERATION_ALLOWED,
+	WFD_RTSP_STATUS_UNSUPPORTED_TRANSPORT,
+	WFD_RTSP_STATUS_DESTINATION_UNREACHABLE,
+
+	WFD_RTSP_STATUS_INTERNAL_SERVER_ERROR = 500,
+	WFD_RTSP_STATUS_NOT_IMPLEMENTED,
+	WFD_RTSP_STATUS_BAD_GATEWAY,
+	WFD_RTSP_STATUS_SERVICE_UNAVAILABLE,
+	WFD_RTSP_STATUS_GATEWAY_TIMEOUT,
+	WFD_RTSP_STATUS_WFD_RTSP_VERSION_NOT_SUPPORTED,
+
+	WFD_RTSP_STATUS_OPTION_NOT_SUPPORTED = 551,
+
+	WFD_RTSP_STATUS_CNT
+};
+
+bool wfd_rtsp_status_is_valid(unsigned int status);
+unsigned int wfd_rtsp_status_get_base(unsigned int status);
+const char *wfd_rtsp_status_get_description(unsigned int status);
+
+enum wfd_rtsp_header_type {
+	WFD_RTSP_HEADER_UNKNOWN,
+
+	WFD_RTSP_HEADER_ACCEPT,
+	WFD_RTSP_HEADER_ACCEPT_ENCODING,
+	WFD_RTSP_HEADER_ACCEPT_LANGUAGE,
+	WFD_RTSP_HEADER_ALLOW,
+	WFD_RTSP_HEADER_AUTHORIZATION,
+	WFD_RTSP_HEADER_BANDWIDTH,
+	WFD_RTSP_HEADER_BLOCKSIZE,
+	WFD_RTSP_HEADER_CACHE_CONTROL,
+	WFD_RTSP_HEADER_CONFERENCE,
+	WFD_RTSP_HEADER_CONNECTION,
+	WFD_RTSP_HEADER_CONTENT_BASE,
+	WFD_RTSP_HEADER_CONTENT_ENCODING,
+	WFD_RTSP_HEADER_CONTENT_LANGUAGE,
+	WFD_RTSP_HEADER_CONTENT_LENGTH,
+	WFD_RTSP_HEADER_CONTENT_LOCATION,
+	WFD_RTSP_HEADER_CONTENT_TYPE,
+	WFD_RTSP_HEADER_CSEQ,
+	WFD_RTSP_HEADER_DATE,
+	WFD_RTSP_HEADER_EXPIRES,
+	WFD_RTSP_HEADER_FROM,
+	WFD_RTSP_HEADER_HOST,
+	WFD_RTSP_HEADER_IF_MATCH,
+	WFD_RTSP_HEADER_IF_MODIFIED_SINCE,
+	WFD_RTSP_HEADER_LAST_MODIFIED,
+	WFD_RTSP_HEADER_LOCATION,
+	WFD_RTSP_HEADER_PROXY_AUTHENTICATE,
+	WFD_RTSP_HEADER_PROXY_REQUIRE,
+	WFD_RTSP_HEADER_PUBLIC,
+	WFD_RTSP_HEADER_RANGE,
+	WFD_RTSP_HEADER_REFERER,
+	WFD_RTSP_HEADER_RETRY_AFTER,
+	WFD_RTSP_HEADER_REQUIRE,
+	WFD_RTSP_HEADER_RTP_INFO,
+	WFD_RTSP_HEADER_SCALE,
+	WFD_RTSP_HEADER_SPEED,
+	WFD_RTSP_HEADER_SERVER,
+	WFD_RTSP_HEADER_SESSION,
+	WFD_RTSP_HEADER_TIMESTAMP,
+	WFD_RTSP_HEADER_TRANSPORT,
+	WFD_RTSP_HEADER_UNSUPPORTED,
+	WFD_RTSP_HEADER_USER_AGENT,
+	WFD_RTSP_HEADER_VARY,
+	WFD_RTSP_HEADER_VIA,
+	WFD_RTSP_HEADER_WWW_AUTHENTICATE,
+
+	WFD_RTSP_HEADER_CNT
+};
+
+const char *wfd_rtsp_header_get_name(unsigned int header);
+unsigned int wfd_rtsp_header_from_name(const char *header);
+unsigned int wfd_rtsp_header_from_name_n(const char *header, size_t len);
+
+struct wfd_rtsp_msg {
+	unsigned int type;
+
+	struct wfd_rtsp_msg_id {
+		char *line;
+		size_t length;
+
+		union {
+			struct {
+				char *method;
+				unsigned int type;
+				char *uri;
+				unsigned int major;
+				unsigned int minor;
+			} request;
+
+			struct {
+				unsigned int major;
+				unsigned int minor;
+				unsigned int status;
+				char *phrase;
+			} response;
+		};
+	} id;
+
+	struct wfd_rtsp_msg_header {
+		size_t count;
+		char **lines;
+		size_t *lengths;
+
+		union {
+			size_t content_length;
+			unsigned long cseq;
+		};
+	} headers[WFD_RTSP_HEADER_CNT];
+
+	struct wfd_rtsp_msg_entity {
+		void *value;
+		size_t size;
+	} entity;
+};
+
+/* rtsp decoder */
+
+struct wfd_rtsp_decoder;
+
+enum wfd_rtsp_decoder_event_type {
+	WFD_RTSP_DECODER_MSG,
+	WFD_RTSP_DECODER_DATA,
+	WFD_RTSP_DECODER_ERROR,
+};
+
+struct wfd_rtsp_decoder_event {
+	unsigned int type;
+
+	union {
+		struct wfd_rtsp_msg *msg;
+		struct wfd_rtsp_decoder_data {
+			uint8_t channel;
+			uint16_t size;
+			uint8_t *value;
+		} data;
+		struct wfd_rtsp_decoder_error {
+			void *data;
+			size_t length;
+		} error;
+	};
+};
+
+typedef int (*wfd_rtsp_decoder_event_t) (struct wfd_rtsp_decoder *dec,
+					 void *data,
+					 struct wfd_rtsp_decoder_event *event);
+
+int wfd_rtsp_decoder_new(wfd_rtsp_decoder_event_t event_fn,
+			 void *data,
+			 wfd_rtsp_log_t log_fn,
+			 void *log_data,
+			 struct wfd_rtsp_decoder **out);
+void wfd_rtsp_decoder_free(struct wfd_rtsp_decoder *dec);
+void wfd_rtsp_decoder_reset(struct wfd_rtsp_decoder *dec);
+
+void wfd_rtsp_decoder_set_data(struct wfd_rtsp_decoder *dec, void *data);
+void *wfd_rtsp_decoder_get_data(struct wfd_rtsp_decoder *dec);
+
+int wfd_rtsp_decoder_feed(struct wfd_rtsp_decoder *dec,
+			  const void *buf,
+			  size_t len);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WFD_LIBWFD_H */
diff --git a/src/rtsp_decoder.c b/src/rtsp_decoder.c
new file mode 100644
index 0000000..fc74076
--- /dev/null
+++ b/src/rtsp_decoder.c
@@ -0,0 +1,1270 @@
+/*
+ * libwfd - Wifi-Display/Miracast Protocol Implementation
+ *
+ * Copyright (c) 2013-2014 David Herrmann <dh.herrmann@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <errno.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include "libwfd.h"
+#include "shl_llog.h"
+#include "shl_macro.h"
+#include "shl_ring.h"
+#include "shl_util.h"
+
+enum state {
+	STATE_NEW,
+	STATE_HEADER,
+	STATE_HEADER_QUOTE,
+	STATE_HEADER_NL,
+	STATE_BODY,
+	STATE_DATA_HEAD,
+	STATE_DATA_BODY,
+};
+
+struct wfd_rtsp_decoder {
+	wfd_rtsp_decoder_event_t event_fn;
+	void *data;
+	llog_submit_t llog;
+	void *llog_data;
+
+	struct wfd_rtsp_msg msg;
+
+	struct shl_ring buf;
+	size_t buflen;
+	unsigned int state;
+	char last_chr;
+	size_t remaining_body;
+
+	uint8_t data_channel;
+	size_t data_size;
+
+	bool quoted : 1;
+	bool dead : 1;
+};
+
+/*
+ * Lookup Tables
+ */
+
+static const char *method_names[] = {
+	[WFD_RTSP_METHOD_ANNOUNCE]		= "ANNOUNCE",
+	[WFD_RTSP_METHOD_DESCRIBE]		= "DESCRIBE",
+	[WFD_RTSP_METHOD_GET_PARAMETER]	= "GET_PARAMETER",
+	[WFD_RTSP_METHOD_OPTIONS]		= "OPTIONS",
+	[WFD_RTSP_METHOD_PAUSE]		= "PAUSE",
+	[WFD_RTSP_METHOD_PLAY]		= "PLAY",
+	[WFD_RTSP_METHOD_RECORD]		= "RECORD",
+	[WFD_RTSP_METHOD_REDIRECT]		= "REDIRECT",
+	[WFD_RTSP_METHOD_SETUP]		= "SETUP",
+	[WFD_RTSP_METHOD_SET_PARAMETER]	= "SET_PARAMETER",
+	[WFD_RTSP_METHOD_TEARDOWN]		= "TEARDOWN",
+	[WFD_RTSP_METHOD_CNT]		= NULL,
+};
+
+_shl_public_
+const char *wfd_rtsp_method_get_name(unsigned int method)
+{
+	if (method >= SHL_ARRAY_LENGTH(method_names))
+		return NULL;
+
+	return method_names[method];
+}
+
+_shl_public_
+unsigned int wfd_rtsp_method_from_name(const char *method)
+{
+	size_t i;
+
+	for (i = 0; i < SHL_ARRAY_LENGTH(method_names); ++i)
+		if (method_names[i] && !strcasecmp(method, method_names[i]))
+			return i;
+
+	return WFD_RTSP_METHOD_UNKNOWN;
+}
+
+_shl_public_
+bool wfd_rtsp_status_is_valid(unsigned int status)
+{
+	return status >= 100 && status < 600;
+}
+
+_shl_public_
+unsigned int wfd_rtsp_status_get_base(unsigned int status)
+{
+	switch (status) {
+	case 100 ... 199:
+		return 100;
+	case 200 ... 299:
+		return 200;
+	case 300 ... 399:
+		return 300;
+	case 400 ... 499:
+		return 400;
+	case 500 ... 599:
+		return 500;
+	default:
+		return 600;
+	}
+}
+
+static const char *status_descriptions[] = {
+	[WFD_RTSP_STATUS_CONTINUE]					= "Continue",
+
+	[WFD_RTSP_STATUS_OK]					= "OK",
+	[WFD_RTSP_STATUS_CREATED]					= "Created",
+
+	[WFD_RTSP_STATUS_LOW_ON_STORAGE_SPACE]			= "Low on Storage Space",
+
+	[WFD_RTSP_STATUS_MULTIPLE_CHOICES]				= "Multiple Choices",
+	[WFD_RTSP_STATUS_MOVED_PERMANENTLY]				= "Moved Permanently",
+	[WFD_RTSP_STATUS_MOVED_TEMPORARILY]				= "Moved Temporarily",
+	[WFD_RTSP_STATUS_SEE_OTHER]					= "See Other",
+	[WFD_RTSP_STATUS_NOT_MODIFIED]				= "Not Modified",
+	[WFD_RTSP_STATUS_USE_PROXY]					= "Use Proxy",
+
+	[WFD_RTSP_STATUS_BAD_REQUEST]				= "Bad Request",
+	[WFD_RTSP_STATUS_UNAUTHORIZED]				= "Unauthorized",
+	[WFD_RTSP_STATUS_PAYMENT_REQUIRED]				= "Payment Required",
+	[WFD_RTSP_STATUS_FORBIDDEN]					= "Forbidden",
+	[WFD_RTSP_STATUS_NOT_FOUND]					= "Not Found",
+	[WFD_RTSP_STATUS_METHOD_NOT_ALLOWED]			= "Method not Allowed",
+	[WFD_RTSP_STATUS_NOT_ACCEPTABLE]				= "Not Acceptable",
+	[WFD_RTSP_STATUS_PROXY_AUTHENTICATION_REQUIRED]		= "Proxy Authentication Required",
+	[WFD_RTSP_STATUS_REQUEST_TIMEOUT]				= "Request Time-out",
+	[WFD_RTSP_STATUS_GONE]					= "Gone",
+	[WFD_RTSP_STATUS_LENGTH_REQUIRED]				= "Length Required",
+	[WFD_RTSP_STATUS_PRECONDITION_FAILED]			= "Precondition Failed",
+	[WFD_RTSP_STATUS_REQUEST_ENTITY_TOO_LARGE]			= "Request Entity Too Large",
+	[WFD_RTSP_STATUS_REQUEST_URI_TOO_LARGE]			= "Request-URI too Large",
+	[WFD_RTSP_STATUS_UNSUPPORTED_MEDIA_TYPE]			= "Unsupported Media Type",
+
+	[WFD_RTSP_STATUS_PARAMETER_NOT_UNDERSTOOD]			= "Parameter not Understood",
+	[WFD_RTSP_STATUS_CONFERENCE_NOT_FOUND]			= "Conference not Found",
+	[WFD_RTSP_STATUS_NOT_ENOUGH_BANDWIDTH]			= "Not Enough Bandwidth",
+	[WFD_RTSP_STATUS_SESSION_NOT_FOUND]				= "Session not Found",
+	[WFD_RTSP_STATUS_METHOD_NOT_VALID_IN_THIS_STATE]		= "Method not Valid in this State",
+	[WFD_RTSP_STATUS_HEADER_FIELD_NOT_VALID_FOR_RESOURCE]	= "Header Field not Valid for Resource",
+	[WFD_RTSP_STATUS_INVALID_RANGE]				= "Invalid Range",
+	[WFD_RTSP_STATUS_PARAMETER_IS_READ_ONLY]			= "Parameter is Read-only",
+	[WFD_RTSP_STATUS_AGGREGATE_OPERATION_NOT_ALLOWED]		= "Aggregate Operation not Allowed",
+	[WFD_RTSP_STATUS_ONLY_AGGREGATE_OPERATION_ALLOWED]		= "Only Aggregate Operation Allowed",
+	[WFD_RTSP_STATUS_UNSUPPORTED_TRANSPORT]			= "Unsupported Transport",
+	[WFD_RTSP_STATUS_DESTINATION_UNREACHABLE]			= "Destination Unreachable",
+
+	[WFD_RTSP_STATUS_INTERNAL_SERVER_ERROR]			= "Internal Server Error",
+	[WFD_RTSP_STATUS_NOT_IMPLEMENTED]				= "Not Implemented",
+	[WFD_RTSP_STATUS_BAD_GATEWAY]				= "Bad Gateway",
+	[WFD_RTSP_STATUS_SERVICE_UNAVAILABLE]			= "Service Unavailable",
+	[WFD_RTSP_STATUS_GATEWAY_TIMEOUT]				= "Gateway Time-out",
+	[WFD_RTSP_STATUS_WFD_RTSP_VERSION_NOT_SUPPORTED]		= "RTSP Version not Supported",
+
+	[WFD_RTSP_STATUS_OPTION_NOT_SUPPORTED]			= "Option not Supported",
+
+	[WFD_RTSP_STATUS_CNT]					= NULL,
+};
+
+_shl_public_
+const char *wfd_rtsp_status_get_description(unsigned int status)
+{
+	if (status >= SHL_ARRAY_LENGTH(status_descriptions))
+		return NULL;
+
+	return status_descriptions[status];
+}
+
+static const char *header_names[] = {
+	[WFD_RTSP_HEADER_ACCEPT]			= "Accept",
+	[WFD_RTSP_HEADER_ACCEPT_ENCODING]		= "Accept-Encoding",
+	[WFD_RTSP_HEADER_ACCEPT_LANGUAGE]		= "Accept-Language",
+	[WFD_RTSP_HEADER_ALLOW]				= "Allow",
+	[WFD_RTSP_HEADER_AUTHORIZATION]			= "Authorization",
+	[WFD_RTSP_HEADER_BANDWIDTH]			= "Bandwidth",
+	[WFD_RTSP_HEADER_BLOCKSIZE]			= "Blocksize",
+	[WFD_RTSP_HEADER_CACHE_CONTROL]			= "Cache-Control",
+	[WFD_RTSP_HEADER_CONFERENCE]			= "Conference",
+	[WFD_RTSP_HEADER_CONNECTION]			= "Connection",
+	[WFD_RTSP_HEADER_CONTENT_BASE]			= "Content-Base",
+	[WFD_RTSP_HEADER_CONTENT_ENCODING]		= "Content-Encoding",
+	[WFD_RTSP_HEADER_CONTENT_LANGUAGE]		= "Content-Language",
+	[WFD_RTSP_HEADER_CONTENT_LENGTH]		= "Content-Length",
+	[WFD_RTSP_HEADER_CONTENT_LOCATION]		= "Content-Location",
+	[WFD_RTSP_HEADER_CONTENT_TYPE]			= "Content-Type",
+	[WFD_RTSP_HEADER_CSEQ]				= "CSeq",
+	[WFD_RTSP_HEADER_DATE]				= "Date",
+	[WFD_RTSP_HEADER_EXPIRES]			= "Expires",
+	[WFD_RTSP_HEADER_FROM]				= "From",
+	[WFD_RTSP_HEADER_HOST]				= "Host",
+	[WFD_RTSP_HEADER_IF_MATCH]			= "If-Match",
+	[WFD_RTSP_HEADER_IF_MODIFIED_SINCE]		= "If-Modified-Since",
+	[WFD_RTSP_HEADER_LAST_MODIFIED]			= "Last-Modified",
+	[WFD_RTSP_HEADER_LOCATION]			= "Location",
+	[WFD_RTSP_HEADER_PROXY_AUTHENTICATE]		= "Proxy-Authenticate",
+	[WFD_RTSP_HEADER_PROXY_REQUIRE]			= "Proxy-Require",
+	[WFD_RTSP_HEADER_PUBLIC]			= "Public",
+	[WFD_RTSP_HEADER_RANGE]				= "Range",
+	[WFD_RTSP_HEADER_REFERER]			= "Referer",
+	[WFD_RTSP_HEADER_RETRY_AFTER]			= "Retry-After",
+	[WFD_RTSP_HEADER_REQUIRE]			= "Require",
+	[WFD_RTSP_HEADER_RTP_INFO]			= "RTP-Info",
+	[WFD_RTSP_HEADER_SCALE]				= "Scale",
+	[WFD_RTSP_HEADER_SPEED]				= "Speed",
+	[WFD_RTSP_HEADER_SERVER]			= "Server",
+	[WFD_RTSP_HEADER_SESSION]			= "Session",
+	[WFD_RTSP_HEADER_TIMESTAMP]			= "Timestamp",
+	[WFD_RTSP_HEADER_TRANSPORT]			= "Transport",
+	[WFD_RTSP_HEADER_UNSUPPORTED]			= "Unsupported",
+	[WFD_RTSP_HEADER_USER_AGENT]			= "User-Agent",
+	[WFD_RTSP_HEADER_VARY]				= "Vary",
+	[WFD_RTSP_HEADER_VIA]				= "Via",
+	[WFD_RTSP_HEADER_WWW_AUTHENTICATE]		= "WWW-Authenticate",
+	[WFD_RTSP_HEADER_CNT]				= NULL,
+};
+
+_shl_public_
+const char *wfd_rtsp_header_get_name(unsigned int header)
+{
+	if (header >= SHL_ARRAY_LENGTH(header_names))
+		return NULL;
+
+	return header_names[header];
+}
+
+_shl_public_
+unsigned int wfd_rtsp_header_from_name(const char *header)
+{
+	size_t i;
+
+	for (i = 0; i < SHL_ARRAY_LENGTH(header_names); ++i)
+		if (header_names[i] && !strcasecmp(header, header_names[i]))
+			return i;
+
+	return WFD_RTSP_HEADER_UNKNOWN;
+}
+
+_shl_public_
+unsigned int wfd_rtsp_header_from_name_n(const char *header, size_t len)
+{
+	size_t i;
+
+	for (i = 0; i < SHL_ARRAY_LENGTH(header_names); ++i)
+		if (header_names[i] &&
+		    !strncasecmp(header, header_names[i], len) &&
+		    !header_names[i][len])
+			return i;
+
+	return WFD_RTSP_HEADER_UNKNOWN;
+}
+
+/*
+ * Helpers
+ */
+
+static void msg_clear_id(struct wfd_rtsp_msg *msg)
+{
+	switch (msg->type) {
+	case WFD_RTSP_MSG_REQUEST:
+		free(msg->id.request.method);
+		free(msg->id.request.uri);
+		break;
+	case WFD_RTSP_MSG_RESPONSE:
+		free(msg->id.response.phrase);
+		break;
+	}
+
+	free(msg->id.line);
+	shl_zero(msg->id);
+}
+
+static void msg_clear_headers(struct wfd_rtsp_msg *msg)
+{
+	struct wfd_rtsp_msg_header *h;
+	size_t i, j;
+
+	for (i = 0; i < WFD_RTSP_HEADER_CNT; ++i) {
+		h = &msg->headers[i];
+
+		for (j = 0; j < h->count; ++j)
+			free(h->lines[j]);
+
+		free(h->lines);
+		free(h->lengths);
+	}
+
+	shl_zero(msg->headers);
+}
+
+static void msg_clear_entity(struct wfd_rtsp_msg *msg)
+{
+	free(msg->entity.value);
+	shl_zero(msg->entity);
+}
+
+static void msg_clear(struct wfd_rtsp_msg *msg)
+{
+	msg_clear_id(msg);
+	msg_clear_headers(msg);
+	msg_clear_entity(msg);
+}
+
+static int decoder_call(struct wfd_rtsp_decoder *dec,
+			struct wfd_rtsp_decoder_event *ev)
+{
+	return dec->event_fn(dec, dec->data, ev);
+}
+
+static int decoder_submit(struct wfd_rtsp_decoder *dec)
+{
+	struct wfd_rtsp_decoder_event ev = { };
+	int r;
+
+	ev.type = WFD_RTSP_DECODER_MSG;
+	ev.msg = &dec->msg;
+	r = decoder_call(dec, &ev);
+	msg_clear(&dec->msg);
+
+	return r;
+}
+
+static int decoder_submit_data(struct wfd_rtsp_decoder *dec, uint8_t *p)
+{
+	struct wfd_rtsp_decoder_event ev = { };
+
+	ev.type = WFD_RTSP_DECODER_DATA;
+	ev.data.channel = dec->data_channel;
+	ev.data.size = dec->data_size;
+	ev.data.value = p;
+	return decoder_call(dec, &ev);
+}
+
+/*
+ * Header ID-line Handling
+ * This parses both, the REQUEST and RESPONSE lines of an RTSP method. It is
+ * always the first header line and defines the type of message. If it is
+ * unrecognized, we set it to UNKNOWN.
+ * Note that regardless of the ID-line, all following lines are parsed as
+ * generic headers followed by an optional entity.
+ */
+
+static int decoder_parse_request(struct wfd_rtsp_decoder *dec,
+				 char *line,
+				 size_t len)
+{
+	unsigned int major, minor;
+	size_t cmdlen, urllen;
+	char *next, *prev, *cmd, *url;
+
+	/* Requests look like this:
+	 *   <cmd> <url> RTSP/<major>.<minor>
+	 * We try to match <cmd> here, but accept invalid commands. <url> is
+	 * never parsed (it can become pretty complex if done properly). */
+
+	next = line;
+
+	/* parse <cmd> */
+	cmd = line;
+	next = strchr(next, ' ');
+	if (!next || next == cmd)
+		goto error;
+	cmdlen = next - cmd;
+
+	/* skip " " */
+	++next;
+
+	/* parse <url> */
+	url = next;
+	next = strchr(next, ' ');
+	if (!next || next == url)
+		goto error;
+	urllen = next - url;
+
+	/* skip " " */
+	++next;
+
+	/* parse "RTSP/" */
+	if (strncasecmp(next, "RTSP/", 5))
+		goto error;
+	next += 5;
+
+	/* parse "%u" */
+	prev = next;
+	shl_atoi_u(prev, 10, (const char**)&next, &major);
+	if (next == prev || *next != '.')
+		goto error;
+
+	/* skip "." */
+	++next;
+
+	/* parse "%u" */
+	prev = next;
+	shl_atoi_u(prev, 10, (const char**)&next, &minor);
+	if (next == prev || *next)
+		goto error;
+
+	cmd = strndup(cmd, cmdlen);
+	url = strndup(url, urllen);
+	if (!cmd || !url) {
+		free(cmd);
+		return llog_ENOMEM(dec);
+	}
+
+	dec->msg.type = WFD_RTSP_MSG_REQUEST;
+	dec->msg.id.line = line;
+	dec->msg.id.length = len;
+	dec->msg.id.request.method = cmd;
+	dec->msg.id.request.type = wfd_rtsp_method_from_name(cmd);
+	dec->msg.id.request.uri = url;
+	dec->msg.id.request.major = major;
+	dec->msg.id.request.minor = minor;
+
+	return 0;
+
+error:
+	/* Invalid request line.. Set type to UNKNOWN and let the caller deal
+	 * with it. We will not try to send any error to avoid triggering
+	 * another error if the remote side doesn't understand proper RTSP (or
+	 * if our implementation is buggy). */
+	dec->msg.type = WFD_RTSP_MSG_UNKNOWN;
+	dec->msg.id.line = line;
+	dec->msg.id.length = len;
+	return 0;
+}
+
+static int decoder_parse_response(struct wfd_rtsp_decoder *dec,
+				  char *line,
+				  size_t len)
+{
+	unsigned int major, minor, code;
+	char *prev, *next, *str;
+
+	/* Responses look like this:
+	 *   RTSP/<major>.<minor> <code> <string..>
+	 *   RTSP/%u.%u %u %s
+	 * We first parse the RTSP version and code. Everything appended to
+	 * this is optional and represents the error string. */
+
+	/* skip "RTSP/", already parsed by parent */
+	next = &line[5];
+
+	/* parse "%u" */
+	prev = next;
+	shl_atoi_u(prev, 10, (const char**)&next, &major);
+	if (next == prev || *next != '.')
+		goto error;
+
+	/* skip "." */
+	++next;
+
+	/* parse "%u" */
+	prev = next;
+	shl_atoi_u(prev, 10, (const char**)&next, &minor);
+	if (next == prev || *next != ' ')
+		goto error;
+
+	/* skip " " */
+	++next;
+
+	/* parse: %u */
+	prev = next;
+	shl_atoi_u(prev, 10, (const char**)&next, &code);
+	if (next == prev)
+		goto error;
+	if (*next && *next != ' ')
+		goto error;
+
+	/* skip " " */
+	if (*next)
+		++next;
+
+	/* parse: %s */
+	str = strdup(next);
+	if (!str)
+		return llog_ENOMEM(dec);
+
+	dec->msg.type = WFD_RTSP_MSG_RESPONSE;
+	dec->msg.id.line = line;
+	dec->msg.id.length = len;
+	dec->msg.id.response.major = major;
+	dec->msg.id.response.minor = minor;
+	dec->msg.id.response.status = code;
+	dec->msg.id.response.phrase = str;
+
+	return 0;
+
+error:
+	/* Couldn't parse line. Avoid sending an error message as we could
+	 * trigger another error and end up in an endless error loop. Instead,
+	 * set message type to UNKNOWN and let the caller deal with it. */
+	dec->msg.type = WFD_RTSP_MSG_UNKNOWN;
+	dec->msg.id.line = line;
+	dec->msg.id.length = len;
+	return 0;
+}
+
+static int decoder_parse_id(struct wfd_rtsp_decoder *dec, char *line, size_t len)
+{
+	if (!strncasecmp(line, "RTSP/", 5))
+		return decoder_parse_response(dec, line, len);
+	else
+		return decoder_parse_request(dec, line, len);
+}
+
+/*
+ * RTSP Header Parser
+ * This parses RTSP header lines. These follow the ID-line and may contain
+ * arbitrary additional information. Note that we parse any kind of message that
+ * we cannot identify as UNKNOWN. Thus, the caller can implement arbitrary
+ * additional parsers.
+ *
+ * Furthermore, if a header-line cannot be parsed correctly, even though the
+ * header-type is known, we still add it as UNKNOWN. Therefore, if the caller
+ * implements extensions to *known* header lines, it still needs to go through
+ * all unknown lines. It's not enough to go through the lines of the given type.
+ */
+
+static int header_append(struct wfd_rtsp_msg_header *h, char *line, size_t len)
+{
+	char **tlines;
+	size_t *tlengths;
+	size_t num;
+
+	num = h->count + 2;
+
+	tlines = realloc(h->lines, num * sizeof(*h->lines));
+	if (!tlines)
+		return -ENOMEM;
+	h->lines = tlines;
+
+	tlengths = realloc(h->lengths, num * sizeof(*h->lengths));
+	if (!tlengths)
+		return -ENOMEM;
+	h->lengths = tlengths;
+
+	h->lines[h->count] = line;
+	h->lengths[h->count] = len;
+	++h->count;
+	h->lines[h->count] = NULL;
+	h->lengths[h->count] = 0;
+
+	return 0;
+}
+
+static int decoder_add_unknown_line(struct wfd_rtsp_decoder *dec,
+				    char *line,
+				    size_t len)
+{
+	struct wfd_rtsp_msg_header *h;
+	int r;
+
+	/* Cannot parse header line. Append it at the end of the line-array
+	 * of type UNKNOWN. Let the caller deal with it. */
+
+	h = &dec->msg.headers[WFD_RTSP_HEADER_UNKNOWN];
+	r = header_append(h, line, len);
+	return r < 0 ? llog_ERR(dec, r) : 0;
+}
+
+static int decoder_parse_content_length(struct wfd_rtsp_decoder *dec,
+					char *line,
+					size_t len,
+					char *tokens,
+					size_t num)
+{
+	struct wfd_rtsp_msg_header *h;
+	int r;
+	size_t clen;
+	char *next;
+
+	h = &dec->msg.headers[WFD_RTSP_HEADER_CONTENT_LENGTH];
+
+	r = shl_atoi_z(tokens, 10, (const char**)&next, &clen);
+	if (r < 0 || *next) {
+		/* Screwed content-length line? We cannot recover from that as
+		 * the attached entity is of unknown length. Abort.. */
+		return -EINVAL;
+	}
+
+	r = header_append(h, line, len);
+	if (r < 0)
+		return llog_ERR(dec, r);
+
+	/* overwrite previous lengths */
+	h->content_length = clen;
+	dec->remaining_body = clen;
+
+	return 0;
+}
+
+static int decoder_parse_cseq(struct wfd_rtsp_decoder *dec,
+			      char *line,
+			      size_t len,
+			      char *tokens,
+			      size_t num)
+{
+	struct wfd_rtsp_msg_header *h;
+	int r;
+	unsigned long val;
+	char *next;
+
+	h = &dec->msg.headers[WFD_RTSP_HEADER_CSEQ];
+
+	r = shl_atoi_ul(tokens, 10, (const char**)&next, &val);
+	if (r < 0 || *next) {
+		/* Screwed cseq line? Append it as unknown line. */
+		return decoder_add_unknown_line(dec, line, len);
+	}
+
+	r = header_append(h, line, len);
+	if (r < 0)
+		return llog_ERR(dec, r);
+
+	/* overwrite previous cseqs */
+	h->cseq = val;
+
+	return 0;
+}
+
+static int decoder_parse_header(struct wfd_rtsp_decoder *dec,
+				char *line,
+				size_t len)
+{
+	unsigned int type;
+	char *next, *tokens;
+	ssize_t num;
+	int r;
+
+	num = wfd_rtsp_tokenize(line, len, &tokens);
+	if (num < 0)
+		return llog_ENOMEM(dec);
+	if (num < 2)
+		goto error;
+
+	/* Header lines look like this:
+	 *   <name>: <value> */
+	next = tokens;
+
+	/* parse <name> */
+	type = wfd_rtsp_header_from_name(next);
+	next = wfd_rtsp_next_token(next);
+	--num;
+
+	/* parse ":" */
+	if (strcmp(next, ":"))
+		goto error;
+	next = wfd_rtsp_next_token(next);
+	--num;
+
+	/* dispatch to header specific parser */
+	switch (type) {
+	case WFD_RTSP_HEADER_CONTENT_LENGTH:
+		r = decoder_parse_content_length(dec, line, len, next, num);
+		break;
+	case WFD_RTSP_HEADER_CSEQ:
+		r = decoder_parse_cseq(dec, line, len, next, num);
+		break;
+	default:
+		/* no parser for given type available; append to list */
+		r = header_append(&dec->msg.headers[type], line, len);
+		if (r < 0)
+			llog_vERR(dec, r);
+		break;
+	}
+
+	free(tokens);
+	return r;
+
+error:
+	free(tokens);
+	return decoder_add_unknown_line(dec, line, len);
+}
+
+/*
+ * Generic Header-line and ID-line parser
+ * This parser is invoked on each successfully read header/id-line. It sanitizes
+ * the input and then calls the correct header or ID parser, depending on
+ * current state.
+ */
+
+static size_t sanitize_header_line(struct wfd_rtsp_decoder *dec,
+				   char *line, size_t len)
+{
+	char *src, *dst, c, prev, last_c;
+	size_t i;
+	bool quoted, escaped;
+
+	src = line;
+	dst = line;
+	last_c = 0;
+	quoted = 0;
+	escaped = 0;
+
+	for (i = 0; i < len; ++i) {
+		c = *src++;
+		prev = last_c;
+		last_c = c;
+
+		if (quoted) {
+			if (prev == '\\' && !escaped) {
+				escaped = 1;
+				/* turn escaped binary zero into "\0" */
+				if (c == '\0')
+					c = '0';
+			} else {
+				escaped = 0;
+				if (c == '"') {
+					quoted = 0;
+				} else if (c == '\0') {
+					/* skip binary 0 */
+					continue;
+				}
+			}
+		} else {
+			/* ignore any binary 0 */
+			if (c == '\0')
+				continue;
+
+			/* turn new-lines/tabs into white-space */
+			if (c == '\r' || c == '\n' || c == '\t') {
+				c = ' ';
+				last_c = c;
+			}
+
+			/* trim whitespace */
+			if (c == ' ' && prev == ' ')
+				continue;
+
+			if (c == '"') {
+				quoted = 1;
+				escaped = 0;
+			}
+		}
+
+		*dst++ = c;
+	}
+
+	/* terminate string with binary zero */
+	*dst = 0;
+
+	/* remove trailing whitespace */
+	while (dst > line && *(dst - 1) == ' ')
+		*--dst = 0;
+
+	/* the decoder already trims leading-whitespace */
+
+	return dst - line;
+}
+
+static int decoder_finish_header_line(struct wfd_rtsp_decoder *dec)
+{
+	char *line;
+	size_t l;
+	int r;
+
+	line = malloc(dec->buflen + 1);
+	if (!line)
+		return llog_ENOMEM(dec);
+
+	shl_ring_copy(&dec->buf, line, dec->buflen);
+	line[dec->buflen] = 0;
+	l = sanitize_header_line(dec, line, dec->buflen);
+
+	if (!dec->msg.id.line)
+		r = decoder_parse_id(dec, line, l);
+	else
+		r = decoder_parse_header(dec, line, l);
+
+	if (r < 0)
+		free(line);
+
+	return r;
+}
+
+/*
+ * State Machine
+ * The decoder state-machine is quite simple. We take an input buffer of
+ * arbitrary length from the user and feed it byte by byte into the state
+ * machine.
+ *
+ * Parsing RTSP messages is rather troublesome due to the ASCII-nature. It's
+ * easy to parse as is, but has lots of corner-cases which we want to be
+ * compatible to maybe broken implementations. Thus, we need this
+ * state-machine.
+ *
+ * All we do here is split the endless input stream into header-lines. The
+ * header-lines are not handled by the state-machine itself but passed on. If a
+ * message contains an entity payload, we parse the body. Otherwise, we submit
+ * the message and continue parsing the next one.
+ */
+
+_shl_public_
+int wfd_rtsp_decoder_new(wfd_rtsp_decoder_event_t event_fn,
+			 void *data,
+			 wfd_rtsp_log_t log_fn,
+			 void *log_data,
+			 struct wfd_rtsp_decoder **out)
+{
+	struct wfd_rtsp_decoder *dec;
+
+	if (!event_fn || !out)
+		return llog_dEINVAL(log_fn, data);
+
+	dec = calloc(1, sizeof(*dec));
+	if (!dec)
+		return llog_dENOMEM(log_fn, data);
+
+	dec->event_fn = event_fn;
+	dec->data = data;
+	dec->llog = log_fn;
+	dec->llog_data = log_data;
+
+	*out = dec;
+	return 0;
+}
+
+_shl_public_
+void wfd_rtsp_decoder_free(struct wfd_rtsp_decoder *dec)
+{
+	if (!dec)
+		return;
+
+	msg_clear(&dec->msg);
+	shl_ring_clear(&dec->buf);
+	free(dec);
+}
+
+_shl_public_
+void wfd_rtsp_decoder_reset(struct wfd_rtsp_decoder *dec)
+{
+	if (!dec)
+		return;
+
+	msg_clear(&dec->msg);
+	shl_ring_flush(&dec->buf);
+
+	dec->buflen = 0;
+	dec->last_chr = 0;
+	dec->state = 0;
+	dec->remaining_body = 0;
+
+	dec->data_channel = 0;
+	dec->data_size = 0;
+
+	dec->quoted = false;
+	dec->dead = false;
+}
+
+_shl_public_
+void wfd_rtsp_decoder_set_data(struct wfd_rtsp_decoder *dec, void *data)
+{
+	if (!dec)
+		return;
+
+	dec->data = data;
+}
+
+_shl_public_
+void *wfd_rtsp_decoder_get_data(struct wfd_rtsp_decoder *dec)
+{
+	if (!dec)
+		return NULL;
+
+	return dec->data;
+}
+
+static int decoder_feed_char_new(struct wfd_rtsp_decoder *dec, char ch)
+{
+	switch (ch) {
+	case '\r':
+	case '\n':
+	case '\t':
+	case ' ':
+		/* If no msg has been started, yet, we ignore LWS for
+		 * compatibility reasons. Note that they're actually not
+		 * allowed, but should be ignored by implementations. */
+		++dec->buflen;
+		break;
+	case '$':
+		/* Interleaved data. Followed by 1 byte channel-id and 2-byte
+		 * data-length. */
+		dec->state = STATE_DATA_HEAD;
+		dec->data_channel = 0;
+		dec->data_size = 0;
+
+		/* clear any previous whitespace and leading '$' */
+		shl_ring_pull(&dec->buf, dec->buflen + 1);
+		dec->buflen = 0;
+		break;
+	default:
+		/* Clear any pending data in the ring-buffer and then just
+		 * push the char into the buffer. Any char except LWS is fine
+		 * here. */
+		dec->state = STATE_HEADER;
+		dec->remaining_body = 0;
+
+		shl_ring_pull(&dec->buf, dec->buflen);
+		dec->buflen = 1;
+		break;
+	}
+
+	return 0;
+}
+
+static int decoder_feed_char_header(struct wfd_rtsp_decoder *dec, char ch)
+{
+	int r;
+
+	switch (ch) {
+	case '\r':
+		if (dec->last_chr == '\r' || dec->last_chr == '\n') {
+			/* \r\r means empty new-line. We actually allow \r\r\n,
+			 * too. \n\r means empty new-line, too, but might also
+			 * be finished off as \n\r\n so go to STATE_HEADER_NL
+			 * to optionally complete the new-line.
+			 * However, if the body is empty, we need to finish the
+			 * msg early as there might be no \n coming.. */
+			dec->state = STATE_HEADER_NL;
+
+			/* First finish the last header line if any. Don't
+			 * include the current \r as it is already part of the
+			 * empty following line. */
+			r = decoder_finish_header_line(dec);
+			if (r < 0)
+				return r;
+
+			/* discard buffer *and* whitespace */
+			shl_ring_pull(&dec->buf, dec->buflen + 1);
+			dec->buflen = 0;
+
+			/* No remaining body. Finish message! */
+			if (!dec->remaining_body) {
+				r = decoder_submit(dec);
+				if (r < 0)
+					return r;
+			}
+		} else {
+			/* '\r' following any character just means newline
+			 * (optionally followed by \n). We don't do anything as
+			 * it might be a continuation line. */
+			++dec->buflen;
+		}
+		break;
+	case '\n':
+		if (dec->last_chr == '\n') {
+			/* We got \n\n, which means we need to finish the
+			 * current header-line. If there's no remaining body,
+			 * we immediately finish the message and go to
+			 * STATE_NEW. Otherwise, we go to STATE_BODY
+			 * straight. */
+
+			/* don't include second \n in header-line */
+			r = decoder_finish_header_line(dec);
+			if (r < 0)
+				return r;
+
+			/* discard buffer *and* whitespace */
+			shl_ring_pull(&dec->buf, dec->buflen + 1);
+			dec->buflen = 0;
+
+			if (dec->remaining_body) {
+				dec->state = STATE_BODY;
+			} else {
+				dec->state = STATE_NEW;
+				r = decoder_submit(dec);
+				if (r < 0)
+					return r;
+			}
+		} else if (dec->last_chr == '\r') {
+			/* We got an \r\n. We cannot finish the header line as
+			 * it might be a continuation line. Next character
+			 * decides what to do. Don't do anything here.
+			 * \r\n\r cannot happen here as it is handled by
+			 * STATE_HEADER_NL. */
+			++dec->buflen;
+		} else {
+			/* Same as above, we cannot finish the line as it
+			 * might be a continuation line. Do nothing. */
+			++dec->buflen;
+		}
+		break;
+	case '\t':
+	case ' ':
+		/* Whitespace. Simply push into buffer and don't do anything.
+		 * In case of a continuation line, nothing has to be done,
+		 * either. */
+		++dec->buflen;
+		break;
+	default:
+		if (dec->last_chr == '\r' || dec->last_chr == '\n') {
+			/* Last line is complete and this is no whitespace,
+			 * thus it's not a continuation line.
+			 * Finish the line. */
+
+			/* don't include new char in line */
+			r = decoder_finish_header_line(dec);
+			if (r < 0)
+				return r;
+			shl_ring_pull(&dec->buf, dec->buflen);
+			dec->buflen = 0;
+		}
+
+		/* consume character and handle special chars */
+		++dec->buflen;
+		if (ch == '"') {
+			/* go to STATE_HEADER_QUOTE */
+			dec->state = STATE_HEADER_QUOTE;
+			dec->quoted = false;
+		}
+
+		break;
+	}
+
+	return 0;
+}
+
+static int decoder_feed_char_header_quote(struct wfd_rtsp_decoder *dec, char ch)
+{
+	if (dec->last_chr == '\\' && !dec->quoted) {
+		/* This character is quoted, so copy it unparsed. To handle
+		 * double-backslash, we set the "quoted" bit. */
+		++dec->buflen;
+		dec->quoted = true;
+	} else {
+		dec->quoted = false;
+
+		/* consume character and handle special chars */
+		++dec->buflen;
+		if (ch == '"')
+			dec->state = STATE_HEADER;
+	}
+
+	return 0;
+}
+
+static int decoder_feed_char_body(struct wfd_rtsp_decoder *dec, char ch)
+{
+	char *line;
+	int r;
+
+	/* If remaining_body was already 0, the message had no body. Note that
+	 * messages without body are finished early, so no need to call
+	 * decoder_submit() here. Simply forward @ch to STATE_NEW.
+	 * @rlen is usually 0. We don't care and forward it, too. */
+	if (!dec->remaining_body) {
+		dec->state = STATE_NEW;
+		return decoder_feed_char_new(dec, ch);
+	}
+
+	/* *any* character is allowed as body */
+	++dec->buflen;
+
+	if (!--dec->remaining_body) {
+		/* full body received, copy it and go to STATE_NEW */
+
+		line = malloc(dec->buflen + 1);
+		if (!line)
+			return llog_ENOMEM(dec);
+
+		shl_ring_copy(&dec->buf, line, dec->buflen);
+		line[dec->buflen] = 0;
+
+		dec->msg.entity.value = line;
+		dec->msg.entity.size = dec->buflen;
+		r = decoder_submit(dec);
+
+		dec->state = STATE_NEW;
+		shl_ring_pull(&dec->buf, dec->buflen);
+		dec->buflen = 0;
+
+		if (r < 0)
+			return r;
+	}
+
+	return 0;
+}
+
+static int decoder_feed_char_header_nl(struct wfd_rtsp_decoder *dec, char ch)
+{
+	/* STATE_HEADER_NL means we received an empty line ending with \r. The
+	 * standard requires a following \n but advises implementations to
+	 * accept \r on itself, too.
+	 * What we do is to parse a \n as end-of-header and any character as
+	 * end-of-header plus start-of-body. Note that we discard anything in
+	 * the ring-buffer that has already been parsed (which normally can
+	 * nothing, but lets be safe). */
+
+	if (ch == '\n') {
+		/* discard transition chars plus new \n */
+		shl_ring_pull(&dec->buf, dec->buflen + 1);
+		dec->buflen = 0;
+
+		dec->state = STATE_BODY;
+		if (!dec->remaining_body)
+			dec->state = STATE_NEW;
+
+		return 0;
+	} else {
+		/* discard any transition chars and push @ch into body */
+		shl_ring_pull(&dec->buf, dec->buflen);
+		dec->buflen = 0;
+
+		dec->state = STATE_BODY;
+		return decoder_feed_char_body(dec, ch);
+	}
+}
+
+static int decoder_feed_char_data_head(struct wfd_rtsp_decoder *dec, char ch)
+{
+	uint8_t buf[3];
+
+	/* Read 1 byte channel-id and 2 byte body length. */
+
+	if (++dec->buflen >= 3) {
+		shl_ring_copy(&dec->buf, buf, 3);
+		shl_ring_pull(&dec->buf, dec->buflen);
+		dec->buflen = 0;
+
+		dec->data_channel = buf[0];
+		dec->data_size = (((uint16_t)buf[1]) << 8) | (uint16_t)buf[2];
+		dec->state = STATE_DATA_BODY;
+	}
+
+	return 0;
+}
+
+static int decoder_feed_char_data_body(struct wfd_rtsp_decoder *dec, char ch)
+{
+	uint8_t *buf;
+	int r;
+
+	/* Read @dec->data_size bytes of raw data. */
+
+	if (++dec->buflen >= dec->data_size) {
+		buf = malloc(dec->data_size + 1);
+		if (!buf)
+			return llog_ENOMEM(dec);
+
+		/* Not really needed, but in case it's actually a text-payload
+		 * make sure it's 0-terminated to work around client bugs. */
+		buf[dec->data_size] = 0;
+
+		shl_ring_copy(&dec->buf, buf, dec->data_size);
+
+		r = decoder_submit_data(dec, buf);
+		free(buf);
+
+		dec->state = STATE_NEW;
+		shl_ring_pull(&dec->buf, dec->buflen);
+		dec->buflen = 0;
+
+		if (r < 0)
+			return r;
+	}
+
+	return 0;
+}
+
+static int decoder_feed_char(struct wfd_rtsp_decoder *dec, char ch)
+{
+	int r = 0;
+
+	switch (dec->state) {
+	case STATE_NEW:
+		r = decoder_feed_char_new(dec, ch);
+		break;
+	case STATE_HEADER:
+		r = decoder_feed_char_header(dec, ch);
+		break;
+	case STATE_HEADER_QUOTE:
+		r = decoder_feed_char_header_quote(dec, ch);
+		break;
+	case STATE_HEADER_NL:
+		r = decoder_feed_char_header_nl(dec, ch);
+		break;
+	case STATE_BODY:
+		r = decoder_feed_char_body(dec, ch);
+		break;
+	case STATE_DATA_HEAD:
+		r = decoder_feed_char_data_head(dec, ch);
+		break;
+	case STATE_DATA_BODY:
+		r = decoder_feed_char_data_body(dec, ch);
+		break;
+	}
+
+	return r;
+}
+
+_shl_public_
+int wfd_rtsp_decoder_feed(struct wfd_rtsp_decoder *dec,
+		      const void *buf,
+		      size_t len)
+{
+	char ch;
+	size_t i;
+	int r;
+
+	if (!dec)
+		return -EINVAL;
+	if (dec->dead)
+		return llog_EINVAL(dec);
+	if (!len)
+		return 0;
+	if (!buf)
+		return llog_EINVAL(dec);
+
+	/* We keep dec->buflen as cache for the current parsed-buffer size. We
+	 * need to push the whole input-buffer into our parser-buffer and go
+	 * through it one-by-one. The parser increments dec->buflen for each of
+	 * these and once we're done, we verify our state is consistent. */
+
+	dec->buflen = shl_ring_get_size(&dec->buf);
+	r = shl_ring_push(&dec->buf, buf, len);
+	if (r < 0) {
+		llog_vERR(dec, r);
+		goto error;
+	}
+
+	for (i = 0; i < len; ++i) {
+		ch = ((const char*)buf)[i];
+		r = decoder_feed_char(dec, ch);
+		if (r < 0)
+			goto error;
+
+		dec->last_chr = ch;
+	}
+
+	/* check for internal parser inconsistencies; should not happen! */
+	if (dec->buflen != shl_ring_get_size(&dec->buf)) {
+		llog_error(dec, "internal RTSP parser error");
+		r = -EFAULT;
+		goto error;
+	}
+
+	return 0;
+
+error:
+	dec->dead = true;
+	return r;
+}
diff --git a/src/rtsp_tokenizer.c b/src/rtsp_tokenizer.c
new file mode 100644
index 0000000..7f56a98
--- /dev/null
+++ b/src/rtsp_tokenizer.c
@@ -0,0 +1,191 @@
+/*
+ * libwfd - Wifi-Display/Miracast Protocol Implementation
+ *
+ * Copyright (c) 2013-2014 David Herrmann <dh.herrmann@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <errno.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include "libwfd.h"
+#include "shl_macro.h"
+
+/*
+ * RTSP Tokenizer
+ * The RTSP standard is word-based and allows linear-whitespace between any two
+ * tokens or special-chars. This tokenizer splits a given line into a list of
+ * tokens and returns how many tokens were generated. It also sanitizes the line
+ * by removing whitespace, trimming leading/trailing whitespace, removing binary
+ * zero characters and decoding escape-sequences.
+ *
+ * This tokenizer can be used before or after the basic RTSP sanitizer. But note
+ * that some RTSP requests or responses contain URIs or other embedded
+ * information which should not be tokenized as they don't follow basic RTSP
+ * rules (yeah, who came up with that shit..).
+ */
+_shl_public_
+ssize_t wfd_rtsp_tokenize(const char *line, ssize_t len, char **out)
+{
+	char *t, *dst, c, prev, last_c;
+	const char *src;
+	size_t num;
+	bool quoted, escaped;
+
+	if (!line || !out)
+		return -EINVAL;
+
+	/* we need at most twice as much space for all the terminating 0s */
+	if (len < 0)
+		len = strlen(line);
+	t = calloc(2, len + 1);
+	if (!t)
+		return -ENOMEM;
+
+	num = 0;
+	src = line;
+	dst = t;
+	quoted = false;
+	escaped = false;
+	prev = 0;
+	last_c = 0;
+
+	for ( ; len > 0; --len) {
+		c = *src++;
+		prev = last_c;
+		last_c = 0;
+
+		if (quoted) {
+			if (escaped) {
+				last_c = c;
+				if (c == '\\') {
+					*dst++ = '\\';
+				} else if (c == '"') {
+					*dst++ = '"';
+				} else if (c == 'n') {
+					*dst++ = '\n';
+				} else if (c == 'r') {
+					*dst++ = '\r';
+				} else if (c == 't') {
+					*dst++ = '\t';
+				} else if (c == 'a') {
+					*dst++ = '\a';
+				} else if (c == 'f') {
+					*dst++ = '\f';
+				} else if (c == 'v') {
+					*dst++ = '\v';
+				} else if (c == 'b') {
+					*dst++ = '\b';
+				} else if (c == 'e') {
+					*dst++ = 0x1b;	/* ESC */
+				} else if (c == 0) {
+					/* turn escaped binary 0 into \0 */
+					*dst++ = '\\';
+					*dst++ = '0';
+					last_c = '0';
+				} else {
+					/* keep unknown escape sequences */
+					*dst++ = '\\';
+					*dst++ = c;
+				}
+				escaped = false;
+			} else {
+				if (c == '"') {
+					*dst++ = 0;
+					++num;
+					quoted = false;
+				} else if (c == '\\') {
+					escaped = true;
+					last_c = prev;
+				} else if (c == 0) {
+					/* discard */
+					last_c = prev;
+				} else {
+					*dst++ = c;
+					last_c = c;
+				}
+			}
+		} else {
+			if (c == '"') {
+				if (prev) {
+					*dst++ = 0;
+					++num;
+				}
+				quoted = true;
+			} else if (c == 0) {
+				/* discard */
+				last_c = prev;
+			} else if (c == ' ' ||
+				   c == '\t' ||
+				   c == '\n' ||
+				   c == '\r') {
+				if (prev) {
+					*dst++ = 0;
+					++num;
+				}
+			} else if (c == '(' ||
+				   c == ')' ||
+				   c == '[' ||
+				   c == ']' ||
+				   c == '{' ||
+				   c == '}' ||
+				   c == '<' ||
+				   c == '>' ||
+				   c == '@' ||
+				   c == ',' ||
+				   c == ';' ||
+				   c == ':' ||
+				   c == '\\' ||
+				   c == '/' ||
+				   c == '?' ||
+				   c == '=') {
+				if (prev) {
+					*dst++ = 0;
+					++num;
+				}
+				*dst++ = c;
+				*dst++ = 0;
+				++num;
+			} else if (c <= 31 || c == 127) {
+				/* ignore CTLs */
+				if (prev) {
+					*dst++ = 0;
+					++num;
+				}
+			} else {
+				*dst++ = c;
+				last_c = c;
+			}
+		}
+	}
+
+	if (last_c || quoted) {
+		if (escaped)
+			*dst++ = '\\';
+		*dst++ = 0;
+		++num;
+	}
+
+	*out = t;
+	return num;
+}
diff --git a/src/shl_llog.h b/src/shl_llog.h
new file mode 100644
index 0000000..1dd4a3c
--- /dev/null
+++ b/src/shl_llog.h
@@ -0,0 +1,247 @@
+/*
+ * SHL - Library Log/Debug Interface
+ *
+ * Copyright (c) 2010-2013 David Herrmann <dh.herrmann@gmail.com>
+ * Dedicated to the Public Domain
+ */
+
+/*
+ * Library Log/Debug Interface
+ * Libraries should always avoid producing side-effects. This includes writing
+ * log-messages of any kind. However, you often don't want to disable debugging
+ * entirely, therefore, the core objects often contain a pointer to a function
+ * which performs logging. If that pointer is NULL (default), logging is
+ * disabled.
+ *
+ * This header should never be installed into the system! This is _no_ public
+ * header. Instead, copy it into your application if you want and use it there.
+ * Your public library API should include something like this:
+ *
+ *   typedef void (*MYPREFIX_log_t) (void *data,
+ *                                   const char *file,
+ *                                   int line,
+ *                                   const char *func,
+ *                                   const char *subs,
+ *                                   unsigned int sev,
+ *                                   const char *format,
+ *                                   va_list args);
+ *
+ * And then the user can supply such a function when creating a new context
+ * object of your library or simply supply NULL. Internally, you have a field of
+ * type "MYPREFIX_log_t llog" in your main structure. If you pass this to the
+ * convenience helpers like llog_dbg(), llog_warn() etc. it will automatically
+ * use the "llog" field to print the message. If it is NULL, nothing is done.
+ *
+ * The arguments of the log-function are defined as:
+ *   data: User-supplied data field that is passed straight through.
+ *   file: Zero terminated string of the file-name where the log-message
+ *         occurred. Can be NULL.
+ *   line: Line number of @file where the message occurred. Set to 0 or smaller
+ *         if not available.
+ *   func: Function name where the log-message occurred. Can be NULL.
+ *   subs: Subsystem where the message occurred (zero terminated). Can be NULL.
+ *   sev: Severity of log-message. An integer between 0 and 7 as defined below.
+ *        These are identical to the linux-kernel severities so there is no need
+ *        to include these in your public API. Every app can define them
+ *        themselves, if they need it.
+ *   format: Format string. Must not be NULL.
+ *   args: Argument array
+ *
+ * The user should also be able to optionally provide a data field which is
+ * always passed unmodified as first parameter to the log-function. This allows
+ * to add context to the logger.
+ */
+
+#ifndef SHL_LLOG_H
+#define SHL_LLOG_H
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+enum llog_severity {
+	LLOG_FATAL = 0,
+	LLOG_ALERT = 1,
+	LLOG_CRITICAL = 2,
+	LLOG_ERROR = 3,
+	LLOG_WARNING = 4,
+	LLOG_NOTICE = 5,
+	LLOG_INFO = 6,
+	LLOG_DEBUG = 7,
+	LLOG_SEV_NUM,
+};
+
+typedef void (*llog_submit_t) (void *data,
+			       const char *file,
+			       int line,
+			       const char *func,
+			       const char *subs,
+			       unsigned int sev,
+			       const char *format,
+			       va_list args);
+
+static inline __attribute__((format(printf, 8, 9)))
+void llog_format(llog_submit_t llog,
+		 void *data,
+		 const char *file,
+		 int line,
+		 const char *func,
+		 const char *subs,
+		 unsigned int sev,
+		 const char *format,
+		 ...)
+{
+	int saved_errno = errno;
+	va_list list;
+
+	if (llog) {
+		va_start(list, format);
+		errno = saved_errno;
+		llog(data, file, line, func, subs, sev, format, list);
+		va_end(list);
+	}
+}
+
+#ifndef LLOG_SUBSYSTEM
+static const char *LLOG_SUBSYSTEM __attribute__((__unused__));
+#endif
+
+#define LLOG_DEFAULT __FILE__, __LINE__, __func__, LLOG_SUBSYSTEM
+
+#define llog_printf(obj, sev, format, ...) \
+	llog_format((obj)->llog, \
+		    (obj)->llog_data, \
+		    LLOG_DEFAULT, \
+		    (sev), \
+		    (format), \
+		    ##__VA_ARGS__)
+#define llog_dprintf(obj, data, sev, format, ...) \
+	llog_format((obj), \
+		    (data), \
+		    LLOG_DEFAULT, \
+		    (sev), \
+		    (format), \
+		    ##__VA_ARGS__)
+
+static inline __attribute__((format(printf, 4, 5)))
+void llog_dummyf(llog_submit_t llog, void *data, unsigned int sev,
+		 const char *format, ...)
+{
+}
+
+/*
+ * Helpers
+ * They pick up all the default values and submit the message to the
+ * llog-subsystem. The llog_debug() function will discard the message unless
+ * BUILD_ENABLE_DEBUG is defined.
+ */
+
+#ifdef BUILD_ENABLE_DEBUG
+	#define llog_ddebug(obj, data, format, ...) \
+		llog_dprintf((obj), (data), LLOG_DEBUG, (format), ##__VA_ARGS__)
+	#define llog_debug(obj, format, ...) \
+		llog_ddebug((obj)->llog, (obj)->llog_data, (format), ##__VA_ARGS__)
+#else
+	#define llog_ddebug(obj, data, format, ...) \
+		llog_dummyf((obj), (data), LLOG_DEBUG, (format), ##__VA_ARGS__)
+	#define llog_debug(obj, format, ...) \
+		llog_ddebug((obj)->llog, (obj)->llog_data, (format), ##__VA_ARGS__)
+#endif
+
+#define llog_info(obj, format, ...) \
+	llog_printf((obj), LLOG_INFO, (format), ##__VA_ARGS__)
+#define llog_dinfo(obj, data, format, ...) \
+	llog_dprintf((obj), (data), LLOG_INFO, (format), ##__VA_ARGS__)
+#define llog_notice(obj, format, ...) \
+	llog_printf((obj), LLOG_NOTICE, (format), ##__VA_ARGS__)
+#define llog_dnotice(obj, data, format, ...) \
+	llog_dprintf((obj), (data), LLOG_NOTICE, (format), ##__VA_ARGS__)
+#define llog_warning(obj, format, ...) \
+	llog_printf((obj), LLOG_WARNING, (format), ##__VA_ARGS__)
+#define llog_dwarning(obj, data, format, ...) \
+	llog_dprintf((obj), (data), LLOG_WARNING, (format), ##__VA_ARGS__)
+#define llog_error(obj, format, ...) \
+	llog_printf((obj), LLOG_ERROR, (format), ##__VA_ARGS__)
+#define llog_derror(obj, data, format, ...) \
+	llog_dprintf((obj), (data), LLOG_ERROR, (format), ##__VA_ARGS__)
+#define llog_critical(obj, format, ...) \
+	llog_printf((obj), LLOG_CRITICAL, (format), ##__VA_ARGS__)
+#define llog_dcritical(obj, data, format, ...) \
+	llog_dprintf((obj), (data), LLOG_CRITICAL, (format), ##__VA_ARGS__)
+#define llog_alert(obj, format, ...) \
+	llog_printf((obj), LLOG_ALERT, (format), ##__VA_ARGS__)
+#define llog_dalert(obj, data, format, ...) \
+	llog_dprintf((obj), (data), LLOG_ALERT, (format), ##__VA_ARGS__)
+#define llog_fatal(obj, format, ...) \
+	llog_printf((obj), LLOG_FATAL, (format), ##__VA_ARGS__)
+#define llog_dfatal(obj, data, format, ...) \
+	llog_dprintf((obj), (data), LLOG_FATAL, (format), ##__VA_ARGS__)
+
+/*
+ * Default log messages
+ * These macros can be used to produce default log messages. You can use them
+ * directly in an "return" statement. The "v" variants automatically cast the
+ * result to void so it can be used in return statements inside of void
+ * functions. The "d" variants use the logging object directly as the parent
+ * might not exist, yet.
+ *
+ * Most of the messages work only if debugging is enabled. This is, because they
+ * are used in debug paths and would slow down normal applications.
+ */
+
+#define llog_dEINVAL(obj, data) \
+	(llog_derror((obj), (data), "invalid arguments"), -EINVAL)
+#define llog_EINVAL(obj) \
+	(llog_dEINVAL((obj)->llog, (obj)->llog_data))
+#define llog_vEINVAL(obj) \
+	((void)llog_EINVAL(obj))
+#define llog_vdEINVAL(obj, data) \
+	((void)llog_dEINVAL((obj), (data)))
+
+#define llog_dEFAULT(obj, data) \
+	(llog_derror((obj), (data), "internal operation failed"), -EFAULT)
+#define llog_EFAULT(obj) \
+	(llog_dEFAULT((obj)->llog, (obj)->llog_data))
+#define llog_vEFAULT(obj) \
+	((void)llog_EFAULT(obj))
+#define llog_vdEFAULT(obj, data) \
+	((void)llog_dEFAULT((obj), (data)))
+
+#define llog_dENOMEM(obj, data) \
+	(llog_derror((obj), (data), "out of memory"), -ENOMEM)
+#define llog_ENOMEM(obj) \
+	(llog_dENOMEM((obj)->llog, (obj)->llog_data))
+#define llog_vENOMEM(obj) \
+	((void)llog_ENOMEM(obj))
+#define llog_vdENOMEM(obj, data) \
+	((void)llog_dENOMEM((obj), (data)))
+
+#define llog_dEPIPE(obj, data) \
+	(llog_derror((obj), (data), "fd closed unexpectedly"), -EPIPE)
+#define llog_EPIPE(obj) \
+	(llog_dEPIPE((obj)->llog, (obj)->llog_data))
+#define llog_vEPIPE(obj) \
+	((void)llog_EPIPE(obj))
+#define llog_vdEPIPE(obj, data) \
+	((void)llog_dEPIPE((obj), (data)))
+
+#define llog_dERRNO(obj, data) \
+	(llog_derror((obj), (data), "syscall failed (%d): %m", errno), -errno)
+#define llog_ERRNO(obj) \
+	(llog_dERRNO((obj)->llog, (obj)->llog_data))
+#define llog_vERRNO(obj) \
+	((void)llog_ERRNO(obj))
+#define llog_vdERRNO(obj, data) \
+	((void)llog_dERRNO((obj), (data)))
+
+#define llog_dERR(obj, data, _r) \
+	(errno = -(_r), llog_derror((obj), (data), "syscall failed (%d): %m", (_r)), (_r))
+#define llog_ERR(obj, _r) \
+	(llog_dERR((obj)->llog, (obj)->llog_data, (_r)))
+#define llog_vERR(obj, _r) \
+	((void)llog_ERR((obj), (_r)))
+#define llog_vdERR(obj, data, _r) \
+	((void)llog_dERR((obj), (data), (_r)))
+
+#endif /* SHL_LLOG_H */
diff --git a/src/shl_macro.h b/src/shl_macro.h
new file mode 100644
index 0000000..ae855df
--- /dev/null
+++ b/src/shl_macro.h
@@ -0,0 +1,219 @@
+/*
+ * SHL - Macros
+ *
+ * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
+ * Dedicated to the Public Domain
+ */
+
+/*
+ * Macros
+ */
+
+#ifndef SHL_MACRO_H
+#define SHL_MACRO_H
+
+#include <assert.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* sanity checks required for some macros */
+#if __SIZEOF_POINTER__ != 4 && __SIZEOF_POINTER__ != 8
+#error "Pointer size is neither 4 nor 8 bytes"
+#endif
+
+/* gcc attributes; look them up for more information */
+#define _shl_printf_(_a, _b) __attribute__((__format__(printf, _a, _b)))
+#define _shl_alloc_(...) __attribute__((__alloc_size__(__VA_ARGS__)))
+#define _shl_sentinel_ __attribute__((__sentinel__))
+#define _shl_noreturn_ __attribute__((__noreturn__))
+#define _shl_unused_ __attribute__((__unused__))
+#define _shl_pure_ __attribute__((__pure__))
+#define _shl_const_ __attribute__((__const__))
+#define _shl_deprecated_ __attribute__((__deprecated__))
+#define _shl_packed_ __attribute__((__packed__))
+#define _shl_malloc_ __attribute__((__malloc__))
+#define _shl_weak_ __attribute__((__weak__))
+#define _shl_likely_(_val) (__builtin_expect(!!(_val), 1))
+#define _shl_unlikely_(_val) (__builtin_expect(!!(_val), 0))
+#define _shl_public_ __attribute__((__visibility__("default")))
+#define _shl_hidden_ __attribute__((__visibility__("hidden")))
+#define _shl_weakref_(_val) __attribute__((__weakref__(#_val)))
+#define _shl_cleanup_(_val) __attribute__((__cleanup__(_val)))
+
+/* 2-level stringify helper */
+#define SHL__STRINGIFY(_val) #_val
+#define SHL_STRINGIFY(_val) SHL__STRINGIFY(_val)
+
+/* 2-level concatenate helper */
+#define SHL__CONCATENATE(_a, _b) _a ## _b
+#define SHL_CONCATENATE(_a, _b) SHL__CONCATENATE(_a, _b)
+
+/* unique identifier with prefix */
+#define SHL_UNIQUE(_prefix) SHL_CONCATENATE(_prefix, __COUNTER__)
+
+/* array element count */
+#define SHL_ARRAY_LENGTH(_array) (sizeof(_array)/sizeof(*(_array)))
+
+/* get parent pointer by container-type, member and member-pointer */
+#define shl_container_of(_ptr, _type, _member) \
+	({ \
+		const typeof( ((_type *)0)->_member ) *__mptr = (_ptr); \
+		(_type *)( (char *)__mptr - offsetof(_type, _member) ); \
+	})
+
+/* return maximum of two values and do strict type checking */
+#define shl_max(_a, _b) \
+	({ \
+		typeof(_a) __a = (_a); \
+		typeof(_b) __b = (_b); \
+		(void) (&__a == &__b); \
+		__a > __b ? __a : __b; \
+	})
+
+/* same as shl_max() but perform explicit cast beforehand */
+#define shl_max_t(_type, _a, _b) \
+	({ \
+		_type __a = (_type)(_a); \
+		_type __b = (_type)(_b); \
+		__a > __b ? __a : __b; \
+	})
+
+/* return minimum of two values and do strict type checking */
+#define shl_min(_a, _b) \
+	({ \
+		typeof(_a) __a = (_a); \
+		typeof(_b) __b = (_b); \
+		(void) (&__a == &__b); \
+		__a < __b ? __a : __b; \
+	})
+
+/* same as shl_min() but perform explicit cast beforehand */
+#define shl_min_t(_type, _a, _b) \
+	({ \
+		_type __a = (_type)(_a); \
+		_type __b = (_type)(_b); \
+		__a < __b ? __a : __b; \
+	})
+
+/* clamp value between low and high barriers */
+#define shl_clamp(_val, _low, _high) \
+	({ \
+		typeof(_val) __v = (_val); \
+		typeof(_low) __l = (_low); \
+		typeof(_high) __h = (_high); \
+		(void) (&__v == &__l); \
+		(void) (&__v == &__h); \
+		((__v > __h) ? __h : ((__v < __l) ? __l : __v)); \
+	})
+
+/* align to next higher power-of-2 (except for: 0 => 0, overflow => 0) */
+static inline size_t SHL_ALIGN_POWER2(size_t u)
+{
+	return 1ULL << ((sizeof(u) * 8ULL) - __builtin_clzll(u - 1ULL));
+}
+
+/* zero memory or type */
+#define shl_memzero(_ptr, _size) (memset((_ptr), 0, (_size)))
+#define shl_zero(_ptr) (shl_memzero(&(_ptr), sizeof(_ptr)))
+
+/* ptr <=> uint casts */
+#define SHL_PTR_TO_TYPE(_type, _ptr) ((_type)((uintptr_t)(_ptr)))
+#define SHL_TYPE_TO_PTR(_type, _int) ((void*)((uintptr_t)(_int)))
+#define SHL_PTR_TO_INT(_ptr) SHL_PTR_TO_TYPE(int, (_ptr))
+#define SHL_INT_TO_PTR(_ptr) SHL_TYPE_TO_PTR(int, (_ptr))
+#define SHL_PTR_TO_UINT(_ptr) SHL_PTR_TO_TYPE(unsigned int, (_ptr))
+#define SHL_UINT_TO_PTR(_ptr) SHL_TYPE_TO_PTR(unsigned int, (_ptr))
+#define SHL_PTR_TO_LONG(_ptr) SHL_PTR_TO_TYPE(long, (_ptr))
+#define SHL_LONG_TO_PTR(_ptr) SHL_TYPE_TO_PTR(long, (_ptr))
+#define SHL_PTR_TO_ULONG(_ptr) SHL_PTR_TO_TYPE(unsigned long, (_ptr))
+#define SHL_ULONG_TO_PTR(_ptr) SHL_TYPE_TO_PTR(unsigned long, (_ptr))
+#define SHL_PTR_TO_S32(_ptr) SHL_PTR_TO_TYPE(int32_t, (_ptr))
+#define SHL_S32_TO_PTR(_ptr) SHL_TYPE_TO_PTR(int32_t, (_ptr))
+#define SHL_PTR_TO_U32(_ptr) SHL_PTR_TO_TYPE(uint32_t, (_ptr))
+#define SHL_U32_TO_PTR(_ptr) SHL_TYPE_TO_PTR(uint32_t, (_ptr))
+#define SHL_PTR_TO_S64(_ptr) SHL_PTR_TO_TYPE(int64_t, (_ptr))
+#define SHL_S64_TO_PTR(_ptr) SHL_TYPE_TO_PTR(int64_t, (_ptr))
+#define SHL_PTR_TO_U64(_ptr) SHL_PTR_TO_TYPE(uint64_t, (_ptr))
+#define SHL_U64_TO_PTR(_ptr) SHL_TYPE_TO_PTR(uint64_t, (_ptr))
+
+/* compile-time assertions */
+#define shl_assert_cc(_expr) static_assert(_expr, #_expr)
+
+/*
+ * Safe Multiplications
+ * Multiplications are subject to overflows. These helpers guarantee that the
+ * multiplication can be done safely and return -ERANGE if not.
+ *
+ * Note: This is horribly slow for ull/uint64_t as we need a division to test
+ * for overflows. Take that into account when using these. For smaller integers,
+ * we can simply use an upcast-multiplication which gcc should be smart enough
+ * to optimize.
+ */
+
+#define SHL__REAL_MULT(_max, _val, _factor) \
+	({ \
+		(_factor == 0 || *(_val) <= (_max) / (_factor)) ? \
+			((*(_val) *= (_factor)), 0) : \
+			-ERANGE; \
+	})
+
+#define SHL__UPCAST_MULT(_type, _max, _val, _factor) \
+	({ \
+		_type v = *(_val) * (_type)(_factor); \
+		(v <= (_max)) ? \
+			((*(_val) = v), 0) : \
+			-ERANGE; \
+	})
+
+static inline int shl_mult_ull(unsigned long long *val,
+			       unsigned long long factor)
+{
+	return SHL__REAL_MULT(ULLONG_MAX, val, factor);
+}
+
+static inline int shl_mult_ul(unsigned long *val, unsigned long factor)
+{
+#if ULONG_MAX < ULLONG_MAX
+	return SHL__UPCAST_MULT(unsigned long long, ULONG_MAX, val, factor);
+#else
+	shl_assert_cc(sizeof(unsigned long) == sizeof(unsigned long long));
+	return shl_mult_ull((unsigned long long*)val, factor);
+#endif
+}
+
+static inline int shl_mult_u(unsigned int *val, unsigned int factor)
+{
+#if UINT_MAX < ULONG_MAX
+	return SHL__UPCAST_MULT(unsigned long, UINT_MAX, val, factor);
+#elif UINT_MAX < ULLONG_MAX
+	return SHL__UPCAST_MULT(unsigned long long, UINT_MAX, val, factor);
+#else
+	shl_assert_cc(sizeof(unsigned int) == sizeof(unsigned long long));
+	return shl_mult_ull(val, factor);
+#endif
+}
+
+static inline int shl_mult_u64(uint64_t *val, uint64_t factor)
+{
+	return SHL__REAL_MULT(UINT64_MAX, val, factor);
+}
+
+static inline int shl_mult_u32(uint32_t *val, uint32_t factor)
+{
+	return SHL__UPCAST_MULT(uint_fast64_t, UINT32_MAX, val, factor);
+}
+
+static inline int shl_mult_u16(uint16_t *val, uint16_t factor)
+{
+	return SHL__UPCAST_MULT(uint_fast32_t, UINT16_MAX, val, factor);
+}
+
+static inline int shl_mult_u8(uint8_t *val, uint8_t factor)
+{
+	return SHL__UPCAST_MULT(uint_fast16_t, UINT8_MAX, val, factor);
+}
+
+#endif  /* SHL_MACRO_H */
diff --git a/src/shl_ring.c b/src/shl_ring.c
new file mode 100644
index 0000000..a703fa8
--- /dev/null
+++ b/src/shl_ring.c
@@ -0,0 +1,188 @@
+/*
+ * SHL - Ring buffer
+ *
+ * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
+ * Dedicated to the Public Domain
+ */
+
+/*
+ * Ring buffer
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/uio.h>
+#include "shl_macro.h"
+#include "shl_ring.h"
+
+#define RING_MASK(_r, _v) ((_v) & ((_r)->size - 1))
+
+void shl_ring_flush(struct shl_ring *r)
+{
+	r->start = 0;
+	r->used = 0;
+}
+
+void shl_ring_clear(struct shl_ring *r)
+{
+	free(r->buf);
+	memset(r, 0, sizeof(*r));
+}
+
+/*
+ * Get data pointers for current ring-buffer data. @vec must be an array of 2
+ * iovec objects. They are filled according to the data available in the
+ * ring-buffer. 0, 1 or 2 is returned according to the number of iovec objects
+ * that were filled (0 meaning buffer is empty).
+ *
+ * Hint: "struct iovec" is defined in <sys/uio.h> and looks like this:
+ *     struct iovec {
+ *         void *iov_base;
+ *         size_t iov_len;
+ *     };
+ */
+size_t shl_ring_peek(struct shl_ring *r, struct iovec *vec)
+{
+	if (r->used == 0) {
+		return 0;
+	} else if (r->start + r->used <= r->size) {
+		if (vec) {
+			vec[0].iov_base = &r->buf[r->start];
+			vec[0].iov_len = r->used;
+		}
+		return 1;
+	} else {
+		if (vec) {
+			vec[0].iov_base = &r->buf[r->start];
+			vec[0].iov_len = r->size - r->start;
+			vec[1].iov_base = r->buf;
+			vec[1].iov_len = r->used - (r->size - r->start);
+		}
+		return 2;
+	}
+}
+
+/*
+ * Copy data from the ring buffer into the linear external buffer @buf. Copy
+ * at most @size bytes. If the ring buffer size is smaller, copy less bytes and
+ * return the number of bytes copied.
+ */
+size_t shl_ring_copy(struct shl_ring *r, void *buf, size_t size)
+{
+	size_t l;
+
+	if (size > r->used)
+		size = r->used;
+
+	if (size > 0) {
+		l = r->size - r->start;
+		if (size <= l) {
+			memcpy(buf, &r->buf[r->start], size);
+		} else {
+			memcpy(buf, &r->buf[r->start], l);
+			memcpy((uint8_t*)buf + l, r->buf, size - l);
+		}
+	}
+
+	return size;
+}
+
+/*
+ * Resize ring-buffer to size @nsize. @nsize must be a power-of-2, otherwise
+ * ring operations will behave incorrectly.
+ */
+static int ring_resize(struct shl_ring *r, size_t nsize)
+{
+	uint8_t *buf;
+	size_t l;
+
+	buf = malloc(nsize);
+	if (!buf)
+		return -ENOMEM;
+
+	if (r->used > 0) {
+		l = r->size - r->start;
+		if (r->used <= l) {
+			memcpy(buf, &r->buf[r->start], r->used);
+		} else {
+			memcpy(buf, &r->buf[r->start], l);
+			memcpy(&buf[l], r->buf, r->used - l);
+		}
+	}
+
+	free(r->buf);
+	r->buf = buf;
+	r->size = nsize;
+	r->start = 0;
+
+	return 0;
+}
+
+/*
+ * Resize ring-buffer to provide enough room for @add bytes of new data. This
+ * resizes the buffer if it is too small. It returns -ENOMEM on OOM and 0 on
+ * success.
+ */
+static int ring_grow(struct shl_ring *r, size_t add)
+{
+	size_t need;
+
+	if (r->size - r->used >= add)
+		return 0;
+
+	need = r->used + add;
+	if (need <= r->used)
+		return -ENOMEM;
+	else if (need < 4096)
+		need = 4096;
+
+	need = SHL_ALIGN_POWER2(need);
+	if (need == 0)
+		return -ENOMEM;
+
+	return ring_resize(r, need);
+}
+
+/*
+ * Push @len bytes from @u8 into the ring buffer. The buffer is resized if it
+ * is too small. -ENOMEM is returned on OOM, 0 on success.
+ */
+int shl_ring_push(struct shl_ring *r, const void *u8, size_t size)
+{
+	int err;
+	size_t pos, l;
+
+	if (size == 0)
+		return 0;
+
+	err = ring_grow(r, size);
+	if (err < 0)
+		return err;
+
+	pos = RING_MASK(r, r->start + r->used);
+	l = r->size - pos;
+	if (l >= size) {
+		memcpy(&r->buf[pos], u8, size);
+	} else {
+		memcpy(&r->buf[pos], u8, l);
+		memcpy(r->buf, (const uint8_t*)u8 + l, size - l);
+	}
+
+	r->used += size;
+
+	return 0;
+}
+
+/*
+ * Remove @len bytes from the start of the ring-buffer. Note that we protect
+ * against overflows so removing more bytes than available is safe.
+ */
+void shl_ring_pull(struct shl_ring *r, size_t size)
+{
+	if (size > r->used)
+		size = r->used;
+
+	r->start = RING_MASK(r, r->start + size);
+	r->used -= size;
+}
diff --git a/src/shl_ring.h b/src/shl_ring.h
new file mode 100644
index 0000000..7be48f6
--- /dev/null
+++ b/src/shl_ring.h
@@ -0,0 +1,52 @@
+/*
+ * SHL - Ring buffer
+ *
+ * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
+ * Dedicated to the Public Domain
+ */
+
+/*
+ * Ring buffer
+ */
+
+#ifndef SHL_RING_H
+#define SHL_RING_H
+
+#include <errno.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/uio.h>
+
+struct shl_ring {
+	uint8_t *buf;		/* buffer or NULL */
+	size_t size;		/* actual size of @buf */
+	size_t start;		/* start position of ring */
+	size_t used;		/* number of actually used bytes */
+};
+
+/* flush buffer so it is empty again */
+void shl_ring_flush(struct shl_ring *r);
+
+/* flush buffer, free allocated data and reset to initial state */
+void shl_ring_clear(struct shl_ring *r);
+
+/* get pointers to buffer data and their length */
+size_t shl_ring_peek(struct shl_ring *r, struct iovec *vec);
+
+/* copy data into external linear buffer */
+size_t shl_ring_copy(struct shl_ring *r, void *buf, size_t size);
+
+/* push data to the end of the buffer */
+int shl_ring_push(struct shl_ring *r, const void *u8, size_t size);
+
+/* pull data from the front of the buffer */
+void shl_ring_pull(struct shl_ring *r, size_t size);
+
+/* return size of occupied buffer in bytes */
+static inline size_t shl_ring_get_size(struct shl_ring *r)
+{
+	return r->used;
+}
+
+#endif  /* SHL_RING_H */
diff --git a/src/shl_util.c b/src/shl_util.c
new file mode 100644
index 0000000..ea4f160
--- /dev/null
+++ b/src/shl_util.c
@@ -0,0 +1,260 @@
+/*
+ * SHL - Utility Helpers
+ *
+ * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
+ * Dedicated to the Public Domain
+ */
+
+/*
+ * Utility Helpers
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include "shl_macro.h"
+#include "shl_util.h"
+
+/*
+ * Strict atoi()
+ * These helpers implement a strict version of atoi() (or strtol()). They only
+ * parse digit/alpha characters. No whitespace or other characters are parsed.
+ * The unsigned-variants explicitly forbid leading +/- signs. Use the signed
+ * variants to allow these.
+ * Base-prefix parsing is only done if base=0 is requested. Otherwise,
+ * base-prefixes are forbidden.
+ * The input string must be ASCII compatbile (which includes UTF8).
+ *
+ * We also always check for overflows and return errors (but continue parsing!)
+ * so callers can catch it correctly.
+ *
+ * Additionally, we allow "length" parameters so strings do not necessarily have
+ * to be zero-terminated. We have wrappers which skip this by passing strlen().
+ */
+
+int shl_ctoi(char ch, unsigned int base)
+{
+	unsigned int v;
+
+	switch (ch) {
+	case '0'...'9':
+		v = ch - '0';
+		break;
+	case 'a'...'z':
+		v = ch - 'a' + 10;
+		break;
+	case 'A'...'Z':
+		v = ch - 'A' + 10;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	if (v >= base)
+		return -EINVAL;
+
+	return v;
+}
+
+/* figure out base and skip prefix */
+static unsigned int shl__skip_base(const char **str, size_t *len)
+{
+	if (*len > 1) {
+		if ((*str)[0] == '0') {
+			if (shl_ctoi((*str)[1], 8) >= 0) {
+				*str += 1;
+				*len -= 1;
+				return 8;
+			}
+		}
+	}
+
+	if (*len > 2) {
+		if ((*str)[0] == '0' && (*str)[1] == 'x') {
+			if (shl_ctoi((*str)[2], 16) >= 0) {
+				*str += 2;
+				*len -= 2;
+				return 16;
+			}
+		}
+	}
+
+	return 10;
+}
+
+int shl_atoi_ulln(const char *str,
+		  size_t len,
+		  unsigned int base,
+		  const char **next,
+		  unsigned long long *out)
+{
+	bool huge;
+	uint32_t val1;
+	unsigned long long val2;
+	size_t pos;
+	int r, c;
+
+	/* We use u32 as storage first so we have fast mult-overflow checks. We
+	 * cast up to "unsigned long long" once we exceed UINT32_MAX. Overflow
+	 * checks will get pretty slow for non-power2 bases, though. */
+
+	huge = false;
+	val1 = 0;
+	val2 = 0;
+	r = 0;
+
+	if (base > 36) {
+		if (next)
+			*next = str;
+		if (out)
+			*out = 0;
+		return -EINVAL;
+	}
+
+	if (base == 0)
+		base = shl__skip_base(&str, &len);
+
+	for (pos = 0; pos < len; ++pos) {
+		c = shl_ctoi(str[pos], base);
+		if (c < 0)
+			break;
+
+		/* skip calculations on error */
+		if (r < 0)
+			continue;
+
+		if (!huge) {
+			val2 = val1;
+			r = shl_mult_u32(&val1, base);
+			if (r >= 0 && val1 + c >= val1)
+				val1 += c;
+			else
+				huge = true;
+		}
+
+		if (huge) {
+			r = shl_mult_ull(&val2, base);
+			if (r >= 0 && val2 + c >= val2)
+				val2 += c;
+		}
+	}
+
+	if (next)
+		*next = (char*)&str[pos];
+	if (out) {
+		if (r < 0)
+			*out = ULLONG_MAX;
+		else if (huge)
+			*out = val2;
+		else
+			*out = val1;
+	}
+
+	return r;
+}
+
+int shl_atoi_uln(const char *str,
+		 size_t len,
+		 unsigned int base,
+		 const char **next,
+		 unsigned long *out)
+{
+	unsigned long long val;
+	int r;
+
+	r = shl_atoi_ulln(str, len, base, next, &val);
+	if (r >= 0 && val > ULONG_MAX)
+		r = -ERANGE;
+
+	if (out)
+		*out = shl_min(val, (unsigned long long)ULONG_MAX);
+
+	return r;
+}
+
+int shl_atoi_un(const char *str,
+		size_t len,
+		unsigned int base,
+		const char **next,
+		unsigned int *out)
+{
+	unsigned long long val;
+	int r;
+
+	r = shl_atoi_ulln(str, len, base, next, &val);
+	if (r >= 0 && val > UINT_MAX)
+		r = -ERANGE;
+
+	if (out)
+		*out = shl_min(val, (unsigned long long)UINT_MAX);
+
+	return r;
+}
+
+int shl_atoi_zn(const char *str,
+		size_t len,
+		unsigned int base,
+		const char **next,
+		size_t *out)
+{
+	unsigned long long val;
+	int r;
+
+	r = shl_atoi_ulln(str, len, base, next, &val);
+	if (r >= 0 && val > SIZE_MAX)
+		r = -ERANGE;
+
+	if (out)
+		*out = shl_min(val, (unsigned long long)SIZE_MAX);
+
+	return r;
+}
+
+/*
+ * Greedy Realloc
+ * The greedy-realloc helpers simplify power-of-2 buffer allocations. If you
+ * have a dynamic array, simply use shl_greedy_realloc() for re-allocations
+ * and it makes sure your buffer-size is always a multiple of 2 and is big
+ * enough for your new entries.
+ * Default size is 64, but you can initialize your buffer to a bigger default
+ * if you need.
+ */
+
+void *shl_greedy_realloc(void **mem, size_t *size, size_t need)
+{
+	size_t nsize;
+	void *p;
+
+	if (*size >= need)
+		return *mem;
+
+	nsize = SHL_ALIGN_POWER2(shl_max_t(size_t, 64U, need));
+	if (nsize == 0)
+		return NULL;
+
+	p = realloc(*mem, nsize);
+	if (!p)
+		return NULL;
+
+	*mem = p;
+	*size = nsize;
+	return p;
+}
+
+void *shl_greedy_realloc0(void **mem, size_t *size, size_t need)
+{
+	size_t prev = *size;
+	uint8_t *p;
+
+	p = shl_greedy_realloc(mem, size, need);
+	if (!p)
+		return NULL;
+
+	if (*size > prev)
+		shl_memzero(&p[prev], *size - prev);
+
+	return p;
+}
diff --git a/src/shl_util.h b/src/shl_util.h
new file mode 100644
index 0000000..a2426bc
--- /dev/null
+++ b/src/shl_util.h
@@ -0,0 +1,83 @@
+/*
+ * SHL - Utility Helpers
+ *
+ * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
+ * Dedicated to the Public Domain
+ */
+
+/*
+ * Utility Helpers
+ */
+
+#ifndef SHL_UTIL_H
+#define SHL_UTIL_H
+
+#include <errno.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* strict atoi */
+
+int shl_ctoi(char ch, unsigned int base);
+
+int shl_atoi_ulln(const char *str,
+		  size_t len,
+		  unsigned int base,
+		  const char **next,
+		  unsigned long long *out);
+int shl_atoi_uln(const char *str,
+		 size_t len,
+		 unsigned int base,
+		 const char **next,
+		 unsigned long *out);
+int shl_atoi_un(const char *str,
+		size_t len,
+		unsigned int base,
+		const char **next,
+		unsigned int *out);
+int shl_atoi_zn(const char *str,
+		size_t len,
+		unsigned int base,
+		const char **next,
+		size_t *out);
+
+static inline int shl_atoi_ull(const char *str,
+			       unsigned int base,
+			       const char **next,
+			       unsigned long long *out)
+{
+	return shl_atoi_ulln(str, strlen(str), base, next, out);
+}
+
+static inline int shl_atoi_ul(const char *str,
+			      unsigned int base,
+			      const char **next,
+			      unsigned long *out)
+{
+	return shl_atoi_uln(str, strlen(str), base, next, out);
+}
+
+static inline int shl_atoi_u(const char *str,
+			     unsigned int base,
+			     const char **next,
+			     unsigned int *out)
+{
+	return shl_atoi_un(str, strlen(str), base, next, out);
+}
+
+static inline int shl_atoi_z(const char *str,
+			     unsigned int base,
+			     const char **next,
+			     size_t *out)
+{
+	return shl_atoi_zn(str, strlen(str), base, next, out);
+}
+
+/* greedy alloc */
+
+void *shl_greedy_realloc(void **mem, size_t *size, size_t need);
+void *shl_greedy_realloc0(void **mem, size_t *size, size_t need);
+
+#endif  /* SHL_UTIL_H */
diff --git a/test/test_common.h b/test/test_common.h
new file mode 100644
index 0000000..bd12647
--- /dev/null
+++ b/test/test_common.h
@@ -0,0 +1,109 @@
+/*
+ * libwfd - Wifi-Display/Miracast Protocol Implementation
+ *
+ * Copyright (c) 2013-2014 David Herrmann <dh.herrmann@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * Test Helper
+ * This header includes all kinds of helpers for testing. It tries to include
+ * everything required and provides simple macros to avoid duplicating code in
+ * each test. We try to keep tests as small as possible and move everything that
+ * might be common here.
+ *
+ * We avoid sticking to our usual coding conventions (including headers in
+ * source files, etc. ..) and instead make this the most convenient we can.
+ */
+
+#ifndef TEST_COMMON_H
+#define TEST_COMMON_H
+
+#include <errno.h>
+#include <check.h>
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "libwfd.h"
+#include "shl_macro.h"
+#include "shl_util.h"
+
+/* lower address-space is protected from user-allocation, so this is invalid */
+#define TEST_INVALID_PTR ((void*)0x10)
+
+#define TEST_DEFINE_CASE(_name)					\
+	static TCase *test_create_case_##_name(void)		\
+	{							\
+		TCase *tc;					\
+								\
+		tc = tcase_create(#_name);			\
+
+#define TEST(_name) tcase_add_test(tc, _name);
+
+#define TEST_END_CASE						\
+		return tc;					\
+	}							\
+
+#define TEST_END NULL
+
+#define TEST_CASE(_name) test_create_case_##_name
+
+static inline Suite *test_create_suite(const char *name, ...)
+{
+	Suite *s;
+	va_list list;
+	TCase *(*fn)(void);
+
+	s = suite_create(name);
+
+	va_start(list, name);
+	while ((fn = va_arg(list, TCase *(*)(void))))
+		suite_add_tcase(s, fn());
+	va_end(list);
+
+	return s;
+}
+
+#define TEST_SUITE(_name, ...) test_create_suite((#_name), ##__VA_ARGS__)
+
+static inline int test_run_suite(Suite *s)
+{
+	int ret;
+	SRunner *sr;
+
+	sr = srunner_create(s);
+	srunner_run_all(sr, CK_NORMAL);
+	ret = srunner_ntests_failed(sr);
+	srunner_free(sr);
+
+	return ret;
+}
+
+#define TEST_DEFINE(_suite) \
+	int main(int argc, char **argv) \
+	{ \
+		return test_run_suite(_suite); \
+	}
+
+#endif /* TEST_COMMON_H */
diff --git a/test/test_rtsp.c b/test/test_rtsp.c
new file mode 100644
index 0000000..2120918
--- /dev/null
+++ b/test/test_rtsp.c
@@ -0,0 +1,558 @@
+/*
+ * libwfd - Wifi-Display/Miracast Protocol Implementation
+ *
+ * Copyright (c) 2013-2014 David Herrmann <dh.herrmann@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "test_common.h"
+
+static int received;
+
+struct orig {
+	ssize_t len;
+	const char *str;
+};
+
+struct expect {
+	size_t times;
+	struct wfd_rtsp_msg msg;
+};
+
+static const struct orig orig[] = {
+	{ -1, "SOMETHING\r\n\r\n" },
+	{ -1, "SOMETHING" },
+	{ -1, "\r" },
+	{ -1, "\n" },
+	{ -1, "\n" },
+	{ -1, "SOME" },
+	{ -1, "THING" },
+	{ -1, "\r" },
+	{ -1, "\r" },
+	{ -1, "\n" },
+	{ -1, "SOME" },
+	{ -1, "THING\n" },
+	{ -1, "\r" },
+	{ -1, "SOMETHING\n\n" },
+	{ -1, "SOMETHING\r\r" },
+	{ -1, "SOMETHING\r\r\n" },
+	{ -1, "SOMETHING\n\r\n" },
+
+	{ -1, "OPTIONS * RTSP/1.0\n\r\n" },
+	{ -1, "OPTIONS    *    RTSP/1.0\n\r\n" },
+	{ -1, "OPTIONS *\r RTSP/1.0\n\r\n" },
+	{ -1, "OPTIONS *\r\n RTSP/1.0\n\r\n" },
+	{ -1, "OPTIONS\r *\n RTSP/1.0\n\r\n" },
+	{ -1, "  \r\n   OPTIONS * RTSP/1.0\n\r\n" },
+	{ -1, "\rOPTIONS * RTSP/1.0\n\r\n" },
+	{ -1, "\nOPTIONS * RTSP/1.0\n\r\n" },
+	{ -1, " OPTIONS *\n\t \r\tRTSP/1.0\n\r\n" },
+	{ -1, "OPTIONS * RTSP/1.0   \n\r\n" },
+
+	{ -1, "RTSP/1.0 200 OK Something\n\n" },
+
+	{ 10, "$\001\000\006RAWSTH" },
+	{ 10, "$\001\000\006RAWSTH" },
+
+	{ -1, "SOMETHING\r\nsome-header:value\r\n\r\n" },
+
+	{ -1, "OPTIONS * RTSP/2.1\n" },
+	{ -1, "some-header:value\n" },
+	{ -1, "some-other-header:buhu\n" },
+	{ -1, "\n" },
+	{ -1, "OPTIONS * RTSP/2.1\n" },
+	{ -1, "some-header:value \n" },
+	{ -1, "some-other-header:buhu \r \n \n" },
+	{ -1, "\n" },
+
+	{ 16, "  \n   $\001\000\006RAWSTH" },
+	{ 11, "  \n   \r\n$\001\000" },
+	{ 7, "\006RAWSTH" },
+
+	{ -1, "OPTIONS * RTSP/2.1\n" },
+	{ -1, "some-header :value \n" },
+	{ -1, "some-other-header: buhu \r \n \n" },
+	{ -1, "some-header : value \n" },
+	{ -1, "\n" },
+	{ -1, "OPTIONS * RTSP/2.1\n" },
+	{ -1, "some-header  \r   \n :value \n" },
+	{ -1, "some-other-header: \r\n buhu \r \n \n" },
+	{ -1, "some-header        \t\t\t:\r\n value    \n" },
+	{ -1, "\n" },
+
+	{ -1, "STH\r\ncontent-length:5\r\n\r\n12345" },
+
+	{ -1, "STH\r\ncontent-length:5/suffix\r\n\r\n12345" },
+
+	{ -1, "OPTIONS * RTSP/1.0\n" },
+	{ -1, "cseq: 100\n" },
+	{ -1, "\n" },
+
+	/* leave this at the end to test missing trailing \n */
+	{ -1, "SOMETHING\n\r" },
+};
+
+static const struct expect expect[] = {
+	{
+		.times = 8,
+		.msg = {
+			.type = WFD_RTSP_MSG_UNKNOWN,
+			.id = {
+				/* test .length comparison in test-module */
+				.line = "SOMETHING" "-STUPID",
+				.length = 9,
+			},
+		},
+	},
+	{
+		.times = 10,
+		.msg = {
+			.type = WFD_RTSP_MSG_REQUEST,
+			.id = {
+				.line = "OPTIONS * RTSP/1.0",
+				.request = {
+					.method = "OPTIONS",
+					.type = WFD_RTSP_METHOD_OPTIONS,
+					.uri = "*",
+					.major = 1,
+					.minor = 0,
+				},
+			},
+		},
+	},
+	{
+		.times = 1,
+		.msg = {
+			.type = WFD_RTSP_MSG_RESPONSE,
+			.id = {
+				.line = "RTSP/1.0 200 OK Something",
+				.response = {
+					.major = 1,
+					.minor = 0,
+					.status = 200,
+					.phrase = "OK Something",
+				},
+			},
+		},
+	},
+	{
+		.times = 1,
+		.msg = {
+			.type = WFD_RTSP_MSG_UNKNOWN,
+			.id = {
+				.line = "SOMETHING",
+			},
+			.headers = {
+				[WFD_RTSP_HEADER_UNKNOWN] = {
+					.count = 1,
+					.lines = (char*[]){
+						(char*)"some-header:value",
+					},
+					.lengths = (size_t[]){
+						0,
+					},
+				},
+			},
+		},
+	},
+	{
+		.times = 2,
+		.msg = {
+			.type = WFD_RTSP_MSG_REQUEST,
+			.id = {
+				.line = "OPTIONS * RTSP/2.1",
+				.request = {
+					.method = "OPTIONS",
+					.type = WFD_RTSP_METHOD_OPTIONS,
+					.uri = "*",
+					.major = 2,
+					.minor = 1,
+				},
+			},
+			.headers = {
+				[WFD_RTSP_HEADER_UNKNOWN] = {
+					.count = 2,
+					.lines = (char*[]){
+						(char*)"some-header:value",
+						(char*)"some-other-header:buhu",
+					},
+					.lengths = (size_t[]){
+						0,
+						0,
+					},
+				},
+			},
+		},
+	},
+	{
+		.times = 2,
+		.msg = {
+			.type = WFD_RTSP_MSG_REQUEST,
+			.id = {
+				.line = "OPTIONS * RTSP/2.1",
+				.request = {
+					.method = "OPTIONS",
+					.type = WFD_RTSP_METHOD_OPTIONS,
+					.uri = "*",
+					.major = 2,
+					.minor = 1,
+				},
+			},
+			.headers = {
+				[WFD_RTSP_HEADER_UNKNOWN] = {
+					.count = 3,
+					.lines = (char*[]){
+						(char*)"some-header :value",
+						(char*)"some-other-header: buhu",
+						(char*)"some-header : value",
+					},
+					.lengths = (size_t[]){
+						0,
+						0,
+						0,
+					},
+				},
+			},
+		},
+	},
+	{
+		.times = 1,
+		.msg = {
+			.type = WFD_RTSP_MSG_UNKNOWN,
+			.id = {
+				.line = "STH",
+			},
+			.headers = {
+				[WFD_RTSP_HEADER_CONTENT_LENGTH] = {
+					.count = 1,
+					.lines = (char*[]){
+						(char*)"content-length:5",
+					},
+					.lengths = (size_t[]){
+						0,
+					},
+				},
+			},
+			.entity = {
+				.value = "12345",
+			},
+		},
+	},
+	{
+		.times = 1,
+		.msg = {
+			.type = WFD_RTSP_MSG_UNKNOWN,
+			.id = {
+				.line = "STH",
+			},
+			.headers = {
+				[WFD_RTSP_HEADER_CONTENT_LENGTH] = {
+					.count = 1,
+					.lines = (char*[]){
+						(char*)"content-length:5/suffix",
+					},
+					.lengths = (size_t[]){
+						0,
+					},
+				},
+			},
+			.entity = {
+				.value = "12345",
+			},
+		},
+	},
+	{
+		.times = 1,
+		.msg = {
+			.type = WFD_RTSP_MSG_REQUEST,
+			.id = {
+				.line = "OPTIONS * RTSP/1.0",
+				.request = {
+					.method = "OPTIONS",
+					.type = WFD_RTSP_METHOD_OPTIONS,
+					.uri = "*",
+					.major = 1,
+					.minor = 0,
+				},
+			},
+			.headers = {
+				[WFD_RTSP_HEADER_CSEQ] = {
+					.count = 1,
+					.lines = (char*[]){
+						(char*)"cseq: 100",
+					},
+					.lengths = (size_t[]){
+						0,
+					},
+				},
+			},
+		},
+	},
+	{
+		.times = 1,
+		.msg = {
+			.type = WFD_RTSP_MSG_UNKNOWN,
+			.id = {
+				.line = "SOMETHING",
+			},
+		},
+	},
+};
+
+#define LEN(_len, _str) ((_len) <= 0 ? ((_str) ? strlen(_str) : 0) : (_len))
+
+static int test_wfd_rtsp_decoder_event(struct wfd_rtsp_decoder *dec,
+				   void *data,
+				   struct wfd_rtsp_decoder_event *ev)
+{
+	bool debug = true;
+	static int pos, num;
+	size_t i, j;
+	const struct expect *e;
+	const struct wfd_rtsp_msg *m, *msg;
+	const struct wfd_rtsp_msg_header *h, *hm;
+
+	if (ev->type == WFD_RTSP_DECODER_DATA) {
+		if (debug)
+			fprintf(stderr, "Raw Data (%u:%u): %s\n",
+				(unsigned int)ev->data.channel,
+				(unsigned int)ev->data.size,
+				(char*)ev->data.value);
+		return 0;
+	}
+
+	if (ev->type != WFD_RTSP_DECODER_MSG)
+		return 0;
+
+	msg = ev->msg;
+	ck_assert(data == TEST_INVALID_PTR);
+	++received;
+
+	ck_assert(pos < SHL_ARRAY_LENGTH(expect));
+	e = &expect[pos];
+	m = &e->msg;
+	if (++num >= e->times) {
+		++pos;
+		num = 0;
+	}
+
+	/* print msg */
+
+	if (debug) {
+		fprintf(stderr, "Received Message:\n");
+		fprintf(stderr, "  type: %u\n", msg->type);
+		fprintf(stderr, "  id: len: %zu line: %s\n",
+			msg->id.length, msg->id.line);
+
+		if (msg->type == WFD_RTSP_MSG_REQUEST) {
+			fprintf(stderr, "  method (%d): %s %s RTSP/%u.%u\n",
+				msg->id.request.type,
+				msg->id.request.method,
+				msg->id.request.uri,
+				msg->id.request.major,
+				msg->id.request.minor);
+		} else if (msg->type == WFD_RTSP_MSG_RESPONSE) {
+			fprintf(stderr, "  RTSP/%u.%u %u %s\n",
+				msg->id.response.major,
+				msg->id.response.minor,
+				msg->id.response.status,
+				msg->id.response.phrase);
+		}
+
+		fprintf(stderr, "  headers:\n");
+		for (i = 0; i < SHL_ARRAY_LENGTH(msg->headers); ++i) {
+			h = &msg->headers[i];
+			if (!h->count)
+				continue;
+
+			fprintf(stderr, "    id: %zu %s (count: %zu)\n",
+				i, wfd_rtsp_header_get_name(i) ? : "<unknown>",
+				h->count);
+
+			for (j = 0; j < h->count; ++j) {
+				fprintf(stderr, "      line (%zu): %s\n",
+					h->lengths[j], h->lines[j]);
+			}
+		}
+
+		if (msg->entity.size)
+			fprintf(stderr, "  body (%zu): %s\n",
+				msg->entity.size, (char*)msg->entity.value);
+	}
+
+	/* compare msgs */
+
+	ck_assert_int_eq(m->type, msg->type);
+	ck_assert_int_eq(LEN(m->id.length, m->id.line), msg->id.length);
+	ck_assert(!memcmp(m->id.line, msg->id.line, msg->id.length));
+
+	if (m->type == WFD_RTSP_MSG_REQUEST) {
+		ck_assert(!strcmp(m->id.request.method,
+				  msg->id.request.method));
+		ck_assert_int_eq(m->id.request.type,
+				 msg->id.request.type);
+		ck_assert(!strcmp(m->id.request.uri,
+				  msg->id.request.uri));
+		ck_assert_int_eq(m->id.request.major,
+				 msg->id.request.major);
+		ck_assert_int_eq(m->id.request.minor,
+				 msg->id.request.minor);
+	} else if (m->type == WFD_RTSP_MSG_RESPONSE) {
+		ck_assert_int_eq(m->id.response.major,
+				 msg->id.response.major);
+		ck_assert_int_eq(m->id.response.minor,
+				 msg->id.response.minor);
+		ck_assert_int_eq(m->id.response.status,
+				 msg->id.response.status);
+		ck_assert(!strcmp(m->id.response.phrase,
+				  msg->id.response.phrase));
+	}
+
+	for (i = 0; i < SHL_ARRAY_LENGTH(msg->headers); ++i) {
+		h = &m->headers[i];
+		hm = &msg->headers[i];
+		ck_assert_int_eq(h->count, hm->count);
+
+		for (j = 0; j < h->count; ++j) {
+			ck_assert_int_eq(LEN(h->lengths[j], h->lines[j]),
+					 hm->lengths[j]);
+			ck_assert(!memcmp(h->lines[j],
+					  hm->lines[j],
+					  hm->lengths[j]));
+		}
+	}
+
+	ck_assert_int_eq(LEN(m->entity.size, m->entity.value),
+			 msg->entity.size);
+	ck_assert(!memcmp(m->entity.value, msg->entity.value,
+			  msg->entity.size));
+
+	return 0;
+}
+
+START_TEST(test_wfd_rtsp_decoder)
+{
+	struct wfd_rtsp_decoder *d;
+	int r, sent = 0;
+	size_t len, num, i;
+
+	r = wfd_rtsp_decoder_new(NULL, NULL, NULL, NULL, &d);
+	ck_assert(r == -EINVAL);
+
+	r = wfd_rtsp_decoder_new(test_wfd_rtsp_decoder_event, NULL, NULL, NULL, &d);
+	ck_assert(r >= 0);
+
+	wfd_rtsp_decoder_set_data(d, TEST_INVALID_PTR);
+	ck_assert(wfd_rtsp_decoder_get_data(d) == TEST_INVALID_PTR);
+	ck_assert(received == sent);
+
+	for (i = 0; i < SHL_ARRAY_LENGTH(orig); ++i) {
+		if (orig[i].len >= 0)
+			len = orig[i].len;
+		else
+			len = strlen(orig[i].str);
+
+		r = wfd_rtsp_decoder_feed(d, orig[i].str, len);
+		ck_assert(r >= 0);
+	}
+
+	num = 0;
+	for (i = 0; i < SHL_ARRAY_LENGTH(expect); ++i)
+		num += expect[i].times;
+
+	ck_assert_int_eq(received, num);
+
+	wfd_rtsp_decoder_free(d);
+}
+END_TEST
+
+static void tokenize(const char *line,
+		     size_t linelen,
+		     const char *expect,
+		     size_t len,
+		     size_t num)
+{
+	const char *s;
+	char *t;
+	ssize_t l, i;
+
+	ck_assert(len > 0);
+
+	l = wfd_rtsp_tokenize(line, linelen, &t);
+	ck_assert(l >= 0);
+
+	if (0) {
+		fprintf(stderr, "TOKENIZER (%lu):\n", (unsigned long)l);
+		s = t;
+		for (i = 0; i < l; ++i) {
+			fprintf(stderr, "  TOKEN: %s\n", s);
+			s += strlen(s) + 1;
+		}
+
+		fprintf(stderr, "EXPECT (%lu):\n", (unsigned long)num);
+		s = expect;
+		for (i = 0; i < l; ++i) {
+			fprintf(stderr, "  TOKEN: %s\n", s);
+			s += strlen(s) + 1;
+		}
+	}
+
+	ck_assert(l == (ssize_t)num);
+	ck_assert(!memcmp(t, expect, len));
+	free(t);
+}
+
+#define TOKENIZE(_line, _exp, _num) \
+	tokenize((_line), strlen(_line), (_exp), sizeof(_exp), _num)
+#define TOKENIZE_N(_line, _len, _exp, _num) \
+	tokenize((_line), _len, (_exp), sizeof(_exp), _num)
+
+START_TEST(test_wfd_rtsp_tokenizer)
+{
+	TOKENIZE("", "", 0);
+	TOKENIZE("asdf", "asdf", 1);
+	TOKENIZE("asdf\"\"asdf", "asdf\0\0asdf", 3);
+	TOKENIZE("asdf\"asdf\"asdf", "asdf\0asdf\0asdf", 3);
+	TOKENIZE("\"asdf\"", "asdf", 1);
+	TOKENIZE("\"\\n\\\\\\r\"", "\n\\\r", 1);
+	TOKENIZE("\"\\\"\"", "\"", 1);
+	TOKENIZE("\"\\0\"", "\\0", 1);
+	TOKENIZE("\"\\\0\"", "\\", 1);
+	TOKENIZE_N("\"\\\0\"", 4, "\\0", 1);
+	TOKENIZE("\"\\0\\\0\"", "\\0\\", 1);
+	TOKENIZE_N("\"\\0\\\0\"", 6, "\\0\\0", 1);
+	TOKENIZE("content-length:   100", "content-length\0:\0""100", 3);
+	TOKENIZE("content-args: (50+10)", "content-args\0:\0(\0""50+10\0)", 5);
+	TOKENIZE("content-args: (50 + 10)", "content-args\0:\0(\0""50\0+\0""10\0)", 7);
+}
+END_TEST
+
+TEST_DEFINE_CASE(decoder)
+	TEST(test_wfd_rtsp_decoder)
+	TEST(test_wfd_rtsp_tokenizer)
+TEST_END_CASE
+
+TEST_DEFINE(
+	TEST_SUITE(rtsp,
+		TEST_CASE(decoder),
+		TEST_END
+	)
+)