diff --git a/src/disp/dispd-encoder.c b/src/disp/dispd-encoder.c
index 4bb0e21..2849fa0 100644
--- a/src/disp/dispd-encoder.c
+++ b/src/disp/dispd-encoder.c
@@ -20,7 +20,6 @@
 #include <systemd/sd-bus.h>
 #include <stdlib.h>
 #include <stdio.h>
-#include <assert.h>
 #include <errno.h>
 #include <stdarg.h>
 #include "dispd-encoder.h"
@@ -77,7 +76,7 @@ static int dispd_encoder_exec(const char *cmd, int fd, struct wfd_session *s)
 	 */
 	r = dup2(fd, 3);
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 
 	if(fd != 3) {
@@ -132,7 +131,7 @@ static int dispd_encoder_kill_child(struct dispd_encoder *e)
 static void dispd_encoder_notify_state_change(struct dispd_encoder *e,
 				enum dispd_encoder_state state)
 {
-	assert(e);
+	assert_vret(e);
 
 	if(!e->handler) {
 		return;
@@ -187,8 +186,8 @@ int dispd_encoder_spawn(struct dispd_encoder **out, struct wfd_session *s)
 	int fds[2] = { -1, -1 };
 	int r;
 
-	assert(out);
-	assert(s);
+	assert_ret(out);
+	assert_ret(s);
 
 	r = dispd_encoder_new(&e);
 	if(0 > r) {
@@ -238,7 +237,7 @@ int dispd_encoder_spawn(struct dispd_encoder **out, struct wfd_session *s)
 	close(fds[1]);
 	*out = dispd_encoder_ref(e);
 
-	goto end;
+	return 0;
 
 close_pipe:
 	close(fds[0]);
@@ -247,18 +246,18 @@ kill_encoder:
 	// dispd will do the cleanup
 	kill(pid, SIGKILL);
 end:
-	return r;
+	return log_ERRNO();
 }
 
 static int dispd_encoder_new(struct dispd_encoder **out)
 {
 	_shl_free_ struct dispd_encoder *e = NULL;
 
-	assert(out);
+	assert_ret(out);
    
 	e = calloc(1, sizeof(struct dispd_encoder));
 	if(!e) {
-		return -ENOMEM;
+		return log_ENOMEM();
 	}
 
 	e->ref = 1;
@@ -270,8 +269,8 @@ static int dispd_encoder_new(struct dispd_encoder **out)
 
 struct dispd_encoder * dispd_encoder_ref(struct dispd_encoder *e)
 {
-	assert(e);
-	assert(0 < e->ref);
+	assert_retv(e, NULL);
+	assert_retv(0 < e->ref, NULL);
 
 	++ e->ref;
 
@@ -287,8 +286,8 @@ void dispd_encoder_unrefp(struct dispd_encoder **e)
 
 void dispd_encoder_unref(struct dispd_encoder *e)
 {
-	assert(e);
-	assert(0 < e->ref);
+	assert_vret(e);
+	assert_vret(0 < e->ref);
 
 	--e->ref;
 	if(e->ref) {
@@ -312,7 +311,7 @@ void dispd_encoder_set_handler(struct dispd_encoder *e,
 				dispd_encoder_state_change_handler handler,
 				void *userdata)
 {
-	assert(e);
+	assert_vret(e);
 
 	e->handler = handler;
 	e->userdata = userdata;
@@ -320,14 +319,14 @@ void dispd_encoder_set_handler(struct dispd_encoder *e,
 
 dispd_encoder_state_change_handler dispd_encoder_get_handler(struct dispd_encoder *e)
 {
-	assert(e);
+	assert_retv(e, NULL);
 
 	return e->handler;
 }
 
 enum dispd_encoder_state dispd_encoder_get_state(struct dispd_encoder *e)
 {
-	assert(e);
+	assert_retv(e, DISPD_ENCODER_STATE_NULL);
 	
 	return e->state;
 }
@@ -354,7 +353,7 @@ static const char * state_to_name(enum dispd_encoder_state s)
 static void dispd_encoder_set_state(struct dispd_encoder *e,
 				enum dispd_encoder_state state)
 {
-	assert(e);
+	assert_vret(e);
 	
 	if(e->state == state) {
 		return;
@@ -440,7 +439,7 @@ static int on_encoder_disappeared(sd_bus_message *m,
 
 	r = dispd_encoder_kill_child(e);
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 	else if(r) {
 		return 0;
@@ -525,6 +524,7 @@ static int dispd_encoder_on_unique_name(sd_event_source *source,
 	goto end;
 
 error:
+	log_vERRNO();
 	dispd_encoder_kill_child(e);
 end:
 	dispd_encoder_close_pipe(e);
@@ -540,22 +540,22 @@ static int config_append(sd_bus_message *m,
 	int r;
 	va_list argv;
 
-	assert(m);
-	assert(t);
+	assert_ret(m);
+	assert_ret(t);
 
 	r = sd_bus_message_open_container(m, 'e', "iv");
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 
 	r = sd_bus_message_append(m, "i", k);
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 
 	r = sd_bus_message_open_container(m, 'v', t);
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 
 	va_start(argv, t);
@@ -572,15 +572,20 @@ static int config_append(sd_bus_message *m,
 	va_end(argv);
 
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 
 	r = sd_bus_message_close_container(m);
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 
-	return sd_bus_message_close_container(m);
+	r = sd_bus_message_close_container(m);
+	if(0 > r) {
+		return log_ERRNO();
+	}
+
+	return 0;
 }
 
 int dispd_encoder_configure(struct dispd_encoder *e, struct wfd_session *s)
@@ -592,9 +597,10 @@ int dispd_encoder_configure(struct dispd_encoder *e, struct wfd_session *s)
 	struct wfd_sink *sink;
 	int r;
 
-	assert(e);
-	assert(s);
-	assert(wfd_is_out_session(s));
+	assert_ret(e);
+	assert_ret(e->bus);
+	assert_ret(s);
+	assert_ret(wfd_is_out_session(s));
 
 	r = sd_bus_message_new_method_call(e->bus,
 					&call,
@@ -603,12 +609,12 @@ int dispd_encoder_configure(struct dispd_encoder *e, struct wfd_session *s)
 					"org.freedesktop.miracle.encoder",
 					"Configure");
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 
 	r = sd_bus_message_open_container(call, 'a', "{iv}");
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 
 	sink = wfd_out_session_get_sink(s);
@@ -617,7 +623,7 @@ int dispd_encoder_configure(struct dispd_encoder *e, struct wfd_session *s)
 					"s",
 					sink->peer->remote_address);
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 
 	r = config_append(call,
@@ -625,7 +631,7 @@ int dispd_encoder_configure(struct dispd_encoder *e, struct wfd_session *s)
 					"u",
 					s->stream.rtp_port);
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 
 	if(s->stream.rtcp_port) {
@@ -634,7 +640,7 @@ int dispd_encoder_configure(struct dispd_encoder *e, struct wfd_session *s)
 						"u",
 						s->stream.rtcp_port);
 		if(0 > r) {
-			return r;
+			return log_ERRNO();
 		}
 	}
 
@@ -643,7 +649,7 @@ int dispd_encoder_configure(struct dispd_encoder *e, struct wfd_session *s)
 					"s",
 					sink->peer->local_address);
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 
 	if(s->stream.rtcp_port) {
@@ -652,7 +658,7 @@ int dispd_encoder_configure(struct dispd_encoder *e, struct wfd_session *s)
 						"u",
 						s->stream.rtcp_port);
 		if(0 > r) {
-			return r;
+			return log_ERRNO();
 		}
 	}
 
@@ -663,7 +669,7 @@ int dispd_encoder_configure(struct dispd_encoder *e, struct wfd_session *s)
 						"u",
 						rect->x);
 		if(0 > r) {
-			return r;
+			return log_ERRNO();
 		}
 
 		r = config_append(call,
@@ -671,7 +677,7 @@ int dispd_encoder_configure(struct dispd_encoder *e, struct wfd_session *s)
 						"u",
 						rect->y);
 		if(0 > r) {
-			return r;
+			return log_ERRNO();
 		}
 
 		r = config_append(call,
@@ -679,7 +685,7 @@ int dispd_encoder_configure(struct dispd_encoder *e, struct wfd_session *s)
 						"u",
 						rect->width);
 		if(0 > r) {
-			return r;
+			return log_ERRNO();
 		}
 
 		r = config_append(call,
@@ -687,22 +693,23 @@ int dispd_encoder_configure(struct dispd_encoder *e, struct wfd_session *s)
 						"u",
 						rect->height);
 		if(0 > r) {
-			return r;
+			return log_ERRNO();
 		}
 	}
 
 	r = sd_bus_message_close_container(call);
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 
 	r = sd_bus_call(e->bus, call, 0, &error, &reply);
 	if(0 > r) {
 		log_warning("%s: %s", error.name, error.message);
 		sd_bus_error_free(&error);
+		return log_ERRNO();
 	}
 
-	return r;
+	return 0;
 }
 
 static int dispd_encoder_call(struct dispd_encoder *e, const char *method)
@@ -712,9 +719,9 @@ static int dispd_encoder_call(struct dispd_encoder *e, const char *method)
 	_cleanup_sd_bus_error_ sd_bus_error error = SD_BUS_ERROR_NULL;
 	int r;
 
-	assert(e);
-	assert(method);
-	assert(e->bus);
+	assert_ret(e);
+	assert_ret(method);
+	assert_ret(e->bus);
 
 	r = sd_bus_message_new_method_call(e->bus,
 					&call,
diff --git a/src/disp/wfd-out-session.c b/src/disp/wfd-out-session.c
index 01e19cd..80b7111 100644
--- a/src/disp/wfd-out-session.c
+++ b/src/disp/wfd-out-session.c
@@ -588,7 +588,7 @@ static int wfd_out_session_handle_play_request(struct wfd_session *s,
 
 	*out_rep = (rtsp_message_ref(m), m);
 
-	return r;
+	return 0;
 }
 
 static void on_encoder_state_changed(struct dispd_encoder *e,
diff --git a/src/disp/wfd-session.c b/src/disp/wfd-session.c
index 6494ae5..5b3c3b8 100644
--- a/src/disp/wfd-session.c
+++ b/src/disp/wfd-session.c
@@ -22,6 +22,7 @@
 #include "wfd-dbus.h"
 #include "wfd-session.h"
 #include "shl_macro.h"
+#include "shl_log.h"
 
 #define rtsp_message_id_is_valid(_id) (				\
 		(_id) >= RTSP_M1_REQUEST_SINK_OPTIONS &&	\
@@ -65,12 +66,12 @@ static int wfd_session_do_request(struct wfd_session *s,
 				const struct wfd_arg_list *args,
 				struct rtsp_message **out)
 {
-	if(!rtsp_message_id_is_valid(id)) {
-		return -EINVAL;
-	}
+	assert_ret(s);
+	assert_ret(rtsp_message_id_is_valid(id));
+	assert_ret(out);
 
 	if(!s->rtsp_disp_tbl[id].request) {
-		log_warning("!!! request not implemented !!!");
+		log_warning("!!! request %d not implemented !!!", id);
 		return -ENOTSUP;
 	}
 
@@ -80,8 +81,13 @@ static int wfd_session_do_request(struct wfd_session *s,
 static int wfd_session_do_handle_request(struct wfd_session *s,
 				enum rtsp_message_id id,
 				struct rtsp_message *req,
-				struct rtsp_message **out_rep)
+				struct rtsp_message **rep)
 {
+	assert_ret(s);
+	assert_ret(rtsp_message_id_is_valid(id));
+	assert_ret(req);
+	assert_ret(rep);
+
 	if(!rtsp_message_id_is_valid(id)) {
 		return -EINVAL;
 	}
@@ -93,13 +99,17 @@ static int wfd_session_do_handle_request(struct wfd_session *s,
 
 	return (*s->rtsp_disp_tbl[id].handle_request)(s,
 					req,
-					out_rep);
+					rep);
 }
 
 static int wfd_session_do_handle_reply(struct wfd_session *s,
 				enum rtsp_message_id id,
-				struct rtsp_message *m)
+				struct rtsp_message *rep)
 {
+	assert_ret(s);
+	assert_ret(rtsp_message_id_is_valid(id));
+	assert_ret(rep);
+
 	if(!rtsp_message_id_is_valid(id)) {
 		return -EINVAL;
 	}
@@ -108,22 +118,28 @@ static int wfd_session_do_handle_reply(struct wfd_session *s,
 		return 0;
 	}
 
-	return (*s->rtsp_disp_tbl[id].handle_reply)(s, m);
+	return (*s->rtsp_disp_tbl[id].handle_reply)(s, rep);
 }
 
 unsigned int wfd_session_get_id(struct wfd_session *s)
 {
+	assert_retv(s, (unsigned int) -1);
+
 	return s->id;
 }
 
 enum wfd_session_state wfd_session_get_state(struct wfd_session *s)
 {
+	assert_retv(s, WFD_SESSION_STATE_NULL);
+
 	return s->state;
 }
 
 void wfd_session_set_state(struct wfd_session *s,
 				enum wfd_session_state state)
 {
+	assert_vret(wfd_is_session(s));
+
 	if(state == s->state) {
 		return;
 	}
@@ -133,16 +149,16 @@ void wfd_session_set_state(struct wfd_session *s,
 	wfd_fn_session_properties_changed(s, "State");
 }
 
-int wfd_session_is_established(struct wfd_session *s)
+bool wfd_session_is_established(struct wfd_session *s)
 {
-	assert(wfd_is_session(s));
+	assert_retv(wfd_is_session(s), false);
 
 	return WFD_SESSION_STATE_ESTABLISHED <= s->state;
 }
 
 int wfd_session_resume(struct wfd_session *s)
 {
-	assert(wfd_is_session(s));
+	assert_ret(wfd_is_session(s));
 
 	if(WFD_SESSION_STATE_PLAYING == s->state) {
 		return 0;
@@ -160,7 +176,7 @@ int wfd_session_resume(struct wfd_session *s)
 
 int wfd_session_pause(struct wfd_session *s)
 {
-	assert(wfd_is_session(s));
+	assert_ret(wfd_is_session(s));
 
 	if(WFD_SESSION_STATE_PAUSED == s->state) {
 		return 0;
@@ -178,7 +194,7 @@ int wfd_session_pause(struct wfd_session *s)
 
 int wfd_session_teardown(struct wfd_session *s)
 {
-	assert(wfd_is_session(s));
+	assert_ret(wfd_is_session(s));
 
 	if(wfd_session_is_established(s)) {
 		if(!session_vtbl[s->dir].teardown) {
@@ -198,9 +214,7 @@ int wfd_session_teardown(struct wfd_session *s)
 
 int wfd_session_terminate(struct wfd_session *s)
 {
-	if(!s) {
-		return 0;
-	}
+	assert_ret(wfd_is_session(s));
 
 	if(session_vtbl[s->dir].destroy) {
 		(*session_vtbl[s->dir].destroy)(s);
@@ -267,7 +281,7 @@ void wfd_session_unref(struct wfd_session *s)
 		return;
 	}
 
-	assert(1 <= s->ref);
+	assert_vret(1 <= s->ref);
 
 	-- s->ref;
 	if(s->ref) {
@@ -281,21 +295,29 @@ void wfd_session_unref(struct wfd_session *s)
 
 enum wfd_session_dir wfd_session_get_dir(struct wfd_session *s)
 {
+	assert_retv(s, WFD_SESSION_DIR_OUT);
+
 	return s->dir;
 }
 
 unsigned int * wfd_session_to_htable(struct wfd_session *s)
 {
+	assert_retv(s, NULL);
+
 	return &s->id;
 }
 
 struct wfd_session * wfd_session_from_htable(unsigned int *e)
 {
+	assert_retv(e, NULL);
+
 	return shl_htable_entry(e, struct wfd_session, id);
 }
 
 const char * wfd_session_get_stream_url(struct wfd_session *s)
 {
+	assert_retv(wfd_is_session(s), NULL);
+
 	return s->stream.url;
 }
 
@@ -306,25 +328,30 @@ int wfd_session_gen_stream_url(struct wfd_session *s,
 	char *url;
 	int r;
 
-	if(!wfd_stream_id_is_valid(id)) {
-		return -EINVAL;
-	}
-   
+	assert_ret(wfd_is_session(s));
+	assert_ret(local_addr);
+	assert_ret(wfd_stream_id_is_valid(id));
+
 	r = asprintf(&url, "rtsp://%s/wfd1.0/streamid=%d", local_addr, id);
-	if(0 <= r) {
-		free(s->stream.url);
-		s->stream.url = url;
-		url = NULL;
+	if(0 > r) {
+		return log_ERRNO();
 	}
 
-	return r;
+	free(s->stream.url);
+	s->stream.url = url;
+
+	return 0;
 }
 
 static enum rtsp_message_id wfd_session_message_to_id(struct wfd_session *s,
 				struct rtsp_message *m)
 {
 
-	const char *method = m ? rtsp_message_get_method(m) : NULL;
+	const char *method;
+
+	assert_retv(wfd_is_session(s), RTSP_M_UNKNOWN);
+   
+	method = m ? rtsp_message_get_method(m) : NULL;
 	if(!method) {
 		return RTSP_M_UNKNOWN;
 	}
@@ -400,13 +427,17 @@ static enum rtsp_message_id wfd_session_message_to_id(struct wfd_session *s,
 static int wfd_session_post_handle_request_n_reply(struct wfd_session *s,
                 enum rtsp_message_id ror)
 {
-    const struct wfd_arg_list *args = &s->rtsp_disp_tbl[ror].rule;
+    const struct wfd_arg_list *args;
 	enum rtsp_message_id next_request = RTSP_M_UNKNOWN;
 	enum wfd_session_arg_id arg_id;
 	enum wfd_session_state new_state = WFD_SESSION_STATE_NULL;
 	const struct wfd_arg_list *req_args = NULL;
 	int i;
 
+	assert_ret(s);
+	assert_ret(RTSP_M_UNKNOWN != ror);
+
+	args = &s->rtsp_disp_tbl[ror].rule;
 	if(!args->len) {
 		return 0;
 	}
@@ -512,7 +543,7 @@ static int wfd_session_handle_request(struct rtsp *bus,
 error:
 	wfd_session_terminate(s);
 
-	return log_ERRNO();
+	return log_ERR(r);
 }
 
 static int wfd_session_handle_reply(struct rtsp *bus,
@@ -553,10 +584,9 @@ static int wfd_session_handle_reply(struct rtsp *bus,
 	return 0;
 
 error:
-	log_info("error while handling reply: %s", strerror(-r));
 	wfd_session_terminate(s);
 
-	return r;
+	return log_ERR(r);
 }
 
 int wfd_session_init(struct wfd_session *s,
@@ -579,7 +609,7 @@ int wfd_session_request(struct wfd_session *s,
 	int r;
 	_rtsp_message_unref_ struct rtsp_message *m = NULL;
 
-	assert(s);
+	assert_ret(s);
 
 	r = wfd_session_do_request(s, id, args, &m);
 	if(0 > r) {
@@ -679,7 +709,7 @@ int wfd_session_start(struct wfd_session *s)
 	_shl_close_ int fd = -1;
 	uint32_t mask;
 
-	assert(wfd_is_session(s));
+	assert_ret(wfd_is_session(s));
 
 	if(WFD_SESSION_STATE_NULL != s->state) {
 		return -EINPROGRESS;
@@ -687,7 +717,7 @@ int wfd_session_start(struct wfd_session *s)
 
 	r = (*session_vtbl[s->dir].initiate_io)(s, &fd, &mask);
 	if(0 > r) {
-		return r;
+		return log_ERRNO();
 	}
 
 	r = sd_event_add_io(ctl_wfd_get_loop(),
@@ -697,7 +727,7 @@ int wfd_session_start(struct wfd_session *s)
 				wfd_session_handle_io,
 				s);
 	if (r < 0) {
-		return r;
+		return log_ERRNO();
 	}
 
 	fd = -1;
@@ -789,7 +819,7 @@ const struct wfd_rectangle * wfd_session_get_disp_dimension(struct wfd_session *
 
 int wfd_session_set_disp_dimension(struct wfd_session *s, const struct wfd_rectangle *rect)
 {
-	assert(rect);
+	assert_ret(rect);
 
 	if(rect) {
 		s->disp_dimen = *rect;
diff --git a/src/disp/wfd-sink.c b/src/disp/wfd-sink.c
index 07c31ea..48aed69 100644
--- a/src/disp/wfd-sink.c
+++ b/src/disp/wfd-sink.c
@@ -16,7 +16,6 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with MiracleCast; If not, see <http://www.gnu.org/licenses/>.
  */
-#include <assert.h>
 #include <time.h>
 #include <systemd/sd-event.h>
 #include "ctl.h"
@@ -28,6 +27,8 @@ static int wfd_sink_set_session(struct wfd_sink *sink,
 {
 	int r;
 
+	assert_ret(sink);
+
 	if(sink->session == session) {
 		return 0;
 	}
@@ -58,9 +59,10 @@ int wfd_sink_new(struct wfd_sink **out,
 {
 	struct wfd_sink *sink;
 
-	assert(out);
-	assert(peer);
-	assert(sube && wfd_sube_device_is_sink(sube));
+	assert_ret(out);
+	assert_ret(peer);
+	assert_ret(sube);
+	assert_ret(wfd_sube_device_is_sink(sube));
 	
 	sink = calloc(1, sizeof(struct wfd_sink));
 	if(!sink) {
@@ -98,16 +100,22 @@ void wfd_sink_free(struct wfd_sink *sink)
 
 const char * wfd_sink_get_label(struct wfd_sink *sink)
 {
+	assert_retv(sink, NULL);
+
 	return sink->label;
 }
 
 const union wfd_sube * wfd_sink_get_dev_info(struct wfd_sink *sink)
 {
+	assert_retv(sink, NULL);
+
 	return &sink->dev_info;
 }
 
 struct ctl_peer * wfd_sink_get_peer(struct wfd_sink *sink)
 {
+	assert_retv(sink, NULL);
+
 	return sink->peer;
 }
 
@@ -116,8 +124,8 @@ int wfd_sink_create_session(struct wfd_sink *sink, struct wfd_session **out)
 	int r;
 	_wfd_session_unref_ struct wfd_session *sess = NULL;
 
-	assert(sink);
-	assert(out);
+	assert_ret(sink);
+	assert_ret(out);
 
 	if(wfd_sink_is_session_started(sink)) {
 		return -EALREADY;
@@ -146,7 +154,7 @@ int wfd_sink_create_session(struct wfd_sink *sink, struct wfd_session **out)
 
 int wfd_fn_out_session_ended(struct wfd_session *s)
 {
-	assert(wfd_is_out_session(s));
+	assert_ret(wfd_is_out_session(s));
 
 	wfd_sink_set_session(wfd_out_session_get_sink(s), NULL);
 
@@ -155,5 +163,7 @@ int wfd_fn_out_session_ended(struct wfd_session *s)
 
 bool wfd_sink_is_session_started(struct wfd_sink *sink)
 {
+	assert_retv(sink, false);
+
 	return NULL != sink->session;
 }
diff --git a/src/shared/shl_log.h b/src/shared/shl_log.h
index 43e972b..19fcd3f 100644
--- a/src/shared/shl_log.h
+++ b/src/shared/shl_log.h
@@ -236,4 +236,13 @@ extern const char *LOG_SUBSYSTEM;
 #define log_vEUNMANAGED() \
 	((void)log_EUNMANAGED())
 
+#define assert_ret(c) \
+	if(!(c)) return (log_error("assertion " #c " failed"), -EINVAL)
+
+#define assert_retv(c, v) \
+	if(!(c)) return (log_error("assertion " #c " failed"), (v))
+
+#define assert_vret(c) \
+	if(!(c)) { log_error("assertion " #c " failed"); return; }
+
 #endif /* SHL_LOG_H */