コード例 #1
0
ファイル: muxer.c プロジェクト: KawaDict/tvheadend
/**
 * Get a list of supported containers
 */
int
muxer_container_list(htsmsg_t *array)
{
  htsmsg_t *mc;
  int c = 0;

  mc = htsmsg_create_map();
  htsmsg_add_str(mc, "name",        muxer_container_type2txt(MC_MATROSKA));
  htsmsg_add_str(mc, "description", "Matroska");
  htsmsg_add_msg(array, NULL, mc);
  c++;
  
  mc = htsmsg_create_map();
  htsmsg_add_str(mc, "name",        muxer_container_type2txt(MC_PASS));
  htsmsg_add_str(mc, "description", "Same as source (pass through)");
  htsmsg_add_msg(array, NULL, mc);
  c++;

#if ENABLE_LIBAV
  mc = htsmsg_create_map();
  htsmsg_add_str(mc, "name",        muxer_container_type2txt(MC_MPEGTS));
  htsmsg_add_str(mc, "description", "MPEG-TS");
  htsmsg_add_msg(array, NULL, mc);
  c++;

  mc = htsmsg_create_map();
  htsmsg_add_str(mc, "name",        muxer_container_type2txt(MC_MPEGPS));
  htsmsg_add_str(mc, "description", "MPEG-PS (DVD)");
  htsmsg_add_msg(array, NULL, mc);
  c++;
#endif

  return c;
}
コード例 #2
0
ファイル: usage.c プロジェクト: Ralbarker/showtime
static htsmsg_t *
make_usage_report(void)
{
  extern const char *htsversion_full;

  htsmsg_t *out = htsmsg_create_map();

  htsmsg_add_str(out, "deviceid", gconf.device_id);
  htsmsg_add_str(out, "version", htsversion_full);
  htsmsg_add_str(out, "arch", arch_get_system_type());
  htsmsg_add_u32(out, "verint", app_get_version_int());
  htsmsg_add_u32(out, "generated", time(NULL));
  if(gconf.os_info[0])
    htsmsg_add_str(out, "os" , gconf.os_info);

  time_t now = arch_get_ts() / 1000000LL;

  int runtime = now - usage_time_base;
  htsmsg_s32_inc(usage_counters, "runtime", runtime);
  usage_time_base = now;

  htsmsg_add_msg(out, "counters", usage_counters);
  usage_counters = htsmsg_create_map();

  htsmsg_add_msg(out, "plugincounters", plugin_counters);
  plugin_counters = htsmsg_create_map();

  return out;
}
コード例 #3
0
ファイル: influxdb.c プロジェクト: andoma/hapd
void
influxdb_put(const char *id, double value)
{
  char url[1024];
  cfg_root(root);

  const char *urlprefix = cfg_get_str(root, CFG("influxdb", "url"), NULL);
  const char *db        = cfg_get_str(root, CFG("influxdb", "db"), NULL);
  const char *username  = cfg_get_str(root, CFG("influxdb", "username"), NULL);
  const char *password  = cfg_get_str(root, CFG("influxdb", "password"), NULL);
  if(urlprefix == NULL || db == NULL || username == NULL || password == NULL)
    return;

  snprintf(url, sizeof(url), "%s/db/%s/series?u=%s&p=%s",
           urlprefix, db, username, password);

  htsmsg_t *doc = htsmsg_create_list();
  htsmsg_t *item = htsmsg_create_map();

  htsmsg_add_str(item, "name", id);

  htsmsg_t *columns = htsmsg_create_list();
  htsmsg_add_str(columns, NULL, "value");
  htsmsg_add_msg(item, "columns", columns);

  htsmsg_t *points = htsmsg_create_list();
  htsmsg_t *point = htsmsg_create_list();
  htsmsg_add_dbl(point, NULL, value);
  htsmsg_add_msg(points, NULL, point);
  htsmsg_add_msg(item, "points", points);

  htsmsg_add_msg(doc, NULL, item);

  char *data = htsmsg_json_serialize_to_str(doc, 0);
  htsmsg_destroy(doc);

  size_t len = strlen(data);

  FILE *f = fmemopen(data, len, "r");

  CURL *curl = curl_easy_init();
  curl_easy_setopt(curl, CURLOPT_URL, url);
  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
  curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1L);
  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &libsvc_curl_waste_output);
  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
  curl_easy_setopt(curl, CURLOPT_READDATA, (void *)f);
  curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)len);

  CURLcode result = curl_easy_perform(curl);

  curl_easy_cleanup(curl);

  if(result)
    trace(LOG_ERR, "CURL Failed %s error %d", url, result);
  fclose(f);
  free(data);
}
コード例 #4
0
ファイル: xmlrpc.c プロジェクト: Ezio-PS/movian
static int
xmlrpc_parse_value(htsmsg_t *dst, htsmsg_field_t *g, const char *name,
		   char *errbuf, size_t errlen)
{
  const char *cdata;
  htsmsg_t *c;
  htsmsg_t *sub;

  if(!strcmp(g->hmf_name, "struct") &&
     (c = htsmsg_get_map_by_field(g)) != NULL) {

    sub = htsmsg_create_map();
    if(xmlrpc_parse_struct(sub, c, errbuf, errlen)) {
      htsmsg_release(sub);
      return -1;
    }
    htsmsg_add_msg(dst, name, sub);
    return 0;

  } else if(!strcmp(g->hmf_name, "array") &&
	    (c = htsmsg_get_map_by_field(g)) != NULL) {

    sub = htsmsg_create_list();
    if(xmlrpc_parse_array(sub, c, errbuf, errlen)) {
      htsmsg_release(sub);
      return -1;
    }
    htsmsg_add_msg(dst, name, sub);
    return 0;
  }

  cdata = g->hmf_type == HMF_STR ? g->hmf_str : NULL;

  if(!strcmp(g->hmf_name, "string")) {
    if(cdata != NULL)
      htsmsg_add_str(dst, name, cdata);

  } else if(!strcmp(g->hmf_name, "boolean")) {
    if(cdata != NULL)
      htsmsg_add_u32(dst, name, atoi(cdata));

  } else if(!strcmp(g->hmf_name, "double")) {
    if(cdata != NULL)
      htsmsg_add_dbl(dst, name, my_str2double(cdata, NULL));

  } else if(!strcmp(g->hmf_name, "int")) {
    if(cdata != NULL)
      htsmsg_add_s64(dst, name, atoll(cdata));

  } else {
    snprintf(errbuf, errlen, "Unknown field type \"%s\" %s = %s",
             g->hmf_name, name, cdata);
    return -1;
  }
  return 0;
}
コード例 #5
0
ファイル: api_dvr.c プロジェクト: joukio/tvheadend
static int
api_dvr_entry_create
  ( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
  dvr_entry_t *de;
  dvr_config_t *cfg;
  htsmsg_t *conf, *m;
  char *s, *lang;
  const char *s1;
  int res = EPERM;

  if (!(conf = htsmsg_get_map(args, "conf")))
    return EINVAL;

  pthread_mutex_lock(&global_lock);
  s1 = htsmsg_get_str(conf, "config_name");
  cfg = dvr_config_find_by_list(perm->aa_dvrcfgs, s1);
  if (cfg) {
    htsmsg_set_str(conf, "config_name", idnode_uuid_as_str(&cfg->dvr_id));
    htsmsg_set_str(conf, "owner", perm->aa_username ?: "");
    htsmsg_set_str(conf, "creator", perm->aa_representative ?: "");

    lang = access_get_lang(perm, htsmsg_get_str(conf, "lang"));
    if (lang) {
      for (s = (char *)lang; *s && *s != ','; s++);
      *s = '\0';
    } else {
      lang = strdup(lang_code_preferred());
    }

    s1 = htsmsg_get_str(conf, "disp_title");
    if (s1 && !htsmsg_get_map(conf, "title")) {
      m = htsmsg_create_map();
      htsmsg_add_str(m, lang, s1);
      htsmsg_add_msg(conf, "title", m);
    }

    s1 = htsmsg_get_str(conf, "disp_subtitle");
    if (s1 && !htsmsg_get_map(conf, "subtitle")) {
      m = htsmsg_create_map();
      htsmsg_add_str(m, lang, s1);
      htsmsg_add_msg(conf, "subtitle", m);
    }
    if ((de = dvr_entry_create(NULL, conf)))
      dvr_entry_save(de);

    res = 0;
    free(lang);
  }
  pthread_mutex_unlock(&global_lock);

  return res;
}
コード例 #6
0
ファイル: api_imagecache.c プロジェクト: 1stsetup/tvheadend
static int
api_imagecache_load
  ( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
  htsmsg_t *l;
  pthread_mutex_lock(&global_lock);
  *resp = htsmsg_create_map();
  l     = htsmsg_create_list();
  htsmsg_add_msg(l, NULL, imagecache_get_config());
  htsmsg_add_msg(*resp, "entries", l);
  pthread_mutex_unlock(&global_lock);
  return 0;
}
コード例 #7
0
ファイル: api_channel.c プロジェクト: atamariya/tvheadend
// TODO: this will need converting to an idnode system
static int
api_channel_list
( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
    channel_t *ch;
    htsmsg_t *l;
    int cfg = api_channel_is_all(perm, args);
    char buf[128], ubuf[UUID_HEX_SIZE];

    l = htsmsg_create_list();
    pthread_mutex_lock(&global_lock);
    CHANNEL_FOREACH(ch) {
        if (!cfg && !channel_access(ch, perm, 0)) continue;
        if (!ch->ch_enabled) {
            snprintf(buf, sizeof(buf), "{%s}", channel_get_name(ch));
            api_channel_key_val(l, idnode_uuid_as_str(&ch->ch_id, ubuf), buf);
        } else {
            api_channel_key_val(l, idnode_uuid_as_str(&ch->ch_id, ubuf), channel_get_name(ch));
        }
    }
    pthread_mutex_unlock(&global_lock);
    *resp = htsmsg_create_map();
    htsmsg_add_msg(*resp, "entries", l);

    return 0;
}
コード例 #8
0
ファイル: api_channel.c プロジェクト: atamariya/tvheadend
static int
api_channel_tag_list
( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
    channel_tag_t *ct;
    htsmsg_t *l;
    int cfg = api_channel_is_all(perm, args);
    char buf[128], ubuf[UUID_HEX_SIZE];

    l = htsmsg_create_list();
    pthread_mutex_lock(&global_lock);
    TAILQ_FOREACH(ct, &channel_tags, ct_link)
    if (cfg || channel_tag_access(ct, perm, 0)) {
        if (ct->ct_enabled) {
            api_channel_key_val(l, idnode_uuid_as_str(&ct->ct_id, ubuf), ct->ct_name);
        } else {
            snprintf(buf, sizeof(buf), "{%s}", ct->ct_name);
            api_channel_key_val(l, idnode_uuid_as_str(&ct->ct_id, ubuf), buf);
        }
    }
    pthread_mutex_unlock(&global_lock);
    *resp = htsmsg_create_map();
    htsmsg_add_msg(*resp, "entries", l);
    return 0;
}
コード例 #9
0
static htsmsg_t *
codec_profile_audio_class_language_list(void *obj, const char *lang)
{
    htsmsg_t *list = htsmsg_create_list();
    lang_code_t *lc = (lang_code_t *)lang_codes;
    char lc_buf[128];

    while (lc->code2b) {
        htsmsg_t *map = NULL;
        if (!strcmp(lc->code2b, "und")) {
            map = htsmsg_create_key_val("", tvh_gettext_lang(lang, N_("Use original")));
        }
        else {
            memset(lc_buf, 0, sizeof(lc_buf));
            if (!str_snprintf(lc_buf, sizeof(lc_buf), "%s (%s)", lc->desc, lc->code2b)) {
                map = htsmsg_create_key_val(lc->code2b, lc_buf);
            }
            else {
                htsmsg_destroy(list);
                list = NULL;
                break;
            }
        }
        htsmsg_add_msg(list, NULL, map);
        lc++;
    }
    return list;
}
コード例 #10
0
ファイル: api_channel.c プロジェクト: atamariya/tvheadend
static void
api_channel_key_val(htsmsg_t *dst, const char *key, const char *val)
{
    htsmsg_t *e = htsmsg_create_map();
    htsmsg_add_str(e, "key", key);
    htsmsg_add_str(e, "val", val ?: "");
    htsmsg_add_msg(dst, NULL, e);
}
コード例 #11
0
ファイル: api_language.c プロジェクト: alexkn/tvheadend
static int
api_language_enum
  ( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
  const lang_code_t *c = lang_codes;
  htsmsg_t *l, *e;

  l = htsmsg_create_list();
  while (c->code2b) {
    e = htsmsg_create_map();
    htsmsg_add_str(e, "key", c->code2b);
    htsmsg_add_str(e, "val", c->desc);
    htsmsg_add_msg(l, NULL, e);
    c++;
  }
  *resp = htsmsg_create_map();
  htsmsg_add_msg(*resp, "entries", l);
  return 0;
}
コード例 #12
0
ファイル: api_access.c プロジェクト: Glandos/tvheadend
static int
api_access_entry_userlist
  ( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
  int i;
  idnode_set_t    *is;
  idnode_t        *in;
  access_entry_t  *ae;
  htsmsg_t        *l, *e;

  l = htsmsg_create_list();

  if (!access_verify2(perm, ACCESS_ADMIN))
    goto empty;

  if ((is = idnode_find_all(&access_entry_class, NULL))) {
    for (i = 0; i < is->is_count; i++) {
      in = is->is_array[i];

      if (idnode_perm(in, perm, NULL))
        continue;

      ae = (access_entry_t *)in;
      if (ae->ae_username != NULL && ae->ae_username[0] != '\0' &&
          ae->ae_username[0] != '*') {
        e = htsmsg_create_map();
        htsmsg_add_str(e, "key", ae->ae_username);
        htsmsg_add_str(e, "val", ae->ae_username);
        htsmsg_add_msg(l, NULL, e);
      }

      idnode_perm_unset(in);
    }
    free(is->is_array);
    free(is);
  }

empty:
  *resp = htsmsg_create_map();
  htsmsg_add_msg(*resp, "entries", l);

  return 0;
}
コード例 #13
0
ファイル: module.c プロジェクト: ProfYaffle/tvheadend
static htsmsg_t *
epggrab_module_ota_scrapper_config_list ( void *o, const char *lang )
{
  htsmsg_t *m = htsmsg_create_list();
  htsmsg_t *e = htsmsg_create_map();
  htsmsg_add_str(e, "key", "");
  htsmsg_add_str(e, "val", tvh_gettext_lang(lang, N_("Use default configuration")));
  htsmsg_add_msg(m, NULL, e);
  htsmsg_t *config;
  /* We load all the config so we can get the names of ones that are
   * valid. This is a bit of overhead but we are rarely called since
   * this is for the configuration GUI drop-down.
   */
  if((config = hts_settings_load_r(1, "epggrab/eit/scrape")) != NULL) {
    htsmsg_field_t *f;
    HTSMSG_FOREACH(f, config) {
      e = htsmsg_create_map();
      htsmsg_add_str(e, "key", htsmsg_field_name(f));
      htsmsg_add_str(e, "val", htsmsg_field_name(f));
      htsmsg_add_msg(m, NULL, e);
    }
コード例 #14
0
ファイル: api_epggrab.c プロジェクト: 1stsetup/tvheadend
static int
api_epggrab_channel_list
  ( access_t *perm, void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
  htsmsg_t *m;
  pthread_mutex_lock(&global_lock);
  m = epggrab_channel_list(0);
  pthread_mutex_unlock(&global_lock);
  *resp = htsmsg_create_map();
  htsmsg_add_msg(*resp, "entries", m);
  return 0;
}
コード例 #15
0
ファイル: api.c プロジェクト: BATYD-Turksat/tvheadend
static int
api_serverinfo
  ( void *opaque, const char *op, htsmsg_t *args, htsmsg_t **resp )
{
  *resp = htsmsg_create_map();
  htsmsg_add_str(*resp, "sw_version",   tvheadend_version);
  htsmsg_add_u32(*resp, "api_version",  TVH_API_VERSION);
  htsmsg_add_str(*resp, "name",         "Tvheadend");
  if (tvheadend_webroot)
    htsmsg_add_str(*resp, "webroot",      tvheadend_webroot);
  htsmsg_add_msg(*resp, "capabilities", tvheadend_capabilities_list(1));
  return 0;
}
コード例 #16
0
ファイル: linuxdvb_ca.c プロジェクト: alexkn/tvheadend
void linuxdvb_ca_save( linuxdvb_ca_t *lca, htsmsg_t *msg )
{
  char id[8];
  htsmsg_t *m = htsmsg_create_map();

  htsmsg_add_str(m, "uuid", idnode_uuid_as_str(&lca->lca_id));
  idnode_save(&lca->lca_id, m);

  /* Add to list */
  snprintf(id, sizeof(id), "ca%u", lca->lca_number);
  htsmsg_add_msg(msg, id, m);

}
コード例 #17
0
ファイル: usage.c プロジェクト: Ralbarker/showtime
void
usage_inc_plugin_counter(const char *plugin, const char *id, int value)
{
  hts_mutex_lock(&usage_mutex);
  htsmsg_t *m = htsmsg_get_map(plugin_counters, plugin);
  if(m == NULL) {
    m = htsmsg_create_map();
    htsmsg_add_msg(plugin_counters, plugin, m);
    m = htsmsg_get_map(plugin_counters, plugin);
    assert(m != NULL);
  }

  htsmsg_s32_inc(m, id, value);
  hts_mutex_unlock(&usage_mutex);
}
コード例 #18
0
ファイル: muxer.c プロジェクト: KawaDict/tvheadend
/**
 * Get a list of supported cache schemes
 */
int
muxer_cache_list(htsmsg_t *array)
{
  htsmsg_t *mc;
  int c;
  const char *s;

  for (c = 0; c <= MC_CACHE_LAST; c++) {
    mc = htsmsg_create_map();
    s = muxer_cache_type2txt(c);
    htsmsg_add_u32(mc, "index",       c);
    htsmsg_add_str(mc, "description", s);
    htsmsg_add_msg(array, NULL, mc);
  }

  return c;
}
コード例 #19
0
ファイル: settings.c プロジェクト: dekarl/tvheadend
static htsmsg_t *
hts_settings_load_path(const char *fullpath, int depth)
{
  char child[256];
  struct filebundle_stat st;
  fb_dirent **namelist, *d;
  htsmsg_t *r, *c;
  int n, i;

  /* Invalid */
  if (fb_stat(fullpath, &st)) return NULL;

  /* Directory */
  if (st.is_dir) {

    /* Get file list */
    if((n = fb_scandir(fullpath, &namelist)) < 0)
      return NULL;

    /* Read files */
    r = htsmsg_create_map();
    for(i = 0; i < n; i++) {
      d = namelist[i];
      if(d->name[0] != '.') {

        snprintf(child, sizeof(child), "%s/%s", fullpath, d->name);
        if(d->type == FB_DIR && depth > 0) {
          c = hts_settings_load_path(child, depth - 1);
        } else {
          c = hts_settings_load_one(child);
        }
        if(c != NULL)
          htsmsg_add_msg(r, d->name, c);

      }
      free(d);
    }
    free(namelist);

  /* File */
  } else {
    r = hts_settings_load_one(fullpath);
  }

  return r;
}
コード例 #20
0
ファイル: satip.c プロジェクト: JPP1/tvheadend
void
satip_device_save( satip_device_t *sd )
{
  satip_frontend_t *lfe;
  htsmsg_t *m, *l;

  m = htsmsg_create_map();
  idnode_save(&sd->th_id, m);

  l = htsmsg_create_map();
  TAILQ_FOREACH(lfe, &sd->sd_frontends, sf_link)
    satip_frontend_save(lfe, l);
  htsmsg_add_msg(m, "frontends", l);

  hts_settings_save(m, "input/satip/adapters/%s",
                    idnode_uuid_as_str(&sd->th_id));
  htsmsg_destroy(m);
}
コード例 #21
0
ファイル: usage.c プロジェクト: Ralbarker/showtime
static void *
send_report(void *aux)
{
  htsmsg_t *m = aux;
  htsbuf_queue_t hq;

  htsbuf_queue_init(&hq, 0);

  htsmsg_add_msg(m, "plugins", plugins_get_installed_list());

  htsmsg_json_serialize(m, &hq, 0);

  http_req("https://movian.tv/movian/status/v1/usage",
           HTTP_POSTDATA(&hq, "application/json"),
           NULL);

  htsmsg_release(m);
  return NULL;
}
コード例 #22
0
ファイル: api_dvr.c プロジェクト: bjoern-r/tvheadend
static htsmsg_t *
api_dvr_entry_create_from_single(htsmsg_t *args)
{
  htsmsg_t *entries, *m;
  const char *s1, *s2, *s3;

  if (!(s1 = htsmsg_get_str(args, "config_uuid")))
    return NULL;
  if (!(s2 = htsmsg_get_str(args, "event_id")))
    return NULL;
  s3 = htsmsg_get_str(args, "comment");
  entries = htsmsg_create_list();
  m = htsmsg_create_map();
  htsmsg_add_str(m, "config_uuid", s1);
  htsmsg_add_str(m, "event_id", s2);
  if (s3)
    htsmsg_add_str(m, "comment", s3);
  htsmsg_add_msg(entries, NULL, m);
  return entries;
}
コード例 #23
0
ファイル: tvhdhomerun.c プロジェクト: Jalle19/tvheadend
void
tvhdhomerun_device_save( tvhdhomerun_device_t *hd )
{
  tvhdhomerun_frontend_t *lfe;
  htsmsg_t *m, *l;

  m = htsmsg_create_map();
  idnode_save(&hd->th_id, m);

  l = htsmsg_create_map();
  TAILQ_FOREACH(lfe, &hd->hd_frontends, hf_link)
    tvhdhomerun_frontend_save(lfe, l);
  htsmsg_add_msg(m, "frontends", l);

  htsmsg_add_str(m, "fe_override", hd->hd_override_type);

  hts_settings_save(m, "input/tvhdhomerun/adapters/%s",
                    idnode_uuid_as_str(&hd->th_id));
  htsmsg_destroy(m);
}
コード例 #24
0
ファイル: tvhdhomerun.c プロジェクト: melmorabity/tvheadend
static htsmsg_t *
tvhdhomerun_device_class_save ( idnode_t *in, char *filename, size_t fsize )
{
  tvhdhomerun_device_t *hd = (tvhdhomerun_device_t *)in;
  tvhdhomerun_frontend_t *lfe;
  htsmsg_t *m, *l;
  char ubuf[UUID_HEX_SIZE];

  m = htsmsg_create_map();
  idnode_save(&hd->th_id, m);

  if (filename) {
    l = htsmsg_create_map();
    TAILQ_FOREACH(lfe, &hd->hd_frontends, hf_link)
      tvhdhomerun_frontend_save(lfe, l);
    htsmsg_add_msg(m, "frontends", l);

    snprintf(filename, fsize, "input/tvhdhomerun/adapters/%s",
             idnode_uuid_as_str(&hd->th_id, ubuf));
  }

  htsmsg_add_str(m, "fe_override", hd->hd_override_type);
  return m;
}
コード例 #25
0
ファイル: keyring.c プロジェクト: Hr-/showtime
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;
}
コード例 #26
0
ファイル: dvb_preconf.c プロジェクト: FSSDawid/tvheadend
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;
}
コード例 #27
0
ファイル: m3u.c プロジェクト: ProfYaffle/tvheadend
/*
 * Note: text in data pointer is not preserved (must be read/write)
 */
