Ejemplo n.º 1
0
static int _lang_code_lookup_add( lang_code_lookup_t* lookup_table, const lang_code_t *code, int (*func)(void*, void*) ) {
  lang_code_lookup_element_t *element;
  element = (lang_code_lookup_element_t *)calloc(1, sizeof(lang_code_lookup_element_t));
  element->lang_code = code;
  RB_INSERT_SORTED(lookup_table, element, link, func);
  return 0;
}
Ejemplo n.º 2
0
static int
vimeo_callback(http_connection_t *hc, const char *remain,
      void *opaque)
{
  state_entry_t *vce;
  static state_entry_t *skel;

  const char *referer = http_arg_get(&hc->hc_args, "referer");
  if(referer == NULL || strcmp(referer, "https://movian.tv/"))
    return 403;

  const char *state = http_arg_get(&hc->hc_req_args, "state");
  const char *code = http_arg_get(&hc->hc_req_args, "code");
  if(state == NULL || code == NULL)
    return 400;

  if(skel == NULL)
    skel = calloc(1, sizeof(state_entry_t));

  skel->se_state = strdup(state);
  skel->se_code = strdup(code);

  pthread_mutex_lock(&state_mutex);

  vce = RB_INSERT_SORTED(&state_entries, skel, se_entry, state_entry_cmp);
  if (vce != NULL)
    vce->se_code = strdup(code);
  else
    skel = NULL;

  pthread_mutex_unlock(&state_mutex);

  return 200;
}
Ejemplo n.º 3
0
static jni_subscription_t *
makesub(JNIEnv *env,
        prop_callback_t *cb,
        jint j_propid,
        jstring j_path,
        jobject j_cbif)
{
  jni_subscription_t *js = malloc(sizeof(jni_subscription_t));
  const char *path = (*env)->GetStringUTFChars(env, j_path, 0);

  js->js_cbif = (*env)->NewGlobalRef(env, j_cbif);

  prop_t *p = j_propid ? (prop_t *)j_propid : prop_get_global();

  js->js_id = ++jni_sub_tally;

  if(RB_INSERT_SORTED(&jni_subscriptions, js, js_link, js_cmp))
    abort();

  js->js_sub = prop_subscribe(PROP_SUB_ALT_PATH,
			      PROP_TAG_NAMESTR, path,
			      PROP_TAG_CALLBACK, cb, js,
			      PROP_TAG_ROOT, p,
                              PROP_TAG_COURIER, jni_courier,
			      NULL);

  (*env)->ReleaseStringUTFChars(env, j_path, path);
  return js;
}
Ejemplo n.º 4
0
ssize_t
intlconv_utf8( char *dst, size_t dst_size,
               const char *dst_charset_id,
               const char *src_utf8 )
{
  intlconv_cache_t templ, *ic;
  char **inbuf, **outbuf;
  size_t inbuf_left, outbuf_left;
  ssize_t res;

  if (dst_charset_id == NULL) {
    strncpy(dst, src_utf8, dst_size);
    dst[dst_size - 1] = '\0';
    return strlen(dst);
  }
  templ.ic_charset_id = (char *)dst_charset_id;
  pthread_mutex_lock(&intlconv_lock);
  if (intlconv_last_ic &&
      strcmp(intlconv_last_ic->ic_charset_id, dst_charset_id) == 0) {
    ic = intlconv_last_ic;
    goto found;
  }
  ic = RB_FIND(&intlconv_all, &templ, ic_link, intlconv_cmp);
  if (!ic) {
    iconv_t c = iconv_open(dst_charset_id, "UTF-8");
    if ((iconv_t)-1 == c) {
      pthread_mutex_unlock(&intlconv_lock);
      return -EIO;
    }
    ic = malloc(sizeof(*ic));
    if (ic == NULL) {
      pthread_mutex_unlock(&intlconv_lock);
      return -ENOMEM;
    }
    ic->ic_charset_id = strdup(dst_charset_id);
    if (ic->ic_charset_id == NULL) {
      pthread_mutex_unlock(&intlconv_lock);
      free(ic);
      iconv_close(c);
      return -ENOMEM;
    }
    ic->ic_handle = c;
    RB_INSERT_SORTED(&intlconv_all, ic, ic_link, intlconv_cmp);
  }
found:
  inbuf       = (char **)&src_utf8;
  inbuf_left  = strlen(src_utf8);
  outbuf      = &dst;
  outbuf_left = dst_size;
  res = iconv(ic->ic_handle, inbuf, &inbuf_left, outbuf, &outbuf_left);
  if (res == -1) {
    res = -errno;
  } else {
    intlconv_last_ic = ic;
  }
  pthread_mutex_unlock(&intlconv_lock);
  if (res >= 0)
    res = dst_size - outbuf_left;
  return res;
}
Ejemplo n.º 5
0
void
api_register ( const api_hook_t *hook )
{
  api_link_t *t;
  SKEL_ALLOC(api_skel);
  api_skel->hook = hook;
  t = RB_INSERT_SORTED(&api_hook_tree, api_skel, link, ah_cmp);
  if (t) {
    tvherror("api", "trying to re-register subsystem");
  } else {
    SKEL_USED(api_skel);
  }
}
Ejemplo n.º 6
0
void
api_register ( const api_hook_t *hook )
{
  static api_link_t *t, *skel = NULL;
  if (!skel)
    skel = calloc(1, sizeof(api_link_t));
  skel->hook = hook;
  t = RB_INSERT_SORTED(&api_hook_tree, skel, link, ah_cmp);
  if (t)
    tvherror("api", "trying to re-register subsystem");
  else
    skel = NULL;
}
Ejemplo n.º 7
0
bouquet_t *
bouquet_create(const char *uuid, htsmsg_t *conf,
               const char *name, const char *src)
{
  bouquet_t *bq, *bq2;
  int i;

  lock_assert(&global_lock);

  bq = calloc(1, sizeof(bouquet_t));
  bq->bq_services = idnode_set_create(1);
  bq->bq_active_services = idnode_set_create(1);

  if (idnode_insert(&bq->bq_id, uuid, &bouquet_class, 0)) {
    if (uuid)
      tvherror("bouquet", "invalid uuid '%s'", uuid);
    free(bq);
    return NULL;
  }

  if (conf) {
    bq->bq_in_load = 1;
    idnode_load(&bq->bq_id, conf);
    bq->bq_in_load = 0;
    if (!htsmsg_get_bool(conf, "shield", &i) && i)
      bq->bq_shield = 1;
  }

  if (name) {
    free(bq->bq_name);
    bq->bq_name = strdup(name);
  }

  if (src) {
    free(bq->bq_src);
    bq->bq_src = strdup(src);
  }

  bq2 = RB_INSERT_SORTED(&bouquets, bq, bq_link, _bq_cmp);
  assert(bq2 == NULL);

  bq->bq_saveflag = 1;

  return bq;
}
Ejemplo n.º 8
0
/* Internal insertion routine */
static int _lang_str_add
  ( lang_str_t *ls, const char *str, const char *lang, int update, int append )
{
  int save = 0;
  lang_str_ele_t *e;

  if (!str) return 0;

  /* Get proper code */
  if (!lang) lang = lang_code_preferred();
  if (!(lang = lang_code_get(lang))) return 0;

  /* Create skel */
  SKEL_ALLOC(lang_str_ele_skel);
  lang_str_ele_skel->lang = lang;

  /* Create */
  e = RB_INSERT_SORTED(ls, lang_str_ele_skel, link, _lang_cmp);
  if (!e) {
    lang_str_ele_skel->str = strdup(str);
    SKEL_USED(lang_str_ele_skel);
    save = 1;

  /* Append */
  } else if (append) {
    e->str = realloc(e->str, strlen(e->str) + strlen(str) + 1);
    strcat(e->str, str);
    save = 1;

  /* Update */
  } else if (update && strcmp(str, e->str)) {
    free(e->str);
    e->str = strdup(str);
    save = 1;
  }
  
  return save;
}
Ejemplo n.º 9
0
ntv_t *
libsvc_http_json_get(const char *url, const char *auth,
                     char *errbuf, size_t errlen)
{
  cache_entry_t *ce;
  static cache_entry_t *skel;
  time_t now = time(NULL);

  pthread_mutex_lock(&cache_mutex);

  if(skel == NULL)
    skel = calloc(1, sizeof(cache_entry_t));

  skel->ce_url = (char *)url;
  skel->ce_auth = (char *)auth;

  ce = RB_INSERT_SORTED(&cache_entries, skel, ce_link,
                        cache_entry_cmp);

  if(ce == NULL) {
    // Nothing found -> New item 'skel' was inserted
    ce = skel;
    skel = NULL;

    ce->ce_url  = strdup(url);
    ce->ce_auth = auth ? strdup(auth) : NULL;
  }

  while(ce->ce_status == -1)
    pthread_cond_wait(&cache_cond, &cache_mutex);

  if(ce->ce_expire > now) {

    if(ce->ce_status == 200) {
      ntv_t *m = ntv_json_deserialize(ce->ce_response, errbuf, errlen);
      pthread_mutex_unlock(&cache_mutex);
      return m;
    }

    if(ce->ce_status >= 400) {
      snprintf(errbuf, errlen, "HTTP Error %d", ce->ce_status);
      pthread_mutex_unlock(&cache_mutex);
      return NULL;
    }
  }

  ce->ce_status = -1;


  char *out;
  size_t outlen;
  FILE *f = open_buffer(&out, &outlen);

  struct curl_slist *slist = NULL;

  CURL *curl = curl_easy_init();
  curl_easy_setopt(curl, CURLOPT_URL, url);
  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
  curl_easy_setopt(curl, CURLOPT_WRITEDATA, f);
  curl_easy_setopt(curl, CURLOPT_USERAGENT, "libsvc");
  curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, hdrfunc);
  curl_easy_setopt(curl, CURLOPT_HEADERDATA, ce);

  slist = curl_slist_append(slist, "Accept: application/json");

  if(auth != NULL)
    slist = curl_slist_append(slist, tsprintf("Authorization: %s", auth));

  if(ce->ce_etag != NULL)
    slist = curl_slist_append(slist, tsprintf("If-None-Match: %s",
                                              ce->ce_etag));
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);

  ce->ce_expire = 0;
  free(ce->ce_etag);
  ce->ce_etag = NULL;

  pthread_mutex_unlock(&cache_mutex);
  CURLcode result = curl_easy_perform(curl);
  curl_slist_free_all(slist);

  pthread_mutex_lock(&cache_mutex);

  pthread_cond_broadcast(&cache_cond);

  fwrite("", 1, 1, f);
  fclose(f);

  if(result) {
    snprintf(errbuf, errlen, "%s", curl_easy_strerror(result));
    curl_easy_cleanup(curl);
    ce->ce_expire = 0;
    ce->ce_status = 0;

    free(ce->ce_response);
    ce->ce_response = NULL;

    pthread_mutex_unlock(&cache_mutex);
    free(out);
    return NULL;
  }

  long http_code = 0;
  curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
  ce->ce_status = http_code;

  if(http_code == 304) {

    ce->ce_status = 200;

  } else if(http_code == 200) {

    free(ce->ce_response);
    ce->ce_response = out;
    out = NULL;

  } else {

    snprintf(errbuf, errlen, "HTTP Error %lu", http_code);
    free(ce->ce_response);
    ce->ce_response = NULL;

  }

  free(out);
  curl_easy_cleanup(curl);

  ntv_t *m = NULL;
  if(ce->ce_response != NULL)
    m = ntv_json_deserialize(ce->ce_response, errbuf, errlen);

  pthread_mutex_unlock(&cache_mutex);
  return m;
}