miracle-dispd: more logging and assertions

Change-Id: I0450b9144390b12eed0646c4a4eacf6beed6ae91

src/disp/disp.h

@@ -99,6 +99,7 @@ int wfd_session_terminate(struct wfd_session *s);
 bool wfd_session_is_established(struct wfd_session *s);
 unsigned int wfd_session_get_id(struct wfd_session *s);
 const char * wfd_session_get_stream_url(struct wfd_session *s);
+bool wfd_session_is_state(struct wfd_session *s, enum wfd_session_state state);
 enum wfd_session_state wfd_session_get_state(struct wfd_session *s);
 enum wfd_session_dir wfd_session_get_dir(struct wfd_session *s);
 struct wfd_sink * wfd_out_session_get_sink(struct wfd_session *s);

src/disp/wfd-dbus.c

@@ -309,12 +309,12 @@ int _wfd_fn_sink_properties_changed(struct wfd_sink *s, char **names)
 	struct wfd_dbus *wfd_dbus = wfd_dbus_get();
 
 	if(!wfd_dbus) {
-		return -ECANCELED;
+		return log_ERR(-ECANCELED);
 	}
 	
 	r = wfd_dbus_get_sink_path(s, &path);
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	r = sd_bus_emit_properties_changed_strv(wfd_dbus->bus,
@@ -322,7 +322,7 @@ int _wfd_fn_sink_properties_changed(struct wfd_sink *s, char **names)
 					"org.freedesktop.miracle.wfd.Sink",
 					names);
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	return 0;

src/disp/wfd-out-session.c

