/* Note that we use marked_message_internal to avoid resetting the
alarm. */
void
update_window_names (rp_screen *s, char *fmt)
{
struct sbuf *bar_buffer;
int mark_start = 0;
int mark_end = 0;
if (s->bar_is_raised != BAR_IS_WINDOW_LIST) return;
bar_buffer = sbuf_new (0);
if(defaults.window_list_style == STYLE_ROW)
{
get_window_list (fmt, NULL, bar_buffer, &mark_start, &mark_end);
marked_message_internal (sbuf_get (bar_buffer), mark_start, mark_end);
}
else
{
get_window_list (fmt, "\n", bar_buffer, &mark_start, &mark_end);
marked_message_internal (sbuf_get (bar_buffer), mark_start, mark_end);
}
/* marked_message (sbuf_get (bar_buffer), mark_start, mark_end); */
sbuf_free (bar_buffer);
}
int
pkg_delete(struct pkg *pkg, struct pkgdb *db, int force)
{
struct pkg **rdeps;
int i, ret;
struct sbuf *rdep_msg;
if (pkg == NULL)
return (ERROR_BAD_ARG("pkg"));
if (db == NULL)
return (ERROR_BAD_ARG("db"));
/*
* Ensure that we have all the informations we need
*/
if ((ret = pkgdb_loadrdeps(db, pkg)) != EPKG_OK)
return (ret);
if ((ret = pkgdb_loadfiles(db, pkg)) != EPKG_OK)
return (ret);
if ((ret = pkgdb_loadscripts(db, pkg)) != EPKG_OK)
return (ret);
if ((ret = pkgdb_loadmtree(db, pkg)) != EPKG_OK)
return (ret);
rdeps = pkg_rdeps(pkg);
if (rdeps[0] != NULL) {
rdep_msg = sbuf_new_auto();
sbuf_printf(rdep_msg, "%s-%s is required by other packages:", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
for (i = 0;rdeps[i] != NULL; i++) {
sbuf_cat(rdep_msg, " ");
sbuf_printf(rdep_msg, "%s-%s", pkg_get(rdeps[i], PKG_NAME), pkg_get(rdeps[i], PKG_VERSION));
}
if (!force) {
sbuf_finish(rdep_msg);
ret = pkg_error_set(EPKG_REQUIRED, "%s", sbuf_get(rdep_msg));
sbuf_free(rdep_msg);
return ret;
}
sbuf_cat(rdep_msg, ", deleting anyway");
sbuf_finish(rdep_msg);
fprintf(stderr, "%s\n", sbuf_get(rdep_msg));
sbuf_free(rdep_msg);
}
if ((ret = pkg_script_pre_deinstall(pkg)) != EPKG_OK)
return (ret);
if ((ret = pkg_delete_files(pkg, force)) != EPKG_OK)
return (ret);
if ((ret = pkg_script_post_deinstall(pkg)) != EPKG_OK)
return (ret);
return (pkgdb_unregister_pkg(db, pkg_get(pkg, PKG_ORIGIN)));
}
struct pkgdb_it *
pkgdb_rquery_provide(struct pkgdb *db, const char *provide, const char *repo)
{
sqlite3_stmt *stmt;
struct sbuf *sql = NULL;
const char *reponame = NULL;
int ret;
const char basesql[] = ""
"SELECT p.id, p.origin, p.name, p.version, p.comment, "
"p.name || '~' || p.origin as uniqueid, "
"p.prefix, p.desc, p.arch, p.maintainer, p.www, "
"p.licenselogic, p.flatsize, p.pkgsize, "
"p.cksum, p.manifestdigest, p.path AS repopath, '%1$s' AS dbname "
"FROM '%1$s'.packages AS p, '%1$s'.pkg_provides AS pp, "
"'%1$s'.provides AS pr "
"WHERE p.id = pp.package_id "
"AND pp.provide_id = pr.id "
"AND pr.name = ?1;";
assert(db != NULL);
reponame = pkgdb_get_reponame(db, repo);
sql = sbuf_new_auto();
/*
* Working on multiple remote repositories
*/
if (reponame == NULL) {
/* duplicate the query via UNION for all the attached
* databases */
ret = pkgdb_sql_all_attached(db->sqlite, sql,
basesql, " UNION ALL ");
if (ret != EPKG_OK) {
sbuf_delete(sql);
return (NULL);
}
} else
sbuf_printf(sql, basesql, reponame);
sbuf_finish(sql);
pkg_debug(4, "Pkgdb: running '%s'", sbuf_get(sql));
ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL);
if (ret != SQLITE_OK) {
ERROR_SQLITE(db->sqlite, sbuf_get(sql));
sbuf_delete(sql);
return (NULL);
}
sbuf_delete(sql);
sqlite3_bind_text(stmt, 1, provide, -1, SQLITE_TRANSIENT);
return (pkgdb_it_new(db, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE));
}
void
hook_add (struct list_head *hook, struct sbuf *s)
{
struct sbuf *cur;
/* Check if it's in the list already. */
list_for_each_entry (cur, hook, node)
{
if (!strcmp (sbuf_get (cur), sbuf_get (s)))
return;
}
/* It's not in the list, so add it. */
list_add_tail (&s->node, hook);
}
void
hook_remove (struct list_head *hook, struct sbuf *s)
{
struct list_head *tmp, *iter;
struct sbuf *cur;
/* If it's in the list, delete it. */
list_for_each_safe_entry (cur, iter, tmp, hook, node)
{
if (!strcmp (sbuf_get (cur), sbuf_get (s)))
{
list_del (&cur->node);
sbuf_free (cur);
}
}
}
/* Return the name of the keysym. caller must free returned pointer */
char *
keysym_to_string (KeySym keysym, unsigned int modifier)
{
static char *null_string = "NULL"; /* A NULL string. */
struct sbuf *name;
char *tmp;
name = sbuf_new (0);
if (modifier & RP_SHIFT_MASK) sbuf_concat (name, "S-");
if (modifier & RP_CONTROL_MASK) sbuf_concat (name, "C-");
if (modifier & RP_META_MASK) sbuf_concat (name, "M-");
if (modifier & RP_ALT_MASK) sbuf_concat (name, "A-");
if (modifier & RP_HYPER_MASK) sbuf_concat (name, "H-");
if (modifier & RP_SUPER_MASK) sbuf_concat (name, "s-");
/* On solaris machines (perhaps other machines as well) this call
can return NULL. In this case use the "NULL" string. */
tmp = XKeysymToString (keysym);
if (tmp == NULL)
tmp = null_string;
sbuf_concat (name, tmp);
/* Eat the nut and throw away the shells. */
tmp = sbuf_get (name);
free (name);
return tmp;
}
char *
frame_dump (rp_frame *frame, rp_screen *screen)
{
rp_window *win;
char *tmp;
struct sbuf *s;
/* rather than use win_number, use the X11 window ID. */
win = find_window_number (frame->win_number);
s = sbuf_new (0);
sbuf_printf (s, "(frame :number %d :x %d :y %d :width %d :height %d :screenw %d :screenh %d :window %ld :last-access %d :dedicated %d)",
frame->number,
frame->x,
frame->y,
frame->width,
frame->height,
screen->width,
screen->height,
win ? win->w:0,
frame->last_access,
frame->dedicated);
/* Extract the string and return it, and don't forget to free s. */
tmp = sbuf_get (s);
free (s);
return tmp;
}
int
packing_append_tree(struct packing *pack, const char *treepath,
const char *newroot)
{
FTS *fts = NULL;
FTSENT *fts_e = NULL;
size_t treelen;
struct sbuf *sb;
char *paths[2] = { __DECONST(char *, treepath), NULL };
treelen = strlen(treepath);
fts = fts_open(paths, FTS_PHYSICAL | FTS_XDEV, NULL);
if (fts == NULL)
goto cleanup;
sb = sbuf_new_auto();
while ((fts_e = fts_read(fts)) != NULL) {
switch(fts_e->fts_info) {
case FTS_D:
case FTS_DEFAULT:
case FTS_F:
case FTS_SL:
case FTS_SLNONE:
/* Entries not within this tree are irrelevant. */
if (fts_e->fts_pathlen <= treelen)
break;
sbuf_clear(sb);
/* Strip the prefix to obtain the target path */
if (newroot) /* Prepend a root if one is specified */
sbuf_cat(sb, newroot);
/* +1 = skip trailing slash */
sbuf_cat(sb, fts_e->fts_path + treelen + 1);
sbuf_finish(sb);
packing_append_file(pack, fts_e->fts_name,
sbuf_get(sb));
break;
case FTS_DC:
case FTS_DNR:
case FTS_ERR:
case FTS_NS:
/* XXX error cases, check fts_e->fts_errno and
* bubble up the call chain */
break;
default:
break;
}
}
sbuf_free(sb);
cleanup:
fts_close(fts);
return EPKG_OK;
}
int
send_command (unsigned char interactive, unsigned char *cmd, int screen_num)
{
Window w, root;
int done = 0;
struct sbuf *s;
s = sbuf_new(0);
sbuf_printf(s, "%c%s", interactive, cmd);
/* If the user specified a specific screen, then send the event to
that screen. */
if (screen_num >= 0)
root = RootWindow (dpy, screen_num);
else
root = DefaultRootWindow (dpy);
w = XCreateSimpleWindow (dpy, root, 0, 0, 1, 1, 0, 0, 0);
/* Select first to avoid race condition */
XSelectInput (dpy, w, PropertyChangeMask);
XChangeProperty (dpy, w, rp_command, XA_STRING,
8, PropModeReplace, sbuf_get(s), strlen ((char *)cmd) + 2);
XChangeProperty (dpy, root,
rp_command_request, XA_WINDOW,
8, PropModeAppend, (unsigned char *)&w, sizeof (Window));
sbuf_free (s);
while (!done)
{
XEvent ev;
XMaskEvent (dpy, PropertyChangeMask, &ev);
if (ev.xproperty.atom == rp_command_result
&& ev.xproperty.state == PropertyNewValue)
{
receive_command_result(ev.xproperty.window);
done = 1;
}
}
XDestroyWindow (dpy, w);
return 1;
}
void
hook_run (struct list_head *hook)
{
struct sbuf *cur;
cmdret *result;
list_for_each_entry (cur, hook, node)
{
result = command (1, sbuf_get (cur));
if (result)
{
if (result->output)
message (result->output);
cmdret_free (result);
}
}
const char *
pkg_conflict_glob(struct pkg_conflict *c)
{
return (sbuf_get(c->glob));
}
struct pkgdb_it *
pkgdb_rquery(struct pkgdb *db, const char *pattern, match_t match,
const char *repo)
{
sqlite3_stmt *stmt = NULL;
struct sbuf *sql = NULL;
const char *reponame = NULL;
const char *comp = NULL;
int ret;
char basesql[BUFSIZ] = ""
"SELECT id, origin, name, version, comment, "
"prefix, desc, arch, maintainer, www, "
"licenselogic, flatsize, pkgsize, "
"cksum, manifestdigest, path AS repopath, '%1$s' AS dbname "
"FROM '%1$s'.packages p";
assert(db != NULL);
assert(match == MATCH_ALL || (pattern != NULL && pattern[0] != '\0'));
/*
* If we have no remote repos loaded, we just return nothing instead of failing
* an assert deep inside pkgdb_get_reponame
*/
if (db->type != PKGDB_REMOTE)
return (NULL);
reponame = pkgdb_get_reponame(db, repo);
sql = sbuf_new_auto();
comp = pkgdb_get_pattern_query(pattern, match);
if (comp && comp[0])
strlcat(basesql, comp, sizeof(basesql));
/*
* Working on multiple remote repositories
*/
if (reponame == NULL) {
/* duplicate the query via UNION for all the attached
* databases */
ret = pkgdb_sql_all_attached(db->sqlite, sql,
basesql, " UNION ALL ");
if (ret != EPKG_OK) {
sbuf_delete(sql);
return (NULL);
}
} else
sbuf_printf(sql, basesql, reponame, reponame);
sbuf_cat(sql, " ORDER BY name;");
sbuf_finish(sql);
pkg_debug(4, "Pkgdb: running '%s'", sbuf_get(sql));
ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), sbuf_size(sql), &stmt, NULL);
if (ret != SQLITE_OK) {
ERROR_SQLITE(db->sqlite);
sbuf_delete(sql);
return (NULL);
}
sbuf_delete(sql);
if (match != MATCH_ALL && match != MATCH_CONDITION)
sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT);
return (pkgdb_it_new(db, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE));
}
static void
print_query(struct pkg *pkg, char *qstr, char multiline)
{
struct sbuf *output = sbuf_new_auto();
struct pkg_dep *dep = NULL;
struct pkg_category *cat = NULL;
struct pkg_option *option = NULL;
struct pkg_file *file = NULL;
struct pkg_dir *dir = NULL;
struct pkg_license *lic = NULL;
struct pkg_user *user = NULL;
struct pkg_group *group = NULL;
struct pkg_script *scripts = NULL;
switch (multiline) {
case 'd':
while (pkg_deps(pkg, &dep) == EPKG_OK) {
format_str(pkg, output, qstr, dep);
printf("%s\n", sbuf_get(output));
break;
}
case 'r':
while (pkg_rdeps(pkg, &dep) == EPKG_OK) {
format_str(pkg, output, qstr, dep);
printf("%s\n", sbuf_get(output));
}
break;
case 'C':
while (pkg_categories(pkg, &cat) == EPKG_OK) {
format_str(pkg, output, qstr, cat);
printf("%s\n", sbuf_get(output));
}
break;
case 'O':
while (pkg_options(pkg, &option) == EPKG_OK) {
format_str(pkg, output, qstr, option);
printf("%s\n", sbuf_get(output));
}
break;
case 'F':
while (pkg_files(pkg, &file) == EPKG_OK) {
format_str(pkg, output, qstr, file);
printf("%s\n", sbuf_get(output));
}
break;
case 'D':
while (pkg_dirs(pkg, &dir) == EPKG_OK) {
format_str(pkg, output, qstr, dir);
printf("%s\n", sbuf_get(output));
}
break;
case 'L':
while (pkg_licenses(pkg, &lic) == EPKG_OK) {
format_str(pkg, output, qstr, lic);
printf("%s\n", sbuf_get(output));
}
break;
case 'U':
while (pkg_users(pkg, &user) == EPKG_OK) {
format_str(pkg, output, qstr, user);
printf("%s\n", sbuf_get(output));
}
break;
case 'G':
while (pkg_users(pkg, &user) == EPKG_OK) {
format_str(pkg, output, qstr, group);
printf("%s\n", sbuf_get(output));
}
break;
case 'S':
while (pkg_scripts(pkg, &scripts) == EPKG_OK) {
format_str(pkg, output, qstr, scripts);
printf("%s\n", sbuf_get(output));
}
break;
default:
format_str(pkg, output, qstr, dep);
printf("%s\n", sbuf_get(output));
break;
}
sbuf_delete(output);
}
static int
pkg_object(struct pkg *pkg, ucl_object_t *obj, int attr)
{
struct sbuf *tmp = NULL;
ucl_object_t *cur;
ucl_object_iter_t it = NULL;
pkg_script script_type;
const char *key, *buf;
size_t len;
pkg_debug(3, "%s", "Manifest: parsing object");
while ((cur = ucl_iterate_object(obj, &it, true))) {
key = ucl_object_key(cur);
if (key == NULL)
continue;
switch (attr) {
case PKG_DEPS:
if (cur->type != UCL_OBJECT && cur->type != UCL_ARRAY)
pkg_emit_error("Skipping malformed dependency %s",
key);
else
pkg_set_deps_from_object(pkg, cur);
break;
case PKG_DIRS:
if (cur->type != UCL_OBJECT)
pkg_emit_error("Skipping malformed dirs %s",
key);
else
pkg_set_dirs_from_object(pkg, cur);
break;
case PKG_USERS:
if (cur->type == UCL_STRING)
pkg_adduid(pkg, key, ucl_object_tostring(cur));
else
pkg_emit_error("Skipping malformed users %s",
key);
break;
case PKG_GROUPS:
if (cur->type == UCL_STRING)
pkg_addgid(pkg, key, ucl_object_tostring(cur));
else
pkg_emit_error("Skipping malformed groups %s",
key);
break;
case PKG_DIRECTORIES:
if (cur->type == UCL_BOOLEAN) {
urldecode(key, &tmp);
pkg_adddir(pkg, sbuf_data(tmp), ucl_object_toboolean(cur), false);
} else if (cur->type == UCL_OBJECT) {
pkg_set_dirs_from_object(pkg, cur);
} else if (cur->type == UCL_STRING) {
urldecode(key, &tmp);
if (ucl_object_tostring(cur)[0] == 'y')
pkg_adddir(pkg, sbuf_data(tmp), 1, false);
else
pkg_adddir(pkg, sbuf_data(tmp), 0, false);
} else {
pkg_emit_error("Skipping malformed directories %s",
key);
}
break;
case PKG_FILES:
if (cur->type == UCL_STRING) {
buf = ucl_object_tolstring(cur, &len);
urldecode(key, &tmp);
pkg_addfile(pkg, sbuf_get(tmp), len == 64 ? buf : NULL, false);
} else if (cur->type == UCL_OBJECT)
pkg_set_files_from_object(pkg, cur);
else
pkg_emit_error("Skipping malformed files %s",
key);
break;
case PKG_OPTIONS:
if (cur->type != UCL_STRING && cur->type != UCL_BOOLEAN)
pkg_emit_error("Skipping malformed option %s",
key);
else
pkg_addoption(pkg, key, ucl_object_tostring_forced(cur));
break;
case PKG_OPTION_DEFAULTS:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed option default %s",
key);
else
pkg_addoption_default(pkg, key,
ucl_object_tostring(cur));
break;
case PKG_OPTION_DESCRIPTIONS:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed option description %s",
key);
else
pkg_addoption_description(pkg, key,
ucl_object_tostring(cur));
break;
case PKG_SCRIPTS:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed scripts %s",
key);
else {
script_type = script_type_str(key);
if (script_type == PKG_SCRIPT_UNKNOWN) {
pkg_emit_error("Skipping unknown script "
"type: %s", key);
break;
}
urldecode(ucl_object_tostring(cur), &tmp);
pkg_addscript(pkg, sbuf_data(tmp), script_type);
}
break;
case PKG_ANNOTATIONS:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed annotation %s",
key);
else
pkg_addannotation(pkg, key, ucl_object_tostring(cur));
break;
}
}
sbuf_free(tmp);
return (EPKG_OK);
}
int
pkg_old_emit_content(struct pkg *pkg, char **dest)
{
struct sbuf *content = sbuf_new_auto();
struct pkg_dep *dep = NULL;
struct pkg_file *file = NULL;
struct pkg_dir *dir = NULL;
struct pkg_option *option = NULL;
char option_type = 0;
pkg_sbuf_printf(content,
"@comment PKG_FORMAT_REVISION:1.1\n"
"@name %n-%v\n"
"@comment ORIGIN:%o\n"
"@cwd %p\n"
/* hack because we can recreate the prefix split or origin */
"@cwd /\n", pkg, pkg, pkg, pkg);
while (pkg_deps(pkg, &dep) == EPKG_OK) {
sbuf_printf(content,
"@pkgdep %s-%s\n"
"@comment DEPORIGIN:%s\n",
pkg_dep_name(dep),
pkg_dep_version(dep),
pkg_dep_origin(dep));
}
while (pkg_files(pkg, &file) == EPKG_OK) {
sbuf_printf(content,
"%s\n"
"@comment MD5:%s\n",
file->path + 1,
file->sum);
}
while (pkg_dirs(pkg, &dir) == EPKG_OK) {
sbuf_printf(content,
"@unexec /sbin/rmdir \"%s\" 2>/dev/null\n",
dir->path);
}
sbuf_printf(content, "@comment OPTIONS:");
while (pkg_options(pkg, &option) == EPKG_OK) {
/* Add space for previous option, if not the first. */
if (option_type != 0)
sbuf_cat(content, " ");
if (strcmp(pkg_option_value(option), "on") == 0)
option_type = '+';
else
option_type = '-';
sbuf_printf(content, "%c%s",
option_type,
pkg_option_opt(option));
}
sbuf_printf(content, "\n");
sbuf_finish(content);
*dest = strdup(sbuf_get(content));
sbuf_delete(content);
return (EPKG_OK);
}
const char *
pkg_option_opt(struct pkg_option *option)
{
return (sbuf_get(option->opt));
}
const char *
pkg_option_value(struct pkg_option *option)
{
return (sbuf_get(option->value));
}
static int
parse_mapping(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc, int attr)
{
struct sbuf *tmp = NULL;
yaml_node_pair_t *pair;
yaml_node_t *key;
yaml_node_t *val;
pkg_script script_type;
pair = item->data.mapping.pairs.start;
while (pair < item->data.mapping.pairs.top) {
key = yaml_document_get_node(doc, pair->key);
val = yaml_document_get_node(doc, pair->value);
if (key->data.scalar.length <= 0) {
pkg_emit_error("Skipping empty dependency name");
++pair;
continue;
}
switch (attr) {
case PKG_DEPS:
if (val->type != YAML_MAPPING_NODE)
pkg_emit_error("Skipping malformed dependency %s",
key->data.scalar.value);
else
pkg_set_deps_from_node(pkg, val, doc,
key->data.scalar.value);
break;
case PKG_DIRS:
if (val->type != YAML_MAPPING_NODE)
pkg_emit_error("Skipping malformed dirs %s",
key->data.scalar.value);
else
pkg_set_dirs_from_node(pkg, val, doc,
key->data.scalar.value);
break;
case PKG_USERS:
if (is_valid_yaml_scalar(val))
pkg_adduid(pkg, key->data.scalar.value,
val->data.scalar.value);
else
pkg_emit_error("Skipping malformed users %s",
key->data.scalar.value);
break;
case PKG_GROUPS:
if (is_valid_yaml_scalar(val))
pkg_addgid(pkg, key->data.scalar.value,
val->data.scalar.value);
else
pkg_emit_error("Skipping malformed groups %s",
key->data.scalar.value);
break;
case PKG_DIRECTORIES:
if (is_valid_yaml_scalar(val)) {
urldecode(key->data.scalar.value, &tmp);
if (val->data.scalar.value[0] == 'y')
pkg_adddir(pkg, sbuf_get(tmp), 1, false);
else
pkg_adddir(pkg, sbuf_get(tmp), 0, false);
} else if (val->type == YAML_MAPPING_NODE) {
pkg_set_dirs_from_node(pkg, val, doc,
key->data.scalar.value);
} else {
pkg_emit_error("Skipping malformed directories %s",
key->data.scalar.value);
}
break;
case PKG_FILES:
if (is_valid_yaml_scalar(val)) {
const char *pkg_sum = NULL;
if (val->data.scalar.length == 64)
pkg_sum = val->data.scalar.value;
urldecode(key->data.scalar.value, &tmp);
pkg_addfile(pkg, sbuf_get(tmp), pkg_sum, false);
} else if (val->type == YAML_MAPPING_NODE)
pkg_set_files_from_node(pkg, val, doc,
key->data.scalar.value);
else
pkg_emit_error("Skipping malformed files %s",
key->data.scalar.value);
break;
case PKG_OPTIONS:
if (val->type != YAML_SCALAR_NODE)
pkg_emit_error("Skipping malformed option %s",
key->data.scalar.value);
else
pkg_addoption(pkg, key->data.scalar.value,
val->data.scalar.value);
break;
case PKG_SCRIPTS:
if (val->type != YAML_SCALAR_NODE)
pkg_emit_error("Skipping malformed scripts %s",
key->data.scalar.value);
script_type = script_type_str(key->data.scalar.value);
if (script_type == PKG_SCRIPT_UNKNOWN) {
pkg_emit_error("Skipping unknown script "
"type: %s", key->data.scalar.value);
break;
}
urldecode(val->data.scalar.value, &tmp);
pkg_addscript(pkg, sbuf_get(tmp), script_type);
break;
}
++pair;
}
sbuf_free(tmp);
return (EPKG_OK);
}
