mirror of
https://github.com/albfan/miraclecast.git
synced 2025-03-09 23:38:56 +00:00
899 lines
18 KiB
C
899 lines
18 KiB
C
/*
|
|
* MiracleCast - Wifi-Display/Miracast Implementation
|
|
*
|
|
* Copyright (c) 2013-2014 David Herrmann <dh.herrmann@gmail.com>
|
|
*
|
|
* MiracleCast is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation; either version 2.1 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* MiracleCast is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* 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 <time.h>
|
|
#include "ctl.h"
|
|
#include "rtsp.h"
|
|
#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 && \
|
|
(_id) <= RTSP_M16_KEEPALIVE \
|
|
)
|
|
#define wfd_stream_id_is_valid(_id) ( \
|
|
(_id) >= WFD_STREAM_ID_PRIMARY && \
|
|
(_id) <= WFD_STREAM_ID_SECONDARY \
|
|
)
|
|
|
|
static const char *rtsp_message_names[];
|
|
extern const struct rtsp_dispatch_entry out_session_rtsp_disp_tbl[];
|
|
|
|
extern int wfd_out_session_initiate_io(struct wfd_session *s, int *out_fd, uint32_t *out_mask);
|
|
extern int wfd_out_session_handle_io(struct wfd_session *s, int error, int *out_fd);
|
|
extern int wfd_out_session_initiate_request(struct wfd_session *);
|
|
extern int wfd_out_session_resume(struct wfd_session *);
|
|
extern int wfd_out_session_pause(struct wfd_session *);
|
|
extern int wfd_out_session_teardown(struct wfd_session *);
|
|
extern void wfd_out_session_end(struct wfd_session *);
|
|
extern void wfd_out_session_destroy(struct wfd_session *);
|
|
static const char * rtsp_message_id_to_string(enum rtsp_message_id id);
|
|
static int wfd_session_handle_request(struct rtsp *bus,
|
|
struct rtsp_message *m,
|
|
void *userdata);
|
|
|
|
const struct wfd_session_vtable session_vtbl[] = {
|
|
[WFD_SESSION_DIR_OUT] = {
|
|
.initiate_io = wfd_out_session_initiate_io,
|
|
.handle_io = wfd_out_session_handle_io,
|
|
.initiate_request = wfd_out_session_initiate_request,
|
|
.resume = wfd_out_session_resume,
|
|
.pause = wfd_out_session_pause,
|
|
.teardown = wfd_out_session_teardown,
|
|
.destroy = wfd_out_session_destroy,
|
|
}
|
|
};
|
|
|
|
static int wfd_session_do_request(struct wfd_session *s,
|
|
enum rtsp_message_id id,
|
|
const struct wfd_arg_list *args,
|
|
struct rtsp_message **out)
|
|
{
|
|
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 -ENOTSUP;
|
|
}
|
|
|
|
return (*s->rtsp_disp_tbl[id].request)(s, args, out);
|
|
}
|
|
|
|
static int wfd_session_do_handle_request(struct wfd_session *s,
|
|
enum rtsp_message_id id,
|
|
struct rtsp_message *req,
|
|
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;
|
|
}
|
|
|
|
if(!s->rtsp_disp_tbl[id].handle_request) {
|
|
log_warning("!!! request handler not implemented !!!");
|
|
return -ENOTSUP;
|
|
}
|
|
|
|
return (*s->rtsp_disp_tbl[id].handle_request)(s,
|
|
req,
|
|
rep);
|
|
}
|
|
|
|
static int wfd_session_do_handle_reply(struct wfd_session *s,
|
|
enum rtsp_message_id id,
|
|
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;
|
|
}
|
|
|
|
if(!s->rtsp_disp_tbl[id].handle_reply) {
|
|
return 0;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
s->state = state;
|
|
|
|
wfd_fn_session_properties_changed(s, "State");
|
|
}
|
|
|
|
int wfd_session_is_established(struct wfd_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_ret(wfd_is_session(s));
|
|
|
|
if(WFD_SESSION_STATE_PLAYING == s->state) {
|
|
return 0;
|
|
}
|
|
else if(WFD_SESSION_STATE_PAUSED != s->state) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
if(!session_vtbl[s->dir].resume) {
|
|
return 0;
|
|
}
|
|
|
|
return session_vtbl[s->dir].resume(s);;
|
|
}
|
|
|
|
int wfd_session_pause(struct wfd_session *s)
|
|
{
|
|
assert_ret(wfd_is_session(s));
|
|
|
|
if(WFD_SESSION_STATE_PAUSED == s->state) {
|
|
return 0;
|
|
}
|
|
else if(WFD_SESSION_STATE_PLAYING != s->state) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
if(!session_vtbl[s->dir].pause) {
|
|
return 0;
|
|
}
|
|
|
|
return session_vtbl[s->dir].pause(s);;
|
|
}
|
|
|
|
int wfd_session_teardown(struct wfd_session *s)
|
|
{
|
|
assert_ret(wfd_is_session(s));
|
|
|
|
if(wfd_session_is_established(s)) {
|
|
if(!session_vtbl[s->dir].teardown) {
|
|
return 0;
|
|
}
|
|
|
|
return session_vtbl[s->dir].teardown(s);;
|
|
}
|
|
else {
|
|
/* notify and detach from sink */
|
|
wfd_session_terminate(s);
|
|
wfd_fn_out_session_ended(s);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int wfd_session_terminate(struct wfd_session *s)
|
|
{
|
|
assert_ret(wfd_is_session(s));
|
|
|
|
if(session_vtbl[s->dir].destroy) {
|
|
(*session_vtbl[s->dir].destroy)(s);
|
|
}
|
|
|
|
if(s->rtsp) {
|
|
rtsp_remove_match(s->rtsp, wfd_session_handle_request, s);
|
|
rtsp_detach_event(s->rtsp);
|
|
rtsp_unref(s->rtsp);
|
|
s->rtsp = NULL;
|
|
}
|
|
|
|
if(s->vformats) {
|
|
wfd_video_formats_free(s->vformats);
|
|
s->vformats = NULL;
|
|
}
|
|
|
|
if(s->acodecs) {
|
|
wfd_audio_codecs_free(s->acodecs);
|
|
s->acodecs = NULL;
|
|
}
|
|
|
|
if(s->stream.url) {
|
|
free(s->stream.url);
|
|
s->stream.url = NULL;
|
|
}
|
|
|
|
if(s->disp_auth) {
|
|
free(s->disp_auth);
|
|
s->disp_auth = NULL;
|
|
}
|
|
|
|
if(s->disp_name) {
|
|
free(s->disp_name);
|
|
s->disp_name = NULL;
|
|
}
|
|
|
|
if(s->audio_dev_name) {
|
|
free(s->audio_dev_name);
|
|
s->audio_dev_name = NULL;
|
|
}
|
|
|
|
s->rtp_ports[0] = 0;
|
|
s->rtp_ports[1] = 0;
|
|
s->last_request = RTSP_M_UNKNOWN;
|
|
|
|
s->state = WFD_SESSION_STATE_TERMINATING;
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct wfd_session * wfd_session_ref(struct wfd_session *s)
|
|
{
|
|
if(s) {
|
|
++ s->ref;
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
void wfd_session_unref(struct wfd_session *s)
|
|
{
|
|
if(!s) {
|
|
return;
|
|
}
|
|
|
|
assert_vret(1 <= s->ref);
|
|
|
|
-- s->ref;
|
|
if(s->ref) {
|
|
return;
|
|
}
|
|
|
|
wfd_session_terminate(s);
|
|
|
|
free(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;
|
|
}
|
|
|
|
int wfd_session_gen_stream_url(struct wfd_session *s,
|
|
const char *local_addr,
|
|
enum wfd_stream_id id)
|
|
{
|
|
char *url;
|
|
int r;
|
|
|
|
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) {
|
|
return log_ERRNO();
|
|
}
|
|
|
|
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;
|
|
|
|
assert_retv(wfd_is_session(s), RTSP_M_UNKNOWN);
|
|
|
|
method = m ? rtsp_message_get_method(m) : NULL;
|
|
if(!method) {
|
|
return RTSP_M_UNKNOWN;
|
|
}
|
|
|
|
if(!strcmp(method, "SET_PARAMETER")) {
|
|
if(!rtsp_message_read(m, "{<>}", "wfd_trigger_method")) {
|
|
return RTSP_M5_TRIGGER;
|
|
}
|
|
|
|
if(!rtsp_message_read(m, "{<>}", "wfd_route")) {
|
|
return RTSP_M10_SET_ROUTE;
|
|
}
|
|
|
|
if(!rtsp_message_read(m, "{<>}", "wfd_connector_type")) {
|
|
return RTSP_M11_SET_CONNECTOR_TYPE;
|
|
}
|
|
|
|
if(!rtsp_message_read(m, "{<>}", "wfd_uibc_setting")) {
|
|
return RTSP_M15_ENABLE_UIBC;
|
|
}
|
|
|
|
if(!strncmp("wfd_standby", rtsp_message_get_body(m), 11)) {
|
|
return RTSP_M12_SET_STANDBY;
|
|
}
|
|
|
|
if(!strncmp("wfd_idr_request", rtsp_message_get_body(m), 15)) {
|
|
return RTSP_M13_REQUEST_IDR;
|
|
}
|
|
|
|
if(WFD_SESSION_STATE_CAPS_EXCHANGING == s->state) {
|
|
return RTSP_M4_SET_PARAMETER;
|
|
}
|
|
|
|
if(!rtsp_message_read(m, "{<>}", "wfd_uibc_capability")) {
|
|
return RTSP_M14_ESTABLISH_UIBC;
|
|
}
|
|
|
|
return RTSP_M_UNKNOWN;
|
|
}
|
|
|
|
if(!strcmp(method, "OPTIONS")) {
|
|
return wfd_is_out_session(s)
|
|
? (RTSP_MESSAGE_REPLY == rtsp_message_get_type(m))
|
|
? RTSP_M1_REQUEST_SINK_OPTIONS
|
|
: RTSP_M2_REQUEST_SRC_OPTIONS
|
|
: (RTSP_MESSAGE_REPLY == rtsp_message_get_type(m))
|
|
? RTSP_M2_REQUEST_SRC_OPTIONS
|
|
: RTSP_M1_REQUEST_SINK_OPTIONS;
|
|
}
|
|
else if(!strcmp(method, "GET_PARAMETER")) {
|
|
if(rtsp_message_get_body_size(m)) {
|
|
return RTSP_M3_GET_PARAMETER;
|
|
}
|
|
|
|
return RTSP_M16_KEEPALIVE;
|
|
}
|
|
else if(!strcmp(method, "SETUP")) {
|
|
return RTSP_M6_SETUP;
|
|
}
|
|
else if(!strcmp(method, "PLAY")) {
|
|
return RTSP_M7_PLAY;
|
|
}
|
|
else if(!strcmp(method, "TEARDOWN")) {
|
|
return RTSP_M8_TEARDOWN;
|
|
}
|
|
else if(!strcmp(method, "PAUSE")) {
|
|
return RTSP_M9_PAUSE;
|
|
}
|
|
|
|
return RTSP_M_UNKNOWN;
|
|
}
|
|
|
|
static int wfd_session_post_handle_request_n_reply(struct wfd_session *s,
|
|
enum rtsp_message_id ror)
|
|
{
|
|
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;
|
|
}
|
|
|
|
for(i = 0; i < args->len; i ++) {
|
|
wfd_arg_list_get_dictk(args, i, &arg_id);
|
|
switch(arg_id) {
|
|
case WFD_SESSION_ARG_NEXT_REQUEST:
|
|
wfd_arg_list_get_dictv(args, i, &next_request);
|
|
break;
|
|
case WFD_SESSION_ARG_NEW_STATE:
|
|
wfd_arg_list_get_dictv(args, i, &new_state);
|
|
wfd_session_set_state(s, new_state);
|
|
break;
|
|
case WFD_SESSION_ARG_REQUEST_ARGS:
|
|
wfd_arg_list_get_dictv(args, i, &req_args);
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(RTSP_M_UNKNOWN != next_request) {
|
|
return wfd_session_request(s, next_request, req_args);
|
|
}
|
|
|
|
if(WFD_SESSION_STATE_TEARING_DOWN == new_state) {
|
|
wfd_fn_out_session_ended(s);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int wfd_session_handle_request(struct rtsp *bus,
|
|
struct rtsp_message *m,
|
|
void *userdata)
|
|
{
|
|
_rtsp_message_unref_ struct rtsp_message *rep = NULL;
|
|
struct wfd_session *s = userdata;
|
|
enum rtsp_message_id id;
|
|
char date[64];
|
|
uint64_t usec;
|
|
time_t sec;
|
|
int r;
|
|
|
|
id = wfd_session_message_to_id(s, m);
|
|
if(RTSP_M_UNKNOWN == id) {
|
|
if(m) {
|
|
log_debug("unable to map request to id: %s",
|
|
(char *) rtsp_message_get_raw(m));
|
|
}
|
|
r = -EPROTO;
|
|
goto error;
|
|
}
|
|
|
|
log_trace("received %s (M%d) request: %s", rtsp_message_id_to_string(id),
|
|
id,
|
|
(char *) rtsp_message_get_raw(m));
|
|
|
|
r = wfd_session_do_handle_request(s,
|
|
id,
|
|
m,
|
|
&rep);
|
|
if(0 > r) {
|
|
goto error;
|
|
}
|
|
|
|
r = sd_event_now(ctl_wfd_get_loop(), CLOCK_REALTIME, &usec);
|
|
if(0 > r) {
|
|
goto error;
|
|
}
|
|
|
|
sec = usec / 1000 / 1000;
|
|
strftime(date, sizeof(date),
|
|
"%a, %d %b %Y %T %z",
|
|
gmtime(&sec));
|
|
|
|
r = rtsp_message_append(rep, "<&>", "Date", date);
|
|
if(0 > r) {
|
|
goto error;
|
|
}
|
|
|
|
r = rtsp_message_seal(rep);
|
|
if(0 > r) {
|
|
goto error;
|
|
}
|
|
|
|
r = rtsp_send(bus, rep);
|
|
if(0 > r) {
|
|
goto error;
|
|
}
|
|
|
|
log_trace("sending %s (M%d) reply: %s", rtsp_message_id_to_string(id),
|
|
id,
|
|
(char *) rtsp_message_get_raw(rep));
|
|
|
|
r = wfd_session_post_handle_request_n_reply(s, id);
|
|
if(0 > r) {
|
|
goto error;
|
|
}
|
|
|
|
return 0;
|
|
|
|
error:
|
|
wfd_session_terminate(s);
|
|
|
|
return log_ERR(r);
|
|
}
|
|
|
|
static int wfd_session_handle_reply(struct rtsp *bus,
|
|
struct rtsp_message *m,
|
|
void *userdata)
|
|
{
|
|
int r;
|
|
enum rtsp_message_id id;
|
|
struct wfd_session *s = userdata;
|
|
|
|
if(!m) {
|
|
r = -EPIPE;
|
|
goto error;
|
|
}
|
|
|
|
if(!rtsp_message_is_reply(m, RTSP_CODE_OK, NULL)) {
|
|
r = -EPROTO;
|
|
goto error;
|
|
}
|
|
|
|
id = s->last_request;
|
|
|
|
log_trace("received %s (M%d) reply: %s",
|
|
rtsp_message_id_to_string(id),
|
|
id,
|
|
(char *) rtsp_message_get_raw(m));
|
|
|
|
r = wfd_session_do_handle_reply(s, id, m);
|
|
if(0 > r) {
|
|
goto error;
|
|
}
|
|
|
|
r = wfd_session_post_handle_request_n_reply(s, id);
|
|
if(0 > r) {
|
|
goto error;
|
|
}
|
|
|
|
return 0;
|
|
|
|
error:
|
|
wfd_session_terminate(s);
|
|
|
|
return log_ERR(r);
|
|
}
|
|
|
|
int wfd_session_init(struct wfd_session *s,
|
|
unsigned int id,
|
|
enum wfd_session_dir dir,
|
|
const struct rtsp_dispatch_entry *disp_tbl)
|
|
{
|
|
s->ref = 1;
|
|
s->id = id;
|
|
s->dir = dir;
|
|
s->rtsp_disp_tbl = disp_tbl;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int wfd_session_request(struct wfd_session *s,
|
|
enum rtsp_message_id id,
|
|
const struct wfd_arg_list *args)
|
|
{
|
|
int r;
|
|
_rtsp_message_unref_ struct rtsp_message *m = NULL;
|
|
|
|
assert_ret(s);
|
|
|
|
r = wfd_session_do_request(s, id, args, &m);
|
|
if(0 > r) {
|
|
goto error;
|
|
}
|
|
|
|
r = rtsp_message_seal(m);
|
|
if(0 > r) {
|
|
goto error;
|
|
}
|
|
|
|
r = rtsp_call_async(s->rtsp,
|
|
m,
|
|
wfd_session_handle_reply,
|
|
s,
|
|
0,
|
|
NULL);
|
|
if(0 > r) {
|
|
goto error;
|
|
}
|
|
|
|
s->last_request = id;
|
|
|
|
log_trace("sending %s (M%d) request: %s",
|
|
rtsp_message_id_to_string(id),
|
|
id,
|
|
(char *) rtsp_message_get_raw(m));
|
|
|
|
return 0;
|
|
|
|
error:
|
|
log_warning("error while requesting: %s", strerror(-r));
|
|
return r;
|
|
}
|
|
|
|
static int wfd_session_handle_io(sd_event_source *source,
|
|
int fd,
|
|
uint32_t mask,
|
|
void *userdata)
|
|
{
|
|
int r = 0, err = 0, conn;
|
|
socklen_t len;
|
|
struct wfd_session *s = userdata;
|
|
_rtsp_unref_ struct rtsp *rtsp = NULL;
|
|
|
|
sd_event_source_set_enabled(source, SD_EVENT_OFF);
|
|
sd_event_source_unref(source);
|
|
|
|
if (mask & EPOLLERR) {
|
|
r = getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len);
|
|
if(0 > r) {
|
|
return log_ERRNO();
|
|
}
|
|
}
|
|
|
|
if (mask & EPOLLIN || mask & EPOLLOUT) {
|
|
r = (*session_vtbl[s->dir].handle_io)(s, err, &conn);
|
|
if(0 > r) {
|
|
return log_ERRNO();
|
|
}
|
|
|
|
r = rtsp_open(&rtsp, conn);
|
|
if (0 > r) {
|
|
return log_ERRNO();
|
|
}
|
|
|
|
conn = -1;
|
|
|
|
r = rtsp_attach_event(rtsp, ctl_wfd_get_loop(), 0);
|
|
if (0 > r) {
|
|
return log_ERRNO();
|
|
}
|
|
|
|
r = rtsp_add_match(rtsp, wfd_session_handle_request, s);
|
|
if (0 > r) {
|
|
return log_ERRNO();
|
|
}
|
|
|
|
s->rtsp = rtsp;
|
|
rtsp = NULL;
|
|
|
|
wfd_session_set_state(s, WFD_SESSION_STATE_CAPS_EXCHANGING);
|
|
|
|
r = (*session_vtbl[s->dir].initiate_request)(s);
|
|
}
|
|
|
|
if(mask & EPOLLHUP) {
|
|
wfd_session_teardown(s);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int wfd_session_start(struct wfd_session *s)
|
|
{
|
|
int r;
|
|
_shl_close_ int fd = -1;
|
|
uint32_t mask;
|
|
|
|
assert_ret(wfd_is_session(s));
|
|
|
|
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();
|
|
}
|
|
|
|
r = sd_event_add_io(ctl_wfd_get_loop(),
|
|
NULL,
|
|
fd,
|
|
mask,
|
|
wfd_session_handle_io,
|
|
s);
|
|
if (r < 0) {
|
|
return log_ERRNO();
|
|
}
|
|
|
|
fd = -1;
|
|
|
|
wfd_session_set_state(s, WFD_SESSION_STATE_CONNECTING);
|
|
|
|
return 0;
|
|
}
|
|
|
|
enum wfd_display_server_type wfd_session_get_disp_type(struct wfd_session *s)
|
|
{
|
|
return s->disp_type;
|
|
}
|
|
|
|
int wfd_session_set_disp_type(struct wfd_session *s, enum wfd_display_server_type disp_type)
|
|
{
|
|
s->disp_type = disp_type;
|
|
|
|
return 0;
|
|
}
|
|
|
|
const char * wfd_session_get_disp_name(struct wfd_session *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;
|
|
if(!name) {
|
|
return -ENOMEM;
|
|
}
|
|
|
|
if(s->disp_name) {
|
|
free(s->disp_name);
|
|
}
|
|
|
|
s->disp_name = name;
|
|
|
|
return 0;
|
|
}
|
|
|
|
const char * wfd_session_get_disp_params(struct wfd_session *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;
|
|
if(disp_params && !params) {
|
|
return -ENOMEM;
|
|
}
|
|
|
|
if(s->disp_params) {
|
|
free(s->disp_params);
|
|
}
|
|
|
|
s->disp_params = params;
|
|
|
|
return 0;
|
|
}
|
|
|
|
const char * wfd_session_get_disp_auth(struct wfd_session *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;
|
|
if(!auth) {
|
|
return -ENOMEM;
|
|
}
|
|
|
|
if(s->disp_auth) {
|
|
free(s->disp_auth);
|
|
}
|
|
|
|
s->disp_auth = auth;
|
|
|
|
return 0;
|
|
}
|
|
|
|
const struct wfd_rectangle * wfd_session_get_disp_dimension(struct wfd_session *s)
|
|
{
|
|
return &s->disp_dimen;
|
|
}
|
|
|
|
int wfd_session_set_disp_dimension(struct wfd_session *s, const struct wfd_rectangle *rect)
|
|
{
|
|
assert_ret(rect);
|
|
|
|
if(rect) {
|
|
s->disp_dimen = *rect;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
enum wfd_audio_server_type wfd_session_get_audio_type(struct wfd_session *s)
|
|
{
|
|
return s->audio_type;
|
|
}
|
|
|
|
int wfd_session_set_audio_type(struct wfd_session *s, enum wfd_audio_server_type audio_type)
|
|
{
|
|
s->audio_type = audio_type;
|
|
|
|
return 0;
|
|
}
|
|
|
|
const char * wfd_session_get_audio_dev_name(struct wfd_session *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;
|
|
if(!name) {
|
|
return -ENOMEM;
|
|
}
|
|
|
|
if(s->audio_dev_name) {
|
|
free(s->audio_dev_name);
|
|
}
|
|
|
|
s->audio_dev_name = name;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void wfd_session_unrefp(struct wfd_session **s)
|
|
{
|
|
if(s) {
|
|
wfd_session_unref(*s);
|
|
}
|
|
}
|
|
|
|
static const char * rtsp_message_id_to_string(enum rtsp_message_id id)
|
|
{
|
|
if(rtsp_message_id_is_valid(id)) {
|
|
return rtsp_message_names[id];
|
|
}
|
|
|
|
return rtsp_message_names[0];
|
|
}
|
|
|
|
static const char *rtsp_message_names[] = {
|
|
"UNKNOWN",
|
|
"OPTIONS(src->sink)",
|
|
"OPTIONS(sink->src)",
|
|
"GET_PARAM",
|
|
"SET_PARAM",
|
|
"SET_PARAM(wfd-trigger-method)",
|
|
"SETUP",
|
|
"PLAY",
|
|
"TEARDOWN",
|
|
"PAUSE",
|
|
"SET_PARAM(wfd-route)",
|
|
"SET_PARAM(wfd-connector-type)",
|
|
"SET_PARAM(wfd-standby)",
|
|
"SET_PARAM(wfd-idr-request)",
|
|
"SET_PARAM(wfd-uibc-cability)",
|
|
"SET_PARAM(wfd-uibc-setting)",
|
|
"GET_PARAM(keepalive)",
|
|
};
|
|
|