@@ -56,9 +56,12 @@ int wfd_out_session_new(struct wfd_session **out,
 	struct wfd_out_session *os;
 	int r;
 
+	assert_ret(out);
+	assert_ret(id);
+	assert_ret(sink);
 	s = calloc(1, sizeof(struct wfd_out_session));
 	if(!s) {
-		return -ENOMEM;
+		return log_ENOMEM();
 	}
 
 	r = wfd_session_init(s,
@@ -66,7 +69,7 @@ int wfd_out_session_new(struct wfd_session **out,
 					WFD_SESSION_DIR_OUT,
 					out_session_rtsp_disp_tbl);
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	os = wfd_out_session(s);
@@ -147,30 +150,25 @@ int wfd_out_session_initiate_io(struct wfd_session *s,
 	int enable;
 	int r;
 
-	if(!os->sink->peer->connected) {
+	assert_retv(os->sink->peer->connected, -ENOTCONN);
-		log_info("peer not connected yet");
+	assert_retv(os->fd, -EINPROGRESS);
-		return -ENOTCONN;
-	}
 
 	r = wfd_sube_parse_with_id(WFD_SUBE_ID_DEVICE_INFO,
 					p->l->wfd_subelements,
 					&sube);
 	if(0 > r) {
 		log_warning("WfdSubelements property of link must be set before P2P scan");
-		return -EINVAL;
+		return log_ERR(-EINVAL);
 	}
 	else if(WFD_SUBE_ID_DEVICE_INFO != sube.id) {
-		return -EAFNOSUPPORT;
+		return log_ERR(-EAFNOSUPPORT);
-	}
-
-	if(-1 != os->fd) {
-		return EINPROGRESS;
 	}
 
 	r = inet_pton(AF_INET, p->local_address, &addr.sin_addr);
-	if (!r) {
+	if (0 >= r) {
-		return -EAFNOSUPPORT;
+		return log_ERR(-EAFNOSUPPORT);
 	}
+
 	addr.sin_family = AF_INET;
 	addr.sin_port = htons(wfd_sube_device_get_rtsp_port(&sube));
 
@@ -178,7 +176,7 @@ int wfd_out_session_initiate_io(struct wfd_session *s,
 					SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
 					0);
 	if (0 > fd) {
-		return fd;
+		return log_ERRNO();
 	}
 
 	enable = true;
@@ -207,7 +205,7 @@ int wfd_out_session_initiate_io(struct wfd_session *s,
 		return log_ERRNO();
 	}
 
-	log_trace("socket listening on %s:%hu",
+	log_trace("socket listen on %s:%hu",
 					p->local_address,
 					wfd_sube_device_get_rtsp_port(&sube));
 
@@ -242,7 +240,11 @@ int wfd_out_session_teardown(struct wfd_session *s)
 
 void wfd_out_session_destroy(struct wfd_session *s)
 {
-	struct wfd_out_session *os = wfd_out_session(s);
+	struct wfd_out_session *os;
+
+	assert_vret(s);
+
+	os = wfd_out_session(s);
 	if(0 <= os->fd) {
 		close(os->fd);
 		os->fd = -1;
@@ -276,7 +278,7 @@ static int wfd_out_session_handle_get_parameter_reply(struct wfd_session *s,
 	if(!rtsp_message_read(m, "{<&>}", "wfd_video_formats", &l)) {
 		r = wfd_video_formats_from_string(l, &vformats);
 		if(0 > r) {
-			return log_ERRNO();
+			return log_ERR(r);
 		}
 
 		if(s->vformats) {
@@ -288,7 +290,7 @@ static int wfd_out_session_handle_get_parameter_reply(struct wfd_session *s,
 	if(!rtsp_message_read(m, "{<&>}", "wfd_audio_codecs", &l)) {
 		r = wfd_audio_codecs_from_string(l, &acodecs);
 		if(0 > r) {
-			return log_ERRNO();
+			return log_ERR(r);
 		}
 		
 		if(s->acodecs) {
@@ -299,7 +301,7 @@ static int wfd_out_session_handle_get_parameter_reply(struct wfd_session *s,
 
 	if(!rtsp_message_read(m, "{<&>}", "wfd_client_rtp_ports", &l)) {
 		if(strncmp("RTP/AVP/UDP;unicast", l, 19)) {
-			return -EPROTO;
+			return log_EPROTO();
 		}
 
 		r = sscanf(l + 20, "%hd %hd %ms",
@@ -307,15 +309,15 @@ static int wfd_out_session_handle_get_parameter_reply(struct wfd_session *s,
 						&rtp_ports[1],
 						&t);
 		if(3 != r) {
-			return -EPROTO;
+			return log_EPROTO();
 		}
 
 		if(strncmp("mode=play", t, 9)) {
-			return -EPROTO;
+			return log_EPROTO();
 		}
 
 		if(!rtp_ports[0] && !rtp_ports[1]) {
-			return -EPROTO;
+			return log_EPROTO();
 		}
 
 		s->rtp_ports[0] = rtp_ports[0];
@@ -335,7 +337,7 @@ static int wfd_out_session_request_get_parameter(struct wfd_session *s,
 					"GET_PARAMETER",
 					"rtsp://localhost/wfd1.0");
 	if (0 > r) {
-		goto error;
+		return log_ERR(r);
 	}
 
 	r = rtsp_message_append(m, "{&}",
@@ -345,16 +347,13 @@ static int wfd_out_session_request_get_parameter(struct wfd_session *s,
 			//"wfd_uibc_capability"
 	);
 	if (0 > r) {
-		goto error;
+		return log_ERR(r);
 	}
 
 	*out = m;
 	m = NULL;
 
 	return 0;
-
-error:
-	return log_ERRNO();
 }
 
 static bool find_strv(const char *str, char **strv)
@@ -379,14 +378,19 @@ static int wfd_out_session_handle_options_request(struct wfd_session *s,
 
 	r = rtsp_message_read(req, "<s>", "Require", &require);
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	if(strcmp("org.wfa.wfd1.0", require)) {
-		return rtsp_message_new_reply_for(req,
+		r = rtsp_message_new_reply_for(req,
 						out_rep, 
 						RTSP_CODE_OPTION_NOT_SUPPORTED,
 						"Invalid specification");
+		if(0 > r) {
+			return log_ERR(r);
+		}
+
+		return 0;
 	}
 
 	r = rtsp_message_new_reply_for(req,
@@ -394,14 +398,14 @@ static int wfd_out_session_handle_options_request(struct wfd_session *s,
 					RTSP_CODE_OK,
 					NULL);
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	r = rtsp_message_append(rep,
 					"<&>",
 					"Public", "org.wfa.wfd1.0, SETUP, TEARDOWN, PLAY, PAUSE, GET_PARAMETER, SET_PARAMETER");
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	*out_rep = rep;
@@ -419,12 +423,12 @@ static int wfd_out_session_handle_options_reply(struct wfd_session *s,
 
 	r = rtsp_message_read(m, "<&>", "Public", &public);
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	r = sscanf(public, "%m[^,], %m[^,], %ms", &methods[0], &methods[1], &methods[2]);
 	if(3 != r) {
-		return -EPROTO;
+		return log_EPROTO();
 	}
 
 	methods[3] = NULL;
@@ -435,7 +439,7 @@ static int wfd_out_session_handle_options_reply(struct wfd_session *s,
 	free(methods[1]);
 	free(methods[0]);
 	if(!r) {
-		return -EPROTO;
+		return log_EPROTO();
 	}
 
 	return 0;
@@ -450,14 +454,14 @@ static int wfd_out_session_request_options(struct wfd_session *s,
 					&m,
 					"OPTIONS", "*");
 	if (0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	r = rtsp_message_append(m,
 					"<s>",
 					"Require", "org.wfa.wfd1.0");
 	if (0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	*out = m;
@@ -489,7 +493,7 @@ static int wfd_out_session_handle_pause_request(struct wfd_session *s,
 
 	r = dispd_encoder_pause(wfd_out_session(s)->encoder);
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	r = rtsp_message_new_reply_for(req,
@@ -497,7 +501,7 @@ static int wfd_out_session_handle_pause_request(struct wfd_session *s,
 					RTSP_CODE_OK,
 					NULL);
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	*out_rep = (rtsp_message_ref(m), m);
@@ -540,7 +544,7 @@ static int wfd_out_session_handle_teardown_request(struct wfd_session *s,
 	/*m = NULL;*/
 
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	return 0;
@@ -561,27 +565,30 @@ static int wfd_out_session_handle_play_request(struct wfd_session *s,
 					RTSP_CODE_OK,
 					NULL);
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	r = asprintf(&v, "%X", wfd_session_get_id(s));
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 	
 	r = rtsp_message_append(m, "<&>", "Session", v);
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	r = sd_event_now(ctl_wfd_get_loop(), CLOCK_MONOTONIC, &now);
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	e = wfd_out_session(s)->encoder;
 	if(DISPD_ENCODER_STATE_CONFIGURED <= dispd_encoder_get_state(e)) {
 		r = dispd_encoder_start(e);
+		if(0 > r) {
+			return log_ERR(r);
+		}
 	}
 
 	*out_rep = (rtsp_message_ref(m), m);
@@ -598,13 +605,15 @@ static void on_encoder_state_changed(struct dispd_encoder *e,
 
 	switch(state) {
 		case DISPD_ENCODER_STATE_SPAWNED:
-			if(WFD_SESSION_STATE_SETTING_UP == wfd_session_get_state(s)) {
+			if(wfd_session_is_state(s, WFD_SESSION_STATE_SETTING_UP)) {
 				r = dispd_encoder_configure(wfd_out_session(s)->encoder, s);
+				log_vERR(r);
 			}
 			break;
 		case DISPD_ENCODER_STATE_CONFIGURED:
-			if(WFD_SESSION_STATE_SETTING_UP == wfd_session_get_state(s)) {
+			if(wfd_session_is_state(s, WFD_SESSION_STATE_SETTING_UP)) {
 				r = dispd_encoder_start(e);
+				log_vERR(r);
 			}
 			break;
 		case DISPD_ENCODER_STATE_READY:
@@ -623,10 +632,6 @@ static void on_encoder_state_changed(struct dispd_encoder *e,
 			break;
 	}
 
-	if(0 > r) {
-		return log_vERRNO();
-	}
-
 	return;
 }
 
@@ -642,17 +647,17 @@ static int wfd_out_session_handle_setup_request(struct wfd_session *s,
 
 	r = rtsp_message_read(req, "<s>", "Transport", &l);
 	if(0 > r) {
-		return -EPROTO;
+		return log_EPROTO();
 	}
 
 	if(strncmp("RTP/AVP/UDP;unicast;", l, 20)) {
-		return -EPROTO;
+		return log_EPROTO();
 	}
 
 	l += 20;
 
 	if(strncmp("client_port=", l, 12)) {
-		return -EPROTO;
+		return log_EPROTO();
 	}
 
 	l += 12;
@@ -660,14 +665,14 @@ static int wfd_out_session_handle_setup_request(struct wfd_session *s,
 	errno = 0;
 	s->stream.rtp_port = strtoul(l, &l, 10);
 	if(errno) {
-		return -errno;
+		return log_EPROTO();
 	}
 
 	if('-' == *l) {
 		errno = 0;
 		s->stream.rtcp_port = strtoul(l + 1, NULL, 10);
 		if(errno) {
-			return -errno;
+			return log_EPROTO();
 		}
 	}
 	else {
@@ -719,10 +724,15 @@ static int wfd_out_session_handle_idr_request(struct wfd_session *s,
 				struct rtsp_message *req,
 				struct rtsp_message **out_rep)
 {
-	return rtsp_message_new_reply_for(req,
+	int r = rtsp_message_new_reply_for(req,
 					out_rep,
 					RTSP_CODE_OK,
 					NULL);
+	if(0 > r) {
+		return log_ERR(r);
+	}
+
+	return 0;
 }
 
 static int wfd_out_session_request_trigger(struct wfd_session *s,

src/disp/wfd-session.c

@@ -66,16 +66,22 @@ static int wfd_session_do_request(struct wfd_session *s,
 				const struct wfd_arg_list *args,
 				struct rtsp_message **out)
 {
+	int r;
+
 	assert_ret(s);
 	assert_ret(rtsp_message_id_is_valid(id));
 	assert_ret(out);
 
 	if(!s->rtsp_disp_tbl[id].request) {
-		log_warning("!!! request %d not implemented !!!", id);
+		return log_ERR(-ENOTSUP);
-		return -ENOTSUP;
 	}
 
-	return (*s->rtsp_disp_tbl[id].request)(s, args, out);
+	r = (*s->rtsp_disp_tbl[id].request)(s, args, out);
+	if(0 > r) {
+		return log_ERR(r);
+	}
+
+	return 0;
 }
 
 static int wfd_session_do_handle_request(struct wfd_session *s,
@@ -83,42 +89,47 @@ static int wfd_session_do_handle_request(struct wfd_session *s,
 				struct rtsp_message *req,
 				struct rtsp_message **rep)
 {
+	int r;
+
 	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;
-	}
-
 	if(!s->rtsp_disp_tbl[id].handle_request) {
-		log_warning("!!! request handler not implemented !!!");
+		return log_ERR(-ENOTSUP);
-		return -ENOTSUP;
 	}
 
-	return (*s->rtsp_disp_tbl[id].handle_request)(s,
+	r = (*s->rtsp_disp_tbl[id].handle_request)(s,
 					req,
 					rep);
+	if(0 > r) {
+		return log_ERR(r);
+	}
+
+	return 0;
 }
 
 static int wfd_session_do_handle_reply(struct wfd_session *s,
 				enum rtsp_message_id id,
 				struct rtsp_message *rep)
 {
+	int r;
+
 	assert_ret(s);
 	assert_ret(rtsp_message_id_is_valid(id));
 	assert_ret(rep);
 
-	if(!rtsp_message_id_is_valid(id)) {
-		return -EINVAL;
-	}
-	
 	if(!s->rtsp_disp_tbl[id].handle_reply) {
 		return 0;
 	}
 
-	return (*s->rtsp_disp_tbl[id].handle_reply)(s, rep);
+	r = (*s->rtsp_disp_tbl[id].handle_reply)(s, rep);
+	if(0 > r) {
+		return log_ERR(r);
+	}
+
+	return 0;
 }
 
 unsigned int wfd_session_get_id(struct wfd_session *s)
@@ -128,6 +139,13 @@ unsigned int wfd_session_get_id(struct wfd_session *s)
 	return s->id;
 }
 
+bool wfd_session_is_state(struct wfd_session *s, enum wfd_session_state state)
+{
+	assert_retv(s, false);
+
+	return state == s->state;
+}
+
 enum wfd_session_state wfd_session_get_state(struct wfd_session *s)
 {
 	assert_retv(s, WFD_SESSION_STATE_NULL);
@@ -432,7 +450,7 @@ static int wfd_session_post_handle_request_n_reply(struct wfd_session *s,
 	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;
+	int i, r;
 
 	assert_ret(s);
 	assert_ret(RTSP_M_UNKNOWN != ror);
@@ -460,7 +478,10 @@ static int wfd_session_post_handle_request_n_reply(struct wfd_session *s,
 	}
 
 	if(RTSP_M_UNKNOWN != next_request) {
-		return wfd_session_request(s, next_request, req_args);
+		r = wfd_session_request(s, next_request, req_args);
+		if(0 > r) {
+			return log_ERR(r);
+		}
 	}
 
 	if(WFD_SESSION_STATE_TEARING_DOWN == new_state) {
@@ -555,12 +576,12 @@ static int wfd_session_handle_reply(struct rtsp *bus,
 	struct wfd_session *s = userdata;
 
 	if(!m) {
-		r = -EPIPE;
+		r = log_EPIPE();
 		goto error;
 	}
 
 	if(!rtsp_message_is_reply(m, RTSP_CODE_OK, NULL)) {
-		r = -EPROTO;
+		r = log_EPROTO();
 		goto error;
 	}
 
@@ -573,20 +594,24 @@ static int wfd_session_handle_reply(struct rtsp *bus,
 
 	r = wfd_session_do_handle_reply(s, id, m);
 	if(0 > r) {
+		log_vERR(r);
 		goto error;
 	}
 
 	r = wfd_session_post_handle_request_n_reply(s, id);
 	if(0 > r) {
+		log_vERR(r);
 		goto error;
 	}
 
-	return 0;
+	goto end;
 
 error:
 	wfd_session_terminate(s);
+end:
+	wfd_session_unref(s);
 
-	return log_ERR(r);
+	return r;
 }
 
 int wfd_session_init(struct wfd_session *s,
@@ -710,14 +735,11 @@ int wfd_session_start(struct wfd_session *s)
 	uint32_t mask;
 
 	assert_ret(wfd_is_session(s));
-
+	assert_retv(wfd_session_is_state(s, WFD_SESSION_STATE_NULL), -EINPROGRESS);
-	if(WFD_SESSION_STATE_NULL != s->state) {
-		return -EINPROGRESS;
-	}
 
 	r = (*session_vtbl[s->dir].initiate_io)(s, &fd, &mask);
 	if(0 > r) {
-		return log_ERRNO();
+		return log_ERR(r);
 	}
 
 	r = sd_event_add_io(ctl_wfd_get_loop(),
@@ -739,11 +761,14 @@ int wfd_session_start(struct wfd_session *s)
 
 enum wfd_display_server_type wfd_session_get_disp_type(struct wfd_session *s)
 {
+	assert_retv(s, WFD_DISPLAY_SERVER_TYPE_UNKNOWN);
 	return s->disp_type;
 }
 
 int wfd_session_set_disp_type(struct wfd_session *s, enum wfd_display_server_type disp_type)
 {
+	assert_ret(s);
+
 	s->disp_type = disp_type;
 
 	return 0;
@@ -751,12 +776,18 @@ int wfd_session_set_disp_type(struct wfd_session *s, enum wfd_display_server_typ
 
 const char * wfd_session_get_disp_name(struct wfd_session *s)
 {
+	assert_retv(s, "");
+
 	return s->disp_name;
 }
 
 int wfd_session_set_disp_name(struct wfd_session *s, const char *disp_name)
 {
-	char *name = disp_name ? strdup(disp_name) : NULL;
+	char *name;
+
+	assert_ret(s);
+
+	name = disp_name ? strdup(disp_name) : NULL;
 	if(!name) {
 		return -ENOMEM;
 	}
@@ -772,12 +803,18 @@ int wfd_session_set_disp_name(struct wfd_session *s, const char *disp_name)
 
 const char * wfd_session_get_disp_params(struct wfd_session *s)
 {
+	assert_retv(s, "");
+
 	return s->disp_params;
 }
 
 int wfd_session_set_disp_params(struct wfd_session *s, const char *disp_params)
 {
-	char *params = disp_params ? strdup(disp_params) : NULL;
+	char *params;
+
+	assert_ret(s);
+
+	params = disp_params ? strdup(disp_params) : NULL;
 	if(disp_params && !params) {
 		return -ENOMEM;
 	}
@@ -793,12 +830,18 @@ int wfd_session_set_disp_params(struct wfd_session *s, const char *disp_params)
 
 const char * wfd_session_get_disp_auth(struct wfd_session *s)
 {
+	assert_retv(s, "");
+
 	return s->disp_auth;
 }
 
 int wfd_session_set_disp_auth(struct wfd_session *s, const char *disp_auth)
 {
-	char *auth = disp_auth ? strdup(disp_auth) : NULL;
+	char *auth;
+
+	assert_ret(s);
+
+	auth = disp_auth ? strdup(disp_auth) : NULL;
 	if(!auth) {
 		return -ENOMEM;
 	}
@@ -814,27 +857,34 @@ int wfd_session_set_disp_auth(struct wfd_session *s, const char *disp_auth)
 
 const struct wfd_rectangle * wfd_session_get_disp_dimension(struct wfd_session *s)
 {
+	assert_retv(s, NULL);
+
 	return &s->disp_dimen;
 }
 
 int wfd_session_set_disp_dimension(struct wfd_session *s, const struct wfd_rectangle *rect)
 {
+	assert_ret(s);
 	assert_ret(rect);
+	assert_ret(rect->width);
+	assert_ret(rect->height);
 
-	if(rect) {
 	s->disp_dimen = *rect;
-	}
 
 	return 0;
 }
 
 enum wfd_audio_server_type wfd_session_get_audio_type(struct wfd_session *s)
 {
+	assert_retv(s, WFD_AUDIO_SERVER_TYPE_UNKNOWN);
+
 	return s->audio_type;
 }
 
 int wfd_session_set_audio_type(struct wfd_session *s, enum wfd_audio_server_type audio_type)
 {
+	assert_ret(s);
+
 	s->audio_type = audio_type;
 
 	return 0;
@@ -842,12 +892,18 @@ int wfd_session_set_audio_type(struct wfd_session *s, enum wfd_audio_server_type
 
 const char * wfd_session_get_audio_dev_name(struct wfd_session *s)
 {
+	assert_retv(s, "");
+
 	return s->audio_dev_name;
 }
 
 int wfd_session_set_audio_dev_name(struct wfd_session *s, char *audio_dev_name)
 {
-	char *name = audio_dev_name ? strdup(audio_dev_name) : NULL;
+	char *name;
+
+	assert_ret(s);
+
+	name = audio_dev_name ? strdup(audio_dev_name) : NULL;
 	if(!name) {
 		return -ENOMEM;
 	}
@@ -863,7 +919,7 @@ int wfd_session_set_audio_dev_name(struct wfd_session *s, char *audio_dev_name)
 
 void wfd_session_unrefp(struct wfd_session **s)
 {
-	if(s) {
+	if(s && *s) {
 		wfd_session_unref(*s);
 	}
 }

src/shared/shl_log.h

@@ -221,6 +221,11 @@ extern const char *LOG_SUBSYSTEM;
 #define log_vEPIPE() \
 	((void)log_EPIPE())
 
+#define log_EPROTO() \
+	(log_error("protocol error"), -EPROTO)
+#define log_vEPROTO() \
+	((void)log_EPROTO())
+
 #define log_ERRNO() \
 	(log_error("syscall failed (%d): %m", errno), -errno)
 #define log_vERRNO() \