/* 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); }