int procfs_doprocctl(PFS_FILL_ARGS) { int error; struct namemap *nm; if (uio == NULL || uio->uio_rw != UIO_WRITE) return (EOPNOTSUPP); /* * Map signal names into signal generation * or debug control. Unknown commands and/or signals * return EOPNOTSUPP. * * Sending a signal while the process is being debugged * also has the side effect of letting the target continue * to run. There is no way to single-step a signal delivery. */ error = EOPNOTSUPP; sbuf_trim(sb); sbuf_finish(sb); nm = findname(ctlnames, sbuf_data(sb), sbuf_len(sb)); if (nm) { printf("procfs: got a %s command\n", sbuf_data(sb)); error = procfs_control(td, p, nm->nm_val); } else { nm = findname(signames, sbuf_data(sb), sbuf_len(sb)); if (nm) { printf("procfs: got a sig%s\n", sbuf_data(sb)); PROC_LOCK(p); /* This is very broken XXXKSE: */ if (TRACE_WAIT_P(td->td_proc, p)) { p->p_xstat = nm->nm_val; #ifdef FIX_SSTEP /* XXXKSE: */ FIX_SSTEP(FIRST_THREAD_IN_PROC(p)); #endif /* XXXKSE: */ p->p_flag &= ~P_STOPPED_SIG; PROC_SLOCK(p); thread_unsuspend(p); PROC_SUNLOCK(p); } else psignal(p, nm->nm_val); PROC_UNLOCK(p); error = 0; } } return (error); }
void testStaticBuffer( Test * pTest) { STATIC_BUFFER sbuffer; char *data1 = "Joshua"; char *data2 = "Anna"; char *data3 = "Christopher"; char *data4 = "Mary"; char data_buffer[480] = ""; char test_data_buffer[480] = ""; char *data; unsigned count; sbuf_init(&sbuffer, NULL, 0); ct_test(pTest, sbuf_empty(&sbuffer) == true); ct_test(pTest, sbuf_data(&sbuffer) == NULL); ct_test(pTest, sbuf_size(&sbuffer) == 0); ct_test(pTest, sbuf_count(&sbuffer) == 0); ct_test(pTest, sbuf_append(&sbuffer, data1, strlen(data1)) == false); sbuf_init(&sbuffer, data_buffer, sizeof(data_buffer)); ct_test(pTest, sbuf_empty(&sbuffer) == true); ct_test(pTest, sbuf_data(&sbuffer) == data_buffer); ct_test(pTest, sbuf_size(&sbuffer) == sizeof(data_buffer)); ct_test(pTest, sbuf_count(&sbuffer) == 0); ct_test(pTest, sbuf_append(&sbuffer, data1, strlen(data1)) == true); ct_test(pTest, sbuf_append(&sbuffer, data2, strlen(data2)) == true); ct_test(pTest, sbuf_append(&sbuffer, data3, strlen(data3)) == true); ct_test(pTest, sbuf_append(&sbuffer, data4, strlen(data4)) == true); strcat(test_data_buffer, data1); strcat(test_data_buffer, data2); strcat(test_data_buffer, data3); strcat(test_data_buffer, data4); ct_test(pTest, sbuf_count(&sbuffer) == strlen(test_data_buffer)); data = sbuf_data(&sbuffer); count = sbuf_count(&sbuffer); ct_test(pTest, memcmp(data, test_data_buffer, count) == 0); ct_test(pTest, count == strlen(test_data_buffer)); ct_test(pTest, sbuf_truncate(&sbuffer, 0) == true); ct_test(pTest, sbuf_count(&sbuffer) == 0); ct_test(pTest, sbuf_size(&sbuffer) == sizeof(data_buffer)); ct_test(pTest, sbuf_append(&sbuffer, data4, strlen(data4)) == true); data = sbuf_data(&sbuffer); count = sbuf_count(&sbuffer); ct_test(pTest, memcmp(data, data4, count) == 0); ct_test(pTest, count == strlen(data4)); return; }
int64_t pkg_repo_binary_stat(struct pkg_repo *repo, pkg_stats_t type) { sqlite3 *sqlite = PRIV_GET(repo); sqlite3_stmt *stmt = NULL; int64_t stats = 0; struct sbuf *sql = NULL; int ret; sql = sbuf_new_auto(); switch(type) { case PKG_STATS_LOCAL_COUNT: goto out; break; case PKG_STATS_LOCAL_SIZE: goto out; break; case PKG_STATS_REMOTE_UNIQUE: sbuf_printf(sql, "SELECT COUNT(id) FROM main.packages;"); break; case PKG_STATS_REMOTE_COUNT: sbuf_printf(sql, "SELECT COUNT(id) FROM main.packages;"); break; case PKG_STATS_REMOTE_SIZE: sbuf_printf(sql, "SELECT SUM(pkgsize) FROM main.packages;"); break; case PKG_STATS_REMOTE_REPOS: goto out; break; } sbuf_finish(sql); pkg_debug(4, "binary_repo: running '%s'", sbuf_data(sql)); ret = sqlite3_prepare_v2(sqlite, sbuf_data(sql), -1, &stmt, NULL); if (ret != SQLITE_OK) { ERROR_SQLITE(sqlite, sbuf_data(sql)); goto out; } while (sqlite3_step(stmt) != SQLITE_DONE) { stats = sqlite3_column_int64(stmt, 0); } out: sbuf_free(sql); if (stmt != NULL) sqlite3_finalize(stmt); return (stats); }
void ctl_data_print(union ctl_io *io) { char str[128]; char path_str[64]; struct sbuf sb; int i, j, len; if (io->io_hdr.io_type != CTL_IO_SCSI) return; if (io->io_hdr.flags & CTL_FLAG_BUS_ADDR) return; if (io->io_hdr.flags & CTL_FLAG_EDPTR_SGLIST) /* XXX: Implement */ return; ctl_scsi_path_string(io, path_str, sizeof(path_str)); len = min(io->scsiio.kern_data_len, 4096); for (i = 0; i < len; ) { sbuf_new(&sb, str, sizeof(str), SBUF_FIXEDLEN); sbuf_cat(&sb, path_str); sbuf_printf(&sb, " %#6x:%04x:", io->scsiio.tag_num, i); for (j = 0; j < 16 && i < len; i++, j++) { if (j == 8) sbuf_cat(&sb, " "); sbuf_printf(&sb, " %02x", io->scsiio.kern_data_ptr[i]); } sbuf_cat(&sb, "\n"); sbuf_finish(&sb); printf("%s", sbuf_data(&sb)); } }
void progressbar_start(const char *pmsg) { free(progress_message); progress_message = NULL; if (quiet) return; if (pmsg != NULL) progress_message = strdup(pmsg); else { sbuf_finish(msg_buf); progress_message = strdup(sbuf_data(msg_buf)); } last_progress_percent = -1; last_tick = 0; begin = last_update = time(NULL); bytes_per_second = 0; stalled = 0; progress_started = true; progress_interrupted = false; if (!isatty(STDOUT_FILENO)) printf("%s: ", progress_message); else printf("%s: 0%%", progress_message); }
/* construct path to node->name */ static char * mtree_file_path(fsnode *node) { fsnode *pnode; struct sbuf *sb; char *res, *rp[MAKEFS_MAX_TREE_DEPTH]; int depth; depth = 0; rp[depth] = node->name; for (pnode = node->parent; pnode && depth < MAKEFS_MAX_TREE_DEPTH; pnode = pnode->parent) { if (strcmp(pnode->name, ".") == 0) break; rp[++depth] = pnode->name; } sb = sbuf_new_auto(); if (sb == NULL) { errno = ENOMEM; return (NULL); } while (depth > 0) { sbuf_cat(sb, rp[depth--]); sbuf_putc(sb, '/'); } sbuf_cat(sb, rp[depth]); sbuf_finish(sb); res = strdup(sbuf_data(sb)); sbuf_delete(sb); if (res == NULL) errno = ENOMEM; return res; }
int procfs_doosrel(PFS_FILL_ARGS) { const char *pp; int ov, osrel, i; if (uio == NULL) return (EOPNOTSUPP); if (uio->uio_rw == UIO_READ) { sbuf_printf(sb, "%d\n", p->p_osrel); } else { sbuf_trim(sb); sbuf_finish(sb); pp = sbuf_data(sb); osrel = 0; i = sbuf_len(sb); while (i--) { if (*pp < '0' || *pp > '9') return (EINVAL); ov = osrel * 10 + *pp++ - '0'; if (ov < osrel) return (EINVAL); osrel = ov; } p->p_osrel = osrel; } return (0); }
static int acpi_cpu_usage_sysctl(SYSCTL_HANDLER_ARGS) { struct acpi_cpu_softc *sc; struct sbuf sb; char buf[128]; int i; uintmax_t fract, sum, whole; sc = (struct acpi_cpu_softc *) arg1; sum = 0; for (i = 0; i < sc->cpu_cx_count; i++) sum += sc->cpu_cx_stats[i]; sbuf_new(&sb, buf, sizeof(buf), SBUF_FIXEDLEN); for (i = 0; i < sc->cpu_cx_count; i++) { if (sum > 0) { whole = (uintmax_t)sc->cpu_cx_stats[i] * 100; fract = (whole % sum) * 100; sbuf_printf(&sb, "%u.%02u%% ", (u_int)(whole / sum), (u_int)(fract / sum)); } else sbuf_printf(&sb, "0.00%% "); } sbuf_printf(&sb, "last %dus", sc->cpu_prev_sleep); sbuf_trim(&sb); sbuf_finish(&sb); sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req); sbuf_delete(&sb); return (0); }
static int sysctl_debug_ddb_scripting_scripts(SYSCTL_HANDLER_ARGS) { struct sbuf sb; int error, i, len; char *buffer; /* * Make space to include a maximum-length name, = symbol, * maximum-length script, and carriage return for every script that * may be defined. */ len = DB_MAXSCRIPTS * (DB_MAXSCRIPTNAME + 1 + DB_MAXSCRIPTLEN + 1); buffer = malloc(len, M_TEMP, M_WAITOK); (void)sbuf_new(&sb, buffer, len, SBUF_FIXEDLEN); mtx_lock(&db_script_mtx); for (i = 0; i < DB_MAXSCRIPTS; i++) { if (strlen(db_script_table[i].ds_scriptname) == 0) continue; (void)sbuf_printf(&sb, "%s=%s\n", db_script_table[i].ds_scriptname, db_script_table[i].ds_script); } mtx_unlock(&db_script_mtx); sbuf_finish(&sb); error = SYSCTL_OUT(req, sbuf_data(&sb), sbuf_len(&sb) + 1); sbuf_delete(&sb); free(buffer, M_TEMP); return (error); }
static int sbuf_copy_lines(struct sbuf *to, const char *from, int N) { int cnt = 0; int i; if (N == 0) return (0); for (i = 0; from[i] != '\0'; i++) { if (from[i] == '\n') { cnt++; continue; } if (cnt == N) break; } if (to == NULL) return (i); if (sbuf_len(to) > 0 && sbuf_data(to)[sbuf_len(to)-1] != '\n') sbuf_putc(to, '\n'); sbuf_bcat(to, from, i); sbuf_finish(to); return (i); }
void virtio_describe(device_t dev, const char *msg, uint64_t features, struct virtio_feature_desc *feature_desc) { struct sbuf sb; uint64_t val; char *buf; const char *name; int n; if ((buf = malloc(512, M_TEMP, M_NOWAIT)) == NULL) { device_printf(dev, "%s features: 0x%"PRIx64"\n", msg, features); return; } sbuf_new(&sb, buf, 512, SBUF_FIXEDLEN); sbuf_printf(&sb, "%s features: 0x%"PRIx64, msg, features); for (n = 0, val = 1ULL << 63; val != 0; val >>= 1) { /* * BAD_FEATURE is used to detect broken Linux clients * and therefore is not applicable to FreeBSD. */ if (((features & val) == 0) || val == VIRTIO_F_BAD_FEATURE) continue; if (n++ == 0) sbuf_cat(&sb, " <"); else sbuf_cat(&sb, ","); name = NULL; if (feature_desc != NULL) name = virtio_feature_name(val, feature_desc); if (name == NULL) name = virtio_feature_name(val, virtio_common_feature_desc); if (name == NULL) sbuf_printf(&sb, "0x%"PRIx64, val); else sbuf_cat(&sb, name); } if (n > 0) sbuf_cat(&sb, ">"); #if __FreeBSD_version < 900020 sbuf_finish(&sb); if (sbuf_overflowed(&sb) == 0) #else if (sbuf_finish(&sb) == 0) #endif device_printf(dev, "%s\n", sbuf_data(&sb)); sbuf_delete(&sb); free(buf, M_TEMP); }
void job_status_end(struct sbuf *msg) { sbuf_finish(msg); printf("%s\n", sbuf_data(msg)); /*printf("\033]0; %s\007", sbuf_data(msg));*/ sbuf_clear(msg); }
static void print_and_set_term_title(struct sbuf *msg) { sbuf_finish(msg); printf("%s", sbuf_data(msg)); /*printf("\033]0; %s\007", sbuf_data(msg));*/ sbuf_delete(msg); }
const char * sbuf_get(struct sbuf *buf) { if (buf == NULL) return (NULL); return sbuf_data(buf); }
static void print_status_end(struct sbuf *msg) { sbuf_finish(msg); printf("%s", sbuf_data(msg)); /*printf("\033]0; %s\007", sbuf_data(msg));*/ sbuf_delete(msg); }
static int pkg_set_files_from_object(struct pkg *pkg, ucl_object_t *obj) { ucl_object_t *cur; ucl_object_iter_t it = NULL; const char *sum = NULL; const char *uname = NULL; const char *gname = NULL; void *set = NULL; mode_t perm = 0; struct sbuf *fname = NULL; const char *key, *okey; okey = ucl_object_key(obj); if (okey == NULL) return (EPKG_FATAL); urldecode(okey, &fname); while ((cur = ucl_iterate_object(obj, &it, true))) { key = ucl_object_key(cur); if (key == NULL) continue; if (!strcasecmp(key, "uname") && cur->type == UCL_STRING) uname = ucl_object_tostring(cur); else if (!strcasecmp(key, "gname") && cur->type == UCL_STRING) gname = ucl_object_tostring(cur); else if (!strcasecmp(key, "sum") && cur->type == UCL_STRING && strlen(ucl_object_tostring(cur)) == 64) sum = ucl_object_tostring(cur); else if (!strcasecmp(key, "perm") && (cur->type == UCL_STRING || cur->type == UCL_INT)) { if ((set = setmode(ucl_object_tostring_forced(cur))) == NULL) pkg_emit_error("Not a valid mode: %s", ucl_object_tostring(cur)); else perm = getmode(set, 0); } else { pkg_emit_error("Skipping unknown key for file(%s): %s", sbuf_data(fname), ucl_object_tostring(cur)); } } pkg_addfile_attr(pkg, sbuf_data(fname), sum, uname, gname, perm, false); sbuf_delete(fname); return (EPKG_OK); }
int pkg_script_run(struct pkg *pkg, pkg_script_t type) { struct pkg_script *script = NULL; pkg_script_t stype; struct sbuf *script_cmd = sbuf_new_auto(); size_t i; struct { const char *arg; const pkg_script_t b; const pkg_script_t a; } const map[] = { /* a implies b with argument arg */ {"PRE-INSTALL", PKG_SCRIPT_INSTALL, PKG_SCRIPT_PRE_INSTALL}, {"POST-INSTALL", PKG_SCRIPT_INSTALL, PKG_SCRIPT_POST_INSTALL}, {"PRE-UPGRADE", PKG_SCRIPT_UPGRADE, PKG_SCRIPT_PRE_UPGRADE}, {"POST-UPGRADE", PKG_SCRIPT_UPGRADE, PKG_SCRIPT_POST_UPGRADE}, {"DEINSTALL", PKG_SCRIPT_DEINSTALL, PKG_SCRIPT_PRE_DEINSTALL}, {"POST-DEINSTALL", PKG_SCRIPT_DEINSTALL, PKG_SCRIPT_POST_DEINSTALL}, }; for (i = 0; i < sizeof(map) / sizeof(map[0]); i++) { if (map[i].a == type) break; } if (map[i].a != type) return (ERROR_BAD_ARG("type")); while (pkg_scripts(pkg, &script) == EPKG_OK) { stype = pkg_script_type(script); if (stype == map[i].a || stype == map[i].b) { sbuf_reset(script_cmd); sbuf_printf(script_cmd, "PKG_PREFIX=%s\nset -- %s-%s", pkg_get(pkg, PKG_PREFIX), pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION)); if (stype == map[i].b) { /* add arg **/ sbuf_cat(script_cmd, " "); sbuf_cat(script_cmd, map[i].arg); } sbuf_cat(script_cmd, "\n"); sbuf_cat(script_cmd, pkg_script_data(script)); sbuf_finish(script_cmd); system(sbuf_data(script_cmd)); } } sbuf_delete(script_cmd); return (EPKG_OK); }
/** * \brief Enumerate all devices of the given type on this bus. * * \param dev NewBus device_t for this XenBus backend bus instance. * \param type String indicating the device sub-tree (e.g. "vfb", "vif") * to enumerate. * * \return On success, 0. Otherwise an errno value indicating the * type of failure. * * Devices that are found are entered into the NewBus hierarchy via * xenbusb_add_device(). xenbusb_add_device() ignores duplicate detects * and ignores duplicate devices, so it can be called unconditionally * for any device found in the XenStore. * * The backend XenStore hierarchy has the following format: * * backend/<device type>/<frontend vm id>/<device id> * */ static int xenbusb_back_enumerate_type(device_t dev, const char *type) { struct xenbusb_softc *xbs; const char **vms; u_int vm_idx; u_int vm_count; int error; xbs = device_get_softc(dev); error = xs_directory(XST_NIL, xbs->xbs_node, type, &vm_count, &vms); if (error) return (error); for (vm_idx = 0; vm_idx < vm_count; vm_idx++) { struct sbuf *vm_path; const char *vm; const char **devs; u_int dev_idx; u_int dev_count; vm = vms[vm_idx]; vm_path = xs_join(type, vm); error = xs_directory(XST_NIL, xbs->xbs_node, sbuf_data(vm_path), &dev_count, &devs); sbuf_delete(vm_path); if (error) break; for (dev_idx = 0; dev_idx < dev_count; dev_idx++) { const char *dev_num; struct sbuf *id; dev_num = devs[dev_idx]; id = xs_join(vm, dev_num); xenbusb_add_device(dev, type, sbuf_data(id)); sbuf_delete(id); } free(devs, M_XENSTORE); } free(vms, M_XENSTORE); return (0); }
struct pkg_repo_it * pkg_repo_binary_query(struct pkg_repo *repo, const char *pattern, match_t match) { sqlite3 *sqlite = PRIV_GET(repo); sqlite3_stmt *stmt = NULL; struct sbuf *sql = NULL; const char *comp = NULL; int ret; char basesql[BUFSIZ] = "" "SELECT id, origin, name, name as uniqueid, version, comment, " "prefix, desc, arch, maintainer, www, " "licenselogic, flatsize, pkgsize, " "cksum, manifestdigest, path AS repopath, '%s' AS dbname " "FROM packages AS p"; if (match != MATCH_ALL && (pattern == NULL || pattern[0] == '\0')) return (NULL); sql = sbuf_new_auto(); comp = pkgdb_get_pattern_query(pattern, match); if (comp && comp[0]) strlcat(basesql, comp, sizeof(basesql)); sbuf_printf(sql, basesql, repo->name); sbuf_cat(sql, " ORDER BY name;"); sbuf_finish(sql); pkg_debug(4, "Pkgdb: running '%s' query for %s", sbuf_data(sql), pattern == NULL ? "all": pattern); ret = sqlite3_prepare_v2(sqlite, sbuf_data(sql), sbuf_len(sql), &stmt, NULL); if (ret != SQLITE_OK) { ERROR_SQLITE(sqlite, sbuf_data(sql)); 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 (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE)); }
/* * Read a symbolic link */ static int pfs_readlink(struct vop_readlink_args *va) { struct vnode *vn = va->a_vp; struct pfs_vdata *pvd = vn->v_data; struct pfs_node *pn = pvd->pvd_pn; struct uio *uio = va->a_uio; struct proc *proc = NULL; struct thread *td = curthread; char buf[PATH_MAX]; struct sbuf sb; int error, locked; PFS_TRACE(("%s", pn->pn_name)); pfs_assert_not_owned(pn); if (vn->v_type != VLNK) PFS_RETURN (EINVAL); KASSERT_PN_IS_LINK(pn); if (pn->pn_fill == NULL) PFS_RETURN (EIO); if (pvd->pvd_pid != NO_PID) { if ((proc = pfind(pvd->pvd_pid)) == NULL) PFS_RETURN (EIO); if (proc->p_flag & P_WEXIT) { PROC_UNLOCK(proc); PFS_RETURN (EIO); } _PHOLD(proc); PROC_UNLOCK(proc); } vhold(vn); locked = VOP_ISLOCKED(vn, td); VOP_UNLOCK(vn, 0, td); /* sbuf_new() can't fail with a static buffer */ sbuf_new(&sb, buf, sizeof buf, 0); error = pn_fill(td, proc, pn, &sb, NULL); if (proc != NULL) PRELE(proc); vn_lock(vn, locked | LK_RETRY, td); vdrop(vn); if (error) { sbuf_delete(&sb); PFS_RETURN (error); } sbuf_finish(&sb); error = uiomove_frombuf(sbuf_data(&sb), sbuf_len(&sb), uio); sbuf_delete(&sb); PFS_RETURN (error); }
static void khttpd_ktr_logging(struct sbuf *sbuf) { struct uio auio; struct iovec aiov; struct ktr_entry *ep; struct thread *td; int error, fd, i, n; KHTTPD_ASSERT_CURPROC_IS_KHTTPD(); td = curthread; error = kern_openat(td, AT_FDCWD, KHTTPD_KTR_FILE, UIO_SYSSPACE, O_WRONLY | O_APPEND, 0666); if (error != 0) { log(LOG_WARNING, "khttpd: failed to open ktr file '%s' (error %d)", KHTTPD_KTR_FILE, error); return; } fd = td->td_retval[0]; sbuf_clear(sbuf); n = ktr_entries; for (i = khttpd_ktr_logging_idx; i != ktr_idx; i = i == n - 1 ? 0 : i + 1) { ep = &ktr_buf[i]; sbuf_printf(sbuf, "%lld %p %d ", (long long)ep->ktr_timestamp, ep->ktr_thread, ep->ktr_cpu); sbuf_printf(sbuf, ep->ktr_desc, ep->ktr_parms[0], ep->ktr_parms[1], ep->ktr_parms[2], ep->ktr_parms[3], ep->ktr_parms[4], ep->ktr_parms[5]); sbuf_cat(sbuf, "\n"); } sbuf_finish(sbuf); khttpd_ktr_logging_idx = i; aiov.iov_base = sbuf_data(sbuf); aiov.iov_len = sbuf_len(sbuf); auio.uio_iov = &aiov; auio.uio_iovcnt = 1; auio.uio_resid = aiov.iov_len; auio.uio_segflg = UIO_SYSSPACE; error = kern_writev(td, fd, &auio); if (error != 0) log(LOG_WARNING, "khttpd: KTR flush failed " "(error: %d)", error); kern_close(td, fd); }
int linux_sysctl(struct thread *td, struct linux_sysctl_args *args) { struct l___sysctl_args la; struct sbuf *sb; l_int *mib; int error, i; error = copyin(args->args, &la, sizeof(la)); if (error) return (error); if (la.nlen <= 0 || la.nlen > LINUX_CTL_MAXNAME) return (ENOTDIR); mib = malloc(la.nlen * sizeof(l_int), M_TEMP, M_WAITOK); error = copyin(PTRIN(la.name), mib, la.nlen * sizeof(l_int)); if (error) { free(mib, M_TEMP); return (error); } switch (mib[0]) { case LINUX_CTL_KERN: if (la.nlen < 2) break; switch (mib[1]) { case LINUX_KERN_VERSION: error = handle_string(&la, version); free(mib, M_TEMP); return (error); default: break; } break; default: break; } sb = sbuf_new(NULL, NULL, 20 + la.nlen * 5, SBUF_AUTOEXTEND); if (sb == NULL) { linux_msg(td, "sysctl is not implemented"); } else { sbuf_printf(sb, "sysctl "); for (i = 0; i < la.nlen; i++) sbuf_printf(sb, "%c%d", (i) ? ',' : '{', mib[i]); sbuf_printf(sb, "} is not implemented"); sbuf_finish(sb); linux_msg(td, "%s", sbuf_data(sb)); sbuf_delete(sb); } free(mib, M_TEMP); return (ENOTDIR); }
char * ctl_io_string(union ctl_io *io, char *str, int str_len) { struct sbuf sb; sbuf_new(&sb, str, str_len, SBUF_FIXEDLEN); ctl_io_sbuf(io, &sb); sbuf_finish(&sb); return (sbuf_data(&sb)); }
char * sbuf_get(struct sbuf *buf) { assert(buf != NULL); if (sbuf_done(buf) == 0) sbuf_finish(buf); return (sbuf_data(buf)); }
struct pkg_repo_it * pkg_repo_binary_search(struct pkg_repo *repo, const char *pattern, match_t match, pkgdb_field field, pkgdb_field sort) { sqlite3 *sqlite = PRIV_GET(repo); sqlite3_stmt *stmt = NULL; struct sbuf *sql = NULL; int ret; const char *multireposql = "" "SELECT id, origin, name, version, comment, " "prefix, desc, arch, maintainer, www, " "licenselogic, flatsize, pkgsize, " "cksum, path AS repopath, '%1$s' AS dbname, '%2$s' AS repourl " "FROM packages "; if (pattern == NULL || pattern[0] == '\0') return (NULL); sql = sbuf_new_auto(); sbuf_printf(sql, multireposql, repo->name, repo->url); /* close the UNIONs and build the search query */ sbuf_cat(sql, "WHERE "); pkg_repo_binary_build_search_query(sql, match, field, sort); sbuf_cat(sql, ";"); sbuf_finish(sql); pkg_debug(4, "Pkgdb: running '%s'", sbuf_data(sql)); ret = sqlite3_prepare_v2(sqlite, sbuf_data(sql), -1, &stmt, NULL); if (ret != SQLITE_OK) { ERROR_SQLITE(sqlite, sbuf_data(sql)); sbuf_delete(sql); return (NULL); } sbuf_delete(sql); sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_TRANSIENT); return (pkg_repo_binary_it_new(repo, stmt, PKGDB_IT_FLAG_ONCE)); }
char * ctl_io_error_string(union ctl_io *io, struct scsi_inquiry_data *inq_data, char *str, int str_len) { struct sbuf sb; sbuf_new(&sb, str, str_len, SBUF_FIXEDLEN); ctl_io_error_sbuf(io, inq_data, &sb); sbuf_finish(&sb); return (sbuf_data(&sb)); }
const char * pkg_script_get(struct pkg const * const p, pkg_script i) { if (p->scripts[i] == NULL) return (NULL); if (sbuf_done(p->scripts[i]) == 0) sbuf_finish(p->scripts[i]); return (sbuf_data(p->scripts[i])); }
char * sbuf_get(struct sbuf *buf) { if (buf == NULL) return (__DECONST(char *, "")); if (sbuf_done(buf) == 0) sbuf_finish(buf); return (sbuf_data(buf)); }
int format_exec_cmd(char **dest, const char *in, const char *prefix, const char *plist_file) { struct sbuf *buf = sbuf_new_auto(); char path[MAXPATHLEN + 1]; char *cp; while (in[0] != '\0') { if (in[0] == '%') { in++; switch(in[0]) { case 'D': sbuf_cat(buf, prefix); break; case 'F': sbuf_cat(buf, plist_file); break; case 'f': if (prefix[strlen(prefix) - 1] == '/') snprintf(path, sizeof(path), "%s%s", prefix, plist_file); else snprintf(path, sizeof(path), "%s/%s", prefix, plist_file); cp = strrchr(path, '/'); cp ++; sbuf_cat(buf, cp); break; case 'B': if (prefix[strlen(prefix) - 1] == '/') snprintf(path, sizeof(path), "%s%s", prefix, plist_file); else snprintf(path, sizeof(path), "%s/%s", prefix, plist_file); cp = strrchr(path, '/'); cp[0] = '\0'; sbuf_cat(buf, path); break; default: sbuf_putc(buf, in[0]); break; } } else { sbuf_putc(buf, in[0]); } in++; } sbuf_finish(buf); *dest = strdup(sbuf_data(buf)); sbuf_free(buf); return (0); }
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_attr(pack, fts_e->fts_name, sbuf_data(sb), NULL, NULL, 0, 0); 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; }