static int _xmltv_parse_tv
(epggrab_module_t *mod, htsmsg_t *body, epggrab_stats_t *stats)
{
int save = 0;
htsmsg_t *tags;
htsmsg_field_t *f;
if((tags = htsmsg_get_map(body, "tags")) == NULL)
return 0;
HTSMSG_FOREACH(f, tags) {
if(!strcmp(f->hmf_name, "channel")) {
save |= _xmltv_parse_channel(mod, htsmsg_get_map_by_field(f), stats);
} else if(!strcmp(f->hmf_name, "programme")) {
save |= _xmltv_parse_programme(mod, htsmsg_get_map_by_field(f), stats);
}
}
return save;
}
linuxdvb_ca_t *
linuxdvb_ca_create
( htsmsg_t *conf, linuxdvb_adapter_t *la, int number, const char *ca_path)
{
linuxdvb_ca_t *lca;
char id[6];
const char *uuid = NULL;
lca = calloc(1, sizeof(linuxdvb_ca_t));
memset(lca, 0, sizeof(linuxdvb_ca_t));
lca->lca_number = number;
lca->lca_ca_path = strdup(ca_path);
lca->lca_ca_fd = -1;
lca->lca_capmt_interval = 100;
lca->lca_capmt_query_interval = 1200;
/* Internal config ID */
snprintf(id, sizeof(id), "ca%u", number);
if (conf)
conf = htsmsg_get_map(conf, id);
if (conf)
uuid = htsmsg_get_str(conf, "uuid");
if (idnode_insert(&lca->lca_id, uuid, &linuxdvb_ca_class, 0)) {
free(lca);
return NULL;
}
if (conf)
idnode_load(&lca->lca_id, conf);
/* Adapter link */
lca->lca_adapter = la;
LIST_INSERT_HEAD(&la->la_ca_devices, lca, lca_link);
TAILQ_INIT(&lca->lca_capmt_queue);
gtimer_arm_ms(&lca->lca_monitor_timer, linuxdvb_ca_monitor, lca, 250);
return lca;
}
static int
api_dvr_config_create
( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
dvr_config_t *cfg;
htsmsg_t *conf;
const char *s;
if (!(conf = htsmsg_get_map(args, "conf")))
return EINVAL;
if (!(s = htsmsg_get_str(conf, "name")))
return EINVAL;
if (s[0] == '\0')
return EINVAL;
pthread_mutex_lock(&global_lock);
if ((cfg = dvr_config_create(NULL, NULL, conf)))
dvr_config_save(cfg);
pthread_mutex_unlock(&global_lock);
return 0;
}
static int
api_dvr_timerec_create
( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
htsmsg_t *conf;
dvr_timerec_entry_t *dte;
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 ?: "");
pthread_mutex_lock(&global_lock);
dte = dvr_timerec_create(NULL, conf);
if (dte) {
dvr_timerec_save(dte);
dvr_timerec_check(dte);
}
pthread_mutex_unlock(&global_lock);
return 0;
}
static int _xmltv_parse_tv
(epggrab_module_t *mod, htsmsg_t *body, epggrab_stats_t *stats)
{
int gsave = 0, save;
htsmsg_t *tags;
htsmsg_field_t *f;
if((tags = htsmsg_get_map(body, "tags")) == NULL)
return 0;
HTSMSG_FOREACH(f, tags) {
save = 0;
if(!strcmp(f->hmf_name, "channel")) {
pthread_mutex_lock(&global_lock);
save = _xmltv_parse_channel(mod, htsmsg_get_map_by_field(f), stats);
pthread_mutex_unlock(&global_lock);
} else if(!strcmp(f->hmf_name, "programme")) {
pthread_mutex_lock(&global_lock);
save = _xmltv_parse_programme(mod, htsmsg_get_map_by_field(f), stats);
if (save) epg_updated();
pthread_mutex_unlock(&global_lock);
}
gsave |= save;
}
static void get_episode_info
(epggrab_module_t *mod,
htsmsg_t *tags, char **uri, char **suri, epg_episode_num_t *epnum )
{
htsmsg_field_t *f;
htsmsg_t *c, *a;
const char *sys, *cdata;
HTSMSG_FOREACH(f, tags) {
if((c = htsmsg_get_map_by_field(f)) == NULL ||
strcmp(f->hmf_name, "episode-num") ||
(a = htsmsg_get_map(c, "attrib")) == NULL ||
(cdata = htsmsg_get_str(c, "cdata")) == NULL ||
(sys = htsmsg_get_str(a, "system")) == NULL)
continue;
if(!strcmp(sys, "onscreen"))
epnum->text = (char*)cdata;
else if(!strcmp(sys, "xmltv_ns"))
parse_xmltv_ns_episode(cdata, epnum);
else if(!strcmp(sys, "dd_progid"))
parse_xmltv_dd_progid(mod, cdata, uri, suri, epnum);
}
}
static void tvhdhomerun_device_create(struct hdhomerun_discover_device_t *dInfo) {
tvhdhomerun_device_t *hd = calloc(1, sizeof(tvhdhomerun_device_t));
htsmsg_t *conf = NULL, *feconf = NULL;
char uhex[UUID_HEX_SIZE];
int j, save = 0;
struct hdhomerun_device_t *hdhomerun_tuner;
dvb_fe_type_t type = DVB_TYPE_C;
tvhdhomerun_device_calc_uuid(uhex, dInfo->device_id);
hdhomerun_tuner = hdhomerun_device_create(dInfo->device_id, dInfo->ip_addr, 0, NULL);
{
const char *deviceModel = hdhomerun_device_get_model_str(hdhomerun_tuner);
if(deviceModel != NULL) {
hd->hd_info.deviceModel = strdup(deviceModel);
}
hdhomerun_device_destroy(hdhomerun_tuner);
}
conf = hts_settings_load("input/tvhdhomerun/adapters/%s", uhex);
if ( conf != NULL ) {
const char *override_type = htsmsg_get_str(conf, "fe_override");
if ( override_type != NULL) {
if ( !strcmp(override_type, "ATSC" ) )
override_type = "ATSC-T";
type = dvb_str2type(override_type);
if ( ! ( type == DVB_TYPE_C || type == DVB_TYPE_T ||
type == DVB_TYPE_ATSC_T || type == DVB_TYPE_ATSC_C ) ) {
type = DVB_TYPE_C;
}
}
} else {
if (strstr(hd->hd_info.deviceModel, "_atsc"))
type = DVB_TYPE_ATSC_T;
}
hd->hd_override_type = strdup(dvb_type2str(type));
tvhinfo(LS_TVHDHOMERUN, "Using Network type : %s", hd->hd_override_type);
/* some sane defaults */
hd->hd_fullmux_ok = 1;
hd->hd_pids_len = 127;
hd->hd_pids_max = 32;
hd->hd_pids_deladd = 1;
if (!tvh_hardware_create0((tvh_hardware_t*)hd, &tvhdhomerun_device_class,
uhex, conf))
return;
TAILQ_INIT(&hd->hd_frontends);
/* we may check if uuid matches, but the SHA hash should be enough */
if (hd->hd_info.uuid)
free(hd->hd_info.uuid);
char fName[128];
snprintf(fName, 128, "HDHomeRun(%08X)",dInfo->device_id);
memset(&hd->hd_info.ip_address, 0, sizeof(hd->hd_info.ip_address));
hd->hd_info.ip_address.ss_family = AF_INET;
((struct sockaddr_in *)&hd->hd_info.ip_address)->sin_addr.s_addr = htonl(dInfo->ip_addr);
hd->hd_info.uuid = strdup(uhex);
hd->hd_info.friendlyname = strdup(fName);
if (conf)
feconf = htsmsg_get_map(conf, "frontends");
save = !conf || !feconf;
for (j = 0; j < dInfo->tuner_count; ++j) {
if (tvhdhomerun_frontend_create(hd, dInfo, feconf, type, j)) {
tvhinfo(LS_TVHDHOMERUN, "Created frontend %08X tuner %d", dInfo->device_id, j);
} else {
tvherror(LS_TVHDHOMERUN, "Unable to create frontend-device. ( %08x-%d )", dInfo->device_id,j);
}
}
if (save)
tvhdhomerun_device_changed(hd);
htsmsg_destroy(conf);
}
static int _pyepg_parse_episode
( epggrab_module_t *mod, htsmsg_t *data, epggrab_stats_t *stats )
{
int save = 0;
htsmsg_t *attr, *tags;
epg_episode_t *episode;
epg_season_t *season;
epg_brand_t *brand;
const char *str;
uint32_t u32, pc, pn;
epg_genre_list_t *egl;
if ( data == NULL ) return 0;
if ((attr = htsmsg_get_map(data, "attrib")) == NULL) return 0;
if ((str = htsmsg_get_str(attr, "id")) == NULL) return 0;
if ((tags = htsmsg_get_map(data, "tags")) == NULL) return 0;
/* Find episode */
if ((episode = epg_episode_find_by_uri(str, 1, &save)) == NULL) return 0;
stats->episodes.total++;
if (save) stats->episodes.created++;
/* Set season */
if ((str = htsmsg_get_str(attr, "series"))) {
if ((season = epg_season_find_by_uri(str, 0, NULL))) {
save |= epg_episode_set_season(episode, season, mod);
}
}
/* Set brand */
if ((str = htsmsg_get_str(attr, "brand"))) {
if ((brand = epg_brand_find_by_uri(str, 0, NULL))) {
save |= epg_episode_set_brand(episode, brand, mod);
}
}
/* Set title/subtitle */
if ((str = htsmsg_xml_get_cdata_str(tags, "title"))) {
save |= epg_episode_set_title(episode, str, NULL, mod);
}
if ((str = htsmsg_xml_get_cdata_str(tags, "subtitle"))) {
save |= epg_episode_set_subtitle(episode, str, NULL, mod);
}
/* Set summary */
if ((str = htsmsg_xml_get_cdata_str(tags, "summary"))) {
save |= epg_episode_set_summary(episode, str, NULL, mod);
}
/* Number */
if (htsmsg_xml_get_cdata_u32(tags, "number", &u32) == 0) {
save |= epg_episode_set_number(episode, u32, mod);
}
if (!htsmsg_xml_get_cdata_u32(tags, "part-number", &pn)) {
pc = 0;
htsmsg_xml_get_cdata_u32(tags, "part-count", &pc);
save |= epg_episode_set_part(episode, pn, pc, mod);
}
/* Set image */
if ((str = htsmsg_xml_get_cdata_str(tags, "image"))) {
save |= epg_episode_set_image(episode, str, mod);
} else if ((str = htsmsg_xml_get_cdata_str(tags, "thumb"))) {
save |= epg_episode_set_image(episode, str, mod);
}
/* Genre */
if ((egl = _pyepg_parse_genre(tags))) {
save |= epg_episode_set_genre(episode, egl, mod);
epg_genre_list_destroy(egl);
}
/* Content */
if ((htsmsg_get_map(tags, "blackandwhite")))
save |= epg_episode_set_is_bw(episode, 1, mod);
if (save) stats->episodes.modified++;
return save;
}
static void
satip_discovery_http_closed(http_client_t *hc, int errn)
{
satip_discovery_t *d = hc->hc_aux;
char *s;
htsmsg_t *xml = NULL, *tags, *root, *device;
const char *friendlyname, *manufacturer, *manufacturerURL, *modeldesc;
const char *modelname, *modelnum, *serialnum;
const char *presentation, *tunercfg, *udn, *uuid;
const char *cs, *arg;
satip_device_info_t info;
char errbuf[100];
char *argv[10];
int i, n;
s = http_arg_get(&hc->hc_args, "Content-Type");
if (s) {
n = http_tokenize(s, argv, ARRAY_SIZE(argv), ';');
if (n <= 0 || strcasecmp(s, "text/xml")) {
errn = ENOENT;
s = NULL;
}
}
if (errn != 0 || s == NULL || hc->hc_code != 200 ||
hc->hc_data_size == 0 || hc->hc_data == NULL) {
tvhlog(LOG_ERR, "satip", "Cannot get %s: %s", d->location, strerror(errn));
return;
}
if (tvhtrace_enabled()) {
tvhtrace("satip", "received XML description from %s", hc->hc_host);
tvhlog_hexdump("satip", hc->hc_data, hc->hc_data_size);
}
if (d->myaddr == NULL || d->myaddr[0] == '\0') {
struct sockaddr_storage ip;
socklen_t addrlen = sizeof(ip);
errbuf[0] = '\0';
getsockname(hc->hc_fd, (struct sockaddr *)&ip, &addrlen);
inet_ntop(ip.ss_family, IP_IN_ADDR(ip), errbuf, sizeof(errbuf));
free(d->myaddr);
d->myaddr = strdup(errbuf);
}
s = hc->hc_data + hc->hc_data_size - 1;
while (s != hc->hc_data && *s != '/')
s--;
if (s != hc->hc_data)
s--;
if (strncmp(s, "</root>", 7))
return;
/* Parse */
xml = htsmsg_xml_deserialize(hc->hc_data, errbuf, sizeof(errbuf));
hc->hc_data = NULL;
if (!xml) {
tvhlog(LOG_ERR, "satip_discovery_desc", "htsmsg_xml_deserialize error %s", errbuf);
goto finish;
}
if ((tags = htsmsg_get_map(xml, "tags")) == NULL)
goto finish;
if ((root = htsmsg_get_map(tags, "root")) == NULL)
goto finish;
if ((device = htsmsg_get_map(root, "tags")) == NULL)
goto finish;
if ((device = htsmsg_get_map(device, "device")) == NULL)
goto finish;
if ((device = htsmsg_get_map(device, "tags")) == NULL)
goto finish;
if ((cs = htsmsg_xml_get_cdata_str(device, "deviceType")) == NULL)
goto finish;
if (strcmp(cs, "urn:ses-com:device:SatIPServer:1"))
goto finish;
if ((friendlyname = htsmsg_xml_get_cdata_str(device, "friendlyName")) == NULL)
goto finish;
if ((manufacturer = htsmsg_xml_get_cdata_str(device, "manufacturer")) == NULL)
goto finish;
if ((manufacturerURL = htsmsg_xml_get_cdata_str(device, "manufacturerURL")) == NULL)
manufacturerURL = "";
if ((modeldesc = htsmsg_xml_get_cdata_str(device, "modelDescription")) == NULL)
modeldesc = "";
if ((modelname = htsmsg_xml_get_cdata_str(device, "modelName")) == NULL)
goto finish;
if ((modelnum = htsmsg_xml_get_cdata_str(device, "modelNumber")) == NULL)
modelnum = "";
if ((serialnum = htsmsg_xml_get_cdata_str(device, "serialNumber")) == NULL)
serialnum = "";
if ((presentation = htsmsg_xml_get_cdata_str(device, "presentationURL")) == NULL)
presentation = "";
if ((udn = htsmsg_xml_get_cdata_str(device, "UDN")) == NULL)
goto finish;
if ((tunercfg = htsmsg_xml_get_cdata_str(device, "urn:ses-com:satipX_SATIPCAP")) == NULL)
tunercfg = "";
uuid = NULL;
n = http_tokenize((char *)udn, argv, ARRAY_SIZE(argv), ':');
for (i = 0; i < n+1; i++)
if (argv[i] && strcmp(argv[i], "uuid") == 0) {
uuid = argv[++i];
break;
}
if (uuid == NULL || (d->uuid[0] && strcmp(uuid, d->uuid)))
goto finish;
info.rtsp_port = 554;
info.srcs = 4;
arg = http_arg_get(&hc->hc_args, "X-SATIP-RTSP-Port");
if (arg) {
i = atoi(arg);
if (i > 0 && i < 65535)
info.rtsp_port = i;
}
arg = http_arg_get(&hc->hc_args, "X-SATIP-Sources");
if (arg) {
i = atoi(arg);
if (i > 0 && i < 128)
info.srcs = i;
}
info.myaddr = strdup(d->myaddr);
info.addr = strdup(d->url.host);
info.uuid = strdup(uuid);
info.bootid = strdup(d->bootid);
info.configid = strdup(d->configid);
info.deviceid = strdup(d->deviceid);
info.location = strdup(d->location);
info.server = strdup(d->server);
info.friendlyname = strdup(friendlyname);
info.manufacturer = strdup(manufacturer);
info.manufacturerURL = strdup(manufacturerURL);
info.modeldesc = strdup(modeldesc);
info.modelname = strdup(modelname);
info.modelnum = strdup(modelnum);
info.serialnum = strdup(serialnum);
info.presentation = strdup(presentation);
info.tunercfg = strdup(tunercfg);
htsmsg_destroy(xml);
xml = NULL;
pthread_mutex_lock(&global_lock);
if (!satip_device_find(info.uuid))
satip_device_create(&info);
pthread_mutex_unlock(&global_lock);
free(info.myaddr);
free(info.location);
free(info.server);
free(info.addr);
free(info.uuid);
free(info.bootid);
free(info.configid);
free(info.deviceid);
free(info.friendlyname);
free(info.manufacturer);
free(info.manufacturerURL);
free(info.modeldesc);
free(info.modelname);
free(info.modelnum);
free(info.serialnum);
free(info.presentation);
free(info.tunercfg);
finish:
htsmsg_destroy(xml);
}
static satip_device_t *
satip_device_create( satip_device_info_t *info )
{
satip_device_t *sd = calloc(1, sizeof(satip_device_t));
tvh_uuid_t uuid;
htsmsg_t *conf = NULL, *feconf = NULL;
char *argv[10], *tunercfg;
int i, j, n, m, fenum, v2, save = 0;
dvb_fe_type_t type;
char buf2[60];
sd->sd_inload = 1;
satip_device_calc_uuid(&uuid, info->uuid);
conf = hts_settings_load("input/satip/adapters/%s", uuid.hex);
/* some sane defaults */
sd->sd_fast_switch = 1;
sd->sd_fullmux_ok = 1;
sd->sd_pids_len = 127;
sd->sd_pids_max = 32;
sd->sd_pids_deladd = 1;
sd->sd_sig_scale = 240;
sd->sd_dbus_allow = 1;
if (!tvh_hardware_create0((tvh_hardware_t*)sd, &satip_device_class,
uuid.hex, conf)) {
/* Note: sd is freed in above fcn */
return NULL;
}
pthread_mutex_init(&sd->sd_tune_mutex, NULL);
TAILQ_INIT(&sd->sd_frontends);
/* we may check if uuid matches, but the SHA hash should be enough */
if (sd->sd_info.uuid)
free(sd->sd_info.uuid);
#define ASSIGN(x) sd->sd_info.x = info->x; info->x = NULL
ASSIGN(myaddr);
ASSIGN(addr);
ASSIGN(uuid);
ASSIGN(bootid);
ASSIGN(configid);
ASSIGN(deviceid);
ASSIGN(server);
ASSIGN(location);
ASSIGN(friendlyname);
ASSIGN(manufacturer);
ASSIGN(manufacturerURL);
ASSIGN(modeldesc);
ASSIGN(modelname);
ASSIGN(modelnum);
ASSIGN(serialnum);
ASSIGN(presentation);
ASSIGN(tunercfg);
#undef ASSIGN
sd->sd_info.rtsp_port = info->rtsp_port;
sd->sd_info.srcs = info->srcs;
/*
* device specific hacks
*/
satip_device_hack(sd);
if (conf)
feconf = htsmsg_get_map(conf, "frontends");
save = !conf || !feconf;
tunercfg = sd->sd_tunercfg;
if (tunercfg == NULL)
tunercfg = sd->sd_tunercfg = strdup("Auto");
if (strncmp(tunercfg, "DVB", 3) && strncmp(tunercfg, "ATSC", 4))
tunercfg = sd->sd_info.tunercfg;
n = http_tokenize(tvh_strdupa(tunercfg), argv, 10, ',');
for (i = m = 0, fenum = 1; i < n; i++) {
type = DVB_TYPE_NONE;
v2 = 0;
if (strncmp(argv[i], "DVBS2-", 6) == 0) {
type = DVB_TYPE_S;
m = atoi(argv[i] + 6);
v2 = 1;
} else if (strncmp(argv[i], "DVBS-", 5) == 0) {
type = DVB_TYPE_S;
m = atoi(argv[i] + 5);
} else if (strncmp(argv[i], "DVBT2-", 6) == 0) {
type = DVB_TYPE_T;
m = atoi(argv[i] + 6);
v2 = 1;
} else if (strncmp(argv[i], "DVBT-", 5) == 0) {
type = DVB_TYPE_T;
m = atoi(argv[i] + 5);
} else if (strncmp(argv[i], "DVBC2-", 6) == 0) {
type = DVB_TYPE_C;
m = atoi(argv[i] + 6);
v2 = 1;
} else if (strncmp(argv[i], "DVBC-", 5) == 0) {
type = DVB_TYPE_C;
m = atoi(argv[i] + 5);
} else if (strncmp(argv[i], "ATSC-", 5) == 0) {
type = DVB_TYPE_ATSC;
m = atoi(argv[i] + 5);
} else if (strncmp(argv[i], "DVBCB-", 6) == 0) {
m = atoi(argv[i] + 6);
v2 = 2;
}
if (type == DVB_TYPE_NONE) {
tvhlog(LOG_ERR, "satip", "%s: bad tuner type [%s]",
satip_device_nicename(sd, buf2, sizeof(buf2)), argv[i]);
} else if (m < 0 || m > 32) {
tvhlog(LOG_ERR, "satip", "%s: bad tuner count [%s]",
satip_device_nicename(sd, buf2, sizeof(buf2)), argv[i]);
} else {
sd->sd_nosave = 1;
for (j = 0; j < m; j++)
if (satip_frontend_create(feconf, sd, type, v2, fenum))
fenum++;
sd->sd_nosave = 0;
}
}
if (save)
satip_device_save(sd);
sd->sd_inload = 0;
htsmsg_destroy(conf);
satip_device_dbus_notify(sd, "start");
return sd;
}
static int
http_github(http_connection_t *hc, const char *remain, void *opaque)
{
const char *pid = http_arg_get(&hc->hc_req_args, "project");
const char *key = http_arg_get(&hc->hc_req_args, "key");
if(pid == NULL) {
trace(LOG_WARNING, "github: Missing 'project' in request");
return 400;
}
if(key == NULL) {
trace(LOG_WARNING, "github: Missing 'key' in request");
return 400;
}
project_cfg(pc, pid);
if(pc == NULL) {
trace(LOG_DEBUG, "github: Project '%s' not configured", pid);
return 404;
}
const char *mykey = cfg_get_str(pc, CFG("github", "key"), "");
if(strcmp(mykey, key)) {
trace(LOG_WARNING, "github: Invalid key received (%s) for project %s",
key, pid);
return 403;
}
project_t *p = project_get(pid);
const char *json = http_arg_get(&hc->hc_req_args, "payload");
if(json == NULL) {
plog(p, "github", "github: Missing payload in request");
return 400;
}
char errbuf[256];
htsmsg_t *msg = htsmsg_json_deserialize(json, errbuf, sizeof(errbuf));
if(msg == NULL) {
plog(p, "github", "github: Malformed JSON in github request -- %s",
errbuf);
return 400;
}
const char *ref = htsmsg_get_str(msg, "ref");
if(ref != NULL && !strncmp(ref, "refs/heads/", strlen("refs/heads/")))
ref += strlen("refs/heads/");
htsmsg_t *list = htsmsg_get_list(msg, "commits");
if(ref != NULL && list != NULL) {
htsmsg_field_t *f;
HTSMSG_FOREACH(f, list) {
htsmsg_t *c = htsmsg_get_map_by_field(f);
if(c == NULL)
continue;
const char *url = htsmsg_get_str(c, "url");
const char *msg = htsmsg_get_str(c, "message");
htsmsg_t *a = htsmsg_get_map(c, "author");
const char *author = a ? htsmsg_get_str(a, "name") : NULL;
int added = count_list(c, "added");
int removed = count_list(c, "removed");
int modified = count_list(c, "modified");
int len;
char buf[512];
char ctx[128];
url = url ? urlshorten(url) : NULL;
snprintf(ctx, sizeof(ctx), "changes/%s", ref);
len = snprintf(buf, sizeof(buf),
"Commit in '"COLOR_BLUE"%s"COLOR_OFF"' by "COLOR_PURPLE"%s"COLOR_OFF" [",
ref, author ?: "???");
if(added)
len += snprintf(buf + len, sizeof(buf) - len,
COLOR_GREEN "%d file%s added",
added, added == 1 ? "" : "s");
if(modified)
len += snprintf(buf + len, sizeof(buf) - len,
COLOR_YELLOW "%s%d file%s modified",
added ? ", " : "",
modified, modified == 1 ? "" : "s");
if(removed)
len += snprintf(buf + len, sizeof(buf) - len,
COLOR_RED "%s%d file%s removed",
added || modified ? ", " : "",
removed, removed == 1 ? "" : "s");
snprintf(buf + len, sizeof(buf) - len, COLOR_OFF"]%s%s",
url ? " " : "", url ?: "");
plog(p, ctx, "%s", buf);
plog(p, ctx, "%s", msg);
}
static satip_device_t *
satip_device_create( satip_device_info_t *info )
{
satip_device_t *sd = calloc(1, sizeof(satip_device_t));
uuid_t uuid;
htsmsg_t *conf = NULL, *feconf = NULL;
char *argv[10];
int i, j, n, m, fenum, t2, save = 0;
dvb_fe_type_t type;
satip_device_calc_uuid(&uuid, info->uuid);
conf = hts_settings_load("input/satip/adapters/%s", uuid.hex);
/* some sane defaults */
sd->sd_fullmux_ok = 1;
sd->sd_pids_len = 127;
sd->sd_pids_max = 32;
sd->sd_pids_deladd = 1;
sd->sd_sig_scale = 240;
if (!tvh_hardware_create0((tvh_hardware_t*)sd, &satip_device_class,
uuid.hex, conf)) {
free(sd);
return NULL;
}
pthread_mutex_init(&sd->sd_tune_mutex, NULL);
TAILQ_INIT(&sd->sd_frontends);
/* we may check if uuid matches, but the SHA hash should be enough */
if (sd->sd_info.uuid)
free(sd->sd_info.uuid);
#define ASSIGN(x) sd->sd_info.x = info->x; info->x = NULL
ASSIGN(myaddr);
ASSIGN(addr);
ASSIGN(uuid);
ASSIGN(bootid);
ASSIGN(configid);
ASSIGN(deviceid);
ASSIGN(server);
ASSIGN(location);
ASSIGN(friendlyname);
ASSIGN(manufacturer);
ASSIGN(manufacturerURL);
ASSIGN(modeldesc);
ASSIGN(modelname);
ASSIGN(modelnum);
ASSIGN(serialnum);
ASSIGN(presentation);
ASSIGN(tunercfg);
#undef ASSIGN
/*
* device specific hacks
*/
satip_device_hack(sd);
if (conf)
feconf = htsmsg_get_map(conf, "frontends");
save = !conf || !feconf;
n = http_tokenize(sd->sd_info.tunercfg, argv, 10, ',');
for (i = 0, fenum = 1; i < n; i++) {
type = DVB_TYPE_NONE;
t2 = 0;
if (strncmp(argv[i], "DVBS2-", 6) == 0) {
type = DVB_TYPE_S;
m = atoi(argv[i] + 6);
} else if (strncmp(argv[i], "DVBT2-", 6) == 0) {
type = DVB_TYPE_T;
m = atoi(argv[i] + 6);
t2 = 1;
} else if (strncmp(argv[i], "DVBT-", 5) == 0) {
type = DVB_TYPE_T;
m = atoi(argv[i] + 5);
} else if (strncmp(argv[i], "DVBC-", 5) == 0) {
type = DVB_TYPE_C;
m = atoi(argv[i] + 5);
}
if (type == DVB_TYPE_NONE) {
tvhlog(LOG_ERR, "satip", "%s: bad tuner type [%s]", sd->sd_info.addr, argv[i]);
} else if (m < 0 || m > 32) {
tvhlog(LOG_ERR, "satip", "%s: bad tuner count [%s]", sd->sd_info.addr, argv[i]);
} else {
for (j = 0; j < m; j++)
if (satip_frontend_create(feconf, sd, type, t2, fenum))
fenum++;
}
}
if (save)
satip_device_save(sd);
htsmsg_destroy(conf);
return sd;
}
static void
svg_parse_element(const svg_state_t *s0, htsmsg_t *element,
int (*element_parser)(svg_state_t *s, htsmsg_t *element))
{
svg_state_t s = *s0;
// FT_Outline ol;
// FT_UInt points;
// FT_UInt contours;
int fill_color = 0xffffffff;
int stroke_color = 0xffffffff;
int stroke_width = 0;
htsmsg_t *a = htsmsg_get_map(element, "attrib");
if(a == NULL)
return;
const char *st = htsmsg_get_str(a, "style");
if(st != NULL) {
char *style, *tmp = NULL, *n, *attr;
n = style = strdup(st);
while((attr = strtok_r(n, ";", &tmp)) != NULL) {
char *value = strchr(attr, ':');
if(value != NULL) {
*value++ = 0;
while(*value < 33 && *value)
value++;
if(!strcmp(attr, "fill")) {
if(!strcmp(value, "none"))
fill_color = 0;
else {
fill_color = (fill_color & 0xff000000) | html_makecolor(value);
}
} else if(!strcmp(attr, "stroke")) {
if(!strcmp(value, "none"))
stroke_color = 0;
else {
stroke_color = (stroke_color & 0xff000000) | html_makecolor(value);
}
} else if(!strcmp(attr, "stroke-width")) {
stroke_width = atoi(value);
}
}
n = NULL;
}
free(style);
}
if(s.pm == NULL)
return;
const char *transform = htsmsg_get_str(a, "transform");
if(transform != NULL)
svg_parse_transform(&s, transform);
vec_emit_0(s.pm, VC_BEGIN);
if(fill_color) {
vec_emit_i1(s.pm, VC_SET_FILL_ENABLE, 1);
vec_emit_i1(s.pm, VC_SET_FILL_COLOR, fill_color);
}
if(stroke_width) {
vec_emit_i1(s.pm, VC_SET_STROKE_WIDTH, stroke_width);
vec_emit_i1(s.pm, VC_SET_STROKE_COLOR, stroke_color);
}
s.cur[0] = 0;
s.cur[1] = 0;
if(element_parser(&s, a))
return;
cmd_close(&s);
vec_emit_0(s.pm, VC_END);
}
int
keyring_lookup(const char *id, char **username, char **password,
char **domain, int query, const char *source,
const char *reason, int force_temporary)
{
htsmsg_t *m;
rstr_t *r;
hts_mutex_lock(&keyring_mutex);
if(query) {
htsmsg_t *parent;
prop_t *p = prop_create_root(NULL);
prop_set_string(prop_create(p, "type"), "auth");
prop_set_string(prop_create(p, "id"), id);
prop_set_string(prop_create(p, "source"), source);
prop_set_string(prop_create(p, "reason"), reason);
int remember = !force_temporary;
prop_set_int(prop_create(p, "canRemember"), remember);
prop_t *rememberMe = prop_create(p, "rememberMe");
prop_set_int(rememberMe, remember);
prop_sub_t *remember_sub =
prop_subscribe(0,
PROP_TAG_CALLBACK_INT, set_remember, &remember,
PROP_TAG_ROOT, rememberMe,
NULL);
prop_t *user = prop_create(p, "username");
prop_t *pass = prop_create(p, "password");
TRACE(TRACE_INFO, "keyring", "Requesting credentials for %s : %s : %s",
id, source, reason);
event_t *e = popup_display(p);
prop_unsubscribe(remember_sub);
if(remember)
parent = persistent_keyring;
else
parent = temporary_keyring;
htsmsg_delete_field(parent, id);
if(event_is_action(e, ACTION_OK)) {
/* OK */
m = htsmsg_create_map();
r = prop_get_string(user);
htsmsg_add_str(m, "username", r ? rstr_get(r) : "");
rstr_release(r);
r = prop_get_string(pass);
htsmsg_add_str(m, "password", r ? rstr_get(r) : "");
rstr_release(r);
htsmsg_add_msg(parent, id, m);
if(parent == persistent_keyring)
keyring_store();
} else {
/* CANCEL, store without adding anything */
keyring_store();
}
prop_destroy(p);
if(event_is_action(e, ACTION_CANCEL)) {
/* return CANCEL to caller */
hts_mutex_unlock(&keyring_mutex);
event_release(e);
return -1;
}
event_release(e);
}
if((m = htsmsg_get_map(temporary_keyring, id)) == NULL &&
(m = htsmsg_get_map(persistent_keyring, id)) == NULL) {
hts_mutex_unlock(&keyring_mutex);
return 1;
}
setstr(username, m, "username");
setstr(password, m, "password");
setstr(domain, m, "domain");
hts_mutex_unlock(&keyring_mutex);
return 0;
}
static void tvhdhomerun_device_create(struct hdhomerun_discover_device_t *dInfo) {
tvhdhomerun_device_t *hd = calloc(1, sizeof(tvhdhomerun_device_t));
htsmsg_t *conf = NULL, *feconf = NULL;
tvh_uuid_t uuid;
int j, save = 0;
struct hdhomerun_device_t *hdhomerun_tuner;
dvb_fe_type_t type = DVB_TYPE_C;
struct in_addr ip_addr;
tvhdhomerun_device_calc_uuid(&uuid, dInfo->device_id);
hdhomerun_tuner = hdhomerun_device_create(dInfo->device_id, dInfo->ip_addr, 0, NULL);
{
const char *deviceModel = hdhomerun_device_get_model_str(hdhomerun_tuner);
if(deviceModel != NULL) {
hd->hd_info.deviceModel = strdup(deviceModel);
}
hdhomerun_device_destroy(hdhomerun_tuner);
}
conf = hts_settings_load("input/tvhdhomerun/adapters/%s", uuid.hex);
if ( conf != NULL ) {
const char *override_type = htsmsg_get_str(conf, "fe_override");
if ( override_type != NULL) {
type = dvb_str2type(override_type);
if ( ! ( type == DVB_TYPE_C || type == DVB_TYPE_T || type == DVB_TYPE_ATSC ) ) {
type = DVB_TYPE_C;
}
}
} else {
if (strstr(hd->hd_info.deviceModel, "_atsc"))
type = DVB_TYPE_ATSC;
}
hd->hd_override_type = strdup(dvb_type2str(type));
tvhlog(LOG_INFO, "tvheadend","Using Network type : %s", hd->hd_override_type);
/* some sane defaults */
hd->hd_fullmux_ok = 1;
hd->hd_pids_len = 127;
hd->hd_pids_max = 32;
hd->hd_pids_deladd = 1;
if (!tvh_hardware_create0((tvh_hardware_t*)hd, &tvhdhomerun_device_class,
uuid.hex, conf)) {
free(hd);
return;
}
TAILQ_INIT(&hd->hd_frontends);
/* we may check if uuid matches, but the SHA hash should be enough */
if (hd->hd_info.uuid)
free(hd->hd_info.uuid);
char fName[128];
snprintf(fName, 128, "HDHomeRun(%08X)",dInfo->device_id);
ip_addr.s_addr = htonl(dInfo->ip_addr);
hd->hd_info.ip_address = strdup(inet_ntoa(ip_addr));
hd->hd_info.uuid = strdup(uuid.hex);
hd->hd_info.friendlyname = strdup(fName);
if (conf)
feconf = htsmsg_get_map(conf, "frontends");
save = !conf || !feconf;
for (j = 0; j < dInfo->tuner_count; ++j) {
if (tvhdhomerun_frontend_create(hd, dInfo, feconf, type, j)) {
tvhlog(LOG_INFO, "tvhdhomerun", "Created frontend %08X tuner %d", dInfo->device_id, j);
} else {
tvhlog(LOG_ERR, "tvhdhomerun", "Unable to create frontend-device. ( %08x-%d )", dInfo->device_id,j);
}
}
if (save)
tvhdhomerun_device_save(hd);
htsmsg_destroy(conf);
}
cfg_t *
cfg_get_map(cfg_t *c, const char *id)
{
return htsmsg_get_map(c, id);
}
/**
* Parse tags inside of a programme
*/
static int _xmltv_parse_programme_tags
(epggrab_module_t *mod, channel_t *ch, htsmsg_t *tags,
time_t start, time_t stop, epggrab_stats_t *stats)
{
int save = 0, save2 = 0, save3 = 0;
epg_episode_t *ee = NULL;
epg_serieslink_t *es = NULL;
epg_broadcast_t *ebc;
epg_genre_list_t *egl;
epg_episode_num_t epnum;
memset(&epnum, 0, sizeof(epnum));
char *suri = NULL, *uri = NULL;
lang_str_t *title = NULL;
lang_str_t *desc = NULL;
lang_str_t *subtitle = NULL;
time_t first_aired = 0;
int8_t bw = -1;
/*
* Broadcast
*/
if (!(ebc = epg_broadcast_find_by_time(ch, start, stop, 0, 1, &save)))
return 0;
stats->broadcasts.total++;
if (save) stats->broadcasts.created++;
/* Description (wait for episode first) */
_xmltv_parse_lang_str(&desc, tags, "desc");
if (desc)
save3 |= epg_broadcast_set_description2(ebc, desc, mod);
/* Quality metadata */
save |= xmltv_parse_vid_quality(mod, ebc, htsmsg_get_map(tags, "video"), &bw);
/* Accessibility */
save |= xmltv_parse_accessibility(mod, ebc, tags);
/* Misc */
save |= _xmltv_parse_previously_shown(mod, ebc, tags, &first_aired);
if (htsmsg_get_map(tags, "premiere") ||
htsmsg_get_map(tags, "new"))
save |= epg_broadcast_set_is_new(ebc, 1, mod);
/*
* Episode/Series info
*/
get_episode_info(mod, tags, &uri, &suri, &epnum);
/*
* Series Link
*/
if (suri) {
es = epg_serieslink_find_by_uri(suri, 1, &save2);
free(suri);
if (es) stats->seasons.total++;
if (save2) stats->seasons.created++;
if (es)
save |= epg_broadcast_set_serieslink(ebc, es, mod);
}
/*
* Episode
*/
if (uri) {
if ((ee = epg_episode_find_by_uri(uri, 1, &save3)))
save |= epg_broadcast_set_episode(ebc, ee, mod);
free(uri);
} else {
ee = epg_broadcast_get_episode(ebc, 1, &save3);
}
if (ee) stats->episodes.total++;
if (save3) stats->episodes.created++;
if (ee) {
_xmltv_parse_lang_str(&title, tags, "title");
_xmltv_parse_lang_str(&subtitle, tags, "sub-title");
if (title)
save3 |= epg_episode_set_title2(ee, title, mod);
if (subtitle)
save3 |= epg_episode_set_subtitle2(ee, subtitle, mod);
if ((egl = _xmltv_parse_categories(tags))) {
save3 |= epg_episode_set_genre(ee, egl, mod);
epg_genre_list_destroy(egl);
}
if (bw != -1)
save3 |= epg_episode_set_is_bw(ee, (uint8_t)bw, mod);
save3 |= epg_episode_set_epnum(ee, &epnum, mod);
save3 |= _xmltv_parse_star_rating(mod, ee, tags);
// TODO: parental rating
}
/* Stats */
if (save) stats->broadcasts.modified++;
if (save2) stats->seasons.modified++;
if (save3) stats->episodes.modified++;
/* Cleanup */
if (title) lang_str_destroy(title);
if (subtitle) lang_str_destroy(subtitle);
if (desc) lang_str_destroy(desc);
return save | save2 | save3;
}
int
keyring_lookup(const char *id, char **username, char **password,
char **domain, int *remember_me, const char *source,
const char *reason, int flags)
{
htsmsg_t *m;
rstr_t *r;
int remember = !!(flags & KEYRING_REMEMBER_ME_SET);
hts_mutex_lock(&keyring_mutex);
if(flags & KEYRING_QUERY_USER) {
htsmsg_t *parent;
prop_t *p = prop_create_root(NULL);
prop_set_string(prop_create(p, "type"), "auth");
prop_set_string(prop_create(p, "id"), id);
prop_set_string(prop_create(p, "source"), source);
prop_set_string(prop_create(p, "reason"), reason);
prop_set_int(prop_create(p, "disableUsername"), username == NULL);
prop_set_int(prop_create(p, "canRemember"),
!!(flags & KEYRING_SHOW_REMEMBER_ME));
prop_t *rememberMe = prop_create(p, "rememberMe");
prop_set_int(rememberMe, remember);
prop_sub_t *remember_sub =
prop_subscribe(0,
PROP_TAG_CALLBACK_INT, set_remember, &remember,
PROP_TAG_ROOT, rememberMe,
NULL);
prop_t *user = prop_create(p, "username");
prop_t *pass = prop_create(p, "password");
TRACE(TRACE_INFO, "keyring", "Requesting credentials for %s : %s : %s",
id, source, reason);
event_t *e = popup_display(p);
prop_unsubscribe(remember_sub);
if(flags & KEYRING_ONE_SHOT)
parent = NULL;
else if(remember)
parent = persistent_keyring;
else
parent = temporary_keyring;
if(parent != NULL)
htsmsg_delete_field(parent, id);
if(event_is_action(e, ACTION_OK)) {
/* OK */
m = htsmsg_create_map();
if(username != NULL) {
r = prop_get_string(user);
htsmsg_add_str(m, "username", r ? rstr_get(r) : "");
*username = strdup(r ? rstr_get(r) : "");
rstr_release(r);
}
r = prop_get_string(pass);
htsmsg_add_str(m, "password", r ? rstr_get(r) : "");
*password = strdup(r ? rstr_get(r) : "");
rstr_release(r);
if(parent != NULL) {
htsmsg_add_msg(parent, id, m);
if(parent == persistent_keyring)
keyring_store();
}
} else {
/* CANCEL */
if(parent == persistent_keyring)
keyring_store();
}
if(remember_me != NULL)
*remember_me = remember;
prop_destroy(p);
if(event_is_action(e, ACTION_CANCEL)) {
/* return CANCEL to caller */
hts_mutex_unlock(&keyring_mutex);
event_release(e);
return -1;
}
event_release(e);
} else {
if((m = htsmsg_get_map(temporary_keyring, id)) == NULL &&
(m = htsmsg_get_map(persistent_keyring, id)) == NULL) {
hts_mutex_unlock(&keyring_mutex);
return 1;
}
setstr(username, m, "username");
setstr(password, m, "password");
setstr(domain, m, "domain");
}
hts_mutex_unlock(&keyring_mutex);
return 0;
}