idnode_list_destroy(&ct->ct_accesses, delconf ? ct : NULL);
}
-/**
- *
- */
-void
-access_entry_save(access_entry_t *ae)
-{
- htsmsg_t *c = htsmsg_create_map();
- char ubuf[UUID_HEX_SIZE];
- idnode_save(&ae->ae_id, c);
- hts_settings_save(c, "accesscontrol/%s", idnode_uuid_as_str(&ae->ae_id, ubuf));
- htsmsg_destroy(c);
-}
-
/**
*
*/
TAILQ_FOREACH(ae, &access_entries, ae_link) {
if (ae->ae_index != i) {
ae->ae_index = i;
- access_entry_save(ae);
+ idnode_changed(&ae->ae_id);
}
i++;
}
* Class definition
* **************************************************************************/
-static void
-access_entry_class_save(idnode_t *self)
+static htsmsg_t *
+access_entry_class_save(idnode_t *self, char *filename, size_t fsize)
{
+ access_entry_t *ae = (access_entry_t *)self;
+ char ubuf[UUID_HEX_SIZE];
+ htsmsg_t *c = htsmsg_create_map();
access_entry_update_rights((access_entry_t *)self);
- access_entry_save((access_entry_t *)self);
+ idnode_save(&ae->ae_id, c);
+ snprintf(filename, fsize, "accesscontrol/%s", idnode_uuid_as_str(&ae->ae_id, ubuf));
+ return c;
}
static void
free(pw);
}
-void
-passwd_entry_save(passwd_entry_t *pw)
+static htsmsg_t *
+passwd_entry_class_save(idnode_t *self, char *filename, size_t fsize)
{
- htsmsg_t *c = htsmsg_create_map();
+ passwd_entry_t *pw = (passwd_entry_t *)self;
char ubuf[UUID_HEX_SIZE];
+ htsmsg_t *c = htsmsg_create_map();
idnode_save(&pw->pw_id, c);
- hts_settings_save(c, "passwd/%s", idnode_uuid_as_str(&pw->pw_id, ubuf));
- htsmsg_destroy(c);
-}
-
-static void
-passwd_entry_class_save(idnode_t *self)
-{
- passwd_entry_save((passwd_entry_t *)self);
+ snprintf(filename, fsize, "passwd/%s", idnode_uuid_as_str(&pw->pw_id, ubuf));
+ return c;
}
static void
free(ib);
}
-void
-ipblock_entry_save(ipblock_entry_t *ib)
+static htsmsg_t *
+ipblock_entry_class_save(idnode_t *self, char *filename, size_t fsize)
{
+ ipblock_entry_t *ib = (ipblock_entry_t *)self;
htsmsg_t *c = htsmsg_create_map();
char ubuf[UUID_HEX_SIZE];
idnode_save(&ib->ib_id, c);
- hts_settings_save(c, "ipblock/%s", idnode_uuid_as_str(&ib->ib_id, ubuf));
- htsmsg_destroy(c);
-}
-
-static void
-ipblock_entry_class_save(idnode_t *self)
-{
- ipblock_entry_save((ipblock_entry_t *)self);
+ snprintf(filename, fsize, "ipblock/%s", idnode_uuid_as_str(&ib->ib_id, ubuf));
+ return c;
}
static const char *
ae->ae_admin = 1;
access_entry_update_rights(ae);
- access_entry_save(ae);
+ idnode_changed(&ae->ae_id);
tvhlog(LOG_WARNING, "access",
"Created default wide open access controle entry");
void
access_entry_destroy(access_entry_t *ae, int delconf);
-/**
- *
- */
-void
-access_entry_save(access_entry_t *ae);
-
/**
*
*/
passwd_entry_create(const char *uuid, htsmsg_t *conf);
void
passwd_entry_destroy(passwd_entry_t *ae, int delconf);
-void
-passwd_entry_save(passwd_entry_t *pw);
/**
*
*/
ipblock_entry_t *
ipblock_entry_create(const char *uuid, htsmsg_t *conf);
-void
-ipblock_entry_save(ipblock_entry_t *pw);
/**
*
pthread_mutex_lock(&global_lock);
if ((pw = passwd_entry_create(NULL, conf)) != NULL)
- passwd_entry_save(pw);
+ idnode_changed(&pw->pw_id);
pthread_mutex_unlock(&global_lock);
return 0;
pthread_mutex_lock(&global_lock);
if ((ib = ipblock_entry_create(NULL, conf)) != NULL)
- ipblock_entry_save(ib);
+ idnode_changed(&ib->ib_id);
pthread_mutex_unlock(&global_lock);
return 0;
pthread_mutex_lock(&global_lock);
if ((ae = access_entry_create(NULL, conf)) != NULL)
- access_entry_save(ae);
+ idnode_changed(&ae->ae_id);
pthread_mutex_unlock(&global_lock);
return 0;
pthread_mutex_lock(&global_lock);
bq = bouquet_create(NULL, conf, NULL, NULL);
if (bq)
- bouquet_save(bq, 0);
+ idnode_changed(&bq->bq_id);
pthread_mutex_unlock(&global_lock);
return 0;
pthread_mutex_lock(&global_lock);
ch = channel_create(NULL, conf, NULL);
if (ch)
- channel_save(ch);
+ idnode_changed(&ch->ch_id);
pthread_mutex_unlock(&global_lock);
return 0;
pthread_mutex_lock(&global_lock);
ct = channel_tag_create(NULL, conf);
if (ct)
- channel_tag_save(ct);
+ idnode_changed(&ct->ct_id);
pthread_mutex_unlock(&global_lock);
return 0;
pthread_mutex_lock(&global_lock);
if ((cfg = dvr_config_create(NULL, NULL, conf)))
- dvr_config_save(cfg);
+ idnode_changed(&cfg->dvr_id);
pthread_mutex_unlock(&global_lock);
return 0;
htsmsg_add_msg(conf, "subtitle", m);
}
if ((de = dvr_entry_create(NULL, conf, 0)))
- dvr_entry_save(de);
+ idnode_changed(&de->de_id);
res = 0;
free(lang);
NULL, DVR_PRIO_NORMAL, DVR_RET_DVRCONFIG,
DVR_RET_DVRCONFIG, comment);
if (de)
- dvr_entry_save(de);
+ idnode_changed(&de->de_id);
}
}
pthread_mutex_unlock(&global_lock);
if (cfg) {
htsmsg_set_str(conf, "config_name", idnode_uuid_as_str(&cfg->dvr_id, ubuf));
dae = dvr_autorec_create(NULL, conf);
- if (dae) {
- dvr_autorec_save(dae);
- dvr_autorec_changed(dae, 1);
- }
+ if (dae)
+ idnode_changed(&dae->dae_id);
}
pthread_mutex_unlock(&global_lock);
perm->aa_username,
perm->aa_representative,
"Created from EPG query");
- if (dae) {
- dvr_autorec_save(dae);
- dvr_autorec_changed(dae, 1);
- }
+ if (dae)
+ idnode_changed(&dae->dae_id);
}
}
pthread_mutex_unlock(&global_lock);
pthread_mutex_lock(&global_lock);
dte = dvr_timerec_create(NULL, conf);
- if (dte) {
- dvr_timerec_save(dte);
- dvr_timerec_check(dte);
- }
+ if (dte)
+ idnode_changed(&dte->dte_id);
pthread_mutex_unlock(&global_lock);
return 0;
if (mn) {
err = 0;
*resp = htsmsg_create_map();
- mn->mn_config_save(mn);
+ idnode_changed(&mn->mn_id);
} else {
err = EINVAL;
}
if (!(mm = mn->mn_mux_create2(mn, conf)))
goto exit;
- mm->mm_config_save(mm);
+ idnode_changed(&mm->mm_id);
err = 0;
exit:
if (mms) {
err = 0;
*resp = htsmsg_create_map();
- mpegts_mux_sched_save(mms);
+ idnode_changed(&mms->mms_id);
} else {
err = EINVAL;
}
if (strcmp(page, config.wizard ?: "")) {
free(config.wizard);
config.wizard = page[0] ? strdup(page) : NULL;
- config_save();
+ idnode_changed(&config.idnode);
}
pthread_mutex_unlock(&global_lock);
return 0;
tvhwarn("bouquet", "bouquet name '%s' changed to '%s'", bq->bq_name ?: "", name);
free(bq->bq_name);
bq->bq_name = strdup(name);
- bouquet_save(bq, 1);
+ idnode_changed(&bq->bq_id);
}
return bq;
}
ct = channel_tag_find_by_name(buf, create);
if (ct) {
bq->bq_chtag_ptr = ct;
- bouquet_save(bq, 0);
+ idnode_changed(&bq->bq_id);
}
return ct;
}
else
ch = (channel_t *)ilm->ilm_in2;
if (ch && bq->bq_chtag)
- if (channel_tag_map(bouquet_tag(bq, 1), ch, ch)) {
- idnode_notify_changed(&ch->ch_id);
- channel_save(ch);
- }
+ if (channel_tag_map(bouquet_tag(bq, 1), ch, ch))
+ idnode_changed(&ch->ch_id);
}
/*
bq->bq_active_services = idnode_set_create(1);
save:
- if (bq->bq_saveflag)
- bouquet_save(bq, 1);
+ if (bq->bq_saveflag) {
+ bq->bq_saveflag = 0;
+ idnode_changed(&bq->bq_id);
+ }
}
/*
} else {
idnode_set_free(bq->bq_services);
bq->bq_services = idnode_set_create(1);
- bouquet_save(bq, 1);
+ idnode_changed(&bq->bq_id);
}
}
-/**
- *
- */
-void
-bouquet_save(bouquet_t *bq, int notify)
-{
- htsmsg_t *c = htsmsg_create_map();
- char ubuf[UUID_HEX_SIZE];
- idnode_save(&bq->bq_id, c);
- hts_settings_save(c, "bouquet/%s", idnode_uuid_as_str(&bq->bq_id, ubuf));
- if (bq->bq_shield)
- htsmsg_add_bool(c, "shield", 1);
- htsmsg_destroy(c);
- bq->bq_saveflag = 0;
- if (notify)
- idnode_notify_changed(&bq->bq_id);
-}
-
/**
*
*/
* Class definition
* **************************************************************************/
-static void
-bouquet_class_save(idnode_t *self)
+static htsmsg_t *
+bouquet_class_save(idnode_t *self, char *filename, size_t fsize)
{
- bouquet_save((bouquet_t *)self, 0);
+ bouquet_t *bq = (bouquet_t *)self;
+ htsmsg_t *c = htsmsg_create_map();
+ char ubuf[UUID_HEX_SIZE];
+ idnode_save(&bq->bq_id, c);
+ snprintf(filename, fsize, "bouquet/%s", idnode_uuid_as_str(&bq->bq_id, ubuf));
+ if (bq->bq_shield)
+ htsmsg_add_bool(c, "shield", 1);
+ bq->bq_saveflag = 0;
+ return c;
}
static void
uint64_t bouquet_get_channel_number(bouquet_t *bq, service_t *t);
-void bouquet_save(bouquet_t *bq, int notify);
-
/**
*
*/
* *************************************************************************/
static void
-channel_class_save ( idnode_t *self )
+channel_class_changed ( idnode_t *self )
{
- channel_save((channel_t *)self);
+ channel_t *ch = (channel_t *)self;
+
+ /* update the EPG channel <-> channel mapping here */
+ if (ch->ch_enabled && ch->ch_epgauto)
+ epggrab_channel_add(ch);
+}
+
+static htsmsg_t *
+channel_class_save ( idnode_t *self, char *filename, size_t fsize )
+{
+ channel_t *ch = (channel_t *)self;
+ htsmsg_t *c = NULL;
+ char ubuf[UUID_HEX_SIZE];
+ /* save channel (on demand) */
+ if (ch->ch_dont_save == 0) {
+ c = htsmsg_create_map();
+ idnode_save(&ch->ch_id, c);
+ snprintf(filename, fsize, "channel/config/%s", idnode_uuid_as_str(&ch->ch_id, ubuf));
+ }
+ return c;
}
static void
.ic_class = "channel",
.ic_caption = N_("Channel"),
.ic_event = "channel",
+ .ic_changed = channel_class_changed,
.ic_save = channel_class_save,
.ic_get_title = channel_class_get_title,
.ic_delete = channel_class_delete,
if (strncmp(icn, "picon://", 8) == 0) continue;
if (check_file(icn)) {
icon = ch->ch_icon = strdup(icn);
- channel_save(ch);
- idnode_notify_changed(&ch->ch_id);
+ idnode_changed(&ch->ch_id);
goto found;
}
}
if (i > 1 || check_file(buf)) {
icon = ch->ch_icon = strdup(buf);
- channel_save(ch);
- idnode_notify_changed(&ch->ch_id);
+ idnode_changed(&ch->ch_id);
}
}
snprintf(buf2, sizeof(buf2), "%s/%s", picon, icn+8);
if (i > 1 || check_file(buf2)) {
icon = ch->ch_icon = strdup(icn);
- channel_save(ch);
- idnode_notify_changed(&ch->ch_id);
+ idnode_changed(&ch->ch_id);
break;
}
}
if (delconf) {
free(ch1->ch_epg_parent);
ch1->ch_epg_parent = NULL;
- channel_save(ch1);
+ idnode_changed(&ch1->ch_id);
}
}
free(ch);
}
-/*
- * Save
- */
-void
-channel_save ( channel_t *ch )
-{
- htsmsg_t *c;
- char ubuf[UUID_HEX_SIZE];
- if (ch->ch_dont_save == 0) {
- c = htsmsg_create_map();
- idnode_save(&ch->ch_id, c);
- hts_settings_save(c, "channel/config/%s", idnode_uuid_as_str(&ch->ch_id, ubuf));
- htsmsg_destroy(c);
- }
- /* update the EPG channel <-> channel mapping here */
- if (ch->ch_enabled && ch->ch_epgauto)
- epggrab_channel_add(ch);
-}
-
-
/**
free(ct);
}
-/**
- *
- */
-void
-channel_tag_save(channel_tag_t *ct)
-{
- htsmsg_t *c = htsmsg_create_map();
- char ubuf[UUID_HEX_SIZE];
- idnode_save(&ct->ct_id, c);
- hts_settings_save(c, "channel/tag/%s", idnode_uuid_as_str(&ct->ct_id, ubuf));
- htsmsg_destroy(c);
- htsp_tag_update(ct);
-}
-
-
/**
*
*/
* Channel Tag Class definition
* **************************************************************************/
-static void
-channel_tag_class_save(idnode_t *self)
+static htsmsg_t *
+channel_tag_class_save(idnode_t *self, char *filename, size_t fsize)
{
- channel_tag_save((channel_tag_t *)self);
+ channel_tag_t *ct = (channel_tag_t *)self;
+ htsmsg_t *c = htsmsg_create_map();
+ char ubuf[UUID_HEX_SIZE];
+ idnode_save(&ct->ct_id, c);
+ snprintf(filename, fsize, "channel/tag/%s", idnode_uuid_as_str(&ct->ct_id, ubuf));
+ htsp_tag_update(ct);
+ return c;
}
static void
ct->ct_enabled = 1;
tvh_str_update(&ct->ct_name, name);
- channel_tag_save(ct);
+ idnode_changed(&ct->ct_id);
return ct;
}
static inline channel_tag_t *channel_tag_find_by_uuid(const char *uuid)
{ return (channel_tag_t*)idnode_find(uuid, &channel_tag_class, NULL); }
-void channel_tag_save(channel_tag_t *ct);
-
htsmsg_t * channel_tag_class_get_list(void *o, const char *lang);
const char * channel_tag_get_icon(channel_tag_t *ct);
int channel_tag_access(channel_tag_t *ct, struct access *a, int disabled);
-void channel_save(channel_t *ch);
-
const char *channel_get_name ( channel_t *ch );
int channel_set_name ( channel_t *ch, const char *name );
update:
config.version = v;
tvh_str_set(&config.full_version, tvheadend_version);
- config_save();
+ idnode_changed(&config.idnode);
return 1;
}
config.version = ARRAY_SIZE(config_migrate_table);
tvh_str_set(&config.full_version, tvheadend_version);
tvh_str_set(&config.server_name, "Tvheadend");
- config_save();
+ idnode_changed(&config.idnode);
/* Perform migrations */
} else {
file_unlock(config_lock, config_lock_fd);
}
-void config_save ( void )
+/* **************************************************************************
+ * Config Class
+ * *************************************************************************/
+
+static htsmsg_t *
+config_class_save(idnode_t *self, char *filename, size_t fsize)
{
htsmsg_t *c = htsmsg_create_map();
idnode_save(&config.idnode, c);
#if ENABLE_SATIP_SERVER
idnode_save(&satip_server_conf.idnode, c);
#endif
- hts_settings_save(c, "config");
- htsmsg_destroy(c);
-}
-
-/* **************************************************************************
- * Config Class
- * *************************************************************************/
-
-static void config_class_save(idnode_t *self)
-{
- config_save();
+ snprintf(filename, fsize, "config");
+ return c;
}
static int
void config_boot ( const char *path, gid_t gid, uid_t uid );
void config_init ( int backup );
void config_done ( void );
-void config_save ( void );
const char *config_get_server_name ( void );
const char *config_get_language ( void );
struct caclient_entry_queue caclients;
static pthread_mutex_t caclients_mutex;
-static void caclient_class_save ( idnode_t *in );
-
static const idclass_t *
caclient_class_find(const char *name)
{
TAILQ_FOREACH(cac, &caclients, cac_link)
if (cac->cac_save) {
cac->cac_save = 0;
- caclient_class_save((idnode_t *)cac);
+ idnode_changed((idnode_t *)cac);
}
}
}
pthread_mutex_unlock(&caclients_mutex);
if (save)
- caclient_class_save((idnode_t *)cac);
+ idnode_changed((idnode_t *)cac);
cac->cac_conf_changed(cac);
return cac;
}
}
static void
-caclient_class_save ( idnode_t *in )
+caclient_class_changed ( idnode_t *in )
{
- char ubuf[UUID_HEX_SIZE];
caclient_t *cac = (caclient_t *)in;
+ cac->cac_conf_changed(cac);
+}
+
+static htsmsg_t *
+caclient_class_save ( idnode_t *in, char *filename, size_t fsize )
+{
+ char ubuf[UUID_HEX_SIZE];
htsmsg_t *c = htsmsg_create_map();
idnode_save(in, c);
- hts_settings_save(c, "caclient/%s", idnode_uuid_as_str(in, ubuf));
- htsmsg_destroy(c);
- cac->cac_conf_changed(cac);
+ snprintf(filename, fsize, "caclient/%s", idnode_uuid_as_str(in, ubuf));
+ return c;
}
static const char *
{
.ic_class = "caclient",
.ic_caption = N_("Conditional access client"),
+ .ic_changed = caclient_class_changed,
.ic_save = caclient_class_save,
.ic_event = "caclient",
.ic_get_title = caclient_class_get_title,
void dvr_config_delete(const char *name);
-void dvr_config_save(dvr_config_t *cfg);
-
void dvr_config_destroy_by_profile(profile_t *pro, int delconf);
static inline uint32_t dvr_retention_cleanup(uint32_t val)
void dvr_entry_done(void);
-void dvr_entry_save(dvr_entry_t *de);
-
void dvr_entry_destroy_by_config(dvr_config_t *cfg, int delconf);
int dvr_entry_set_state(dvr_entry_t *de, dvr_entry_sched_state_t state,
const char *owner, const char *creator,
const char *comment);
-void dvr_autorec_save(dvr_autorec_entry_t *dae);
-
void dvr_autorec_changed(dvr_autorec_entry_t *dae, int purge);
static inline dvr_autorec_entry_t *
{ return (dvr_timerec_entry_t*)idnode_find(uuid, &dvr_timerec_entry_class, NULL); }
-void dvr_timerec_save(dvr_timerec_entry_t *dae);
-
void dvr_timerec_check(dvr_timerec_entry_t *dae);
void timerec_destroy_by_config(dvr_config_t *cfg, int delconf);
}
dvr_entry_cancel(de, 0);
} else
- dvr_entry_save(de);
+ idnode_changed(&de->de_id);
}
if (bcast)
bcast[i] = NULL;
dae = dvr_autorec_create(NULL, conf);
htsmsg_destroy(conf);
- if (dae) {
- dvr_autorec_save(dae);
- dvr_autorec_changed(dae, 1);
- }
+ if (dae)
+ idnode_changed(&dae->dae_id);
return dae;
}
dvr_autorec_update_htsp(dvr_autorec_entry_t *dae, htsmsg_t *conf)
{
idnode_update(&dae->dae_id, conf);
- dvr_autorec_save(dae);
- dvr_autorec_changed(dae, 1);
+ idnode_changed(&dae->dae_id);
tvhlog(LOG_INFO, "autorec", "\"%s\" on \"%s\": Updated", dae->dae_title ? dae->dae_title : "",
(dae->dae_channel && dae->dae_channel->ch_name) ? dae->dae_channel->ch_name : "any channel");
}
free(dae);
}
-/**
- *
- */
-void
-dvr_autorec_save(dvr_autorec_entry_t *dae)
-{
- htsmsg_t *m = htsmsg_create_map();
- char ubuf[UUID_HEX_SIZE];
-
- lock_assert(&global_lock);
-
- idnode_save(&dae->dae_id, m);
- hts_settings_save(m, "dvr/autorec/%s", idnode_uuid_as_str(&dae->dae_id, ubuf));
- htsmsg_destroy(m);
-}
-
/* **************************************************************************
* DVR Autorec Entry Class definition
* **************************************************************************/
static void
-dvr_autorec_entry_class_save(idnode_t *self)
+dvr_autorec_entry_class_changed(idnode_t *self)
{
dvr_autorec_entry_t *dae = (dvr_autorec_entry_t *)self;
- dvr_autorec_save(dae);
+
dvr_autorec_changed(dae, 1);
dvr_autorec_completed(dae, 0);
htsp_autorec_entry_update(dae);
}
+static htsmsg_t *
+dvr_autorec_entry_class_save(idnode_t *self, char *filename, size_t fsize)
+{
+ dvr_autorec_entry_t *dae = (dvr_autorec_entry_t *)self;
+ htsmsg_t *m = htsmsg_create_map();
+ char ubuf[UUID_HEX_SIZE];
+ idnode_save(&dae->dae_id, m);
+ snprintf(filename, fsize, "dvr/autorec/%s", idnode_uuid_as_str(&dae->dae_id, ubuf));
+ return m;
+}
+
static void
dvr_autorec_entry_class_delete(idnode_t *self)
{
.ic_class = "dvrautorec",
.ic_caption = N_("DVR Auto-record entry"),
.ic_event = "dvrautorec",
+ .ic_changed = dvr_autorec_entry_class_changed,
.ic_save = dvr_autorec_entry_class_save,
.ic_get_title = dvr_autorec_entry_class_get_title,
.ic_delete = dvr_autorec_entry_class_delete,
dae->dae_channel_tag = NULL;
idnode_notify_changed(&dae->dae_id);
if (delconf)
- dvr_autorec_save(dae);
+ idnode_changed(&dae->dae_id);
}
}
LIST_INSERT_HEAD(&cfg->dvr_autorec_entries, dae, dae_config_link);
dae->dae_config = cfg;
if (delconf)
- dvr_autorec_save(dae);
+ idnode_changed(&dae->dae_id);
}
}
if (dvrdefaultconfig == NULL) {
cfg = dvr_config_create("", NULL, NULL);
assert(cfg);
- dvr_config_save(cfg);
+ idnode_changed(&cfg->dvr_id);
dvrdefaultconfig = cfg;
}
tvhwarn("dvr", "Attempt to delete default config ignored");
}
-/*
- *
- */
-void
-dvr_config_save(dvr_config_t *cfg)
-{
- htsmsg_t *m = htsmsg_create_map();
- char ubuf[UUID_HEX_SIZE];
-
- lock_assert(&global_lock);
-
- dvr_config_storage_check(cfg);
- if (cfg->dvr_cleanup_threshold_free < 50)
- cfg->dvr_cleanup_threshold_free = 50; // as checking is only periodically, lower is not save
- if (cfg->dvr_removal_days != DVR_RET_FOREVER &&
- cfg->dvr_removal_days > cfg->dvr_retention_days)
- cfg->dvr_retention_days = DVR_RET_ONREMOVE;
- if (cfg->dvr_removal_days > DVR_RET_FOREVER)
- cfg->dvr_removal_days = DVR_RET_FOREVER;
- if (cfg->dvr_retention_days > DVR_RET_FOREVER)
- cfg->dvr_retention_days = DVR_RET_FOREVER;
- idnode_save(&cfg->dvr_id, m);
- hts_settings_save(m, "dvr/config/%s", idnode_uuid_as_str(&cfg->dvr_id, ubuf));
- htsmsg_destroy(m);
-}
-
/* **************************************************************************
* DVR Config Class definition
* **************************************************************************/
static void
-dvr_config_class_save(idnode_t *self)
+dvr_config_class_changed(idnode_t *self)
{
dvr_config_t *cfg = (dvr_config_t *)self;
if (dvr_config_is_default(cfg))
} else {
dvr_update_pathname_from_booleans(cfg);
}
- dvr_config_save(cfg);
+ dvr_config_storage_check(cfg);
+ if (cfg->dvr_cleanup_threshold_free < 50)
+ cfg->dvr_cleanup_threshold_free = 50; // as checking is only periodically, lower is not save
+ if (cfg->dvr_removal_days != DVR_RET_FOREVER &&
+ cfg->dvr_removal_days > cfg->dvr_retention_days)
+ cfg->dvr_retention_days = DVR_RET_ONREMOVE;
+ if (cfg->dvr_removal_days > DVR_RET_FOREVER)
+ cfg->dvr_removal_days = DVR_RET_FOREVER;
+ if (cfg->dvr_retention_days > DVR_RET_FOREVER)
+ cfg->dvr_retention_days = DVR_RET_FOREVER;
+}
+
+static htsmsg_t *
+dvr_config_class_save(idnode_t *self, char *filename, size_t fsize)
+{
+ dvr_config_t *cfg = (dvr_config_t *)self;
+ htsmsg_t *m = htsmsg_create_map();
+ char ubuf[UUID_HEX_SIZE];
+ idnode_save(&cfg->dvr_id, m);
+ snprintf(filename, fsize, "dvr/config/%s", idnode_uuid_as_str(&cfg->dvr_id, ubuf));
+ return m;
}
static void
.ic_class = "dvrconfig",
.ic_caption = N_("DVR configuration profile"),
.ic_event = "dvrconfig",
+ .ic_changed = dvr_config_class_changed,
.ic_save = dvr_config_class_save,
.ic_get_title = dvr_config_class_get_title,
.ic_delete = dvr_config_class_delete,
dont_rerecord = dont_rerecord ? 1 : 0;
if (de->de_dont_rerecord ? 1 : 0 != dont_rerecord) {
de->de_dont_rerecord = dont_rerecord;
- dvr_entry_save(de);
+ idnode_changed(&de->de_id);
idnode_notify_changed(&de->de_id);
htsp_dvr_entry_update(de);
}
if (parent->de_child) {
p = parent->de_child->de_parent;
parent->de_child->de_parent = NULL;
- if (save && p && p != origin) dvr_entry_save(p);
+ if (save && p && p != origin) idnode_changed(&p->de_id);
parent->de_child = NULL;
- if (save && origin != parent) dvr_entry_save(parent);
+ if (save && origin != parent) idnode_changed(&parent->de_id);
return 1;
}
return 0;
if (child->de_parent) {
p = child->de_parent->de_child;
child->de_parent->de_child = NULL;
- if (save && p && p != origin) dvr_entry_save(p);
+ if (save && p && p != origin) idnode_changed(&p->de_id);
child->de_parent = NULL;
- if (save && origin != child) dvr_entry_save(child);
+ if (save && origin != child) idnode_changed(&child->de_id);
return 1;
}
return 0;
if (parent->de_child) {
p = parent->de_child->de_parent;
parent->de_child->de_parent = NULL;
- if (save && p) dvr_entry_save(p);
+ if (save && p) idnode_changed(&p->de_id);
}
if (child->de_parent) {
p = child->de_parent->de_child;
child->de_parent->de_child = NULL;
- if (save && p) dvr_entry_save(p);
+ if (save && p) idnode_changed(&p->de_id);
}
parent->de_child = child;
child->de_parent = parent;
- if (save && origin != parent) dvr_entry_save(parent);
- if (save && origin != child) dvr_entry_save(child);
+ if (save && origin != parent) idnode_changed(&parent->de_id);
+ if (save && origin != child) idnode_changed(&child->de_id);
return 1;
}
return;
}
if (save)
- dvr_entry_save(de);
+ idnode_changed(&de->de_id);
}
if (retention < DVR_RET_ONREMOVE) {
idnode_uuid_as_str(&de->de_id, ubuf),
lang_str_get(de->de_title, NULL), DVR_CH_NAME(de), tbuf, creator ?: "");
- dvr_entry_save(de);
+ idnode_changed(&de->de_id);
return de;
}
} else {
dvr_entry_set_timer(n);
}
- dvr_entry_save(n);
+ idnode_changed(&n->de_id);
}
return n == NULL ? de : n;
} else {
/* we have already queued similar recordings, mark as resolved */
de->de_dont_rerecord = 1;
- dvr_entry_save(de);
+ idnode_changed(&de->de_id);
}
return 0;
if (def)
LIST_INSERT_HEAD(&def->dvr_entries, de, de_config_link);
if (delconf)
- dvr_entry_save(de);
- }
-}
-
-/**
- *
- */
-void
-dvr_entry_save(dvr_entry_t *de)
-{
- htsmsg_t *m = htsmsg_create_map(), *e, *l, *c, *info;
- htsmsg_field_t *f;
- char ubuf[UUID_HEX_SIZE];
- const char *filename;
-
- lock_assert(&global_lock);
-
- idnode_save(&de->de_id, m);
- if (de->de_files) {
- l = htsmsg_create_list();
- HTSMSG_FOREACH(f, de->de_files)
- if ((e = htsmsg_field_get_map(f)) != NULL) {
- filename = htsmsg_get_str(e, "filename");
- info = htsmsg_get_list(e, "info");
- if (filename) {
- c = htsmsg_create_map();
- htsmsg_add_str(c, "filename", filename);
- if (info)
- htsmsg_add_msg(c, "info", htsmsg_copy(info));
- htsmsg_add_msg(l, NULL, c);
- }
- }
- htsmsg_add_msg(m, "files", l);
+ idnode_changed(&de->de_id);
}
- hts_settings_save(m, "dvr/log/%s", idnode_uuid_as_str(&de->de_id, ubuf));
- htsmsg_destroy(m);
}
-
/**
*
*/
if (de->de_bcast != e)
continue;
dvr_entry_assign_broadcast(de, NULL);
- dvr_entry_save(de);
+ idnode_changed(&de->de_id);
}
}
return;
if (saveconf)
- dvr_entry_save(de);
+ idnode_changed(&de->de_id);
dvr_entry_retention_timer(de);
* **************************************************************************/
static void
-dvr_entry_class_save(idnode_t *self)
+dvr_entry_class_changed(idnode_t *self)
{
dvr_entry_t *de = (dvr_entry_t *)self;
- dvr_entry_save(de);
if (dvr_entry_is_valid(de))
dvr_entry_set_timer(de);
-
htsp_dvr_entry_update(de);
}
+static htsmsg_t *
+dvr_entry_class_save(idnode_t *self, char *filename, size_t fsize)
+{
+ dvr_entry_t *de = (dvr_entry_t *)self;
+ htsmsg_t *m = htsmsg_create_map(), *e, *l, *c, *info;
+ htsmsg_field_t *f;
+ char ubuf[UUID_HEX_SIZE];
+ const char *filename2;
+
+ idnode_save(&de->de_id, m);
+ if (de->de_files) {
+ l = htsmsg_create_list();
+ HTSMSG_FOREACH(f, de->de_files)
+ if ((e = htsmsg_field_get_map(f)) != NULL) {
+ filename2 = htsmsg_get_str(e, "filename");
+ info = htsmsg_get_list(e, "info");
+ if (filename2) {
+ c = htsmsg_create_map();
+ htsmsg_add_str(c, "filename", filename2);
+ if (info)
+ htsmsg_add_msg(c, "info", htsmsg_copy(info));
+ htsmsg_add_msg(l, NULL, c);
+ }
+ }
+ htsmsg_add_msg(m, "files", l);
+ }
+ snprintf(filename, fsize, "dvr/log/%s", idnode_uuid_as_str(&de->de_id, ubuf));
+ return m;
+}
+
static void
dvr_entry_class_delete(idnode_t *self)
{
.ic_class = "dvrentry",
.ic_caption = N_("DVR entry"),
.ic_event = "dvrentry",
+ .ic_changed = dvr_entry_class_changed,
.ic_save = dvr_entry_class_save,
.ic_get_title = dvr_entry_class_get_title,
.ic_delete = dvr_entry_class_delete,
if (to) {
snprintf(path, sizeof(path), "%s/%s", die->path, to);
htsmsg_set_str(m, "filename", path);
- dvr_entry_save(de);
+ idnode_changed(&de->de_id);
} else {
htsmsg_field_destroy(de->de_files, f);
if (htsmsg_is_empty(de->de_files))
if (de->de_sched_state == DVR_SCHEDULED)
dvr_entry_cancel(de, 0);
else
- dvr_entry_save(de);
+ idnode_changed(&de->de_id);
}
}
}
dte = dvr_timerec_create(NULL, conf);
htsmsg_destroy(conf);
- if (dte) {
- dvr_timerec_save(dte);
- dvr_timerec_check(dte);
- }
+ if (dte)
+ idnode_changed(&dte->dte_id);
return dte;
}
dvr_timerec_update_htsp (dvr_timerec_entry_t *dte, htsmsg_t *conf)
{
idnode_update(&dte->dte_id, conf);
- dvr_timerec_save(dte);
- dvr_timerec_check(dte);
- htsp_timerec_entry_update(dte);
+ idnode_changed(&dte->dte_id);
tvhlog(LOG_INFO, "timerec", "\"%s\" on \"%s\": Updated", dte->dte_title ? dte->dte_title : "",
(dte->dte_channel && dte->dte_channel->ch_name) ? dte->dte_channel->ch_name : "any channel");
}
free(dte);
}
-/**
- *
- */
-void
-dvr_timerec_save(dvr_timerec_entry_t *dte)
-{
- htsmsg_t *m = htsmsg_create_map();
- char ubuf[UUID_HEX_SIZE];
-
- lock_assert(&global_lock);
-
- idnode_save(&dte->dte_id, m);
- hts_settings_save(m, "dvr/timerec/%s", idnode_uuid_as_str(&dte->dte_id, ubuf));
- htsmsg_destroy(m);
-}
-
/* **************************************************************************
* DVR Autorec Entry Class definition
* **************************************************************************/
static void
-dvr_timerec_entry_class_save(idnode_t *self)
+dvr_timerec_entry_class_changed(idnode_t *self)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)self;
- dvr_timerec_save(dte);
dvr_timerec_check(dte);
htsp_timerec_entry_update(dte);
}
+static htsmsg_t *
+dvr_timerec_entry_class_save(idnode_t *self, char *filename, size_t fsize)
+{
+ dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)self;
+ htsmsg_t *m = htsmsg_create_map();
+ char ubuf[UUID_HEX_SIZE];
+ idnode_save(&dte->dte_id, m);
+ snprintf(filename, fsize, "dvr/timerec/%s", idnode_uuid_as_str(&dte->dte_id, ubuf));
+ return m;
+}
+
static void
dvr_timerec_entry_class_delete(idnode_t *self)
{
.ic_class = "dvrtimerec",
.ic_caption = N_("DVR time record entry"),
.ic_event = "dvrtimerec",
+ .ic_changed = dvr_timerec_entry_class_changed,
.ic_save = dvr_timerec_entry_class_save,
.ic_get_title = dvr_timerec_entry_class_get_title,
.ic_delete = dvr_timerec_entry_class_delete,
LIST_INSERT_HEAD(&cfg->dvr_timerec_entries, dte, dte_config_link);
dte->dte_config = cfg;
if (delconf)
- dvr_timerec_save(dte);
+ idnode_changed(&dte->dte_id);
}
}
dvr_entry_destroy(oldest, 1); // also delete database entry
} else {
if (dvr_entry_delete(oldest)) // delete actual file
- dvr_entry_save(oldest);
+ idnode_changed(&oldest->de_id);
}
} else {
tvhlog(LOG_WARNING, "dvr", "%s \"until space needed\" recordings found for config \"%s\", you are running out of disk space very soon!",
xmltv_load();
}
-void epggrab_save ( void )
-{
- epggrab_module_t *mod;
- htsmsg_t *m, *a;
+/* **************************************************************************
+ * Class
+ * *************************************************************************/
+static void
+epggrab_class_changed(idnode_t *self)
+{
/* Register */
epggrab_confver++;
pthread_cond_signal(&epggrab_cond);
+}
+
+static htsmsg_t *
+epggrab_class_save(idnode_t *self, char *filename, size_t fsize)
+{
+ epggrab_module_t *mod;
+ htsmsg_t *m, *a;
/* Save */
m = htsmsg_create_map();
htsmsg_add_msg(a, mod->id, m);
}
htsmsg_add_msg(m, "modules", a);
- hts_settings_save(m, "epggrab/config");
- htsmsg_destroy(m);
-}
-
-/* **************************************************************************
- * Class
- * *************************************************************************/
-
-static void epggrab_class_save(idnode_t *self)
-{
- epggrab_save();
+ snprintf(filename, fsize, "epggrab/config");
+ return m;
}
epggrab_conf_t epggrab_conf = {
.ic_caption = N_("EPG grabber configuration"),
.ic_event = "epggrab",
.ic_perm_def = ACCESS_ADMIN,
+ .ic_changed = epggrab_class_changed,
.ic_save = epggrab_class_save,
.ic_groups = (const property_group_t[]) {
{
*/
void epggrab_init ( void );
void epggrab_done ( void );
-void epggrab_save ( void );
void epggrab_ota_init ( void );
void epggrab_ota_post ( void );
void epggrab_ota_shutdown ( void );
if (ec->icon && epggrab_conf.channel_reicon)
save |= channel_set_icon(ch, ec->icon);
if (save)
- channel_save(ch);
+ idnode_changed(&ch->ch_id);
if (origin == NULL)
- epggrab_channel_save(ec);
+ idnode_changed(&ec->idnode);
return 1;
}
LIST_FOREACH(ilm, &ec->channels, ilm_in1_link) {
ch = (channel_t *)ilm->ilm_in2;
if (channel_set_name(ch, name))
- channel_save(ch);
+ idnode_changed(&ch->ch_id);
}
}
save = 1;
LIST_FOREACH(ilm, &ec->channels, ilm_in1_link) {
ch = (channel_t *)ilm->ilm_in2;
if (channel_set_icon(ch, icon))
- channel_save(ch);
+ idnode_changed(&ch->ch_id);
}
}
save = 1;
if (channel_set_number(ch,
lcn / CHANNEL_SPLIT,
lcn % CHANNEL_SPLIT))
- channel_save(ch);
+ idnode_changed(&ch->ch_id);
}
}
save = 1;
epggrab_channel_autolink(ec);
/* Save */
- epggrab_channel_save(ec);
+ idnode_changed(&ec->idnode);
}
/* ID comparison */
return ec;
}
-void epggrab_channel_save( epggrab_channel_t *ec )
-{
- htsmsg_t *m = htsmsg_create_map();
- char ubuf[UUID_HEX_SIZE];
- idnode_save(&ec->idnode, m);
- hts_settings_save(m, "epggrab/%s/channels/%s",
- ec->mod->saveid, idnode_uuid_as_str(&ec->idnode, ubuf));
- htsmsg_destroy(m);
-}
-
void epggrab_channel_destroy( epggrab_channel_t *ec, int delconf, int rb_remove )
{
char ubuf[UUID_HEX_SIZE];
return prop_sbuf;
}
-static void
-epggrab_channel_class_save(idnode_t *self)
+static htsmsg_t *
+epggrab_channel_class_save(idnode_t *self, char *filename, size_t fsize)
{
- epggrab_channel_save((epggrab_channel_t *)self);
+ epggrab_channel_t *ec = (epggrab_channel_t *)self;
+ htsmsg_t *m = htsmsg_create_map();
+ char ubuf[UUID_HEX_SIZE];
+ idnode_save(&ec->idnode, m);
+ snprintf(filename, fsize, "epggrab/%s/channels/%s",
+ ec->mod->saveid, idnode_uuid_as_str(&ec->idnode, ubuf));
+ return m;
}
static void
return prop_sbuf;
}
-static void epggrab_mod_class_save(idnode_t *self)
+static void
+epggrab_mod_class_changed(idnode_t *self)
{
epggrab_module_t *mod = (epggrab_module_t *)self;
epggrab_activate_module(mod, mod->enabled);
- epggrab_save();
+ idnode_changed(&epggrab_conf.idnode);
}
static const void *epggrab_mod_class_type_get(void *o)
.ic_event = "epggrab_mod",
.ic_perm_def = ACCESS_ADMIN,
.ic_get_title = epggrab_mod_class_title,
- .ic_save = epggrab_mod_class_save,
+ .ic_changed = epggrab_mod_class_changed,
.ic_groups = (const property_group_t[]) {
{
.name = N_("Settings"),
struct esfilter_entry_queue esfilters[ESF_CLASS_LAST + 1];
-static void esfilter_class_save(idnode_t *self);
-
/*
* Class masks
*/
TAILQ_FOREACH(esf, &esfilters[cls], esf_link)
if (esf->esf_save) {
esf->esf_save = 0;
- esfilter_class_save((idnode_t *)esf);
+ idnode_changed(&esf->esf_id);
}
}
if (!conf)
esfilter_reindex(esf->esf_class);
if (save)
- esfilter_class_save((idnode_t *)esf);
+ idnode_changed(&esf->esf_id);
return esf;
}
* Class functions
*/
-static void
-esfilter_class_save(idnode_t *self)
+static htsmsg_t *
+esfilter_class_save(idnode_t *self, char *filename, size_t fsize)
{
htsmsg_t *c = htsmsg_create_map();
char ubuf[UUID_HEX_SIZE];
idnode_save(self, c);
- hts_settings_save(c, "esfilter/%s", idnode_uuid_as_str(self, ubuf));
- htsmsg_destroy(c);
+ snprintf(filename, fsize, "esfilter/%s", idnode_uuid_as_str(self, ubuf));
+ return c;
}
static const char *
RB_REMOVE(in->in_domain, in, in_domain_link);
tvhtrace("idnode", "unlink node %s", idnode_uuid_as_str(in, ubuf));
idnode_notify(in, "delete");
+
+ if (in->in_save) {
+ TAILQ_REMOVE(&idnodes_save, in->in_save, ise_link);
+ in->in_save = NULL;
+ }
}
/**
}
static void
-idnode_savefn ( idnode_t *self )
+idnode_changedfn ( idnode_t *self )
{
const idclass_t *idc = self->in_class;
while (idc) {
- if (idc->ic_save) {
- idc->ic_save(self);
+ if (idc->ic_changed) {
+ idc->ic_changed(self);
break;
}
idc = idc->ic_super;
}
}
+static htsmsg_t *
+idnode_savefn ( idnode_t *self, char *filename, size_t fsize )
+{
+ const idclass_t *idc = self->in_class;
+ while (idc) {
+ if (idc->ic_save)
+ return idc->ic_save(self, filename, fsize);
+ idc = idc->ic_super;
+ }
+ return NULL;
+}
+
static void
idnode_save_queue ( idnode_t *self )
{
int save = 0;
const idclass_t *idc = self->in_class;
save = idnode_class_write_values(self, idc, c, optmask);
- if ((idc->ic_flags & IDCLASS_ALWAYS_SAVE) != 0 || (save && dosave))
+ if ((idc->ic_flags & IDCLASS_ALWAYS_SAVE) != 0 || (save && dosave)) {
+ idnode_changedfn(self);
idnode_save_queue(self);
+ }
if (dosave)
idnode_notify_changed(self);
// Note: always output event if "dosave", reason is that UI updates on
save_thread ( void *aux )
{
idnode_save_t *ise;
+ htsmsg_t *m;
+ char filename[PATH_MAX];
tvhtread_renice(15);
pthread_cond_wait(&save_cond, &global_lock);
continue;
}
- idnode_savefn(ise->ise_node);
+ m = idnode_savefn(ise->ise_node, filename, sizeof(filename));
ise->ise_node->in_save = NULL;
TAILQ_REMOVE(&idnodes_save, ise, ise_link);
+ pthread_mutex_unlock(&global_lock);
free(ise);
+ if (m) {
+ hts_settings_save(m, "%s", filename);
+ htsmsg_destroy(m);
+ }
+ pthread_mutex_lock(&global_lock);
}
while ((ise = TAILQ_FIRST(&idnodes_save)) != NULL) {
- idnode_savefn(ise->ise_node);
+ m = idnode_savefn(ise->ise_node, filename, sizeof(filename));
ise->ise_node->in_save = NULL;
TAILQ_REMOVE(&idnodes_save, ise, ise_link);
+ pthread_mutex_unlock(&global_lock);
free(ise);
+ if (m) {
+ hts_settings_save(m, "%s", filename);
+ htsmsg_destroy(m);
+ }
+ pthread_mutex_lock(&global_lock);
}
pthread_mutex_unlock(&global_lock);
/* Callbacks */
idnode_set_t *(*ic_get_childs) (idnode_t *self);
const char *(*ic_get_title) (idnode_t *self, const char *lang);
- void (*ic_save) (idnode_t *self);
+ void (*ic_changed) (idnode_t *self);
+ htsmsg_t *(*ic_save) (idnode_t *self, char *filename, size_t fsize);
void (*ic_delete) (idnode_t *self);
void (*ic_moveup) (idnode_t *self);
void (*ic_movedown) (idnode_t *self);
.idnode.in_class = &imagecache_class,
};
-static void imagecache_save(idnode_t *self);
+static htsmsg_t *imagecache_save(idnode_t *self, char *filename, size_t fsize);
const idclass_t imagecache_class = {
.ic_snode = (idnode_t *)&imagecache_conf,
/*
* Save
*/
-static void
-imagecache_save ( idnode_t *self )
+static htsmsg_t *
+imagecache_save ( idnode_t *self, char *filename, size_t fsize )
{
htsmsg_t *c = htsmsg_create_map();
idnode_save(&imagecache_conf.idnode, c);
- hts_settings_save(c, "imagecache/config");
- htsmsg_destroy(c);
+ snprintf(filename, fsize, "imagecache/config");
pthread_cond_broadcast(&imagecache_cond);
+ return c;
}
/*
*/
void (*mn_delete) (mpegts_network_t*, int delconf);
void (*mn_display_name) (mpegts_network_t*, char *buf, size_t len);
- void (*mn_config_save) (mpegts_network_t*);
+ htsmsg_t * (*mn_config_save) (mpegts_network_t*, char *filename, size_t fsize);
mpegts_mux_t* (*mn_create_mux)
(mpegts_network_t*, void *origin, uint16_t onid, uint16_t tsid,
void *conf, int force);
*/
void (*mm_delete) (mpegts_mux_t *mm, int delconf);
- void (*mm_config_save) (mpegts_mux_t *mm);
+ htsmsg_t *(*mm_config_save) (mpegts_mux_t *mm, char *filename, size_t fsize);
void (*mm_display_name) (mpegts_mux_t*, char *buf, size_t len);
int (*mm_is_enabled) (mpegts_mux_t *mm);
void (*mm_stop) (mpegts_mux_t *mm, int force, int reason);
if (bi)
dvb_bat_find_service(bi, s, 0, UINT_MAX);
if (save)
- s->s_config_save((service_t*)s);
+ idnode_changed(&s->s_id);
}
}
return 0;
s->s_dvb_channel_num != lcn) {
s->s_dvb_channel_dtag = dtag;
s->s_dvb_channel_num = lcn;
- s->s_config_save((service_t*)s);
+ idnode_changed(&s->s_id);
service_refresh_channel((service_t*)s);
}
}
tvhdebug(mt->mt_name, "network %04X (%d) [%s]", nbid, nbid, name);
save |= mpegts_network_set_network_name(mn, name);
if (save)
- mn->mn_config_save(mn);
+ idnode_changed(&mn->mn_id);
if (mpegts_mux_set_network_name(mm, name))
- mm->mm_config_save(mm);
+ idnode_changed(&mm->mm_id);
}
/* Transport length */
/* Save */
if (save)
- s->s_config_save((service_t*)s);
+ idnode_changed(&s->s_id);
}
/* Move on */
if (bq == NULL)
goto fail;
bq->bq_shield = 1;
- if (bq->bq_saveflag)
- bouquet_save(bq, 1);
+ if (bq->bq_saveflag) {
+ bq->bq_saveflag = 0;
+ idnode_changed(&bq->bq_id);
+ }
fs = RB_INSERT_SORTED(&fastscan_rb, fastscan_rb_skel, link, _fs_cmp);
if (!fs) {
return &iptv_mux_class;
}
-static void
-iptv_network_config_save ( mpegts_network_t *mn )
+static htsmsg_t *
+iptv_network_config_save ( mpegts_network_t *mn, char *filename, size_t fsize )
{
htsmsg_t *c = htsmsg_create_map();
char ubuf[UUID_HEX_SIZE];
idnode_save(&mn->mn_id, c);
- hts_settings_save(c, "input/iptv/networks/%s/config",
- idnode_uuid_as_str(&mn->mn_id, ubuf));
- htsmsg_destroy(c);
+ snprintf(filename, fsize, "input/iptv/networks/%s/config",
+ idnode_uuid_as_str(&mn->mn_id, ubuf));
+ return c;
}
iptv_network_t *
htsmsg_destroy(conf);
if (im) {
- im->mm_config_save((mpegts_mux_t *)im);
+ idnode_changed(&im->mm_id);
(*total)++;
(*count)++;
}
}
};
-static void
-iptv_mux_config_save ( mpegts_mux_t *mm )
+static htsmsg_t *
+iptv_mux_config_save ( mpegts_mux_t *mm, char *filename, size_t fsize )
{
char ubuf1[UUID_HEX_SIZE];
char ubuf2[UUID_HEX_SIZE];
htsmsg_t *c = htsmsg_create_map();
mpegts_mux_save(mm, c);
- hts_settings_save(c, "input/iptv/networks/%s/muxes/%s/config",
- idnode_uuid_as_str(&mm->mm_network->mn_id, ubuf1),
- idnode_uuid_as_str(&mm->mm_id, ubuf2));
- htsmsg_destroy(c);
+ snprintf(filename, fsize, "input/iptv/networks/%s/muxes/%s/config",
+ idnode_uuid_as_str(&mm->mm_network->mn_id, ubuf1),
+ idnode_uuid_as_str(&mm->mm_id, ubuf2));
+ return c;
}
static void
extern const idclass_t mpegts_service_class;
-static void
-iptv_service_config_save ( service_t *s )
+static htsmsg_t *
+iptv_service_config_save ( service_t *s, char *filename, size_t fsize )
{
mpegts_mux_t *mm = ((mpegts_service_t *)s)->s_dvb_mux;
htsmsg_t *c = htsmsg_create_map();
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);
+ snprintf(filename, fsize, "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));
+ return c;
}
static void
* DVB Adapter
* **************************************************************************/
-static void
-linuxdvb_adapter_class_save ( idnode_t *in )
+static htsmsg_t *
+linuxdvb_adapter_class_save ( idnode_t *in, char *filename, size_t fsize )
{
linuxdvb_adapter_t *la = (linuxdvb_adapter_t*)in;
- linuxdvb_adapter_save(la);
+ htsmsg_t *m, *l;
+ linuxdvb_frontend_t *lfe;
+#if ENABLE_LINUXDVB_CA
+ linuxdvb_ca_t *lca;
+#endif
+ char ubuf[UUID_HEX_SIZE];
+
+ m = htsmsg_create_map();
+ idnode_save(&la->th_id, m);
+
+ /* Frontends */
+ l = htsmsg_create_map();
+ LIST_FOREACH(lfe, &la->la_frontends, lfe_link)
+ linuxdvb_frontend_save(lfe, l);
+ htsmsg_add_msg(m, "frontends", l);
+
+ /* CAs */
+#if ENABLE_LINUXDVB_CA
+ l = htsmsg_create_map();
+ LIST_FOREACH(lca, &la->la_ca_devices, lca_link)
+ linuxdvb_ca_save(lca, l);
+ htsmsg_add_msg(m, "ca_devices", l);
+#endif
+
+ /* Save */
+ snprintf(filename, fsize, "input/linuxdvb/adapters/%s",
+ idnode_uuid_as_str(&la->th_id, ubuf));
+ return m;
}
static idnode_set_t *
}
};
-/*
- * Save data
- */
-void
-linuxdvb_adapter_save ( linuxdvb_adapter_t *la )
-{
- htsmsg_t *m, *l;
- linuxdvb_frontend_t *lfe;
-#if ENABLE_LINUXDVB_CA
- linuxdvb_ca_t *lca;
-#endif
- char ubuf[UUID_HEX_SIZE];
-
- m = htsmsg_create_map();
- idnode_save(&la->th_id, m);
-
- /* Frontends */
- l = htsmsg_create_map();
- LIST_FOREACH(lfe, &la->la_frontends, lfe_link)
- linuxdvb_frontend_save(lfe, l);
- htsmsg_add_msg(m, "frontends", l);
-
- /* CAs */
-#if ENABLE_LINUXDVB_CA
- l = htsmsg_create_map();
- LIST_FOREACH(lca, &la->la_ca_devices, lca_link)
- linuxdvb_ca_save(lca, l);
- htsmsg_add_msg(m, "ca_devices", l);
-#endif
-
- /* Save */
- hts_settings_save(m, "input/linuxdvb/adapters/%s",
- idnode_uuid_as_str(&la->th_id, ubuf));
- htsmsg_destroy(m);
-}
-
/*
* Check if enabled
*/
/* Save configuration */
if (save && la)
- linuxdvb_adapter_save(la);
+ linuxdvb_adapter_changed(la);
}
static void
}
static void
-linuxdvb_ca_class_save ( idnode_t *in )
+linuxdvb_ca_class_changed ( idnode_t *in )
{
linuxdvb_adapter_t *la = ((linuxdvb_ca_t*)in)->lca_adapter;
- linuxdvb_adapter_save(la);
+ linuxdvb_adapter_changed(la);
}
static void
{
.ic_class = "linuxdvb_ca",
.ic_caption = N_("Linux DVB CA"),
- .ic_save = linuxdvb_ca_class_save,
+ .ic_changed = linuxdvb_ca_class_changed,
.ic_get_title = linuxdvb_ca_class_get_title,
.ic_properties = (const property_t[]) {
{
* *************************************************************************/
static void
-linuxdvb_frontend_class_save ( idnode_t *in )
+linuxdvb_frontend_class_changed ( idnode_t *in )
{
linuxdvb_adapter_t *la = ((linuxdvb_frontend_t*)in)->lfe_adapter;
- linuxdvb_adapter_save(la);
+ linuxdvb_adapter_changed(la);
}
const idclass_t linuxdvb_frontend_class =
.ic_super = &mpegts_input_class,
.ic_class = "linuxdvb_frontend",
.ic_caption = N_("Linux DVB frontend"),
- .ic_save = linuxdvb_frontend_class_save,
+ .ic_changed = linuxdvb_frontend_class_changed,
.ic_properties = (const property_t[]) {
{
.type = PT_STR,
}
if (linuxdvb_frontend_wizard_network(lfe))
mpegts_input_set_enabled((mpegts_input_t *)lfe, 1);
- linuxdvb_adapter_save(lfe->lfe_adapter);
+ linuxdvb_adapter_changed(lfe->lfe_adapter);
} else {
htsmsg_destroy(nlist);
}
void linuxdvb_adapter_done ( void );
-void linuxdvb_adapter_save ( linuxdvb_adapter_t *la );
+static inline void linuxdvb_adapter_changed ( linuxdvb_adapter_t *la )
+ { idnode_changed(&la->th_id); }
int linuxdvb_adapter_current_weight ( linuxdvb_adapter_t *la );
}
static void
-linuxdvb_satconf_class_save ( idnode_t *s )
+linuxdvb_satconf_class_changed ( idnode_t *s )
{
linuxdvb_satconf_t *ls = (linuxdvb_satconf_t*)s;
linuxdvb_frontend_t *lfe = (linuxdvb_frontend_t*)ls->ls_frontend;
linuxdvb_adapter_t *la = lfe->lfe_adapter;
- linuxdvb_adapter_save(la);
+ linuxdvb_adapter_changed(la);
}
static const void *
.ic_caption = N_("DVB-S satellite configuration"),
.ic_event = "linuxdvb_satconf",
.ic_get_title = linuxdvb_satconf_class_get_title,
- .ic_save = linuxdvb_satconf_class_save,
+ .ic_changed = linuxdvb_satconf_class_changed,
.ic_properties = (const property_t[]) {
{
.type = PT_BOOL,
}
static void
-linuxdvb_satconf_ele_class_save ( idnode_t *in )
+linuxdvb_satconf_ele_class_changed ( idnode_t *in )
{
linuxdvb_satconf_ele_t *lse = (linuxdvb_satconf_ele_t*)in;
- linuxdvb_satconf_class_save(&lse->lse_parent->ls_id);
+ linuxdvb_satconf_class_changed(&lse->lse_parent->ls_id);
}
const idclass_t linuxdvb_satconf_ele_class =
.ic_event = "linuxdvb_satconf_ele",
.ic_get_title = linuxdvb_satconf_ele_class_get_title,
.ic_get_childs = linuxdvb_satconf_ele_class_get_childs,
- .ic_save = linuxdvb_satconf_ele_class_save,
+ .ic_changed = linuxdvb_satconf_ele_class_changed,
.ic_properties = (const property_t[]) {
{
.type = PT_BOOL,
}
static void
-linuxdvb_diseqc_class_save ( idnode_t *o )
+linuxdvb_diseqc_class_changed ( idnode_t *o )
{
linuxdvb_diseqc_t *ld = (linuxdvb_diseqc_t*)o;
if (ld->ld_satconf)
- linuxdvb_satconf_ele_class_save(&ld->ld_satconf->lse_id);
+ linuxdvb_satconf_ele_class_changed(&ld->ld_satconf->lse_id);
}
const idclass_t linuxdvb_diseqc_class =
.ic_caption = N_("DiseqC"),
.ic_event = "linuxdvb_diseqc",
.ic_get_title = linuxdvb_diseqc_class_get_title,
- .ic_save = linuxdvb_diseqc_class_save,
+ .ic_changed = linuxdvb_diseqc_class_changed,
};
linuxdvb_diseqc_t *
* Class definition
* ***************************************************************************/
-static void
-mpegts_mux_class_save ( idnode_t *self )
+static htsmsg_t *
+mpegts_mux_class_save ( idnode_t *self, char *filename, size_t fsize )
{
mpegts_mux_t *mm = (mpegts_mux_t*)self;
- if (mm->mm_config_save) mm->mm_config_save(mm);
+ if (mm->mm_config_save)
+ return mm->mm_config_save(mm, filename, fsize);
+ return NULL;
}
static void
free(mm);
}
-static void
-mpegts_mux_config_save ( mpegts_mux_t *mm )
+static htsmsg_t *
+mpegts_mux_config_save ( mpegts_mux_t *mm, char *filename, size_t fsize )
{
+ return NULL;
}
static int
return 0;
mm->mm_onid = onid;
mpegts_mux_nice_name(mm, buf, sizeof(buf));
- mm->mm_config_save(mm);
- idnode_notify_changed(&mm->mm_id);
+ idnode_changed(&mm->mm_id);
return 1;
}
if (!force && mm->mm_tsid)
return 0;
mm->mm_tsid = tsid;
- mm->mm_config_save(mm);
if (tvhtrace_enabled()) {
char buf[256];
mpegts_mux_nice_name(mm, buf, sizeof(buf));
tvhtrace("mpegts", "%s - set tsid %04X (%d)", buf, tsid, tsid);
}
- idnode_notify_changed(&mm->mm_id);
+ idnode_changed(&mm->mm_id);
return 1;
}
if (defauth && !strcmp(defauth, mm->mm_crid_authority ?: ""))
return 0;
tvh_str_update(&mm->mm_crid_authority, defauth);
- mm->mm_config_save(mm);
if (tvhtrace_enabled()) {
char buf[256];
mpegts_mux_nice_name(mm, buf, sizeof(buf));
tvhtrace("mpegts", "%s - set crid authority %s", buf, defauth);
}
- idnode_notify_changed(&mm->mm_id);
+ idnode_changed(&mm->mm_id);
return 1;
}
* Class methods
* *************************************************************************/
-static void
-dvb_mux_config_save ( mpegts_mux_t *mm )
+static htsmsg_t *
+dvb_mux_config_save ( mpegts_mux_t *mm, char *filename, size_t fsize )
{
char ubuf1[UUID_HEX_SIZE];
char ubuf2[UUID_HEX_SIZE];
htsmsg_t *c = htsmsg_create_map();
mpegts_mux_save(mm, c);
- hts_settings_save(c, "input/dvb/networks/%s/muxes/%s/config",
- idnode_uuid_as_str(&mm->mm_network->mn_id, ubuf1),
- idnode_uuid_as_str(&mm->mm_id, ubuf2));
- htsmsg_destroy(c);
+ snprintf(filename, fsize, "input/dvb/networks/%s/muxes/%s/config",
+ idnode_uuid_as_str(&mm->mm_network->mn_id, ubuf1),
+ idnode_uuid_as_str(&mm->mm_id, ubuf2));
+ return c;
}
static void
}
static void
-mpegts_mux_sched_class_save ( idnode_t *in )
+mpegts_mux_sched_class_changed ( idnode_t *in )
{
mpegts_mux_sched_t *mms = (mpegts_mux_sched_t*)in;
/* Update timer */
mpegts_mux_sched_set_timer(mms);
+}
- /* Save */
- mpegts_mux_sched_save(mms);
+static htsmsg_t *
+mpegts_mux_sched_class_save ( idnode_t *in, char *filename, size_t fsize )
+{
+ htsmsg_t *c = htsmsg_create_map();
+ char ubuf[UUID_HEX_SIZE];
+ idnode_save(in, c);
+ snprintf(filename, fsize, "muxsched/%s", idnode_uuid_as_str(in, ubuf));
+ return c;
}
static void
.ic_class = "mpegts_mux_sched",
.ic_caption = N_("Mux schedule entry"),
.ic_event = "mpegts_mux_sched",
+ .ic_changed = mpegts_mux_sched_class_changed,
.ic_save = mpegts_mux_sched_class_save,
.ic_delete = mpegts_mux_sched_class_delete,
.ic_properties = (const property_t[]){
return mms;
}
-void
-mpegts_mux_sched_save ( mpegts_mux_sched_t *mms )
-{
- htsmsg_t *c = htsmsg_create_map();
- char ubuf[UUID_HEX_SIZE];
- idnode_save(&mms->mms_id, c);
- hts_settings_save(c, "muxsched/%s", idnode_uuid_as_str(&mms->mms_id, ubuf));
- htsmsg_destroy(c);
-}
-
void
mpegts_mux_sched_delete ( mpegts_mux_sched_t *mms, int delconf )
{
mpegts_mux_sched_t *mpegts_mux_sched_create ( const char *uuid, htsmsg_t *c );
void mpegts_mux_sched_delete ( mpegts_mux_sched_t *mms, int delconf );
-void mpegts_mux_sched_save ( mpegts_mux_sched_t *mms );
void mpegts_mux_sched_init ( void );
void mpegts_mux_sched_done ( void );
* Class definition
* ***************************************************************************/
-static void
+static htsmsg_t *
mpegts_network_class_save
- ( idnode_t *in )
+ ( idnode_t *in, char *filename, size_t fsize )
{
mpegts_network_t *mn = (mpegts_network_t*)in;
if (mn->mn_config_save)
- mn->mn_config_save(mn);
+ return mn->mn_config_save(mn, filename, fsize);
+ return NULL;
}
static const char *
strncpy(buf, mn->mn_network_name ?: "unknown", len);
}
-static void
+static htsmsg_t *
mpegts_network_config_save
- ( mpegts_network_t *mn )
+ ( mpegts_network_t *mn, char *filename, size_t size )
{
// Nothing - leave to child classes
+ return NULL;
}
static mpegts_mux_t *
mn = mnb->build(mnb->idc, conf);
htsmsg_destroy(conf);
if (mn)
- mn->mn_config_save(mn);
+ idnode_changed(&mn->mn_id);
found:
if (mn && nlist) {
mm = dvb_mux_create0(ln, MPEGTS_ONID_NONE, MPEGTS_TSID_NONE,
dmc, NULL, NULL);
if (mm)
- mm->mm_config_save((mpegts_mux_t *)mm);
+ idnode_changed(&mm->mm_id);
if (tvhtrace_enabled()) {
char buf[128];
dvb_mux_conf_str(dmc, buf, sizeof(buf));
return (dvb_mux_t *)mm;
}
-static void
-dvb_network_config_save ( mpegts_network_t *mn )
+static htsmsg_t *
+dvb_network_config_save ( mpegts_network_t *mn, char *filename, size_t fsize )
{
htsmsg_t *c = htsmsg_create_map();
char ubuf[UUID_HEX_SIZE];
idnode_save(&mn->mn_id, c);
htsmsg_add_str(c, "class", mn->mn_id.in_class->ic_class);
- hts_settings_save(c, "input/dvb/networks/%s/config",
- idnode_uuid_as_str(&mn->mn_id, ubuf));
- htsmsg_destroy(c);
+ snprintf(filename, fsize, "input/dvb/networks/%s/config",
+ idnode_uuid_as_str(&mn->mn_id, ubuf));
+ return c;
}
const idclass_t *
if (mm && save) {
mm->mm_dmc_origin = origin;
mm->mm_dmc_origin_expire = dispatch_clock + 3600 * 24; /* one day */
- mm->mm_config_save((mpegts_mux_t *)mm);
+ idnode_changed(&mm->mm_id);
}
noop:
return (mpegts_mux_t *)mm;
TAILQ_REMOVE(&mn->mn_scan_pend, mm, mm_scan_link);
if (mm->mm_scan_result != MM_SCAN_FAIL) {
mm->mm_scan_result = MM_SCAN_FAIL;
- mm->mm_config_save(mm);
+ idnode_changed(&mm->mm_id);
}
mm->mm_scan_state = MM_SCAN_STATE_IDLE;
mm->mm_scan_weight = 0;
if (result != MM_SCAN_NONE && mm->mm_scan_result != result) {
mm->mm_scan_result = result;
- mm->mm_config_save(mm);
+ idnode_changed(&mm->mm_id);
}
/* Re-enable? */
MPEGTS_ONID_NONE,
MPEGTS_TSID_NONE,
mux, NULL, NULL);
- if (mm)
- {
- mm->mm_config_save(mm);
+ if (mm) {
char buf[256];
+ idnode_changed(&mm->mm_id);
mn->mn_display_name(mn, buf, sizeof(buf));
tvhinfo("mpegts", "fastscan mux add to network '%s'", buf);
}
/*
* Save
*/
-static void
-mpegts_service_config_save ( service_t *t )
+static htsmsg_t *
+mpegts_service_config_save ( service_t *t, char *filename, size_t fsize )
{
htsmsg_t *c = htsmsg_create_map();
mpegts_service_t *s = (mpegts_service_t*)t;
char ubuf1[UUID_HEX_SIZE];
char ubuf2[UUID_HEX_SIZE];
service_save(t, c);
- hts_settings_save(c, "input/dvb/networks/%s/muxes/%s/services/%s",
- idnode_uuid_as_str(&s->s_dvb_mux->mm_network->mn_id, ubuf0),
- idnode_uuid_as_str(&s->s_dvb_mux->mm_id, ubuf1),
- idnode_uuid_as_str(&s->s_id, ubuf2));
- htsmsg_destroy(c);
+ snprintf(filename, fsize, "input/dvb/networks/%s/muxes/%s/services/%s",
+ idnode_uuid_as_str(&s->s_dvb_mux->mm_network->mn_id, ubuf0),
+ idnode_uuid_as_str(&s->s_dvb_mux->mm_id, ubuf1),
+ idnode_uuid_as_str(&s->s_id, ubuf2));
+ return c;
}
/*
* SAT-IP client
*/
-static void
-satip_device_class_save ( idnode_t *in )
+static htsmsg_t *
+satip_device_class_save ( idnode_t *in, char *filename, size_t fsize )
{
- satip_device_save((satip_device_t *)in);
+ satip_device_t *sd = (satip_device_t *)in;
+ satip_frontend_t *lfe;
+ htsmsg_t *m, *l;
+ char ubuf[UUID_HEX_SIZE];
+
+ if (sd->sd_nosave)
+ return NULL;
+
+ 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);
+
+ snprintf(filename, fsize, "input/satip/adapters/%s",
+ idnode_uuid_as_str(&sd->th_id, ubuf));
+ return m;
}
static idnode_set_t *
}
if (save)
- satip_device_save(sd);
+ satip_device_changed(sd);
sd->sd_inload = 0;
return NULL;
}
-void
-satip_device_save( satip_device_t *sd )
-{
- satip_frontend_t *lfe;
- htsmsg_t *m, *l;
- char ubuf[UUID_HEX_SIZE];
-
- if (sd->sd_nosave)
- return;
-
- 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, ubuf));
- htsmsg_destroy(m);
-}
-
void
satip_device_destroy( satip_device_t *sd )
{
* *************************************************************************/
static void
-satip_frontend_class_save ( idnode_t *in )
+satip_frontend_class_changed ( idnode_t *in )
{
satip_device_t *la = ((satip_frontend_t*)in)->sf_device;
- satip_device_save(la);
+ satip_device_changed(la);
}
static int
.ic_super = &mpegts_input_class,
.ic_class = "satip_frontend",
.ic_caption = N_("SAT>IP DVB frontend"),
- .ic_save = satip_frontend_class_save,
+ .ic_changed = satip_frontend_class_changed,
.ic_properties = (const property_t[]) {
{
.type = PT_INT,
htsmsg_destroy(conf);
if (satip_frontend_wizard_network(lfe))
mpegts_input_set_enabled((mpegts_input_t *)lfe, 1);
- satip_device_save(lfe->sf_device);
+ satip_device_changed(lfe->sf_device);
} else {
htsmsg_destroy(nlist);
}
void satip_device_done ( void );
-void satip_device_save ( satip_device_t *sd );
+static inline void satip_device_changed ( satip_device_t *sd )
+ { idnode_changed(&sd->th_id); }
void satip_device_destroy ( satip_device_t *sd );
}
static void
-satip_satconf_class_save ( idnode_t *in )
+satip_satconf_class_changed ( idnode_t *in )
{
satip_satconf_t *sfc = (satip_satconf_t*)in;
- satip_device_save(sfc->sfc_lfe->sf_device);
+ satip_device_changed(sfc->sfc_lfe->sf_device);
}
const idclass_t satip_satconf_class =
.ic_caption = N_("Satconf"),
.ic_event = "satip_satconf",
.ic_get_title = satip_satconf_class_get_title,
- .ic_save = satip_satconf_class_save,
+ .ic_changed = satip_satconf_class_changed,
.ic_properties = (const property_t[]) {
{
.type = PT_BOOL,
extern const idclass_t mpegts_service_class;
extern const idclass_t mpegts_network_class;
-static void
-tsfile_service_config_save ( service_t *s )
+static htsmsg_t *
+tsfile_service_config_save ( service_t *s, char *filename, size_t fsize )
{
+ return NULL;
}
static void
return mmi;
}
-static void
-iptv_mux_config_save ( mpegts_mux_t *m )
+static htsmsg_t *
+iptv_mux_config_save ( mpegts_mux_t *m, char *filename, size_t fsize )
{
+ return NULL;
}
mpegts_mux_t *
hdhomerun_discover_find_devices_custom_v2
#endif
-static void
-tvhdhomerun_device_class_save ( idnode_t *in )
+static htsmsg_t *
+tvhdhomerun_device_class_save ( idnode_t *in, char *filename, size_t fsize )
{
- tvhdhomerun_device_save((tvhdhomerun_device_t *)in);
+ 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);
+
+ 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);
+
+ snprintf(filename, fsize, "input/tvhdhomerun/adapters/%s",
+ idnode_uuid_as_str(&hd->th_id, ubuf));
+ return m;
}
static idnode_set_t *
};
-void
-tvhdhomerun_device_save( tvhdhomerun_device_t *hd )
-{
- tvhdhomerun_frontend_t *lfe;
- htsmsg_t *m, *l;
- char ubuf[UUID_HEX_SIZE];
-
- 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, ubuf));
- htsmsg_destroy(m);
-}
-
static void
tvhdhomerun_discovery_destroy(tvhdhomerun_discovery_t *d, int unlink)
{
if (save)
- tvhdhomerun_device_save(hd);
+ tvhdhomerun_device_changed(hd);
htsmsg_destroy(conf);
}
}
static void
-tvhdhomerun_frontend_class_save ( idnode_t *in )
+tvhdhomerun_frontend_class_changed ( idnode_t *in )
{
tvhdhomerun_device_t *la = ((tvhdhomerun_frontend_t*)in)->hf_device;
- tvhdhomerun_device_save(la);
+ tvhdhomerun_device_changed(la);
}
void
.ic_super = &mpegts_input_class,
.ic_class = "tvhdhomerun_frontend",
.ic_caption = N_("HDHomeRun DVB frontend"),
- .ic_save = tvhdhomerun_frontend_class_save,
+ .ic_changed = tvhdhomerun_frontend_class_changed,
.ic_properties = (const property_t[]) {
{
.type = PT_INT,
htsmsg_destroy(nlist);
if (tvhdhomerun_frontend_wizard_network(hfe))
mpegts_input_set_enabled((mpegts_input_t *)hfe, 1);
- tvhdhomerun_device_save(hfe->hf_device);
+ tvhdhomerun_device_changed(hfe->hf_device);
} else {
htsmsg_destroy(nlist);
}
void tvhdhomerun_frontend_delete ( tvhdhomerun_frontend_t *lfe );
-void tvhdhomerun_device_save ( tvhdhomerun_device_t *sd );
+static inline void tvhdhomerun_device_changed ( tvhdhomerun_device_t *sd )
+ { idnode_changed(&sd->th_id); }
+
void tvhdhomerun_frontend_save ( tvhdhomerun_frontend_t *lfe, htsmsg_t *m );
#endif
static profile_t *profile_default;
-static void profile_class_save ( idnode_t *in );
-
/*
*
*/
pro->pro_refcount = 1;
TAILQ_INSERT_TAIL(&profiles, pro, pro_link);
if (save)
- profile_class_save((idnode_t *)pro);
+ idnode_changed(&pro->pro_id);
if (pro->pro_conf_changed)
pro->pro_conf_changed(pro);
return pro;
profile_release(pro);
}
-static void
-profile_class_save ( idnode_t *in )
+static htsmsg_t *
+profile_class_save ( idnode_t *in, char *filename, size_t fsize )
{
profile_t *pro = (profile_t *)in;
htsmsg_t *c = htsmsg_create_map();
idnode_save(in, c);
if (pro->pro_shield)
htsmsg_add_bool(c, "shield", 1);
- hts_settings_save(c, "profile/%s", idnode_uuid_as_str(in, ubuf));
- htsmsg_destroy(c);
+ snprintf(filename, fsize, "profile/%s", idnode_uuid_as_str(in, ubuf));
if (pro->pro_conf_changed)
pro->pro_conf_changed(pro);
+ return c;
}
static const char *
old = profile_default;
profile_default = pro;
if (old)
- profile_class_save(&old->pro_id);
+ idnode_changed(&old->pro_id);
return 1;
}
return 0;
.satip_allow_remote_weight = 1
};
-static void satip_server_class_save(idnode_t *self)
+static void satip_server_class_changed(idnode_t *self)
{
- config_save();
+ idnode_changed(&config.idnode);
satip_server_save();
}
.ic_caption = N_("SAT>IP server"),
.ic_event = "satip_server",
.ic_perm_def = ACCESS_ADMIN,
- .ic_save = satip_server_class_save,
+ .ic_changed = satip_server_class_changed,
.ic_groups = (const property_group_t[]) {
{
.name = N_("General"),
int descramble, rewrite_pmt, muxcnf;
char *nat_ip;
- config_save();
if (!satip_server_rtsp_port_locked) {
satips_rtsp_port(0);
if (satip_server_rtsp_port > 0) {
}
if (save)
- config_save();
+ idnode_changed(&config.idnode);
satips_upnp_discovery = upnp_service_create(upnp_service);
if (satips_upnp_discovery == NULL) {
static void service_data_timeout(void *aux);
static void service_class_delete(struct idnode *self);
-static void service_class_save(struct idnode *self);
+static htsmsg_t *service_class_save(struct idnode *self, char *filename, size_t fsize);
struct service_queue service_all;
struct service_queue service_raw_all;
/**
*
*/
-static void
-service_class_save(struct idnode *self)
+static htsmsg_t *
+service_class_save(struct idnode *self, char *filename, size_t fsize)
{
service_t *s = (service_t *)self;
if (s->s_config_save)
- s->s_config_save(s);
+ return s->s_config_save(s, filename, fsize);
+ return NULL;
}
/**
pthread_mutex_lock(&global_lock);
if(t->s_status != SERVICE_ZOMBIE && t->s_config_save)
- t->s_config_save(t);
+ idnode_changed(&t->s_id);
if(t->s_status == SERVICE_RUNNING && restart)
service_restart(t);
service_unref(t);
void (*s_stop_feed)(struct service *t);
- void (*s_config_save)(struct service *t);
+ htsmsg_t *(*s_config_save)(struct service *t, char *filename, size_t fsize);
void (*s_setsourceinfo)(struct service *t, struct source_info *si);
}
/* save */
- idnode_notify_changed(&chn->ch_id);
- channel_save(chn);
+ idnode_changed(&chn->ch_id);
}
if (!bq) {
service_mapper_stat.ok++;
/*
* Save settings
*/
-static void service_mapper_conf_class_save ( idnode_t *self )
+static htsmsg_t *
+service_mapper_conf_class_save ( idnode_t *self, char *filename, size_t fsize )
{
htsmsg_t *m;
m = htsmsg_create_map();
idnode_save(&service_mapper_conf.idnode, m);
- hts_settings_save(m, "service_mapper/config");
- htsmsg_destroy(m);
+ snprintf(filename, fsize, "service_mapper/config");
if (!htsmsg_is_empty(service_mapper_conf.services))
service_mapper_start(&service_mapper_conf.d, service_mapper_conf.services);
htsmsg_destroy(service_mapper_conf.services);
service_mapper_conf.services = NULL;
+
+ return m;
}
/*
* Configuration
*/
-static void tvhlog_class_save(idnode_t *self)
-{
-}
-
static const void *
tvhlog_class_path_get ( void *o )
{
.ic_caption = N_("Debugging"),
.ic_event = "tvhlog_conf",
.ic_perm_def = ACCESS_ADMIN,
- .ic_save = tvhlog_class_save,
.ic_groups = (const property_group_t[]) {
{
.name = N_("Settings"),
} wizard_hello_t;
-static void hello_save(idnode_t *in)
+static void hello_changed(idnode_t *in)
{
wizard_page_t *p = (wizard_page_t *)in;
wizard_hello_t *w = p->aux;
save = 1;
}
if (save)
- config_save();
+ idnode_changed(&config.idnode);
}
BASIC_STR_OPS(wizard_hello_t, ui_lang)
ic->ic_properties = props;
ic->ic_groups = groups;
- ic->ic_save = hello_save;
+ ic->ic_changed = hello_changed;
page->aux = w = calloc(1, sizeof(wizard_hello_t));
if (config.language_ui)
} wizard_login_t;
-static void login_save(idnode_t *in)
+static void login_changed(idnode_t *in)
{
wizard_page_t *p = (wizard_page_t *)in;
wizard_login_t *w = p->aux;
ae = access_entry_create(NULL, conf);
if (ae) {
ae->ae_wizard = 1;
- access_entry_save(ae);
+ idnode_changed(&ae->ae_id);
}
htsmsg_destroy(conf);
pw = passwd_entry_create(NULL, conf);
if (pw) {
pw->pw_wizard = 1;
- passwd_entry_save(pw);
+ idnode_changed(&pw->pw_id);
}
htsmsg_destroy(conf);
}
ae = access_entry_create(NULL, conf);
if (ae) {
ae->ae_wizard = 1;
- access_entry_save(ae);
+ idnode_changed(&ae->ae_id);
}
htsmsg_destroy(conf);
pw = passwd_entry_create(NULL, conf);
if (pw) {
pw->pw_wizard = 1;
- passwd_entry_save(pw);
+ idnode_changed(&pw->pw_id);
}
htsmsg_destroy(conf);
}
ic->ic_properties = props;
ic->ic_groups = groups;
- ic->ic_save = login_save;
+ ic->ic_changed = login_changed;
page->aux = w = calloc(1, sizeof(wizard_login_t));
TAILQ_FOREACH(ae, &access_entries, ae_link) {
page_free(page);
}
-static void network_save(idnode_t *in)
+static void network_changed(idnode_t *in)
{
wizard_page_t *p = (wizard_page_t *)in;
wizard_network_t *w = p->aux;
page->aux = w = calloc(1, sizeof(wizard_network_t));
ic->ic_groups = groups;
ic->ic_properties = w->props;
- ic->ic_save = network_save;
+ ic->ic_changed = network_changed;
page->free = network_free;
snprintf(w->lang, sizeof(w->lang), "%s", lang ?: "");
page_free(page);
}
-static void muxes_save(idnode_t *in)
+static void muxes_changed(idnode_t *in)
{
wizard_page_t *p = (wizard_page_t *)in;
wizard_muxes_t *w = p->aux;
page->aux = w = calloc(1, sizeof(wizard_muxes_t));
ic->ic_groups = groups;
ic->ic_properties = w->props;
- ic->ic_save = muxes_save;
+ ic->ic_changed = muxes_changed;
page->free = muxes_free;
snprintf(w->lang, sizeof(w->lang), "%s", lang ?: "");
int nettags;
} wizard_mapping_t;
-static void mapping_save(idnode_t *in)
+static void mapping_changed(idnode_t *in)
{
wizard_page_t *p = (wizard_page_t *)in;
wizard_mapping_t *w = p->aux;
idclass_t *ic = (idclass_t *)page->idnode.in_class;
wizard_mapping_t *w;
ic->ic_properties = props;
- ic->ic_save = mapping_save;
+ ic->ic_changed = mapping_changed;
page->aux = w = calloc(1, sizeof(wizard_mapping_t));
w->provtags = service_mapper_conf.d.provider_tags;
w->nettags = service_mapper_conf.d.network_tags;
* Discovered channels
*/
-static void channels_save(idnode_t *in)
+static void channels_changed(idnode_t *in)
{
access_entry_t *ae, *ae_next;
ic->ic_properties = props;
ic->ic_flags |= IDCLASS_ALWAYS_SAVE;
- ic->ic_save = channels_save;
+ ic->ic_changed = channels_changed;
/* do we have an admin created by wizard? */
TAILQ_FOREACH(ae, &access_entries, ae_link)
if (ae->ae_admin && ae->ae_wizard) break;
projects / thirdparty / tvheadend.git / commitdiff
