static int
api_channel_tag_list
( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
channel_tag_t *ct;
htsmsg_t *l;
int cfg = api_channel_is_all(perm, args);
char buf[128], ubuf[UUID_HEX_SIZE];
l = htsmsg_create_list();
pthread_mutex_lock(&global_lock);
TAILQ_FOREACH(ct, &channel_tags, ct_link)
if (cfg || channel_tag_access(ct, perm, 0)) {
if (ct->ct_enabled) {
api_channel_key_val(l, idnode_uuid_as_str(&ct->ct_id, ubuf), ct->ct_name);
} else {
snprintf(buf, sizeof(buf), "{%s}", ct->ct_name);
api_channel_key_val(l, idnode_uuid_as_str(&ct->ct_id, ubuf), buf);
}
}
pthread_mutex_unlock(&global_lock);
*resp = htsmsg_create_map();
htsmsg_add_msg(*resp, "entries", l);
return 0;
}
// TODO: this will need converting to an idnode system
static int
api_channel_list
( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
channel_t *ch;
htsmsg_t *l;
int cfg = api_channel_is_all(perm, args);
char buf[128], ubuf[UUID_HEX_SIZE];
l = htsmsg_create_list();
pthread_mutex_lock(&global_lock);
CHANNEL_FOREACH(ch) {
if (!cfg && !channel_access(ch, perm, 0)) continue;
if (!ch->ch_enabled) {
snprintf(buf, sizeof(buf), "{%s}", channel_get_name(ch));
api_channel_key_val(l, idnode_uuid_as_str(&ch->ch_id, ubuf), buf);
} else {
api_channel_key_val(l, idnode_uuid_as_str(&ch->ch_id, ubuf), channel_get_name(ch));
}
}
pthread_mutex_unlock(&global_lock);
*resp = htsmsg_create_map();
htsmsg_add_msg(*resp, "entries", l);
return 0;
}
static void
iptv_service_config_save ( service_t *s )
{
mpegts_mux_t *mm = ((mpegts_service_t *)s)->s_dvb_mux;
htsmsg_t *c = htsmsg_create_map();
char ubuf0[UUID_HEX_SIZE];
char ubuf1[UUID_HEX_SIZE];
char ubuf2[UUID_HEX_SIZE];
service_save(s, c);
hts_settings_save(c, "input/iptv/networks/%s/muxes/%s/services/%s",
idnode_uuid_as_str(&mm->mm_network->mn_id, ubuf0),
idnode_uuid_as_str(&mm->mm_id, ubuf1),
idnode_uuid_as_str(&s->s_id, ubuf2));
htsmsg_destroy(c);
}
static int
api_dvr_autorec_create
( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
htsmsg_t *conf;
dvr_config_t *cfg;
dvr_autorec_entry_t *dae;
const char *s1;
if (!(conf = htsmsg_get_map(args, "conf")))
return EINVAL;
htsmsg_set_str(conf, "owner", perm->aa_username ?: "");
htsmsg_set_str(conf, "creator", perm->aa_representative ?: "");
s1 = htsmsg_get_str(conf, "config_uuid");
if (s1 == NULL)
s1 = htsmsg_get_str(conf, "config_name");
pthread_mutex_lock(&global_lock);
cfg = dvr_config_find_by_list(perm->aa_dvrcfgs, s1);
if (cfg) {
htsmsg_set_str(conf, "config_name", idnode_uuid_as_str(&cfg->dvr_id));
dae = dvr_autorec_create(NULL, conf);
if (dae) {
dvr_autorec_save(dae);
dvr_autorec_changed(dae, 1);
}
}
pthread_mutex_unlock(&global_lock);
return 0;
}
static int
api_dvr_entry_create
( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
dvr_entry_t *de;
dvr_config_t *cfg;
htsmsg_t *conf;
const char *s1;
int res = EPERM;
if (!(conf = htsmsg_get_map(args, "conf")))
return EINVAL;
pthread_mutex_lock(&global_lock);
s1 = htsmsg_get_str(conf, "config_name");
cfg = dvr_config_find_by_list(perm->aa_dvrcfgs, s1);
if (cfg) {
htsmsg_set_str(conf, "config_name", idnode_uuid_as_str(&cfg->dvr_id));
if (perm->aa_representative)
htsmsg_set_str(conf, "creator", perm->aa_representative);
if ((de = dvr_entry_create(NULL, conf)))
dvr_entry_save(de);
res = 0;
}
pthread_mutex_unlock(&global_lock);
return res;
}
static void
iptv_service_delete ( service_t *s, int delconf )
{
iptv_service_t *is = (iptv_service_t *)s;
mpegts_mux_t *mm = is->s_dvb_mux;
char ubuf0[UUID_HEX_SIZE];
char ubuf1[UUID_HEX_SIZE];
char ubuf2[UUID_HEX_SIZE];
/* Remove config */
if (delconf && s->s_type == STYPE_STD)
hts_settings_remove("input/iptv/networks/%s/muxes/%s/services/%s",
idnode_uuid_as_str(&mm->mm_network->mn_id, ubuf0),
idnode_uuid_as_str(&mm->mm_id, ubuf1),
idnode_uuid_as_str(&s->s_id, ubuf2));
/* Note - do no pass the delconf flag - another file location */
mpegts_service_delete(s, 0);
}
static int
api_dvr_entry_create
( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
dvr_entry_t *de;
dvr_config_t *cfg;
htsmsg_t *conf, *m;
char *s, *lang;
const char *s1;
int res = EPERM;
if (!(conf = htsmsg_get_map(args, "conf")))
return EINVAL;
pthread_mutex_lock(&global_lock);
s1 = htsmsg_get_str(conf, "config_name");
cfg = dvr_config_find_by_list(perm->aa_dvrcfgs, s1);
if (cfg) {
htsmsg_set_str(conf, "config_name", idnode_uuid_as_str(&cfg->dvr_id));
htsmsg_set_str(conf, "owner", perm->aa_username ?: "");
htsmsg_set_str(conf, "creator", perm->aa_representative ?: "");
lang = access_get_lang(perm, htsmsg_get_str(conf, "lang"));
if (lang) {
for (s = (char *)lang; *s && *s != ','; s++);
*s = '\0';
} else {
lang = strdup(lang_code_preferred());
}
s1 = htsmsg_get_str(conf, "disp_title");
if (s1 && !htsmsg_get_map(conf, "title")) {
m = htsmsg_create_map();
htsmsg_add_str(m, lang, s1);
htsmsg_add_msg(conf, "title", m);
}
s1 = htsmsg_get_str(conf, "disp_subtitle");
if (s1 && !htsmsg_get_map(conf, "subtitle")) {
m = htsmsg_create_map();
htsmsg_add_str(m, lang, s1);
htsmsg_add_msg(conf, "subtitle", m);
}
if ((de = dvr_entry_create(NULL, conf)))
dvr_entry_save(de);
res = 0;
free(lang);
}
pthread_mutex_unlock(&global_lock);
return res;
}
void linuxdvb_ca_save( linuxdvb_ca_t *lca, htsmsg_t *msg )
{
char id[8];
htsmsg_t *m = htsmsg_create_map();
htsmsg_add_str(m, "uuid", idnode_uuid_as_str(&lca->lca_id));
idnode_save(&lca->lca_id, m);
/* Add to list */
snprintf(id, sizeof(id), "ca%u", lca->lca_number);
htsmsg_add_msg(msg, id, m);
}
static void
satip_device_dbus_notify( satip_device_t *sd, const char *sig_name )
{
#if ENABLE_DBUS_1
char buf[256];
htsmsg_t *msg = htsmsg_create_list();
htsmsg_add_str(msg, NULL, sd->sd_info.addr);
htsmsg_add_str(msg, NULL, sd->sd_info.location);
htsmsg_add_str(msg, NULL, sd->sd_info.server);
snprintf(buf, sizeof(buf), "/input/mpegts/satip/%s", idnode_uuid_as_str(&sd->th_id));
dbus_emit_signal(buf, sig_name, msg);
#endif
}
static int
api_dvr_autorec_create_by_series
( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
dvr_autorec_entry_t *dae;
epg_broadcast_t *e;
htsmsg_t *entries, *entries2 = NULL, *m;
htsmsg_field_t *f;
const char *config_uuid, *s;
int count = 0;
if (!(entries = htsmsg_get_list(args, "entries"))) {
entries = entries2 = api_dvr_entry_create_from_single(args);
if (!entries)
return EINVAL;
}
HTSMSG_FOREACH(f, entries) {
if (!(m = htsmsg_get_map_by_field(f))) continue;
if (!(s = htsmsg_get_str(m, "event_id")))
continue;
config_uuid = htsmsg_get_str(m, "config_uuid");
pthread_mutex_lock(&global_lock);
if ((e = epg_broadcast_find_by_id(strtoll(s, NULL, 10)))) {
dvr_config_t *cfg = dvr_config_find_by_list(perm->aa_dvrcfgs, config_uuid);
if (cfg) {
dae = dvr_autorec_add_series_link(idnode_uuid_as_str(&cfg->dvr_id),
e,
perm->aa_username,
perm->aa_representative,
"Created from EPG query");
if (dae) {
dvr_autorec_save(dae);
dvr_autorec_changed(dae, 1);
}
}
}
pthread_mutex_unlock(&global_lock);
count++;
}
htsmsg_destroy(entries2);
return !count ? EINVAL : 0;
}
void
satip_device_save( satip_device_t *sd )
{
satip_frontend_t *lfe;
htsmsg_t *m, *l;
m = htsmsg_create_map();
idnode_save(&sd->th_id, m);
l = htsmsg_create_map();
TAILQ_FOREACH(lfe, &sd->sd_frontends, sf_link)
satip_frontend_save(lfe, l);
htsmsg_add_msg(m, "frontends", l);
hts_settings_save(m, "input/satip/adapters/%s",
idnode_uuid_as_str(&sd->th_id));
htsmsg_destroy(m);
}
void
tvhdhomerun_device_save( tvhdhomerun_device_t *hd )
{
tvhdhomerun_frontend_t *lfe;
htsmsg_t *m, *l;
m = htsmsg_create_map();
idnode_save(&hd->th_id, m);
l = htsmsg_create_map();
TAILQ_FOREACH(lfe, &hd->hd_frontends, hf_link)
tvhdhomerun_frontend_save(lfe, l);
htsmsg_add_msg(m, "frontends", l);
htsmsg_add_str(m, "fe_override", hd->hd_override_type);
hts_settings_save(m, "input/tvhdhomerun/adapters/%s",
idnode_uuid_as_str(&hd->th_id));
htsmsg_destroy(m);
}
void
epggrab_ota_queue_mux( mpegts_mux_t *mm )
{
const char *id = idnode_uuid_as_str(&mm->mm_id);
epggrab_ota_mux_t *om;
int epg_flag;
if (!mm)
return;
lock_assert(&global_lock);
epg_flag = mm->mm_is_epg(mm);
if (epg_flag < 0 || epg_flag == MM_EPG_DISABLE)
return;
RB_FOREACH(om, &epggrab_ota_all, om_global_link)
if (!strcmp(om->om_mux_uuid, id)) {
if (epggrab_ota_queue_one(om))
epggrab_ota_kick(4);
break;
}
}
/*
* find a dvr config by name using a filter list,
* return the first config from list if name is not valid
* return the default config if not found
*/
dvr_config_t *
dvr_config_find_by_list(htsmsg_t *uuids, const char *name)
{
dvr_config_t *cfg, *res = NULL;
htsmsg_field_t *f;
const char *uuid, *uuid2;
cfg = dvr_config_find_by_uuid(name);
if (!cfg)
cfg = dvr_config_find_by_name(name);
uuid = cfg ? idnode_uuid_as_str(&cfg->dvr_id) : "";
if (uuids) {
HTSMSG_FOREACH(f, uuids) {
uuid2 = htsmsg_field_get_str(f) ?: "";
if (strcmp(uuid, uuid2) == 0)
return cfg;
if (!res) {
res = dvr_config_find_by_uuid(uuid2);
if (!res->dvr_enabled)
res = NULL;
}
}
} else {
static htsmsg_t *
tvhdhomerun_device_class_save ( idnode_t *in, char *filename, size_t fsize )
{
tvhdhomerun_device_t *hd = (tvhdhomerun_device_t *)in;
tvhdhomerun_frontend_t *lfe;
htsmsg_t *m, *l;
char ubuf[UUID_HEX_SIZE];
m = htsmsg_create_map();
idnode_save(&hd->th_id, m);
if (filename) {
l = htsmsg_create_map();
TAILQ_FOREACH(lfe, &hd->hd_frontends, hf_link)
tvhdhomerun_frontend_save(lfe, l);
htsmsg_add_msg(m, "frontends", l);
snprintf(filename, fsize, "input/tvhdhomerun/adapters/%s",
idnode_uuid_as_str(&hd->th_id, ubuf));
}
htsmsg_add_str(m, "fe_override", hd->hd_override_type);
return m;
}