htsmsg_t *parse_m3u
  (char *data, const char *charset, const char *url)
{
  char *p, *x, *y;
  char *charset_id = intlconv_charset_id(charset, 0, 1);
  const char *multi_name;
  int delim;
  htsmsg_t *m = htsmsg_create_map();
  htsmsg_t *item = NULL, *l = NULL, *t, *key = NULL;
  char buf[512];

  while (*data && *data <= ' ') data++;
  p = data;
  data = until_eol(data);
  if (strncmp(p, "#EXTM3U", 7)) {
    htsmsg_add_msg(m, "items", htsmsg_create_list());
    return m;
  }
  while (*data) {
    if (strncmp(data, "#EXTINF:", 8) == 0) {
      if (item == NULL)
        item = htsmsg_create_map();
      data += 8;
      p = data;
      if (*data == '-') data++;
      while (*data >= '0' && *data <= '9') data++;
      delim = *data;
      *data = '\0';
      htsmsg_add_s64(item, "m3u-duration", strtoll(p, NULL, 10));
      *data = delim;
      while (*data > ' ' && *data != ',') data++;
      while (delim && delim != ',' && delim != '\n' && delim != '\r') {
        while (*data && *data <= ' ') data++;
        if (*data == '\0' || *data == ',') break;
        p = data++;
        while (*data && *data != ',' && *data != '=') data++;
        if (*data == '=') {
          *data = '\0';
          x = get_m3u_str(data + 1, &data, &delim);
          if (*p && *x) {
            y = intlconv_to_utf8safestr(charset_id, x, strlen(x)*2);
            htsmsg_add_str(item, p, y ?: ".invalid.charset.");
            free(y);
          }
          get_m3u_str_post(&data, delim);
        }
      }
      p = NULL;
      if (*data == ',') {
        delim = ',';
        data++;
      }
      if (delim == ',') {
        while (*data && *data <= ' ' && *data != '\n' && *data != '\r') data++;
        if (*data)
          p = data;
      }
      data = until_eol(data);
      if (p && *p) {
        y = intlconv_to_utf8safestr(charset_id, p, strlen(p)*2);
        htsmsg_add_str(item, "m3u-name", y ?: ".invalid.charset.");
        free(y);
      }
コード例 #28
0
ファイル: keyring.c プロジェクト: CrashSerious/showtime
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;
}