static htsmsg_t * avt_generate_props(upnp_local_service_t *uls, const char *myhost, int myport) { char *event; htsbuf_queue_t xml; char str[256]; const char *s; htsbuf_queue_init(&xml, 0); htsbuf_qprintf(&xml, "<Event xmlns=\"urn:schemas-upnp-org:metadata-1-0/RCS/\">" "<InstanceID val=\"0\">"); upnp_event_encode_str(&xml, "TransportState", current_playstate()); upnp_event_encode_str(&xml, "CurrentMediaCategory", current_mediaCategory()); // PlaybackStorageMedium if(upnp_current_playstatus == NULL) s = "NONE"; else s = "NETWORK"; upnp_event_encode_str(&xml, "PlaybackStorageMedium", s); upnp_event_encode_str(&xml, "CurrentPlayMode", current_playMode()); current_transportActions(str, sizeof(str)); upnp_event_encode_str(&xml, "CurrentTransportActions", str); upnp_event_encode_int(&xml, "NumberOfTracks", upnp_current_total_tracks); upnp_event_encode_int(&xml, "CurrentTrack", upnp_current_track); upnp_event_encode_str(&xml, "AVTransportURI", upnp_current_url ?: ""); upnp_event_encode_int(&xml, "TransportPlaySpeed", 1); // Metadata char *meta = build_didl(myhost, myport); upnp_event_encode_str(&xml, "AVTransportURIMetaData", meta); upnp_event_encode_str(&xml, "CurrentTrackMetaData", meta); free(meta); fmttime(str, sizeof(str), upnp_current_track_duration); upnp_event_encode_str(&xml, "CurrentTrackDuration", str); upnp_event_encode_str(&xml, "CurrentMediaDuration", str); upnp_event_encode_str(&xml, "PossibleRecordQualityModes", NULL); upnp_event_encode_str(&xml, "TransportStatus", "OK"); upnp_event_encode_str(&xml, "DRMState", "UNKNOWN"); upnp_event_encode_str(&xml, "RecordMediumWriteStatus", NULL); upnp_event_encode_str(&xml, "RecordStorageMedium", NULL); upnp_event_encode_str(&xml, "PossibleRecordStorageMedia", NULL); upnp_event_encode_str(&xml, "NextAVTransportURI", ""); upnp_event_encode_str(&xml, "NextAVTransportURIMetaData", NULL); upnp_event_encode_str(&xml, "CurrentRecordQualityMode", NULL); upnp_event_encode_str(&xml, "PossiblePlaybackStorageMedia", "NETWORK"); htsbuf_qprintf(&xml, "</InstanceID></Event>"); event = htsbuf_to_string(&xml); htsmsg_t *r = htsmsg_create_map(); htsmsg_add_str(r, "LastChange", event); free(event); return r; }
/* * Extended Event - 0x4e */ static int _eit_desc_ext_event ( epggrab_module_t *mod, const uint8_t *ptr, int len, eit_event_t *ev ) { int r, ilen; char ikey[512], ival[512]; char buf[512], lang[4]; const uint8_t *iptr; if (len < 6) return -1; /* Descriptor numbering (skip) */ len -= 1; ptr += 1; /* Language */ memcpy(lang, ptr, 3); lang[3] = '\0'; len -= 3; ptr += 3; /* Key/Value items */ ilen = *ptr; len -= 1; ptr += 1; iptr = ptr; if (len < ilen) return -1; /* Skip past */ ptr += ilen; len -= ilen; /* Process */ while (ilen) { /* Key */ if ( (r = _eit_get_string_with_len(mod, ikey, sizeof(ikey), iptr, ilen, ev->default_charset)) < 0 ) break; ilen -= r; iptr += r; /* Value */ if ( (r = _eit_get_string_with_len(mod, ival, sizeof(ival), iptr, ilen, ev->default_charset)) < 0 ) break; ilen -= r; iptr += r; /* Store */ // TODO: extend existing? #if TODO_ADD_EXTRA if (*ikey && *ival) { if (!ev->extra) ev->extra = htsmsg_create_map(); htsmsg_add_str(ev->extra, ikey, ival); } #endif } /* Description */ if ( _eit_get_string_with_len(mod, buf, sizeof(buf), ptr, len, ev->default_charset) > 1 ) { if (!ev->desc) ev->desc = lang_str_create(); lang_str_append(ev->desc, buf, lang); } return 0; }
int soap_exec(const char *uri, const char *service, int version, const char *method, htsmsg_t *in, htsmsg_t **outp, char *errbuf, size_t errlen) { int r; htsmsg_t *out; htsbuf_queue_t post; buf_t *result; struct http_header_list hdrs = {0}; char tmp[100]; htsbuf_queue_init(&post, 0); htsbuf_qprintf(&post, "<?xml version=\"1.0\" encoding=\"utf-8\"?>" "<s:Envelope s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\" xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\">" "<s:Body><ns0:%s xmlns:ns0=\"urn:schemas-upnp-org:service:%s:%d\">", method, service, version); soap_encode_args(&post, in); htsbuf_qprintf(&post, "</ns0:%s></s:Body></s:Envelope>", method); snprintf(tmp, sizeof(tmp),"\"urn:schemas-upnp-org:service:%s:%d#%s\"", service, version, method); http_header_add(&hdrs, "SOAPACTION", tmp, 0); r = http_request(uri, NULL, &result, errbuf, errlen, &post, "text/xml; charset=\"utf-8\"", 0, NULL, &hdrs, NULL, NULL, NULL); http_headers_free(&hdrs); htsbuf_queue_flush(&post); if(r) return -1; out = htsmsg_xml_deserialize_buf2(result, errbuf, errlen); if(out == NULL) return -1; snprintf(tmp, sizeof(tmp), "urn:schemas-upnp-org:service:%s:%d%sResponse", service, version, method); htsmsg_t *outargs = htsmsg_get_map_multi(out, "tags", "http://schemas.xmlsoap.org/soap/envelope/Envelope", "tags", "http://schemas.xmlsoap.org/soap/envelope/Body", "tags", tmp, "tags", NULL); if(outargs != NULL) { htsmsg_field_t *f; htsmsg_t *out = htsmsg_create_map(); // Convert args from XML style to more compact style HTSMSG_FOREACH(f, outargs) { htsmsg_t *a; const char *s; if((a = htsmsg_get_map_by_field(f)) == NULL) continue; if((s = htsmsg_get_str(a, "cdata")) != NULL) htsmsg_add_str(out, f->hmf_name, s); }
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; }
htsmsg_t * dvb_mux_preconf_get_node(int fetype, const char *node) { const struct region *r; const struct network *n; int nr, nn, i; htsmsg_t *out, *e; switch(fetype) { case FE_QAM: r = regions_DVBC; nr = sizeof(regions_DVBC) / sizeof(regions_DVBC[0]); break; case FE_QPSK: r = regions_DVBS; nr = sizeof(regions_DVBS) / sizeof(regions_DVBS[0]); break; case FE_OFDM: r = regions_DVBT; nr = sizeof(regions_DVBT) / sizeof(regions_DVBT[0]); break; case FE_ATSC: r = regions_ATSC; nr = sizeof(regions_ATSC) / sizeof(regions_ATSC[0]); break; default: tvhlog(LOG_ERR, "DVB", "No built-in config for fetype %d", fetype); return NULL; } out = htsmsg_create_list(); if(!strcmp(node, "root")) { for(i = 0; i < nr; i++) { e = htsmsg_create_map(); htsmsg_add_u32(e, "leaf", 0); htsmsg_add_str(e, "text", r[i].name); htsmsg_add_str(e, "id", r[i].name); htsmsg_add_msg(out, NULL, e); } return out; } for(i = 0; i < nr; i++) if(!strcmp(node, r[i].name)) break; if(i == nr) return out; n = r[i].networks; nn = r[i].nnetworks; for(i = 0; i < nn; i++) { e = htsmsg_create_map(); htsmsg_add_u32(e, "leaf", 1); htsmsg_add_str(e, "text", n[i].name); htsmsg_add_str(e, "id", n[i].name); htsmsg_add_msg(out, NULL, e); } return out; }
static void hello_save(idnode_t *in) { wizard_page_t *p = (wizard_page_t *)in; wizard_hello_t *w = p->aux; access_entry_t *ae, *ae_next; passwd_entry_t *pw, *pw_next; htsmsg_t *conf; const char *s; for (ae = TAILQ_FIRST(&access_entries); ae; ae = ae_next) { ae_next = TAILQ_NEXT(ae, ae_link); if (ae->ae_wizard) access_entry_destroy(ae, 1); } for (pw = TAILQ_FIRST(&passwd_entries); pw; pw = pw_next) { pw_next = TAILQ_NEXT(pw, pw_link); if (pw->pw_wizard) passwd_entry_destroy(pw, 1); } s = w->admin_username[0] ? w->admin_username : "******"; conf = htsmsg_create_map(); htsmsg_add_bool(conf, "enabled", 1); htsmsg_add_str(conf, "prefix", w->network); htsmsg_add_str(conf, "username", s); htsmsg_add_str(conf, "password", w->admin_password); htsmsg_add_bool(conf, "streaming", 1); htsmsg_add_bool(conf, "adv_streaming", 1); htsmsg_add_bool(conf, "htsp_streaming", 1); htsmsg_add_bool(conf, "dvr", 1); htsmsg_add_bool(conf, "htsp_dvr", 1); htsmsg_add_bool(conf, "webui", 1); htsmsg_add_bool(conf, "admin", 1); ae = access_entry_create(NULL, conf); if (ae) { ae->ae_wizard = 1; access_entry_save(ae); } htsmsg_destroy(conf); if (s && s[0] != '*' && w->admin_password[0]) { conf = htsmsg_create_map(); htsmsg_add_bool(conf, "enabled", 1); htsmsg_add_str(conf, "username", s); htsmsg_add_str(conf, "password", w->admin_password); pw = passwd_entry_create(NULL, conf); if (pw) { pw->pw_wizard = 1; passwd_entry_save(pw); } } if (w->username[0]) { s = w->username && w->username[0] ? w->username : "******"; conf = htsmsg_create_map(); htsmsg_add_str(conf, "prefix", w->network); htsmsg_add_str(conf, "username", s); htsmsg_add_str(conf, "password", w->password); ae = access_entry_create(NULL, conf); if (ae) { ae->ae_wizard = 1; access_entry_save(ae); } htsmsg_destroy(conf); if (s && s[0] != '*' && w->password && w->password[0]) { conf = htsmsg_create_map(); htsmsg_add_bool(conf, "enabled", 1); htsmsg_add_str(conf, "username", s); htsmsg_add_str(conf, "password", w->password); pw = passwd_entry_create(NULL, conf); if (pw) { pw->pw_wizard = 1; passwd_entry_save(pw); } } } }
bool CHTSPData::SendEnableAsync() { htsmsg_t *m = htsmsg_create_map(); htsmsg_add_str(m, "method", "enableAsyncMetadata"); return m_session->ReadSuccess(m, true, "enableAsyncMetadata failed"); }
static int scanfile_load_dvbv5 ( scanfile_network_t *net, char *line, fb_file *fp ) { int res = 1, r = 1; char buf[256]; char *s, *t; const char *x; dvb_mux_conf_t *mux; htsmsg_t *l; /* validity check for [text] */ s = str_trim(line); if (s == '\0' || s[strlen(s) - 1] != ']') return 1; l = htsmsg_create_map(); /* Process file */ while (!fb_eof(fp)) { /* Get line */ buf[sizeof(buf)-1] = '\0'; if (!fb_gets(fp, buf, sizeof(buf) - 1)) break; s = str_trim(buf); if (*s == '#' || *s == '\0') continue; if (*s == '[') { res = 0; break; } if ((t = strchr(s, '=')) == NULL) continue; *t = '\0'; s = str_trim(s); t = str_trim(t + 1); htsmsg_add_str(l, s, t); } mux = malloc(sizeof(dvb_mux_conf_t)); mux->dmc_fe_delsys = -1; x = htsmsg_get_str(l, "DELIVERY_SYSTEM"); if (x && (mux->dmc_fe_delsys = dvb_str2delsys(x)) == -1) { if (!strcmp(s, "DVBC")) mux->dmc_fe_delsys = DVB_SYS_DVBC_ANNEX_A; } if (!x || (int)mux->dmc_fe_delsys < 0) mux_fail(r, "wrong system '%s'", x); dvb_mux_conf_init(mux, mux->dmc_fe_delsys); if (mux->dmc_fe_delsys == DVB_SYS_DVBT || mux->dmc_fe_delsys == DVB_SYS_DVBT2) { mux->u.dmc_fe_ofdm.bandwidth = DVB_BANDWIDTH_AUTO; mux->u.dmc_fe_ofdm.code_rate_HP = DVB_FEC_AUTO; mux->u.dmc_fe_ofdm.code_rate_LP = DVB_FEC_NONE; mux->dmc_fe_modulation = DVB_MOD_QAM_64; mux->u.dmc_fe_ofdm.transmission_mode = DVB_TRANSMISSION_MODE_8K; mux->u.dmc_fe_ofdm.hierarchy_information = DVB_HIERARCHY_NONE; if ((x = htsmsg_get_str(l, "BANDWIDTH_HZ"))) { if (isdigit(x[0])) { /* convert to kHz */ int64_t ll = strtoll(x, NULL, 0); ll /= 1000; snprintf(buf, sizeof(buf), "%llu", (long long unsigned)ll); x = buf; } if ((mux->u.dmc_fe_ofdm.bandwidth = dvb_str2bw(x)) == -1) mux_fail(r, "wrong bandwidth '%s'", x); } if ((x = htsmsg_get_str(l, "CODE_RATE_HP"))) if ((mux->u.dmc_fe_ofdm.code_rate_HP = dvb_str2fec(x)) == -1) mux_fail(r, "wrong code rate HP '%s'", x); if ((x = htsmsg_get_str(l, "CODE_RATE_LP"))) if ((mux->u.dmc_fe_ofdm.code_rate_LP = dvb_str2fec(x)) == -1) mux_fail(r, "wrong code rate LP '%s'", x); if ((x = htsmsg_get_str(l, "MODULATION"))) if ((mux->dmc_fe_modulation = dvb_str2qam(x)) == -1) mux_fail(r, "wrong modulation '%s'", x); if ((x = htsmsg_get_str(l, "TRANSMISSION_MODE"))) if ((mux->u.dmc_fe_ofdm.transmission_mode = dvb_str2mode(x)) == -1) mux_fail(r, "wrong transmission mode '%s'", x); if ((x = htsmsg_get_str(l, "GUARD_INTERVAL"))) if ((mux->u.dmc_fe_ofdm.guard_interval = dvb_str2guard(x)) == -1) mux_fail(r, "wrong guard interval '%s'", x); if ((x = htsmsg_get_str(l, "HIERARCHY"))) if ((mux->u.dmc_fe_ofdm.hierarchy_information = dvb_str2hier(x)) == -1) mux_fail(r, "wrong hierarchy '%s'", x); if ((x = htsmsg_get_str(l, "INVERSION"))) if ((mux->dmc_fe_inversion = dvb_str2inver(x)) == -1) mux_fail(r, "wrong inversion '%s'", x); if (htsmsg_get_s32(l, "STREAM_ID", &mux->dmc_fe_stream_id)) mux->dmc_fe_stream_id = DVB_NO_STREAM_ID_FILTER; } else if (mux->dmc_fe_delsys == DVB_SYS_DVBS || mux->dmc_fe_delsys == DVB_SYS_DVBS2) { mux->dmc_fe_modulation = mux->dmc_fe_delsys == DVB_SYS_DVBS2 ? DVB_MOD_PSK_8 : DVB_MOD_QPSK; mux->u.dmc_fe_qpsk.fec_inner = DVB_FEC_AUTO; mux->dmc_fe_rolloff = DVB_ROLLOFF_35; if ((x = htsmsg_get_str(l, "MODULATION"))) if ((mux->dmc_fe_modulation = dvb_str2qam(x)) == -1) mux_fail(r, "wrong modulation '%s'", x); if ((x = htsmsg_get_str(l, "INNER_FEC"))) if ((mux->u.dmc_fe_qpsk.fec_inner = dvb_str2fec(x)) == -1) mux_fail(r, "wrong inner FEC '%s'", x); if ((x = htsmsg_get_str(l, "INVERSION"))) if ((mux->dmc_fe_inversion = dvb_str2inver(x)) == -1) mux_fail(r, "wrong inversion '%s'", x); if ((x = htsmsg_get_str(l, "ROLLOFF"))) if ((mux->dmc_fe_rolloff = dvb_str2rolloff(x)) == -1) mux_fail(r, "wrong rolloff '%s'", x); if ((x = htsmsg_get_str(l, "PILOT"))) if ((mux->dmc_fe_pilot = dvb_str2rolloff(x)) == -1) mux_fail(r, "wrong pilot '%s'", x); if (htsmsg_get_s32(l, "STREAM_ID", &r)) { mux->dmc_fe_stream_id = DVB_NO_STREAM_ID_FILTER; mux->dmc_fe_pls_mode = 0; mux->dmc_fe_pls_code = 1; } else { mux->dmc_fe_stream_id = r&0xff; mux->dmc_fe_pls_mode = (r>>26)&0x3; mux->dmc_fe_pls_code = (r>>8)&0x3FFFF; } if ((x = htsmsg_get_str(l, "POLARIZATION"))) { char pol[2]; pol[0] = x[0]; pol[1] = '\0'; if ((mux->u.dmc_fe_qpsk.polarisation = dvb_str2pol(pol)) == -1) mux_fail(r, "wrong polarisation '%s'", x); } else { mux_fail0(r, "dvb-s: undefined polarisation"); } if (htsmsg_get_u32(l, "SYMBOL_RATE", &mux->u.dmc_fe_qpsk.symbol_rate)) mux_fail0(r, "dvb-s: undefined symbol rate"); } else if (mux->dmc_fe_delsys == DVB_SYS_DVBC_ANNEX_A ||
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; }
/** * Internal log function */ static void tvhlogv(int notify, int severity, const char *subsys, const char *fmt, va_list ap) { char buf[2048]; char buf2[2048]; char t[50]; int l; struct tm tm; time_t now; static int log_path_fail = 0; l = snprintf(buf, sizeof(buf), "%s: ", subsys); vsnprintf(buf + l, sizeof(buf) - l, fmt, ap); if(log_debug_to_syslog || severity < LOG_DEBUG) syslog(severity, "%s", buf); /** * Get time (string) */ time(&now); localtime_r(&now, &tm); strftime(t, sizeof(t), "%b %d %H:%M:%S", &tm); /** * Send notification to Comet (Push interface to web-clients) */ if(notify) { htsmsg_t *m; snprintf(buf2, sizeof(buf2), "%s %s", t, buf); m = htsmsg_create_map(); htsmsg_add_str(m, "notificationClass", "logmessage"); htsmsg_add_str(m, "logtxt", buf2); comet_mailbox_add_message(m, severity == LOG_DEBUG); htsmsg_destroy(m); } /** * Write to stderr */ if(log_stderr && (log_debug_to_console || severity < LOG_DEBUG)) { const char *leveltxt = logtxtmeta[severity][0]; const char *sgr = logtxtmeta[severity][1]; const char *sgroff; if(!log_decorate) { sgr = ""; sgroff = ""; } else { sgroff = "\033[0m"; } fprintf(stderr, "%s%s [%7s]:%s%s\n", sgr, t, leveltxt, buf, sgroff); } /** * Write to file */ if (log_path && (log_debug_to_path || severity < LOG_DEBUG)) { const char *leveltxt = logtxtmeta[severity][0]; FILE *fp = fopen(log_path, "a"); if (fp) { log_path_fail = 0; fprintf(fp, "%s [%7s]:%s\n", t, leveltxt, buf); fclose(fp); } else { if (!log_path_fail) syslog(LOG_WARNING, "failed to write log file %s", log_path); log_path_fail = 1; } } }
static htsmsg_t * timeshift_input_info(void *opaque, htsmsg_t *list) { htsmsg_add_str(list, NULL, "wtimeshift input"); return list; }
/** * Front end monitor * * Monitor status every second */ static void dvb_fe_monitor(void *aux) { th_dvb_adapter_t *tda = aux; fe_status_t fe_status; int status, v, update = 0, vv, i, fec, q; th_dvb_mux_instance_t *tdmi = tda->tda_mux_current; char buf[50]; gtimer_arm(&tda->tda_fe_monitor_timer, dvb_fe_monitor, tda, 1); if(tdmi == NULL) return; /** * Read out front end status */ if(ioctl(tda->tda_fe_fd, FE_READ_STATUS, &fe_status)) fe_status = 0; if(fe_status & FE_HAS_LOCK) status = -1; else if(fe_status & (FE_HAS_SYNC | FE_HAS_VITERBI | FE_HAS_CARRIER)) status = TDMI_FE_BAD_SIGNAL; else if(fe_status & FE_HAS_SIGNAL) status = TDMI_FE_FAINT_SIGNAL; else status = TDMI_FE_NO_SIGNAL; if(tda->tda_fe_monitor_hold > 0) { /* Post tuning threshold */ if(status == -1) { /* We have a lock, don't hold off */ tda->tda_fe_monitor_hold = 0; /* Reset FEC counter */ dvb_fe_get_unc(tda); } else { tda->tda_fe_monitor_hold--; return; } } if(status == -1) { /* Read FEC counter (delta) */ fec = dvb_fe_get_unc(tda); tdmi->tdmi_fec_err_histogram[tdmi->tdmi_fec_err_ptr++] = fec; if(tdmi->tdmi_fec_err_ptr == TDMI_FEC_ERR_HISTOGRAM_SIZE) tdmi->tdmi_fec_err_ptr = 0; v = vv = 0; for(i = 0; i < TDMI_FEC_ERR_HISTOGRAM_SIZE; i++) { if(tdmi->tdmi_fec_err_histogram[i] > DVB_FEC_ERROR_LIMIT) v++; vv += tdmi->tdmi_fec_err_histogram[i]; } vv = vv / TDMI_FEC_ERR_HISTOGRAM_SIZE; if(v == 0) { status = TDMI_FE_OK; } else if(v == 1) { status = TDMI_FE_BURSTY_FEC; } else { status = TDMI_FE_CONSTANT_FEC; } /* bit error rate */ if(ioctl(tda->tda_fe_fd, FE_READ_BER, &tdmi->tdmi_ber) == -1) tdmi->tdmi_ber = -2; /* signal strength */ if(ioctl(tda->tda_fe_fd, FE_READ_SIGNAL_STRENGTH, &tdmi->tdmi_signal) == -1) tdmi->tdmi_signal = -2; /* signal/noise ratio */ if(ioctl(tda->tda_fe_fd, FE_READ_SNR, &tdmi->tdmi_snr) == -1) tdmi->tdmi_snr = -2; } if(status != tdmi->tdmi_fe_status) { tdmi->tdmi_fe_status = status; dvb_mux_nicename(buf, sizeof(buf), tdmi); tvhlog(LOG_DEBUG, "dvb", "\"%s\" on adapter \"%s\", status changed to %s", buf, tda->tda_displayname, dvb_mux_status(tdmi)); update = 1; } if(status != TDMI_FE_UNKNOWN) { if(tda->tda_qmon) { q = tdmi->tdmi_quality + (status - TDMI_FE_OK + 1); q = MAX(MIN(q, 100), 0); } else { q = 100; } if(q != tdmi->tdmi_quality) { tdmi->tdmi_quality = q; update = 1; } } if(update) { htsmsg_t *m = htsmsg_create_map(); htsmsg_add_str(m, "id", tdmi->tdmi_identifier); htsmsg_add_u32(m, "quality", tdmi->tdmi_quality); notify_by_msg("dvbMux", m); dvb_mux_save(tdmi); } }
static void update_events(htsp_connection_t *hc, prop_t *metadata, int id, int next) { int i; htsmsg_t *m; prop_t *events = prop_create(metadata, "events"); prop_t *current_event = prop_create(metadata, "current"); prop_t *next_event = prop_create(metadata, "next"); char buf[10]; uint32_t u32; int linkstate = 0; if(id == 0) { if(next == 0) { // No events at all prop_destroy_childs(events); return; } id = next; linkstate = 1; } for(i = 0; i < EPG_TAIL; i++) { snprintf(buf, sizeof(buf), "id%d", i); if(id != 0) { m = htsmsg_create_map(); htsmsg_add_str(m, "method", "getEvent"); htsmsg_add_u32(m, "eventId", id); if((m = htsp_reqreply(hc, m)) != NULL) { prop_t *e = prop_create(events, buf); prop_set_string(prop_create(e, "title"), htsmsg_get_str(m, "title")); if(!htsmsg_get_u32(m, "start", &u32)) prop_set_int(prop_create(e, "start"), u32); if(!htsmsg_get_u32(m, "stop", &u32)) prop_set_int(prop_create(e, "stop"), u32); switch(linkstate) { case 0: prop_link(e, current_event); break; case 1: prop_link(e, next_event); break; } linkstate++; id = htsmsg_get_u32_or_default(m, "nextEventId", 0); continue; } else { id = 0; } } prop_destroy_by_name(events, buf); switch(linkstate) { case 0: prop_unlink(current_event); break; case 1: prop_unlink(next_event); break; } linkstate++; } }
static htsmsg_t * htsp_reqreply(htsp_connection_t *hc, htsmsg_t *m) { void *buf; size_t len; uint32_t seq; int r; tcpcon_t *tc = hc->hc_tc; uint32_t noaccess; htsmsg_t *reply; htsp_msg_t *hm = NULL; int retry = 0; char id[100]; char *username; char *password; struct AVSHA1 *shactx = alloca(av_sha1_size); uint8_t d[20]; if(tc == NULL) return NULL; /* Generate a sequence number for our message */ seq = atomic_add(&hc->hc_seq_generator, 1); htsmsg_add_u32(m, "seq", seq); again: snprintf(id, sizeof(id), "htsp://%s:%d", hc->hc_hostname, hc->hc_port); r = keyring_lookup(id, &username, &password, NULL, !!retry, "TV client", "Access denied"); if(r == -1) { /* User rejected */ return NULL; } if(r == 0) { /* Got auth credentials */ htsmsg_delete_field(m, "username"); htsmsg_delete_field(m, "digest"); if(username != NULL) htsmsg_add_str(m, "username", username); if(password != NULL) { av_sha1_init(shactx); av_sha1_update(shactx, (const uint8_t *)password, strlen(password)); av_sha1_update(shactx, hc->hc_challenge, 32); av_sha1_final(shactx, d); htsmsg_add_bin(m, "digest", d, 20); } free(username); free(password); } if(htsmsg_binary_serialize(m, &buf, &len, -1) < 0) { htsmsg_destroy(m); return NULL; } if(hc->hc_is_async) { /* Async, set up a struct that will be signalled when we get a reply */ hm = malloc(sizeof(htsp_msg_t)); hm->hm_msg = NULL; hm->hm_seq = seq; hm->hm_error = 0; hts_mutex_lock(&hc->hc_rpc_mutex); TAILQ_INSERT_TAIL(&hc->hc_rpc_queue, hm, hm_link); hts_mutex_unlock(&hc->hc_rpc_mutex); } if(tc->write(tc, buf, len)) { free(buf); htsmsg_destroy(m); if(hm != NULL) { hts_mutex_lock(&hc->hc_rpc_mutex); TAILQ_REMOVE(&hc->hc_rpc_queue, hm, hm_link); hts_mutex_unlock(&hc->hc_rpc_mutex); free(hm); } return NULL; } free(buf); if(hm != NULL) { hts_mutex_lock(&hc->hc_rpc_mutex); while(1) { if(hm->hm_error != 0) { r = hm->hm_error; TAILQ_REMOVE(&hc->hc_rpc_queue, hm, hm_link); hts_mutex_unlock(&hc->hc_rpc_mutex); free(hm); htsmsg_destroy(m); return NULL; } if(hm->hm_msg != NULL) break; hts_cond_wait(&hc->hc_rpc_cond, &hc->hc_rpc_mutex); } TAILQ_REMOVE(&hc->hc_rpc_queue, hm, hm_link); hts_mutex_unlock(&hc->hc_rpc_mutex); reply = hm->hm_msg; free(hm); } else { if((reply = htsp_recv(hc)) == NULL) { htsmsg_destroy(m); return NULL; } } if(!htsmsg_get_u32(reply, "noaccess", &noaccess) && noaccess) { retry++; goto again; } htsmsg_destroy(m); /* Destroy original message */ return reply; }