/**
* Load a view file and do lexographical parsing
*
* Returns pointer to last token, or NULL if an error occured.
* If an error occured 'ei' will be filled with data
*/
token_t *
glw_view_load1(glw_root_t *gr, rstr_t *url, errorinfo_t *ei, token_t *prev,
int may_unlock)
{
token_t *last;
char errbuf[256];
rstr_t *p = fa_absolute_path(url, prev->file);
if(may_unlock)
glw_unlock(gr);
buf_t *b = fa_load(rstr_get(p),
FA_LOAD_VPATHS(gr->gr_vpaths),
FA_LOAD_ERRBUF(errbuf, sizeof(errbuf)),
NULL);
if(may_unlock)
glw_lock(gr);
if(b == NULL) {
snprintf(ei->error, sizeof(ei->error), "Unable to open \"%s\" -- %s",
rstr_get(p), errbuf);
snprintf(ei->file, sizeof(ei->file), "%s", rstr_get(prev->file));
ei->line = prev->line;
rstr_release(p);
return NULL;
}
last = glw_view_lexer(gr, buf_cstr(b), ei, p, prev);
buf_release(b);
rstr_release(p);
return last;
}
void
jpeg_info_clear(jpeginfo_t *ji)
{
if(ji->ji_thumbnail != NULL)
pixmap_release(ji->ji_thumbnail);
rstr_release(ji->ji_manufacturer);
rstr_release(ji->ji_equipment);
}
static void
artist_query(bmdb_t *b, void *db)
{
sqlite3_stmt *stmt;
int rc;
int artist_id = atoi(b->b_query);
rc = db_prepare(db, &stmt,
"SELECT title "
"FROM artist "
"WHERE ds_id = 1 "
"AND id = ?1");
if(rc != SQLITE_OK)
return;
sqlite3_bind_int(stmt, 1, artist_id);
if(db_step(stmt) == SQLITE_ROW) {
rstr_t *artist = db_rstr(stmt, 0);
prop_set(b->b_metadata, "title", PROP_SET_RSTRING, artist);
prop_t *p = prop_create_r(b->b_metadata, "artist_images");
metadata_bind_artistpics(p, artist);
prop_ref_dec(p);
rstr_release(artist);
}
sqlite3_finalize(stmt);
rc = db_prepare(db, &stmt,
"SELECT id,title "
"FROM album "
"WHERE ds_id = 1 "
"AND artist_id = ?1");
if(rc != SQLITE_OK)
return;
sqlite3_bind_int(stmt, 1, artist_id);
rstr_t *ct = rstr_alloc("album");
while((rc = db_step(stmt)) == SQLITE_ROW) {
char url[PATH_MAX];
snprintf(url, sizeof(url), "library:album:%d",
sqlite3_column_int(stmt, 0));
add_item(b, url, NULL, ct,
(const char *)sqlite3_column_text(stmt, 1), 0, NULL, 0);
}
rstr_release(ct);
sqlite3_finalize(stmt);
}
static int
sidfile_scandir(fa_dir_t *fd, const char *url, char *errbuf, size_t errlen)
{
void *fh = NULL;
char *p, *fpath = mystrdupa(url);
char buf[128];
char name[32];
char turl[URL_MAX];
int tracks, i;
fa_dir_entry_t *fde;
rstr_t *album, *artist;
if((p = strrchr(fpath, '/')) == NULL) {
snprintf(errbuf, errlen, "Invalid filename");
return -1;
}
*p = 0;
if((fh = fa_open(fpath, errbuf, errlen)) == NULL)
return -1;
if(fa_read(fh, buf, 128) != 128) {
snprintf(errbuf, errlen, "Unable to read file");
fa_close(fh);
return -1;
}
album = rstr_alloc(utf8_from_bytes((char *)buf + 0x16, 32, NULL));
artist = rstr_alloc(utf8_from_bytes((char *)buf + 0x36, 32, NULL));
tracks = buf[0xf];
for(i = 0; i < tracks; i++) {
snprintf(name, sizeof(name), "Track %02d", i + 1);
snprintf(turl, sizeof(turl), "sidplayer:%s/%d", fpath, i + 1);
fde = fa_dir_add(fd, turl, name, CONTENT_AUDIO);
fde->fde_probestatus = FDE_PROBE_DEEP;
fde->fde_metadata = prop_create_root("metadata");
prop_set_string(prop_create(fde->fde_metadata, "title"), name);
prop_set_rstring(prop_create(fde->fde_metadata, "album"), album);
prop_set_rstring(prop_create(fde->fde_metadata, "artist"), artist);
}
rstr_release(album);
rstr_release(artist);
fa_close(fh);
return 0;
}
static void
ns_val_clr(nls_string_t *ns)
{
if(ns->ns_values == 1) {
rstr_release(ns->ns_u.rstr);
ns->ns_u.rstr = NULL;
} else if(ns->ns_values > 1) {
int i;
for(i = 0; i < ns->ns_values; i++)
rstr_release(ns->ns_u.vec[i]);
free(ns->ns_u.vec);
ns->ns_u.vec = NULL;
}
ns->ns_values = 0;
}
int
search_class_create(prop_t *parent, prop_t **nodesp, prop_t **entriesp,
const char *title, const char *icon)
{
prop_t *p = prop_create_root(NULL);
prop_t *m = prop_create(p, "metadata");
prop_t *n, *e;
rstr_t *url = backend_prop_make(p, NULL);
prop_set_rstring(prop_create(p, "url"), url);
rstr_release(url);
prop_set_string(prop_create(m, "title"), title);
if(icon != NULL)
prop_set_string(prop_create(m, "icon"), icon);
prop_set_string(prop_create(p, "type"), "directory");
n = prop_create(p, "nodes");
e = prop_create(p, "entries");
prop_set_int(e, 0);
*nodesp = prop_ref_inc(n);
*entriesp = prop_ref_inc(e);
if(prop_set_parent(p, parent)) {
prop_destroy(p);
return 1;
}
return 0;
}
static int
set_path(glw_view_eval_context_t *ec, const token_attrib_t *a,
struct token *t)
{
glw_t *w = ec->w;
rstr_t *r;
void (*fn)(glw_t *w, rstr_t *r) = a->fn;
switch(t->type) {
case TOKEN_VOID:
fn(w, NULL);
return 0;
case TOKEN_RSTRING:
case TOKEN_LINK:
r = t->t_rstring;
break;
default:
return glw_view_seterr(ec->ei, t,
"Attribute '%s' expects a string or scalar not %s",
a->name, token2name(t));
}
r = fa_absolute_path(r, t->file);
fn(w, r);
rstr_release(r);
return 0;
}
/**
* Try to open the given URL with a playqueue context
*/
static int
file_open_audio(prop_t *page, const char *url)
{
char parent[URL_MAX];
char parent2[URL_MAX];
struct fa_stat fs;
prop_t *model;
if(fa_parent(parent, sizeof(parent), url))
return 1;
if(fa_stat(parent, &fs, NULL, 0))
return 1;
model = prop_create(page, "model");
prop_set_string(prop_create(model, "type"), "directory");
/* Find a meaningful page title (last component of URL) */
rstr_t *title = title_from_url(parent);
prop_setv(model, "metadata", "title", NULL, PROP_SET_RSTRING, title);
// Set parent
if(!fa_parent(parent2, sizeof(parent2), parent))
prop_set_string(prop_create(page, "parent"), parent2);
fa_scanner_page(parent, fs.fs_mtime, model, url,
prop_create(page, "directClose"), title);
rstr_release(title);
return 0;
}
static void
artists_query(bmdb_t *b, void *db)
{
sqlite3_stmt *stmt;
int rc = db_prepare(db, &stmt,
"SELECT artist.id, artist.title "
"FROM artist,item,audioitem "
"WHERE audioitem.item_id = item.id "
"AND audioitem.artist_id = artist.id "
"AND item.url like ?1 "
"AND audioitem.ds_id = 1 "
"GROUP by artist_id");
if(rc != SQLITE_OK)
return;
char q[PATH_MAX];
db_escape_path_query(q, sizeof(q), b->b_query);
sqlite3_bind_text(stmt, 1, q, -1, SQLITE_STATIC);
rstr_t *ct = rstr_alloc("artist");
while((rc = db_step(stmt)) == SQLITE_ROW) {
char url[PATH_MAX];
snprintf(url, sizeof(url), "library:artist:%d",
sqlite3_column_int(stmt, 0));
add_item(b, url, NULL, ct,
(const char *)sqlite3_column_text(stmt, 1), 0, NULL, 0);
}
rstr_release(ct);
sqlite3_finalize(stmt);
}
static void
event_prop_action_dtor(event_t *e)
{
event_prop_action_t *epa = (event_prop_action_t *)e;
prop_ref_dec(epa->p);
rstr_release(epa->action);
}
static void
video_query(bmdb_t *b, void *db)
{
sqlite3_stmt *stmt;
int rc = db_prepare(db, &stmt,
"SELECT i.url, p.url, i.contenttype "
"FROM item AS i, item AS p "
"WHERE i.url LIKE ?1 "
"AND (i.contenttype == 5 OR i.contenttype == 7) "
"AND i.parent = p.id"
);
if(rc != SQLITE_OK)
return;
char q[PATH_MAX];
db_escape_path_query(q, sizeof(q), b->b_query);
sqlite3_bind_text(stmt, 1, q, -1, SQLITE_STATIC);
while((rc = db_step(stmt)) == SQLITE_ROW) {
const char *url = (const char *)sqlite3_column_text(stmt, 0);
const char *parent = (const char *)sqlite3_column_text(stmt, 1);
rstr_t *ct = rstr_alloc(content2type(sqlite3_column_int(stmt, 2)));
add_item(b, url, parent, ct, NULL, 0, NULL, 0);
rstr_release(ct);
}
sqlite3_finalize(stmt);
}
static rstr_t *
ffmpeg_metadata_rstr(AVMetadata *m, const char *key)
{
AVMetadataTag *tag;
int len;
rstr_t *ret;
const char *str;
char *d;
if((tag = av_metadata_get(m, key, NULL, AV_METADATA_IGNORE_SUFFIX)) == NULL)
return NULL;
if(!utf8_verify(tag->value))
return NULL;
str = tag->value;
len = strlen(str);
ret = rstr_allocl(str, len);
d = rstr_data(ret);
while(len > 0) {
len--;
if(d[len] <= ' ' || d[len] == '-')
d[len] = 0;
else
break;
}
if(*d == 0 || !strncasecmp(d, "http://", 7)) {
rstr_release(ret);
return NULL;
}
return ret;
}
static int
is_plugin_blacklisted(const char *id, const char *version, rstr_t **reason)
{
char tmp[512];
int verint = parse_version_int(version);
if(!strcmp(id, "custombg")) {
if(reason != NULL) {
*reason =
_("Custom backgrounds can now be set in Settings -> Look and Feel");
}
return 1;
}
for(int i = 0; i < ARRAYSIZE(blacklist); i++) {
if(strcmp(id, blacklist[i].id))
continue;
if(verint >= blacklist[i].version)
continue;
if(reason != NULL) {
rstr_t *f = _("Version %s is no longer compatible with Movian");
snprintf(tmp, sizeof(tmp), rstr_get(f), version);
rstr_release(f);
*reason = rstr_alloc(tmp);
}
return 1;
}
return 0;
}
static int
set_alt(glw_view_eval_context_t *ec, const token_attrib_t *a,
struct token *t)
{
glw_t *w = ec->w;
rstr_t *r;
switch(t->type) {
default:
if(w->glw_class->gc_set_alt != NULL)
w->glw_class->gc_set_alt(w, NULL);
return 0;
case TOKEN_RSTRING:
r = t->t_rstring;
break;
case TOKEN_LINK:
r = t->t_link_rurl;
break;
}
r = fa_absolute_path(r, t->file);
if(w->glw_class->gc_set_alt != NULL)
w->glw_class->gc_set_alt(w, r);
rstr_release(r);
return 0;
}
static void
news_sink(void *opaque, prop_event_t event, ...)
{
prop_t *p = opaque;
event_t *e;
va_list ap;
va_start(ap, event);
switch(event) {
case PROP_DESTROYED:
prop_unsubscribe(va_arg(ap, prop_sub_t *));
prop_ref_dec(p);
break;
case PROP_EXT_EVENT:
e = va_arg(ap, event_t *);
if(event_is_type(e, EVENT_DYNAMIC_ACTION)) {
const event_payload_t *ep = (const event_payload_t *)e;
if(!strcmp(ep->payload, "dismiss")) {
rstr_t *id = prop_get_string(p, "id", NULL);
dismis_news(rstr_get(id));
rstr_release(id);
prop_destroy(opaque);
}
}
break;
default:
break;
}
va_end(ap);
}
static int
hc_prop(http_connection_t *hc, const char *remain, void *opaque,
http_cmd_t method)
{
htsbuf_queue_t out;
rstr_t *r;
int rval, i;
prop_t *p;
const char *action = http_arg_get_req(hc, "action");
if(remain == NULL)
return 404;
p = prop_from_path(remain);
if(p == NULL)
return 404;
htsbuf_queue_init(&out, 0);
switch(method) {
case HTTP_CMD_GET:
if(action != NULL) {
event_t *e = event_create_action_str(action);
prop_send_ext_event(p, e);
event_release(e);
rval = HTTP_STATUS_OK;
break;
}
r = prop_get_string(p, NULL);
if(r == NULL) {
char **childs = prop_get_name_of_childs(p);
if(childs == NULL) {
rval = HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE;
break;
}
for(i = 0; childs[i] != NULL; i++) {
htsbuf_qprintf(&out, "\t%s\n", childs[i]);
}
} else {
htsbuf_append(&out, rstr_get(r), strlen(rstr_get(r)));
htsbuf_append(&out, "\n", 1);
rstr_release(r);
}
rval = http_send_reply(hc, 0, "text/ascii", NULL, NULL, 0, &out);
break;
default:
rval = HTTP_STATUS_METHOD_NOT_ALLOWED;
break;
}
prop_ref_dec(p);
return rval;
}
static void
set_source(glw_t *w, rstr_t *filename)
{
glw_image_t *gi = (glw_image_t *)w;
const rstr_t *curname;
if(gi->gi_pending_url != NULL)
curname = gi->gi_pending_url;
else if(gi->gi_pending != NULL)
curname = gi->gi_pending->glt_url;
else if(gi->gi_current != NULL)
curname = gi->gi_current->glt_url;
else
curname = NULL;
if(curname != NULL && filename != NULL && !strcmp(rstr_get(filename),
rstr_get(curname)))
return;
if(gi->gi_pending_url != NULL)
rstr_release(gi->gi_pending_url);
gi->gi_pending_url = filename ? rstr_dup(filename) : rstr_alloc("");
}
static void
callback_opt(void *opaque, prop_event_t event, ...)
{
setting_t *s = opaque;
prop_callback_string_t *cb;
prop_t *c;
rstr_t *name;
va_list ap;
va_start(ap, event);
cb = s->s_callback;
if(event != PROP_SELECT_CHILD)
return;
c = va_arg(ap, prop_t *);
name = c ? prop_get_name(c) : NULL;
va_end(ap);
if(cb != NULL)
cb(s->s_opaque, rstr_get(name));
if(s->s_store != NULL && s->s_saver != NULL) {
htsmsg_delete_field(s->s_store, s->s_id);
if(name != NULL)
htsmsg_add_str(s->s_store, s->s_id, rstr_get(name));
s->s_saver(s->s_saver_opaque, s->s_store);
}
rstr_release(name);
}
static void
notifications_update(void *opaque, prop_event_t event, ...)
{
statusbar_t *sb = opaque;
prop_t *p, *txt;
statusbar_entry_t *sbe;
char *buf;
rstr_t *msg;
int i, l;
va_list ap;
va_start(ap, event);
switch(event) {
case PROP_ADD_CHILD:
p = va_arg(ap, prop_t *);
txt = prop_get_by_name(PNVEC("self", "text"), 1,
PROP_TAG_NAMED_ROOT, p, "self",
NULL);
if(txt != NULL) {
msg = prop_get_string(txt);
if(msg != NULL) {
buf = mystrdupa(rstr_get(msg));
l = strlen(buf);
for(i = 0; i < l; i++)
if(buf[i] < ' ')
buf[i] = ' ';
sbe = calloc(1, sizeof(statusbar_entry_t));
sbe->p = prop_ref_inc(p);
sbe->id = gtk_statusbar_push(GTK_STATUSBAR(sb->bar), sb->ctxid, buf);
LIST_INSERT_HEAD(&sb->entries, sbe, link);
rstr_release(msg);
}
prop_ref_dec(txt);
}
break;
case PROP_DEL_CHILD:
p = va_arg(ap, prop_t *);
LIST_FOREACH(sbe, &sb->entries, link)
if(sbe->p == p)
break;
if(sbe == NULL)
break;
prop_ref_dec(sbe->p);
gtk_statusbar_remove(GTK_STATUSBAR(sb->bar), sb->ctxid, sbe->id);
LIST_REMOVE(sbe, link);
free(sbe);
break;
default:
break;
}
}
static void
glw_quad_dtor(glw_t *w)
{
glw_quad_t *q = (glw_quad_t *)w;
glw_renderer_free(&q->r);
rstr_release(q->fs);
glw_destroy_program(w->glw_root, q->prog);
}
void
rstr_vec_free(rstr_vec_t *rv)
{
int i;
for(i = 0; i < rv->size; i++)
rstr_release(rv->v[i]);
free(rv);
}
static void
set_torrent_cache_path(void *opaque, const char *str)
{
rstr_release(btg.btg_cache_path);
btg.btg_cache_path = rstr_alloc(str);
if(allow_update)
torrent_diskio_scan(0);
}
static void
sources_free(rstr_t **v)
{
int i;
if(v == NULL)
return;
for(i = 0; v[i] != NULL; i++)
rstr_release(v[i]);
free(v);
}
static int
set_rstring(glw_view_eval_context_t *ec, const token_attrib_t *a,
struct token *t)
{
rstr_t *rstr;
char buf[30];
void (*fn)(struct glw *w, rstr_t *str) = a->fn;
switch(t->type) {
case TOKEN_VOID:
buf[0] = 0;
break;
case TOKEN_CSTRING:
rstr = rstr_alloc(t->t_cstring);
fn(ec->w, rstr);
rstr_release(rstr);
return 0;
case TOKEN_RSTRING:
case TOKEN_LINK:
fn(ec->w, t->t_rstring);
return 0;
case TOKEN_INT:
snprintf(buf, sizeof(buf), "%d", t->t_int);
break;
case TOKEN_FLOAT:
snprintf(buf, sizeof(buf), "%f", t->t_float);
break;
default:
return glw_view_seterr(ec->ei, t,
"Attribute '%s' expects a string or scalar, got %s",
a->name, token2name(t));
}
rstr = rstr_alloc(buf);
fn(ec->w, rstr);
rstr_release(rstr);
return 0;
}
static void
input_req_event(void *opaque, event_t *e)
{
connman_service_t *cs = opaque;
if(cs->cs_input_req_inv == NULL)
return;
if(event_is_action(e, ACTION_OK)) {
rstr_t *username = prop_get_string(cs->cs_input_req_prop, "username", NULL);
rstr_t *password = prop_get_string(cs->cs_input_req_prop, "password", NULL);
GVariant *result;
GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(builder, "{sv}", "Passphrase",
g_variant_new_string(rstr_get(password)));
if(cs->cs_input_req_want_identity)
g_variant_builder_add(builder, "{sv}", "Identity",
g_variant_new_string(rstr_get(username)));
result = g_variant_new("(a{sv})", builder);
TRACE(TRACE_DEBUG, "CONNMAN", "Auth response: %s",
g_variant_print(result, TRUE));
g_dbus_method_invocation_return_value(cs->cs_input_req_inv, result);
g_variant_builder_unref(builder);
rstr_release(username);
rstr_release(password);
connman_stop_input_request(cs);
}
if(event_is_action(e, ACTION_CANCEL)) {
g_dbus_method_invocation_return_dbus_error(cs->cs_input_req_inv,
"net.connman.Agent.Error.Canceled",
"Canceled by user");
connman_stop_input_request(cs);
}
}
void *
notify_add(prop_t *root, notify_type_t type, const char *icon, int delay,
rstr_t *fmt, ...)
{
char msg[256];
prop_t *p;
const char *typestr;
int tl;
va_list ap, apx;
switch(type) {
case NOTIFY_INFO: typestr = "info"; tl = TRACE_INFO; break;
case NOTIFY_WARNING: typestr = "warning"; tl = TRACE_INFO; break;
case NOTIFY_ERROR: typestr = "error"; tl = TRACE_ERROR; break;
default: return NULL;
}
va_start(ap, fmt);
va_copy(apx, ap);
tracev(0, tl, "notify", rstr_get(fmt), ap);
vsnprintf(msg, sizeof(msg), rstr_get(fmt), apx);
va_end(ap);
va_end(apx);
rstr_release(fmt);
p = prop_create_root(NULL);
prop_set_string(prop_create(p, "text"), msg);
prop_set_string(prop_create(p, "type"), typestr);
if(icon != NULL)
prop_set_string(prop_create(p, "icon"), icon);
p = prop_ref_inc(p);
if(prop_set_parent(p, root ?: notify_prop_entries))
prop_destroy(p);
if(delay != 0) {
prop_t *r = NULL;
if(delay < 0) {
r = prop_ref_inc(p);
delay = -delay;
}
callout_arm(NULL, notify_timeout, p, delay);
return r;
}
return p;
}
int
nav_open_errorf(prop_t *root, rstr_t *fmt, ...)
{
va_list ap;
char buf[200];
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), rstr_get(fmt), ap);
va_end(ap);
rstr_release(fmt);
return nav_open_error(root, buf);
}
static JSBool
js_item_bindVideoMetadata(JSContext *cx, JSObject *obj,
uintN argc, jsval *argv, jsval *rval)
{
js_item_t *ji = JS_GetPrivate(cx, obj);
JSObject *o = NULL;
rstr_t *title;
if(!JS_ConvertArguments(cx, argc, argv, "o", &o))
return JS_FALSE;
rstr_t *filename = js_prop_rstr(cx, o, "filename");
int year = js_prop_int_or_default(cx, o, "year", 0);
if(filename != NULL) {
// Raw filename case
title = metadata_remove_postfix_rstr(filename);
rstr_release(filename);
year = -1;
} else {
title = js_prop_rstr(cx, o, "title");
}
int season = js_prop_int_or_default(cx, o, "season", -1);
int episode = js_prop_int_or_default(cx, o, "episode", -1);
rstr_t *imdb = js_prop_rstr(cx, o, "imdb");
int duration = js_prop_int_or_default(cx, o, "duration", 0);
if(ji->ji_mlv != NULL)
mlv_unbind(ji->ji_mlv, 0);
ji->ji_mlv =
metadata_bind_video_info(ji->ji_url, title, imdb, duration,
ji->ji_root, NULL, 0, 0, year, season, episode,
0);
rstr_release(imdb);
rstr_release(title);
*rval = JSVAL_VOID;
return JS_TRUE;
}
static void
item_finalize(JSContext *cx, JSObject *obj)
{
js_item_t *ji = JS_GetPrivate(cx, obj);
assert(LIST_FIRST(&ji->ji_event_handlers) == NULL);
TAILQ_REMOVE(&ji->ji_model->jm_items, ji, ji_link);
js_model_release(ji->ji_model);
prop_ref_dec(ji->ji_root);
rstr_release(ji->ji_url);
if(ji->ji_mlv != NULL)
mlv_unbind(ji->ji_mlv, 0);
free(ji);
}
void
glw_fini(glw_root_t *gr)
{
glw_text_bitmap_fini(gr);
rstr_release(gr->gr_default_font);
glw_tex_fini(gr);
free(gr->gr_skin);
glw_fini_settings(gr);
pool_destroy(gr->gr_token_pool);
pool_destroy(gr->gr_clone_pool);
prop_courier_destroy(gr->gr_courier);
hts_mutex_destroy(&gr->gr_mutex);
}
