/* * Decode a SMP request buffer into a string of hexadecimal numbers. * * smp_request: SMP request * request_len: length of the SMP request buffer, may be reduced if the * caller only wants part of the buffer printed * sb: sbuf(9) buffer * line_prefix: prefix for new lines, or an empty string ("") * first_line_len: length left on first line * line_len: total length of subsequent lines, 0 for no additional lines * if there are no additional lines, first line will get ... * at the end if there is additional data */ void smp_command_decode(uint8_t *smp_request, int request_len, struct sbuf *sb, char *line_prefix, int first_line_len, int line_len) { int i, cur_len; for (i = 0, cur_len = first_line_len; i < request_len; i++) { /* * Each byte takes 3 characters. As soon as we go less * than 6 (meaning we have at least 3 and at most 5 * characters left), check to see whether the subsequent * line length (line_len) is long enough to bother with. * If the user set it to 0, or some other length that isn't * enough to hold at least the prefix and one byte, put ... * on the first line to indicate that there is more data * and bail out. */ if ((cur_len < 6) && (line_len < (strlen(line_prefix) + 3))) { sbuf_printf(sb, "..."); return; } if (cur_len < 3) { sbuf_printf(sb, "\n%s", line_prefix); cur_len = line_len - strlen(line_prefix); } sbuf_printf(sb, "%02x ", smp_request[i]); cur_len = cur_len - 3; } }
/* * Dump configuration information in XML format. * Notice that the function is called once for the geom and once for each * consumer and provider. We let g_slice_dumpconf() do most of the work. */ static void g_bsd_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp, struct g_consumer *cp, struct g_provider *pp) { struct g_bsd_softc *ms; struct g_slicer *gsp; gsp = gp->softc; ms = gsp->softc; g_slice_dumpconf(sb, indent, gp, cp, pp); if (indent != NULL && pp == NULL && cp == NULL) { sbuf_printf(sb, "%s<labeloffset>%jd</labeloffset>\n", indent, (intmax_t)ms->labeloffset); sbuf_printf(sb, "%s<rawoffset>%jd</rawoffset>\n", indent, (intmax_t)ms->rawoffset); sbuf_printf(sb, "%s<mbroffset>%jd</mbroffset>\n", indent, (intmax_t)ms->mbroffset); } else if (pp != NULL) { if (indent == NULL) sbuf_printf(sb, " ty %d", ms->ondisk.d_partitions[pp->index].p_fstype); else sbuf_printf(sb, "%s<type>%d</type>\n", indent, ms->ondisk.d_partitions[pp->index].p_fstype); } }
/* * CONTROL MESSAGES */ static int text_status(node_p node, struct priv *priv, char *arg, u_int len) { struct sbuf sbuf; sbuf_new(&sbuf, arg, len, 0); if (priv->upper) sbuf_printf(&sbuf, "upper hook: %s connected to %s:%s\n", NG_HOOK_NAME(priv->upper), NG_NODE_NAME(NG_HOOK_NODE(NG_HOOK_PEER(priv->upper))), NG_HOOK_NAME(NG_HOOK_PEER(priv->upper))); else sbuf_printf(&sbuf, "upper hook: <not connected>\n"); if (priv->lower) sbuf_printf(&sbuf, "lower hook: %s connected to %s:%s\n", NG_HOOK_NAME(priv->lower), NG_NODE_NAME(NG_HOOK_NODE(NG_HOOK_PEER(priv->lower))), NG_HOOK_NAME(NG_HOOK_PEER(priv->lower))); else sbuf_printf(&sbuf, "lower hook: <not connected>\n"); sbuf_printf(&sbuf, "sscf state: %s\n", priv->enabled == NULL ? "<disabled>" : sscfu_statename(sscfu_getstate(priv->sscf))); sbuf_finish(&sbuf); return (sbuf_len(&sbuf)); }
/* * ata_status_abuf() returns 0 for success and -1 for failure. */ int ata_status_sbuf(struct ccb_ataio *ataio, struct sbuf *sb) { sbuf_printf(sb, "ATA status: %02x (%s%s%s%s%s%s%s%s)", ataio->res.status, (ataio->res.status & 0x80) ? "BSY " : "", (ataio->res.status & 0x40) ? "DRDY " : "", (ataio->res.status & 0x20) ? "DF " : "", (ataio->res.status & 0x10) ? "SERV " : "", (ataio->res.status & 0x08) ? "DRQ " : "", (ataio->res.status & 0x04) ? "CORR " : "", (ataio->res.status & 0x02) ? "IDX " : "", (ataio->res.status & 0x01) ? "ERR" : ""); if (ataio->res.status & 1) { sbuf_printf(sb, ", error: %02x (%s%s%s%s%s%s%s%s)", ataio->res.error, (ataio->res.error & 0x80) ? "ICRC " : "", (ataio->res.error & 0x40) ? "UNC " : "", (ataio->res.error & 0x20) ? "MC " : "", (ataio->res.error & 0x10) ? "IDNF " : "", (ataio->res.error & 0x08) ? "MCR " : "", (ataio->res.error & 0x04) ? "ABRT " : "", (ataio->res.error & 0x02) ? "NM " : "", (ataio->res.error & 0x01) ? "ILI" : ""); } return(0); }
static int sysctl_handle_dpi(SYSCTL_HANDLER_ARGS) { struct ioat_softc *ioat; struct sbuf sb; #define PRECISION "1" const uintmax_t factor = 10; uintmax_t rate; int error; ioat = arg1; sbuf_new_for_sysctl(&sb, NULL, 16, req); if (ioat->stats.interrupts == 0) { sbuf_printf(&sb, "NaN"); goto out; } rate = ioat->stats.descriptors_processed * factor / ioat->stats.interrupts; sbuf_printf(&sb, "%ju.%." PRECISION "ju", rate / factor, rate % factor); #undef PRECISION out: error = sbuf_finish(&sb); sbuf_delete(&sb); if (error != 0 || req->newptr == NULL) return (error); return (EINVAL); }
static int i915_capabilities(struct drm_device *dev, struct sbuf *m, void *data) { const struct intel_device_info *info = INTEL_INFO(dev); sbuf_printf(m, "gen: %d\n", info->gen); if (HAS_PCH_SPLIT(dev)) sbuf_printf(m, "pch: %d\n", INTEL_PCH_TYPE(dev)); #define B(x) sbuf_printf(m, #x ": %s\n", yesno(info->x)) B(is_mobile); B(is_i85x); B(is_i915g); B(is_i945gm); B(is_g33); B(need_gfx_hws); B(is_g4x); B(is_pineview); B(has_fbc); B(has_pipe_cxsr); B(has_hotplug); B(cursor_needs_physical); B(has_overlay); B(overlay_needs_physical); B(supports_tv); B(has_bsd_ring); B(has_blt_ring); B(has_llc); #undef B return (0); }
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)); } }
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); }
int sysctl_l2t(SYSCTL_HANDLER_ARGS) { struct adapter *sc = arg1; struct l2t_data *l2t = sc->l2t; struct l2t_entry *e; struct sbuf *sb; int rc, i, header = 0; char ip[INET6_ADDRSTRLEN]; if (l2t == NULL) return (ENXIO); rc = sysctl_wire_old_buffer(req, 0); if (rc != 0) return (rc); sb = sbuf_new_for_sysctl(NULL, NULL, 4096, req); if (sb == NULL) return (ENOMEM); e = &l2t->l2tab[0]; for (i = 0; i < l2t->l2t_size; i++, e++) { mtx_lock(&e->lock); if (e->state == L2T_STATE_UNUSED) goto skip; if (header == 0) { sbuf_printf(sb, " Idx IP address " "Ethernet address VLAN/P LP State Users Port"); header = 1; } if (e->state == L2T_STATE_SWITCHING) ip[0] = 0; else { inet_ntop(e->ipv6 ? AF_INET6 : AF_INET, &e->addr[0], &ip[0], sizeof(ip)); } /* * XXX: e->ifp may not be around. * XXX: IPv6 addresses may not align properly in the output. */ sbuf_printf(sb, "\n%4u %-15s %02x:%02x:%02x:%02x:%02x:%02x %4d" " %u %2u %c %5u %s", e->idx, ip, e->dmac[0], e->dmac[1], e->dmac[2], e->dmac[3], e->dmac[4], e->dmac[5], e->vlan & 0xfff, vlan_prio(e), e->lport, l2e_state(e), atomic_load_acq_int(&e->refcnt), e->ifp->if_xname); skip: mtx_unlock(&e->lock); } rc = sbuf_finish(sb); sbuf_delete(sb); return (rc); }
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); }
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 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))); }
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); }
int procfs_doproctype(PFS_FILL_ARGS) { static const char *none = "Not Available"; if (p != NULL && p->p_sysent && p->p_sysent->sv_name) sbuf_printf(sb, "%s", p->p_sysent->sv_name); else sbuf_printf(sb, "%s", none); sbuf_putc(sb, '\n'); return (0); }
int procfs_doprocrlimit(PFS_FILL_ARGS) { struct plimit *limp; int i; /* * Obtain a private reference to resource limits */ PROC_LOCK(p); limp = lim_hold(p->p_limit); PROC_UNLOCK(p); for (i = 0; i < RLIM_NLIMITS; i++) { /* * Add the rlimit ident */ sbuf_printf(sb, "%s ", rlimit_ident[i]); /* * Replace RLIM_INFINITY with -1 in the string */ /* * current limit */ if (limp->pl_rlimit[i].rlim_cur == RLIM_INFINITY) { sbuf_printf(sb, "-1 "); } else { sbuf_printf(sb, "%llu ", (unsigned long long)limp->pl_rlimit[i].rlim_cur); } /* * maximum limit */ if (limp->pl_rlimit[i].rlim_max == RLIM_INFINITY) { sbuf_printf(sb, "-1\n"); } else { sbuf_printf(sb, "%llu\n", (unsigned long long)limp->pl_rlimit[i].rlim_max); } } lim_free(limp); return (0); }
void nvme_print_ident(const struct nvme_controller_data *cdata, const struct nvme_namespace_data *data, struct sbuf *sb) { sbuf_printf(sb, "<"); cam_strvis_sbuf(sb, cdata->mn, sizeof(cdata->mn), 0); sbuf_printf(sb, " "); cam_strvis_sbuf(sb, cdata->fr, sizeof(cdata->fr), 0); sbuf_printf(sb, " "); cam_strvis_sbuf(sb, cdata->sn, sizeof(cdata->sn), 0); sbuf_printf(sb, ">\n"); }
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); }
/* * ctl_scsi_sense_sbuf() returns 0 for success and -1 for failure. */ int ctl_scsi_sense_sbuf(struct ctl_scsiio *ctsio, struct scsi_inquiry_data *inq_data, struct sbuf *sb, scsi_sense_string_flags flags) { char path_str[64]; if ((ctsio == NULL) || (sb == NULL)) return(-1); ctl_scsi_path_string((union ctl_io *)ctsio, path_str, sizeof(path_str)); if (flags & SSS_FLAG_PRINT_COMMAND) { sbuf_cat(sb, path_str); ctl_scsi_command_string(ctsio, inq_data, sb); sbuf_printf(sb, "\n"); } scsi_sense_only_sbuf(&ctsio->sense_data, ctsio->sense_len, sb, path_str, inq_data, ctsio->cdb, ctsio->cdb_len); return(0); }
static int vfs_mountroot_readconf(struct thread *td, struct sbuf *sb) { static char buf[128]; struct nameidata nd; off_t ofs; ssize_t resid; int error, flags, len; NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, "/.mount.conf", td); flags = FREAD; error = vn_open(&nd, &flags, 0, NULL); if (error) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); ofs = 0; len = sizeof(buf) - 1; while (1) { error = vn_rdwr(UIO_READ, nd.ni_vp, buf, len, ofs, UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, NOCRED, &resid, td); if (error) break; if (resid == len) break; buf[len - resid] = 0; sbuf_printf(sb, "%s", buf); ofs += len - resid; } VOP_UNLOCK(nd.ni_vp, 0); vn_close(nd.ni_vp, FREAD, td->td_ucred, td); return (error); }
static void print_status_begin(struct sbuf *msg) { if (nbactions > 0) sbuf_printf(msg, "[%d/%d] ", nbdone, nbactions); }
static int pkg_repo_binary_build_search_query(struct sbuf *sql, match_t match, pkgdb_field field, pkgdb_field sort) { const char *how = NULL; const char *what = NULL; const char *orderby = NULL; how = pkg_repo_binary_search_how(match); switch (field) { case FIELD_NONE: what = NULL; break; case FIELD_ORIGIN: what = "origin"; break; case FIELD_NAME: what = "name"; break; case FIELD_NAMEVER: what = "name || '-' || version"; break; case FIELD_COMMENT: what = "comment"; break; case FIELD_DESC: what = "desc"; break; } if (what != NULL && how != NULL) sbuf_printf(sql, how, what); switch (sort) { case FIELD_NONE: orderby = NULL; break; case FIELD_ORIGIN: orderby = " ORDER BY origin"; break; case FIELD_NAME: orderby = " ORDER BY name"; break; case FIELD_NAMEVER: orderby = " ORDER BY name, version"; break; case FIELD_COMMENT: orderby = " ORDER BY comment"; break; case FIELD_DESC: orderby = " ORDER BY desc"; break; } if (orderby != NULL) sbuf_cat(sql, orderby); return (EPKG_OK); }
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 ucl_sbuf_append_double(double val, void *data) { struct sbuf *buf = data; const double delta = 0.0000001; if (val == (double)(int)val) { sbuf_printf(buf, "%.1lf", val); } else if (fabs(val - (double)(int)val) < delta) { sbuf_printf(buf, "%.*lg", DBL_DIG, val); } else { sbuf_printf(buf, "%lf", val); } return (0); }
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 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); }
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); }
static int ucl_sbuf_append_int(int64_t val, void *data) { struct sbuf *buf = data; sbuf_printf(buf, "%"PRId64, val); return (0); }
int exec_add(int argc, char **argv) { struct pkgdb *db = NULL; struct sbuf *failedpkgs = sbuf_new_auto(); char path[MAXPATHLEN + 1]; char *file; int retcode = EPKG_OK; int i; int failedpkgcount = 0; struct pkg *p = NULL; if (argc < 2) { usage_add(); return (EX_USAGE); } if (geteuid() != 0) { warnx("adding packages can only be done as root"); return (EX_NOPERM); } if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) { return (EX_IOERR); } for (i = 1; i < argc; i++) { if (is_url(argv[i]) == EPKG_OK) { snprintf(path, sizeof(path), "./%s", basename(argv[i])); if ((retcode = pkg_fetch_file(argv[i], path)) != EPKG_OK) break; file = path; } else file = argv[i]; pkg_open(&p, file, NULL); if ((retcode = pkg_add(db, file, 0)) != EPKG_OK) { sbuf_cat(failedpkgs, argv[i]); if (i != argc - 1) sbuf_printf(failedpkgs, ", "); failedpkgcount++; } } pkgdb_close(db); if(failedpkgcount > 0) { sbuf_finish(failedpkgs); printf("Failed to install the following %d package(s): %s.\n", failedpkgcount, sbuf_data(failedpkgs)); } sbuf_delete(failedpkgs); return (retcode == EPKG_OK ? EX_OK : EX_SOFTWARE); }
static int partition_cred_externalize_label(struct label *label, char *element_name, struct sbuf *sb, int *claimed) { if (strcmp(MAC_PARTITION_LABEL_NAME, element_name) != 0) return (0); (*claimed)++; if (label != NULL) { if (sbuf_printf(sb, "%jd", (intmax_t)SLOT(label)) == -1) return (EINVAL); } else { if (sbuf_printf(sb, "0") == -1) return (EINVAL); } return (0); }
/* * ata_res_sbuf() returns 0 for success and -1 for failure. */ int ata_res_sbuf(struct ccb_ataio *ataio, struct sbuf *sb) { char res_str[(11 * 3) + 1]; sbuf_printf(sb, "RES: %s", ata_res_string(&ataio->res, res_str, sizeof(res_str))); return(0); }