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); }
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); }
/* * 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)); }
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); }
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); }
void term_commit(void) { if (term_sbuf) { write(1, sbuf_buf(term_sbuf), sbuf_len(term_sbuf)); sbuf_free(term_sbuf); term_sbuf = NULL; } }
ssize_t sbuf_size(struct sbuf *buf) { if (buf != NULL) return sbuf_len(buf); return 0; }
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); }
/* * 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); }
/* split the arguments in sbuf, after calling one of mkargs_*() */ static void chopargs(struct sbuf *sbuf, char **args) { char *s = sbuf_buf(sbuf); char *e = s + sbuf_len(sbuf); int n = 0; while (n < NARGS && s && s < e) { args[n++] = s; if ((s = memchr(s, '\0', e - s))) s++; } }
/* Concatenate string in safebuf s2 to end of string in safebuf s1, * growing if necessary */ void sbuf_catb(safebuf_t *s1, const safebuf_t *s2) { size_t s2len; size_t res; assert(SAFEBUF_CHECK(s1)); assert(SAFEBUF_CHECK(s2)); s2len = sbuf_len(s2); sbuf_grow(s1, 1 + s1->cl + s2len); res = strlcat(s1->buf + s1->cl, s2->buf, s1->len); assert( res < s1->len ); s1->cl += s2len; assert(SAFEBUF_CHECK(s1)); }
static void tr_chop(char **args) { struct sbuf sbuf; int id; id = map(args[1]); if (str_get(id)) { sbuf_init(&sbuf); sbuf_append(&sbuf, str_get(id)); if (!sbuf_empty(&sbuf)) { sbuf_cut(&sbuf, sbuf_len(&sbuf) - 1); str_set(id, sbuf_buf(&sbuf)); } sbuf_done(&sbuf); } }
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)); }
struct sbuf * exec_buf(const char *cmd) { FILE *fp; char buf[BUFSIZ]; struct sbuf *res; if ((fp = popen(cmd, "r")) == NULL) return (NULL); res = sbuf_new_auto(); while (fgets(buf, BUFSIZ, fp) != NULL) sbuf_cat(res, buf); pclose(fp); if (sbuf_len(res) == 0) { sbuf_delete(res); return (NULL); } sbuf_finish(res); return (res); }
static int convert_to_old(const char *pkg_add_dbdir, bool dry_run) { struct pkgdb *db = NULL; struct pkg *pkg = NULL; struct pkg_dep *dep = NULL; struct pkgdb_it *it = NULL; char *content, *name, *version, *buf; const char *tmp; int ret = EX_OK; char path[MAXPATHLEN]; int query_flags = PKG_LOAD_DEPS | PKG_LOAD_FILES | PKG_LOAD_DIRS | PKG_LOAD_SCRIPTS | PKG_LOAD_OPTIONS | PKG_LOAD_MTREE | PKG_LOAD_USERS | PKG_LOAD_GROUPS | PKG_LOAD_RDEPS; FILE *fp, *rq; struct sbuf *install_script = sbuf_new_auto(); struct sbuf *deinstall_script = sbuf_new_auto(); if (mkdir(pkg_add_dbdir, 0755) != 0 && errno != EEXIST) err(EX_CANTCREAT, "%s", pkg_add_dbdir); if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) { pkgdb_close(db); return (EX_IOERR); } if ((it = pkgdb_query(db, NULL, MATCH_ALL)) == NULL) { ret = EPKG_FATAL; goto cleanup; } while (pkgdb_it_next(it, &pkg, query_flags) == EPKG_OK) { rq = NULL; pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version); printf("Converting %s-%s...", name, version); if (dry_run) { printf("\n"); continue; } pkg_to_old(pkg); pkg_old_emit_content(pkg, &content); snprintf(path, MAXPATHLEN, "%s/%s-%s", pkg_add_dbdir, name, version); mkdir(path, 0755); snprintf(path, MAXPATHLEN, "%s/%s-%s/+CONTENTS", pkg_add_dbdir, name, version); fp = fopen(path, "w"); fputs(content, fp); fclose(fp); pkg_get(pkg, PKG_DESC, &buf); snprintf(path, MAXPATHLEN, "%s/%s-%s/+DESC", pkg_add_dbdir, name, version); fp = fopen(path, "w"); fputs(buf, fp); fclose(fp); pkg_get(pkg, PKG_COMMENT, &buf); snprintf(path, MAXPATHLEN, "%s/%s-%s/+COMMENT", pkg_add_dbdir, name, version); fp = fopen(path, "w"); fprintf(fp, "%s\n", buf); fclose(fp); pkg_get(pkg, PKG_MESSAGE, &buf); if (buf != NULL && buf[0] != '\0') { snprintf(path, MAXPATHLEN, "%s/%s-%s/+DISPLAY", pkg_add_dbdir, name, version); fp = fopen(path, "w"); fputs(buf, fp); fclose(fp); } pkg_get(pkg, PKG_MTREE, &buf); if (buf != NULL && buf[0] != '\0') { snprintf(path, MAXPATHLEN, "%s/%s-%s/+MTREE_DIRS", pkg_add_dbdir, name, version); fp = fopen(path, "w"); fputs(buf, fp); fclose(fp); } sbuf_clear(install_script); tmp = pkg_script_get(pkg, PKG_SCRIPT_PRE_INSTALL); if (tmp != NULL && tmp[0] != '\0') { if (sbuf_len(install_script) == 0) sbuf_cat(install_script, "#!/bin/sh\n\n"); sbuf_printf(install_script, "if [ \"$2\" = \"PRE-INSTALL\" ]; then\n" "%s\n" "fi\n", tmp); } tmp = pkg_script_get(pkg, PKG_SCRIPT_INSTALL); if (tmp != NULL && tmp[0] != '\0') { if (sbuf_len(install_script) == 0) sbuf_cat(install_script, "#!/bin/sh\n\n"); sbuf_cat(install_script, tmp); } tmp = pkg_script_get(pkg, PKG_SCRIPT_POST_INSTALL); if (tmp != NULL && tmp[0] != '\0') { if (sbuf_len(install_script) == 0) sbuf_cat(install_script, "#!/bin/sh\n\n"); sbuf_printf(install_script, "if [ \"$2\" = \"POST-INSTALL\" ]; then\n" "%s\n" "fi\n", tmp); } if (sbuf_len(install_script) > 0) { sbuf_finish(install_script); snprintf(path, MAXPATHLEN, "%s/%s-%s/+INSTALL", pkg_add_dbdir, name, version); fp = fopen(path, "w"); fputs(sbuf_data(install_script), fp); fclose(fp); } sbuf_clear(deinstall_script); tmp = pkg_script_get(pkg, PKG_SCRIPT_PRE_DEINSTALL); if (tmp != NULL && tmp[0] != '\0') { if (sbuf_len(deinstall_script) == 0) sbuf_cat(deinstall_script, "#!/bin/sh\n\n"); sbuf_printf(deinstall_script, "if [ \"$2\" = \"DEINSTALL\" ]; then\n" "%s\n" "fi\n", tmp); } tmp = pkg_script_get(pkg, PKG_SCRIPT_DEINSTALL); if (tmp != NULL && tmp[0] != '\0') { if (sbuf_len(deinstall_script) == 0) sbuf_cat(deinstall_script, "#!/bin/sh\n\n"); sbuf_cat(deinstall_script, tmp); } tmp = pkg_script_get(pkg, PKG_SCRIPT_POST_DEINSTALL); if (tmp != NULL && tmp[0] != '\0') { if (sbuf_len(deinstall_script) == 0) sbuf_cat(deinstall_script, "#!/bin/sh\n\n"); sbuf_printf(deinstall_script, "if [ \"$2\" = \"POST-DEINSTALL\" ]; then\n" "%s\n" "fi\n", tmp); } if (sbuf_len(deinstall_script) > 0) { sbuf_finish(deinstall_script); snprintf(path, MAXPATHLEN, "%s/%s-%s/+DEINSTALL", pkg_add_dbdir, name, version); fp = fopen(path, "w"); fputs(sbuf_data(deinstall_script), fp); fclose(fp); } snprintf(path, MAXPATHLEN, "%s/%s-%s/+REQUIRED_BY", pkg_add_dbdir, name, version); while (pkg_rdeps(pkg, &dep) == EPKG_OK) { if (rq == NULL) rq = fopen(path, "w"); fprintf(rq, "%s-%s\n", pkg_dep_name(dep), pkg_dep_version(dep)); } if (rq != NULL) fclose(rq); printf("done.\n"); free(content); } sbuf_delete(install_script); sbuf_delete(deinstall_script); cleanup: pkg_free(pkg); pkgdb_it_free(it); pkgdb_close(db); return (ret); }
static int do_extract(struct archive *a, struct archive_entry *ae, const char *location, int nfiles, struct pkg *pkg, struct pkg *local) { int retcode = EPKG_OK; int ret = 0, cur_file = 0; char path[MAXPATHLEN], pathname[MAXPATHLEN], rpath[MAXPATHLEN]; struct stat st; const struct stat *aest; bool renamed = false; const struct pkg_file *rf; struct pkg_config_file *rcf; struct sbuf *newconf; bool automerge = pkg_object_bool(pkg_config_get("AUTOMERGE")); unsigned long set, clear; #ifndef HAVE_ARC4RANDOM srand(time(NULL)); #endif if (nfiles == 0) return (EPKG_OK); pkg_emit_extract_begin(pkg); pkg_emit_progress_start(NULL); newconf = sbuf_new_auto(); do { ret = ARCHIVE_OK; sbuf_clear(newconf); rf = NULL; rcf = NULL; pkg_absolutepath(archive_entry_pathname(ae), path, sizeof(path)); snprintf(pathname, sizeof(pathname), "%s%s%s", location ? location : "", *path == '/' ? "" : "/", path ); strlcpy(rpath, pathname, sizeof(rpath)); aest = archive_entry_stat(ae); archive_entry_fflags(ae, &set, &clear); if (lstat(rpath, &st) != -1) { /* * We have an existing file on the path, so handle it */ if (!S_ISDIR(aest->st_mode)) { pkg_debug(2, "Old version found, renaming"); pkg_add_file_random_suffix(rpath, sizeof(rpath), 12); renamed = true; } if (!S_ISDIR(st.st_mode) && S_ISDIR(aest->st_mode)) { if (S_ISLNK(st.st_mode)) { if (stat(rpath, &st) == -1) { pkg_emit_error("Dead symlink %s", rpath); } else { pkg_debug(2, "Directory is a symlink, use it"); pkg_emit_progress_tick(cur_file++, nfiles); continue; } } } } archive_entry_set_pathname(ae, rpath); /* load in memory the content of config files */ if (pkg_is_config_file(pkg, path, &rf, &rcf)) { pkg_debug(1, "Populating config_file %s", pathname); size_t len = archive_entry_size(ae); rcf->content = malloc(len); archive_read_data(a, rcf->content, len); if (renamed && (!automerge || local == NULL)) strlcat(pathname, ".pkgnew", sizeof(pathname)); } /* * check if the file is already provided by previous package */ if (!automerge) attempt_to_merge(renamed, rcf, local, pathname, path, newconf); if (sbuf_len(newconf) == 0 && (rcf == NULL || rcf->content == NULL)) { pkg_debug(1, "Extracting: %s", archive_entry_pathname(ae)); int install_as_user = (getenv("INSTALL_AS_USER") != NULL); int extract_flags = EXTRACT_ARCHIVE_FLAGS; if (install_as_user) { /* when installing as user don't try to set file ownership */ extract_flags &= ~ARCHIVE_EXTRACT_OWNER; } ret = archive_read_extract(a, ae, extract_flags); } else { if (sbuf_len(newconf) == 0) { sbuf_cat(newconf, rcf->content); sbuf_finish(newconf); } pkg_debug(2, "Writing conf in %s", pathname); unlink(rpath); FILE *f = fopen(rpath, "w+"); fprintf(f, "%s", sbuf_data(newconf)); fclose(f); } if (ret != ARCHIVE_OK) { /* * show error except when the failure is during * extracting a directory and that the directory already * exists. * this allow to install packages linux_base from * package for example */ if (archive_entry_filetype(ae) != AE_IFDIR || !is_dir(pathname)) { pkg_emit_error("archive_read_extract(): %s", archive_error_string(a)); retcode = EPKG_FATAL; goto cleanup; } } /* Reapply modes to the directories to work around a problem on FreeBSD 9 */ if (archive_entry_filetype(ae) == AE_IFDIR) chmod(pathname, aest->st_mode); pkg_emit_progress_tick(cur_file++, nfiles); /* Rename old file */ if (renamed) { pkg_debug(1, "Renaming %s -> %s", rpath, pathname); #ifdef HAVE_CHFLAGS bool old = false; if (set & NOCHANGESFLAGS) chflags(rpath, 0); if (lstat(pathname, &st) != -1) { old = true; if (st.st_flags & NOCHANGESFLAGS) chflags(pathname, 0); } #endif if (rename(rpath, pathname) == -1) { #ifdef HAVE_CHFLAGS /* restore flags */ if (old) chflags(pathname, st.st_flags); #endif pkg_emit_error("cannot rename %s to %s: %s", rpath, pathname, strerror(errno)); retcode = EPKG_FATAL; goto cleanup; } #ifdef HAVE_CHFLAGS /* Restore flags */ chflags(pathname, set); #endif } if (string_end_with(pathname, ".pkgnew")) pkg_emit_notice("New configuration file: %s", pathname); renamed = false; } while ((ret = archive_read_next_header(a, &ae)) == ARCHIVE_OK); if (ret != ARCHIVE_EOF) { pkg_emit_error("archive_read_next_header(): %s", archive_error_string(a)); retcode = EPKG_FATAL; } cleanup: pkg_emit_progress_tick(nfiles, nfiles); pkg_emit_extract_finished(pkg); if (renamed && retcode == EPKG_FATAL) { #ifdef HAVE_CHFLAGS if (set & NOCHANGESFLAGS) chflags(rpath, set & ~NOCHANGESFLAGS); #endif unlink(rpath); } return (retcode); }
/* * Produce a readable status description */ 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"); if (priv->manage) sbuf_printf(&sbuf, "manage hook: %s connected to %s:%s\n", NG_HOOK_NAME(priv->manage), NG_NODE_NAME(NG_HOOK_NODE(NG_HOOK_PEER(priv->manage))), NG_HOOK_NAME(NG_HOOK_PEER(priv->manage))); else sbuf_printf(&sbuf, "manage hook: <not connected>\n"); sbuf_printf(&sbuf, "sscop state: %s\n", !priv->enabled ? "<disabled>" : sscop_statename(sscop_getstate(priv->sscop))); sbuf_printf(&sbuf, "input packets: %ju\n", (uintmax_t)priv->stats.in_packets); sbuf_printf(&sbuf, "input dropped: %ju\n", (uintmax_t)priv->stats.in_dropped); sbuf_printf(&sbuf, "output packets: %ju\n", (uintmax_t)priv->stats.out_packets); sbuf_printf(&sbuf, "output dropped: %ju\n", (uintmax_t)priv->stats.out_dropped); sbuf_printf(&sbuf, "aa signals: %ju\n", (uintmax_t)priv->stats.aa_signals); sbuf_printf(&sbuf, "aa dropped: %ju\n", (uintmax_t)priv->stats.aa_dropped); sbuf_printf(&sbuf, "maa signals: %ju\n", (uintmax_t)priv->stats.maa_signals); sbuf_printf(&sbuf, "maa dropped: %ju\n", (uintmax_t)priv->stats.maa_dropped); sbuf_printf(&sbuf, "errors: %ju\n", (uintmax_t)priv->stats.errors); sbuf_printf(&sbuf, "data delivered: %ju\n", (uintmax_t)priv->stats.data_delivered); sbuf_printf(&sbuf, "window: %u\n", sscop_window(priv->sscop, 0)); sbuf_finish(&sbuf); return (sbuf_len(&sbuf)); }
static int pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archive) { char fpath[MAXPATHLEN]; struct pkg_file *file = NULL; struct pkg_dir *dir = NULL; char *m; int ret; bool developer; struct stat st; char sha256[SHA256_DIGEST_LENGTH * 2 + 1]; int64_t flatsize = 0; const char *relocation; struct hardlinks *hardlinks = NULL; if (pkg_is_valid(pkg) != EPKG_OK) { pkg_emit_error("the package is not valid"); return (EPKG_FATAL); } relocation = pkg_kv_get(&pkg->annotations, "relocated"); if (relocation == NULL) relocation = ""; /* * Get / compute size / checksum if not provided in the manifest */ while (pkg_files(pkg, &file) == EPKG_OK) { snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "", relocation, file->path); if (lstat(fpath, &st) == -1) { pkg_emit_error("file '%s' is missing", fpath); return (EPKG_FATAL); } if (file->size == 0) file->size = (int64_t)st.st_size; if (st.st_nlink == 1 || !check_for_hardlink(&hardlinks, &st)) { flatsize += file->size; } if (S_ISLNK(st.st_mode)) { if (file->sum[0] == '\0') { if (pkg_symlink_cksum(fpath, root, sha256) == EPKG_OK) strlcpy(file->sum, sha256, sizeof(file->sum)); else return (EPKG_FATAL); } } else { if (file->sum[0] == '\0') { if (pkg->type == PKG_OLD_FILE) { if (md5_file(fpath, sha256) != EPKG_OK) return (EPKG_FATAL); } else { if (sha256_file(fpath, sha256) != EPKG_OK) return (EPKG_FATAL); } strlcpy(file->sum, sha256, sizeof(file->sum)); } } } pkg->flatsize = flatsize; HASH_FREE(hardlinks, free); if (pkg->type == PKG_OLD_FILE) { char oldcomment[BUFSIZ]; pkg_old_emit_content(pkg, &m); packing_append_buffer(pkg_archive, m, "+CONTENTS", strlen(m)); free(m); packing_append_buffer(pkg_archive, pkg->desc, "+DESC", strlen(pkg->desc)); packing_append_buffer(pkg_archive, pkg->message, "+DISPLAY", strlen(pkg->message)); pkg_snprintf(oldcomment, sizeof(oldcomment), "%c\n", pkg); packing_append_buffer(pkg_archive, oldcomment, "+COMMENT", strlen(oldcomment)); } else { /* * Register shared libraries used by the package if * SHLIBS enabled in conf. Deletes shlib info if not. */ struct sbuf *b = sbuf_new_auto(); pkg_analyse_files(NULL, pkg, root); pkg_emit_manifest_sbuf(pkg, b, PKG_MANIFEST_EMIT_COMPACT, NULL); packing_append_buffer(pkg_archive, sbuf_data(b), "+COMPACT_MANIFEST", sbuf_len(b)); sbuf_clear(b); pkg_emit_manifest_sbuf(pkg, b, 0, NULL); sbuf_finish(b); packing_append_buffer(pkg_archive, sbuf_data(b), "+MANIFEST", sbuf_len(b)); sbuf_delete(b); } while (pkg_files(pkg, &file) == EPKG_OK) { snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "", relocation, file->path); ret = packing_append_file_attr(pkg_archive, fpath, file->path, file->uname, file->gname, file->perm); developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE")); if (developer && ret != EPKG_OK) return (ret); } while (pkg_dirs(pkg, &dir) == EPKG_OK) { snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "", relocation, dir->path); ret = packing_append_file_attr(pkg_archive, fpath, dir->path, dir->uname, dir->gname, dir->perm); developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE")); if (developer && ret != EPKG_OK) return (ret); } return (EPKG_OK); }
static void pipeevent(struct pkg_event *ev) { struct pkg *pkg = NULL; struct pkg_dep *dep = NULL; struct sbuf *msg, *buf; const char *message; const char *name, *version, *newversion; if (eventpipe < 0) return; msg = sbuf_new_auto(); buf = sbuf_new_auto(); switch(ev->type) { case PKG_EVENT_ERRNO: sbuf_printf(msg, "{ \"type\": \"ERROR\", " "\"data\": {" "\"msg\": \"%s(%s): %s\"," "\"errno\": %d}}", sbuf_json_escape(buf, ev->e_errno.func), sbuf_json_escape(buf, ev->e_errno.arg), sbuf_json_escape(buf, strerror(ev->e_errno.no)), ev->e_errno.no); break; case PKG_EVENT_ERROR: sbuf_printf(msg, "{ \"type\": \"ERROR\", " "\"data\": {\"msg\": \"%s\"}}", sbuf_json_escape(buf, ev->e_pkg_error.msg)); break; case PKG_EVENT_DEVELOPER_MODE: sbuf_printf(msg, "{ \"type\": \"ERROR\", " "\"data\": {\"msg\": \"DEVELOPER_MODE: %s\"}}", sbuf_json_escape(buf, ev->e_pkg_error.msg)); break; case PKG_EVENT_FETCHING: sbuf_printf(msg, "{ \"type\": \"INFO_FETCH\", " "\"data\": { " "\"url\": \"%s\", " "\"fetched\": %" PRId64 ", " "\"total\": %" PRId64 "}}", sbuf_json_escape(buf, ev->e_fetching.url), ev->e_fetching.done, ev->e_fetching.total ); break; case PKG_EVENT_INSTALL_BEGIN: pkg_get(ev->e_install_begin.pkg, PKG_NAME, &name, PKG_VERSION, &version); sbuf_printf(msg, "{ \"type\": \"INFO_INSTALL_BEGIN\", " "\"data\": { " "\"pkgname\": \"%s\", " "\"pkgversion\": \"%s\"" "}}", name, version ); break; case PKG_EVENT_INSTALL_FINISHED: pkg_get(ev->e_install_finished.pkg, PKG_MESSAGE, &message, PKG_NAME, &name, PKG_VERSION, &version); sbuf_printf(msg, "{ \"type\": \"INFO_INSTALL_FINISHED\", " "\"data\": { " "\"pkgname\": \"%s\", " "\"pkgversion\": \"%s\", " "\"message\": \"%s\"" "}}", name, version, sbuf_json_escape(buf, message)); break; case PKG_EVENT_INTEGRITYCHECK_BEGIN: sbuf_printf(msg, "{ \"type\": \"INFO_INTEGRITYCHECK_BEGIN\", " "\"data\": {}}"); break; case PKG_EVENT_INTEGRITYCHECK_FINISHED: sbuf_printf(msg, "{ \"type\": \"INFO_INTEGRITYCHECK_FINISHED\", " "\"data\": {}}"); break; case PKG_EVENT_DEINSTALL_BEGIN: pkg_get(ev->e_deinstall_begin.pkg, PKG_NAME, &name, PKG_VERSION, &version); sbuf_printf(msg, "{ \"type\": \"INFO_DEINSTALL_BEGIN\", " "\"data\": { " "\"pkgname\": \"%s\", " "\"pkgversion\": \"%s\"" "}}", name, version); break; case PKG_EVENT_DEINSTALL_FINISHED: pkg_get(ev->e_deinstall_finished.pkg, PKG_NAME, &name, PKG_VERSION, &version); sbuf_printf(msg, "{ \"type\": \"INFO_DEINSTALL_FINISHED\", " "\"data\": { " "\"pkgname\": \"%s\", " "\"pkgversion\": \"%s\"" "}}", name, version); break; case PKG_EVENT_UPGRADE_BEGIN: pkg_get(ev->e_upgrade_begin.pkg, PKG_NAME, &name, PKG_VERSION, &version, PKG_NEWVERSION, &newversion); sbuf_printf(msg, "{ \"type\": \"INFO_UPGRADE_BEGIN\", " "\"data\": { " "\"pkgname\": \"%s\", " "\"pkgversion\": \"%s\" ," "\"pkgnewversion\": \"%s\"" "}}", name, version, newversion); break; case PKG_EVENT_UPGRADE_FINISHED: pkg_get(ev->e_upgrade_finished.pkg, PKG_NAME, &name, PKG_VERSION, &version, PKG_NEWVERSION, &newversion); sbuf_printf(msg, "{ \"type\": \"INFO_UPGRADE_FINISHED\", " "\"data\": { " "\"pkgname\": \"%s\", " "\"pkgversion\": \"%s\" ," "\"pkgnewversion\": \"%s\"" "}}", name, version, newversion); break; case PKG_EVENT_LOCKED: pkg_get(ev->e_locked.pkg, PKG_NAME, &name, PKG_VERSION, &version); sbuf_printf(msg, "{ \"type\": \"ERROR_LOCKED\", " "\"data\": { " "\"pkgname\": \"%s\", " "\"pkgversion\": \"%s\"" "}}", name, version); break; case PKG_EVENT_REQUIRED: pkg_get(ev->e_required.pkg, PKG_NAME, &name, PKG_VERSION, &version); sbuf_printf(msg, "{ \"type\": \"ERROR_REQUIRED\", " "\"data\": { " "\"pkgname\": \"%s\", " "\"pkgversion\": \"%s\", " "\"force\": %s, " "\"required_by\": [", name, version, ev->e_required.force == 1 ? "true": "false"); while (pkg_rdeps(pkg, &dep) == EPKG_OK) sbuf_printf(msg, "{ \"pkgname\": \"%s\", " "\"pkgversion\": \"%s\" }, ", pkg_dep_name(dep), pkg_dep_version(dep)); sbuf_setpos(msg, sbuf_len(msg) - 2); sbuf_cat(msg, "]}}"); break; case PKG_EVENT_ALREADY_INSTALLED: pkg_get(ev->e_already_installed.pkg, PKG_NAME, &name, PKG_VERSION, &version); sbuf_printf(msg, "{ \"type\": \"ERROR_ALREADY_INSTALLED\", " "\"data\": { " "\"pkgname\": \"%s\", " "\"pkgversion\": \"%s\"" "}}", name, version); break; case PKG_EVENT_MISSING_DEP: sbuf_printf(msg, "{ \"type\": \"ERROR_MISSING_DEP\", " "\"data\": { " "\"depname\": \"%s\", " "\"depversion\": \"%s\"" "}}" , pkg_dep_name(ev->e_missing_dep.dep), pkg_dep_version(ev->e_missing_dep.dep)); break; case PKG_EVENT_NOREMOTEDB: sbuf_printf(msg, "{ \"type\": \"ERROR_NOREMOTEDB\", " "\"data\": { " "\"url\": \"%s\" " "}}" , ev->e_remotedb.repo); break; case PKG_EVENT_NOLOCALDB: sbuf_printf(msg, "{ \"type\": \"ERROR_NOLOCALDB\", " "\"data\": {} "); break; case PKG_EVENT_NEWPKGVERSION: sbuf_printf(msg, "{ \"type\": \"INFO_NEWPKGVERSION\", " "\"data\": {} "); break; case PKG_EVENT_FILE_MISMATCH: pkg_get(ev->e_file_mismatch.pkg, PKG_NAME, &name, PKG_VERSION, &version); sbuf_printf(msg, "{ \"type\": \"ERROR_FILE_MISMATCH\", " "\"data\": { " "\"pkgname\": \"%s\", " "\"pkgversion\": \"%s\", " "\"path\": \"%s\"" "}}", name, version, sbuf_json_escape(buf, pkg_file_path(ev->e_file_mismatch.file))); break; case PKG_EVENT_PLUGIN_ERRNO: sbuf_printf(msg, "{ \"type\": \"ERROR_PLUGIN\", " "\"data\": {" "\"plugin\": \"%s\", " "\"msg\": \"%s(%s): %s\"," "\"errno\": %d" "}}", pkg_plugin_get(ev->e_plugin_errno.plugin, PKG_PLUGIN_NAME), sbuf_json_escape(buf, ev->e_plugin_errno.func), sbuf_json_escape(buf, ev->e_plugin_errno.arg), sbuf_json_escape(buf, strerror(ev->e_plugin_errno.no)), ev->e_plugin_errno.no); break; case PKG_EVENT_PLUGIN_ERROR: sbuf_printf(msg, "{ \"type\": \"ERROR_PLUGIN\", " "\"data\": {" "\"plugin\": \"%s\", " "\"msg\": \"%s\"" "}}", pkg_plugin_get(ev->e_plugin_error.plugin, PKG_PLUGIN_NAME), sbuf_json_escape(buf, ev->e_plugin_error.msg)); break; case PKG_EVENT_PLUGIN_INFO: sbuf_printf(msg, "{ \"type\": \"INFO_PLUGIN\", " "\"data\": {" "\"plugin\": \"%s\", " "\"msg\": \"%s\"" "}}", pkg_plugin_get(ev->e_plugin_info.plugin, PKG_PLUGIN_NAME), sbuf_json_escape(buf, ev->e_plugin_info.msg)); break; default: break; } sbuf_finish(msg); dprintf(eventpipe, "%s\n", sbuf_data(msg)); sbuf_delete(msg); sbuf_delete(buf); }
/* * Read from a file */ static int pfs_read(struct vop_read_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; struct sbuf *sb = NULL; int error, locked; unsigned int buflen, offset, resid; PFS_TRACE(("%s", pn->pn_name)); pfs_assert_not_owned(pn); if (vn->v_type != VREG) PFS_RETURN (EINVAL); KASSERT_PN_IS_FILE(pn); if (!(pn->pn_flags & PFS_RD)) PFS_RETURN (EBADF); if (pn->pn_fill == NULL) PFS_RETURN (EIO); /* * This is necessary because either process' privileges may * have changed since the open() call. */ if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc)) PFS_RETURN (EIO); if (proc != NULL) { _PHOLD(proc); PROC_UNLOCK(proc); } vhold(vn); locked = VOP_ISLOCKED(vn, curthread); VOP_UNLOCK(vn, 0, curthread); if (pn->pn_flags & PFS_RAWRD) { PFS_TRACE(("%lu resid", (unsigned long)uio->uio_resid)); error = pn_fill(curthread, proc, pn, NULL, uio); PFS_TRACE(("%lu resid", (unsigned long)uio->uio_resid)); goto ret; } /* beaucoup sanity checks so we don't ask for bogus allocation */ if (uio->uio_offset < 0 || uio->uio_resid < 0 || (offset = uio->uio_offset) != uio->uio_offset || (resid = uio->uio_resid) != uio->uio_resid || (buflen = offset + resid + 1) < offset || buflen > INT_MAX) { if (proc != NULL) PRELE(proc); error = EINVAL; goto ret; } if (buflen > MAXPHYS + 1) { error = EIO; goto ret; } sb = sbuf_new(sb, NULL, buflen, 0); if (sb == NULL) { error = EIO; goto ret; } error = pn_fill(curthread, proc, pn, sb, uio); if (error) { sbuf_delete(sb); goto ret; } sbuf_finish(sb); error = uiomove_frombuf(sbuf_data(sb), sbuf_len(sb), uio); sbuf_delete(sb); ret: vn_lock(vn, locked | LK_RETRY, curthread); vdrop(vn); if (proc != NULL) PRELE(proc); PFS_RETURN (error); }
int pkg_register_old(struct pkg *pkg) { FILE *fp; char *content; const char *pkgdbdir, *tmp; char path[MAXPATHLEN]; struct sbuf *install_script = sbuf_new_auto(); struct sbuf *deinstall_script = sbuf_new_auto(); struct pkg_dep *dep = NULL; pkg_to_old(pkg); pkg_old_emit_content(pkg, &content); pkgdbdir = pkg_object_string(pkg_config_get("PKG_DBDIR")); pkg_snprintf(path, sizeof(path), "%S/%n-%v", pkgdbdir, pkg, pkg); mkdir(path, 0755); pkg_snprintf(path, sizeof(path), "%S/%n-%v/+CONTENTS", pkgdbdir, pkg, pkg); fp = fopen(path, "w"); fputs(content, fp); fclose(fp); pkg_snprintf(path, sizeof(path), "%S/%n-%v/+DESC", pkgdbdir, pkg, pkg); fp = fopen(path, "w"); pkg_fprintf(fp, "%e", pkg); fclose(fp); pkg_snprintf(path, sizeof(path), "%s/%n-%v/+COMMENT", pkgdbdir, pkg, pkg); fp = fopen(path, "w"); pkg_fprintf(fp, "%c\n", pkg); fclose(fp); if (pkg_has_message(pkg)) { pkg_snprintf(path, sizeof(path), "%s/%n-%v/+DISPLAY", pkgdbdir, pkg, pkg); fp = fopen(path, "w"); pkg_fprintf(fp, "%M", pkg); fclose(fp); } sbuf_clear(install_script); tmp = pkg_script_get(pkg, PKG_SCRIPT_PRE_INSTALL); if (tmp != NULL && *tmp != '\0') { if (sbuf_len(install_script) == 0) sbuf_cat(install_script, "#!/bin/sh\n\n"); sbuf_printf(install_script, "if [ \"$2\" = \"PRE-INSTALL\" ]; then\n" "%s\n" "fi\n", tmp); } tmp = pkg_script_get(pkg, PKG_SCRIPT_INSTALL); if (tmp != NULL && *tmp != '\0') { if (sbuf_len(install_script) == 0) sbuf_cat(install_script, "#!/bin/sh\n\n"); sbuf_cat(install_script, tmp); } tmp = pkg_script_get(pkg, PKG_SCRIPT_POST_INSTALL); if (tmp != NULL && *tmp != '\0') { if (sbuf_len(install_script) == 0) sbuf_cat(install_script, "#!/bin/sh\n\n"); sbuf_printf(install_script, "if [ \"$2\" = \"POST-INSTALL\" ]; then\n" "%s\n" "fi\n", tmp); } if (sbuf_len(install_script) > 0) { sbuf_finish(install_script); pkg_snprintf(path, sizeof(path), "%s/%n-%v/+INSTALL", pkgdbdir, pkg, pkg); fp = fopen(path, "w"); fputs(sbuf_data(install_script), fp); fclose(fp); } sbuf_clear(deinstall_script); tmp = pkg_script_get(pkg, PKG_SCRIPT_PRE_DEINSTALL); if (tmp != NULL && *tmp != '\0') { if (sbuf_len(deinstall_script) == 0) sbuf_cat(deinstall_script, "#!/bin/sh\n\n"); sbuf_printf(deinstall_script, "if [ \"$2\" = \"DEINSTALL\" ]; then\n" "%s\n" "fi\n", tmp); } tmp = pkg_script_get(pkg, PKG_SCRIPT_DEINSTALL); if (tmp != NULL && *tmp != '\0') { if (sbuf_len(deinstall_script) == 0) sbuf_cat(deinstall_script, "#!/bin/sh\n\n"); sbuf_cat(deinstall_script, tmp); } tmp = pkg_script_get(pkg, PKG_SCRIPT_POST_DEINSTALL); if (tmp != NULL && tmp[0] != '\0') { if (sbuf_len(deinstall_script) == 0) sbuf_cat(deinstall_script, "#!/bin/sh\n\n"); sbuf_printf(deinstall_script, "if [ \"$2\" = \"POST-DEINSTALL\" ]; then\n" "%s\n" "fi\n", tmp); } if (sbuf_len(deinstall_script) > 0) { sbuf_finish(deinstall_script); pkg_snprintf(path, sizeof(path), "%s/%n-%v/+DEINSTALL", pkgdbdir, pkg, pkg); fp = fopen(path, "w"); fputs(sbuf_data(deinstall_script), fp); fclose(fp); } while (pkg_deps(pkg, &dep)) { snprintf(path, sizeof(path), "%s/%s-%s/+REQUIRED_BY", pkgdbdir, pkg_dep_name(dep), pkg_dep_version(dep)); fp = fopen(path, "a"); pkg_fprintf(fp, "%n-%v\n", pkg, pkg); fclose(fp); } return (EPKG_OK); }
static void pipeevent(struct pkg_event *ev) { int i; struct pkg_dep *dep = NULL; struct sbuf *msg, *buf; struct pkg_event_conflict *cur_conflict; if (eventpipe < 0) return; msg = sbuf_new_auto(); buf = sbuf_new_auto(); switch(ev->type) { case PKG_EVENT_ERRNO: sbuf_printf(msg, "{ \"type\": \"ERROR\", " "\"data\": {" "\"msg\": \"%s(%s): %s\"," "\"errno\": %d}}", sbuf_json_escape(buf, ev->e_errno.func), sbuf_json_escape(buf, ev->e_errno.arg), sbuf_json_escape(buf, strerror(ev->e_errno.no)), ev->e_errno.no); break; case PKG_EVENT_ERROR: sbuf_printf(msg, "{ \"type\": \"ERROR\", " "\"data\": {\"msg\": \"%s\"}}", sbuf_json_escape(buf, ev->e_pkg_error.msg)); break; case PKG_EVENT_NOTICE: sbuf_printf(msg, "{ \"type\": \"NOTICE\", " "\"data\": {\"msg\": \"%s\"}}", sbuf_json_escape(buf, ev->e_pkg_notice.msg)); break; case PKG_EVENT_DEVELOPER_MODE: sbuf_printf(msg, "{ \"type\": \"ERROR\", " "\"data\": {\"msg\": \"DEVELOPER_MODE: %s\"}}", sbuf_json_escape(buf, ev->e_pkg_error.msg)); break; case PKG_EVENT_UPDATE_ADD: sbuf_printf(msg, "{ \"type\": \"INFO_UPDATE_ADD\", " "\"data\": { " "\"fetched\": %d, " "\"total\": %d" "}}", ev->e_upd_add.done, ev->e_upd_add.total ); break; case PKG_EVENT_UPDATE_REMOVE: sbuf_printf(msg, "{ \"type\": \"INFO_UPDATE_REMOVE\", " "\"data\": { " "\"fetched\": %d, " "\"total\": %d" "}}", ev->e_upd_remove.done, ev->e_upd_remove.total ); break; case PKG_EVENT_FETCH_BEGIN: sbuf_printf(msg, "{ \"type\": \"INFO_FETCH_BEGIN\", " "\"data\": { " "\"url\": \"%s\" " "}}", sbuf_json_escape(buf, ev->e_fetching.url) ); break; case PKG_EVENT_FETCH_FINISHED: sbuf_printf(msg, "{ \"type\": \"INFO_FETCH_FINISHED\", " "\"data\": { " "\"url\": \"%s\" " "}}", sbuf_json_escape(buf, ev->e_fetching.url) ); break; case PKG_EVENT_INSTALL_BEGIN: pkg_sbuf_printf(msg, "{ \"type\": \"INFO_INSTALL_BEGIN\", " "\"data\": { " "\"pkgname\": \"%n\", " "\"pkgversion\": \"%v\"" "}}", ev->e_install_begin.pkg, ev->e_install_begin.pkg); break; case PKG_EVENT_EXTRACT_BEGIN: pkg_sbuf_printf(msg, "{ \"type\": \"INFO_EXTRACT_BEGIN\", " "\"data\": { " "\"pkgname\": \"%n\", " "\"pkgversion\": \"%v\"" "}}", ev->e_extract_begin.pkg, ev->e_extract_begin.pkg); break; case PKG_EVENT_EXTRACT_FINISHED: pkg_sbuf_printf(msg, "{ \"type\": \"INFO_EXTRACT_FINISHED\", " "\"data\": { " "\"pkgname\": \"%n\", " "\"pkgversion\": \"%v\"" "}}", ev->e_extract_finished.pkg, ev->e_extract_finished.pkg); break; case PKG_EVENT_INSTALL_FINISHED: pkg_sbuf_printf(msg, "{ \"type\": \"INFO_INSTALL_FINISHED\", " "\"data\": { " "\"pkgname\": \"%n\", " "\"pkgversion\": \"%v\", " "\"message\": \"%S\"" "}}", ev->e_install_finished.pkg, ev->e_install_finished.pkg, ev->e_install_finished.pkg->message ? sbuf_json_escape(buf, ev->e_install_finished.pkg->message->str) : ""); break; case PKG_EVENT_INTEGRITYCHECK_BEGIN: sbuf_printf(msg, "{ \"type\": \"INFO_INTEGRITYCHECK_BEGIN\", " "\"data\": {}}"); break; case PKG_EVENT_INTEGRITYCHECK_CONFLICT: sbuf_printf(msg, "{ \"type\": \"INFO_INTEGRITYCHECK_CONFLICT\"," "\"data\": { " "\"pkguid\": \"%s\", " "\"pkgpath\": \"%s\", " "\"conflicts\": [", ev->e_integrity_conflict.pkg_uid, ev->e_integrity_conflict.pkg_path); cur_conflict = ev->e_integrity_conflict.conflicts; while (cur_conflict != NULL) { if (cur_conflict->next != NULL) { sbuf_printf(msg, "{\"uid\":\"%s\"},", cur_conflict->uid); } else { sbuf_printf(msg, "{\"uid\":\"%s\"}", cur_conflict->uid); break; } cur_conflict = cur_conflict->next; } sbuf_cat(msg, "]}}"); break; case PKG_EVENT_INTEGRITYCHECK_FINISHED: sbuf_printf(msg, "{ \"type\": \"INFO_INTEGRITYCHECK_FINISHED\", " "\"data\": {\"conflicting\": %d}}", ev->e_integrity_finished.conflicting); break; case PKG_EVENT_DEINSTALL_BEGIN: pkg_sbuf_printf(msg, "{ \"type\": \"INFO_DEINSTALL_BEGIN\", " "\"data\": { " "\"pkgname\": \"%n\", " "\"pkgversion\": \"%v\"" "}}", ev->e_deinstall_begin.pkg, ev->e_deinstall_begin.pkg); break; case PKG_EVENT_DEINSTALL_FINISHED: pkg_sbuf_printf(msg, "{ \"type\": \"INFO_DEINSTALL_FINISHED\", " "\"data\": { " "\"pkgname\": \"%n\", " "\"pkgversion\": \"%v\"" "}}", ev->e_deinstall_finished.pkg, ev->e_deinstall_finished.pkg); break; case PKG_EVENT_UPGRADE_BEGIN: pkg_sbuf_printf(msg, "{ \"type\": \"INFO_UPGRADE_BEGIN\", " "\"data\": { " "\"pkgname\": \"%n\", " "\"pkgversion\": \"%v\" ," "\"pkgnewversion\": \"%v\"" "}}", ev->e_upgrade_begin.o, ev->e_upgrade_begin.o, ev->e_upgrade_begin.n); break; case PKG_EVENT_UPGRADE_FINISHED: pkg_sbuf_printf(msg, "{ \"type\": \"INFO_UPGRADE_FINISHED\", " "\"data\": { " "\"pkgname\": \"%n\", " "\"pkgversion\": \"%v\" ," "\"pkgnewversion\": \"%v\"" "}}", ev->e_upgrade_finished.o, ev->e_upgrade_finished.o, ev->e_upgrade_finished.n); break; case PKG_EVENT_LOCKED: pkg_sbuf_printf(msg, "{ \"type\": \"ERROR_LOCKED\", " "\"data\": { " "\"pkgname\": \"%n\", " "\"pkgversion\": \"%n\"" "}}", ev->e_locked.pkg, ev->e_locked.pkg); break; case PKG_EVENT_REQUIRED: pkg_sbuf_printf(msg, "{ \"type\": \"ERROR_REQUIRED\", " "\"data\": { " "\"pkgname\": \"%n\", " "\"pkgversion\": \"%v\", " "\"force\": %S, " "\"required_by\": [", ev->e_required.pkg, ev->e_required.pkg, ev->e_required.force == 1 ? "true": "false"); while (pkg_rdeps(ev->e_required.pkg, &dep) == EPKG_OK) sbuf_printf(msg, "{ \"pkgname\": \"%s\", " "\"pkgversion\": \"%s\" }, ", dep->name, dep->version); sbuf_setpos(msg, sbuf_len(msg) - 2); sbuf_cat(msg, "]}}"); break; case PKG_EVENT_ALREADY_INSTALLED: pkg_sbuf_printf(msg, "{ \"type\": \"ERROR_ALREADY_INSTALLED\", " "\"data\": { " "\"pkgname\": \"%n\", " "\"pkgversion\": \"%v\"" "}}", ev->e_already_installed.pkg, ev->e_already_installed.pkg); break; case PKG_EVENT_MISSING_DEP: sbuf_printf(msg, "{ \"type\": \"ERROR_MISSING_DEP\", " "\"data\": { " "\"depname\": \"%s\", " "\"depversion\": \"%s\"" "}}" , ev->e_missing_dep.dep->name, ev->e_missing_dep.dep->version); break; case PKG_EVENT_NOREMOTEDB: sbuf_printf(msg, "{ \"type\": \"ERROR_NOREMOTEDB\", " "\"data\": { " "\"url\": \"%s\" " "}}" , ev->e_remotedb.repo); break; case PKG_EVENT_NOLOCALDB: sbuf_printf(msg, "{ \"type\": \"ERROR_NOLOCALDB\", " "\"data\": {} "); break; case PKG_EVENT_NEWPKGVERSION: sbuf_printf(msg, "{ \"type\": \"INFO_NEWPKGVERSION\", " "\"data\": {} "); break; case PKG_EVENT_FILE_MISMATCH: pkg_sbuf_printf(msg, "{ \"type\": \"ERROR_FILE_MISMATCH\", " "\"data\": { " "\"pkgname\": \"%n\", " "\"pkgversion\": \"%v\", " "\"path\": \"%S\"" "}}", ev->e_file_mismatch.pkg, ev->e_file_mismatch.pkg, sbuf_json_escape(buf, ev->e_file_mismatch.file->path)); break; case PKG_EVENT_PLUGIN_ERRNO: sbuf_printf(msg, "{ \"type\": \"ERROR_PLUGIN\", " "\"data\": {" "\"plugin\": \"%s\", " "\"msg\": \"%s(%s): %s\"," "\"errno\": %d" "}}", pkg_plugin_get(ev->e_plugin_errno.plugin, PKG_PLUGIN_NAME), sbuf_json_escape(buf, ev->e_plugin_errno.func), sbuf_json_escape(buf, ev->e_plugin_errno.arg), sbuf_json_escape(buf, strerror(ev->e_plugin_errno.no)), ev->e_plugin_errno.no); break; case PKG_EVENT_PLUGIN_ERROR: sbuf_printf(msg, "{ \"type\": \"ERROR_PLUGIN\", " "\"data\": {" "\"plugin\": \"%s\", " "\"msg\": \"%s\"" "}}", pkg_plugin_get(ev->e_plugin_error.plugin, PKG_PLUGIN_NAME), sbuf_json_escape(buf, ev->e_plugin_error.msg)); break; case PKG_EVENT_PLUGIN_INFO: sbuf_printf(msg, "{ \"type\": \"INFO_PLUGIN\", " "\"data\": {" "\"plugin\": \"%s\", " "\"msg\": \"%s\"" "}}", pkg_plugin_get(ev->e_plugin_info.plugin, PKG_PLUGIN_NAME), sbuf_json_escape(buf, ev->e_plugin_info.msg)); break; case PKG_EVENT_INCREMENTAL_UPDATE: sbuf_printf(msg, "{ \"type\": \"INFO_INCREMENTAL_UPDATE\", " "\"data\": {" "\"name\": \"%s\", " "\"processed\": %d" "}}", ev->e_incremental_update.reponame, ev->e_incremental_update.processed); break; case PKG_EVENT_QUERY_YESNO: sbuf_printf(msg, "{ \"type\": \"QUERY_YESNO\", " "\"data\": {" "\"msg\": \"%s\"," "\"default\": \"%d\"" "}}", ev->e_query_yesno.msg, ev->e_query_yesno.deft); break; case PKG_EVENT_QUERY_SELECT: sbuf_printf(msg, "{ \"type\": \"QUERY_SELECT\", " "\"data\": {" "\"msg\": \"%s\"," "\"ncnt\": \"%d\"," "\"default\": \"%d\"," "\"items\": [" , ev->e_query_select.msg, ev->e_query_select.ncnt, ev->e_query_select.deft); for (i = 0; i < ev->e_query_select.ncnt - 1; i++) { sbuf_printf(msg, "{ \"text\": \"%s\" },", ev->e_query_select.items[i]); } sbuf_printf(msg, "{ \"text\": \"%s\" } ] }}", ev->e_query_select.items[i]); break; case PKG_EVENT_PROGRESS_START: sbuf_printf(msg, "{ \"type\": \"INFO_PROGRESS_START\", " "\"data\": {}}"); break; case PKG_EVENT_PROGRESS_TICK: sbuf_printf(msg, "{ \"type\": \"INFO_PROGRESS_TICK\", " "\"data\": { \"current\": %ld, \"total\" : %ld}}", ev->e_progress_tick.current, ev->e_progress_tick.total); break; case PKG_EVENT_BACKUP: case PKG_EVENT_RESTORE: break; default: break; } sbuf_finish(msg); dprintf(eventpipe, "%s\n", sbuf_data(msg)); sbuf_delete(msg); sbuf_delete(buf); }
struct t_rename_pattern * t_rename_parse(const char *source) { const char sep = '%'; const char *c = source; struct t_rename_pattern *pattern = NULL; struct t_rename_token *token; struct sbuf *sb = NULL; enum { PARSING_STRING, PARSING_SIMPLE_TAG, PARSING_BRACE_TAG } state; sb = sbuf_new_auto(); if (sb == NULL) goto error_label; pattern = malloc(sizeof(struct t_rename_pattern)); if (pattern == NULL) goto error_label; TAILQ_INIT(pattern); state = PARSING_STRING; while (*c != '\0') { /* if we parse a litteral string, check if this is the start of a tag */ if (state == PARSING_STRING && *c == sep) { /* avoid to add a empty token. This can happen when when parsing two consecutive tags like `%tag%tag' */ if (sbuf_len(sb) > 0) { if (sbuf_finish(sb) == -1) goto error_label; token = t_rename_token_new(T_STRING, sbuf_data(sb)); if (token == NULL) goto error_label; TAILQ_INSERT_TAIL(pattern, token, entries); } sbuf_clear(sb); c += 1; if (*c == '{') { c += 1; state = PARSING_BRACE_TAG; } else { state = PARSING_SIMPLE_TAG; } /* if we parse a tag, check for the end of it */ } else if ((state == PARSING_SIMPLE_TAG && (*c == sep || !isalnum(*c))) || (state == PARSING_BRACE_TAG && *c == '}')) { if (sbuf_len(sb) == 0) warnx("empty tag in rename pattern"); if (sbuf_finish(sb) == -1) goto error_label; token = t_rename_token_new(T_TAG, sbuf_data(sb)); if (token == NULL) goto error_label; sbuf_clear(sb); TAILQ_INSERT_TAIL(pattern, token, entries); if (state == PARSING_BRACE_TAG) { /* eat the closing `}' */ c += 1; } state = PARSING_STRING; } else { /* default case for both string and tags. `\' escape everything */ if (*c == '\\') { c += 1; if (*c == '\0') break; } sbuf_putc(sb, *c); c += 1; } } /* we've hit the end of the source. Check in which state we are and try to finish cleany */ switch (state) { case PARSING_BRACE_TAG: warnx("missing closing `}' at the end of the rename pattern"); goto error_label; case PARSING_SIMPLE_TAG: if (sbuf_len(sb) == 0) warnx("empty tag at the end of the rename pattern"); case PARSING_STRING: /* FALLTHROUGH */ default: /* all is right */; } /* finish the last tag unless it is the empty string */ if (state != PARSING_STRING || sbuf_len(sb) > 0) { if (sbuf_finish(sb) == -1) goto error_label; token = t_rename_token_new( (state == PARSING_STRING ? T_STRING : T_TAG), sbuf_data(sb)); if (token == NULL) goto error_label; TAILQ_INSERT_TAIL(pattern, token, entries); } sbuf_delete(sb); return (pattern); /* NOTREACHED */ error_label: sbuf_delete(sb); t_rename_pattern_delete(pattern); return (NULL); }
int pkg_ini(const char *path, const char *reposdir, pkg_init_flags flags) { struct ucl_parser *p = NULL; size_t i; const char *val = NULL; const char *buf, *walk, *value, *key, *k; const char *evkey = NULL; const char *nsname = NULL; const char *evpipe = NULL; const ucl_object_t *cur, *object; ucl_object_t *obj = NULL, *o, *ncfg; ucl_object_iter_t it = NULL; struct sbuf *ukey = NULL; bool fatal_errors = false; k = NULL; o = NULL; pkg_get_myarch(myabi, BUFSIZ); pkg_get_myarch_legacy(myabi_legacy, BUFSIZ); if (parsed != false) { pkg_emit_error("pkg_init() must only be called once"); return (EPKG_FATAL); } if (((flags & PKG_INIT_FLAG_USE_IPV4) == PKG_INIT_FLAG_USE_IPV4) && ((flags & PKG_INIT_FLAG_USE_IPV6) == PKG_INIT_FLAG_USE_IPV6)) { pkg_emit_error("Invalid flags for pkg_init()"); return (EPKG_FATAL); } config = ucl_object_typed_new(UCL_OBJECT); for (i = 0; i < c_size; i++) { switch (c[i].type) { case PKG_STRING: obj = ucl_object_fromstring_common( c[i].def != NULL ? c[i].def : "", 0, UCL_STRING_TRIM); ucl_object_insert_key(config, obj, c[i].key, strlen(c[i].key), false); break; case PKG_INT: ucl_object_insert_key(config, ucl_object_fromstring_common(c[i].def, 0, UCL_STRING_PARSE_INT), c[i].key, strlen(c[i].key), false); break; case PKG_BOOL: ucl_object_insert_key(config, ucl_object_fromstring_common(c[i].def, 0, UCL_STRING_PARSE_BOOLEAN), c[i].key, strlen(c[i].key), false); break; case PKG_OBJECT: obj = ucl_object_typed_new(UCL_OBJECT); if (c[i].def != NULL) { walk = buf = c[i].def; while ((buf = strchr(buf, ',')) != NULL) { key = walk; value = walk; while (*value != ',') { if (*value == '=') break; value++; } ucl_object_insert_key(obj, ucl_object_fromstring_common(value + 1, buf - value - 1, UCL_STRING_TRIM), key, value - key, false); buf++; walk = buf; } key = walk; value = walk; while (*value != ',') { if (*value == '=') break; value++; } if (o == NULL) o = ucl_object_typed_new(UCL_OBJECT); ucl_object_insert_key(o, ucl_object_fromstring_common(value + 1, strlen(value + 1), UCL_STRING_TRIM), key, value - key, false); } ucl_object_insert_key(config, obj, c[i].key, strlen(c[i].key), false); break; case PKG_ARRAY: obj = ucl_object_typed_new(UCL_ARRAY); if (c[i].def != NULL) { walk = buf = c[i].def; while ((buf = strchr(buf, ',')) != NULL) { ucl_array_append(obj, ucl_object_fromstring_common(walk, buf - walk, UCL_STRING_TRIM)); buf++; walk = buf; } ucl_array_append(obj, ucl_object_fromstring_common(walk, strlen(walk), UCL_STRING_TRIM)); } ucl_object_insert_key(config, obj, c[i].key, strlen(c[i].key), false); break; } } if (path == NULL) path = PREFIX"/etc/pkg.conf"; p = ucl_parser_new(0); errno = 0; obj = NULL; if (!ucl_parser_add_file(p, path)) { if (errno != ENOENT) pkg_emit_error("Invalid configuration file: %s", ucl_parser_get_error(p)); } else { obj = ucl_parser_get_object(p); } ncfg = NULL; while (obj != NULL && (cur = ucl_iterate_object(obj, &it, true))) { sbuf_init(&ukey); key = ucl_object_key(cur); for (i = 0; key[i] != '\0'; i++) sbuf_putc(ukey, toupper(key[i])); sbuf_finish(ukey); object = ucl_object_find_keyl(config, sbuf_data(ukey), sbuf_len(ukey)); if (strncasecmp(sbuf_data(ukey), "PACKAGESITE", sbuf_len(ukey)) == 0 || strncasecmp(sbuf_data(ukey), "PUBKEY", sbuf_len(ukey)) == 0 || strncasecmp(sbuf_data(ukey), "MIRROR_TYPE", sbuf_len(ukey)) == 0) { pkg_emit_error("%s in pkg.conf is no longer " "supported. Convert to the new repository style." " See pkg.conf(5)", sbuf_data(ukey)); fatal_errors = true; continue; } /* ignore unknown keys */ if (object == NULL) continue; if (object->type != cur->type) { pkg_emit_error("Malformed key %s, ignoring", key); continue; } if (ncfg == NULL) ncfg = ucl_object_typed_new(UCL_OBJECT); ucl_object_insert_key(ncfg, ucl_object_copy(cur), sbuf_data(ukey), sbuf_len(ukey), true); } if (fatal_errors) { ucl_object_unref(ncfg); ucl_parser_free(p); return (EPKG_FATAL); } if (ncfg != NULL) { it = NULL; while (( cur = ucl_iterate_object(ncfg, &it, true))) { key = ucl_object_key(cur); ucl_object_replace_key(config, ucl_object_ref(cur), key, strlen(key), true); } ucl_object_unref(ncfg); } ncfg = NULL; it = NULL; while ((cur = ucl_iterate_object(config, &it, true))) { o = NULL; key = ucl_object_key(cur); val = getenv(key); if (val == NULL) continue; switch (cur->type) { case UCL_STRING: o = ucl_object_fromstring_common(val, 0, UCL_STRING_TRIM); break; case UCL_INT: o = ucl_object_fromstring_common(val, 0, UCL_STRING_PARSE_INT); if (o->type != UCL_INT) { pkg_emit_error("Invalid type for environment " "variable %s, got %s, while expecting an integer", key, val); ucl_object_unref(o); continue; } break; case UCL_BOOLEAN: o = ucl_object_fromstring_common(val, 0, UCL_STRING_PARSE_BOOLEAN); if (o->type != UCL_BOOLEAN) { pkg_emit_error("Invalid type for environment " "variable %s, got %s, while expecting a boolean", key, val); ucl_object_unref(o); continue; } break; case UCL_OBJECT: o = ucl_object_typed_new(UCL_OBJECT); walk = buf = val; while ((buf = strchr(buf, ',')) != NULL) { k = walk; value = walk; while (*value != ',') { if (*value == '=') break; value++; } ucl_object_insert_key(o, ucl_object_fromstring_common(value + 1, buf - value - 1, UCL_STRING_TRIM), k, value - k, false); buf++; walk = buf; } key = walk; value = walk; while (*value != '\0') { if (*value == '=') break; value++; } ucl_object_insert_key(o, ucl_object_fromstring_common(value + 1, strlen(value + 1), UCL_STRING_TRIM), k, value - k, false); break; case UCL_ARRAY: o = ucl_object_typed_new(UCL_ARRAY); walk = buf = val; while ((buf = strchr(buf, ',')) != NULL) { ucl_array_append(o, ucl_object_fromstring_common(walk, buf - walk, UCL_STRING_TRIM)); buf++; walk = buf; } ucl_array_append(o, ucl_object_fromstring_common(walk, strlen(walk), UCL_STRING_TRIM)); break; default: /* ignore other types */ break; } if (o != NULL) { if (ncfg == NULL) ncfg = ucl_object_typed_new(UCL_OBJECT); ucl_object_insert_key(ncfg, o, key, strlen(key), true); } } if (ncfg != NULL) { it = NULL; while (( cur = ucl_iterate_object(ncfg, &it, true))) { key = ucl_object_key(cur); ucl_object_replace_key(config, ucl_object_ref(cur), key, strlen(key), true); } ucl_object_unref(ncfg); } disable_plugins_if_static(); parsed = true; ucl_object_unref(obj); ucl_parser_free(p); if (strcmp(pkg_object_string(pkg_config_get("ABI")), "unknown") == 0) { pkg_emit_error("Unable to determine ABI"); return (EPKG_FATAL); } pkg_debug(1, "%s", "pkg initialized"); /* Start the event pipe */ evpipe = pkg_object_string(pkg_config_get("EVENT_PIPE")); if (evpipe != NULL) connect_evpipe(evpipe); debug_level = pkg_object_int(pkg_config_get("DEBUG_LEVEL")); it = NULL; object = ucl_object_find_key(config, "PKG_ENV"); while ((cur = ucl_iterate_object(object, &it, true))) { evkey = ucl_object_key(cur); pkg_debug(1, "Setting env var: %s", evkey); if (evkey != NULL && evkey[0] != '\0') setenv(evkey, ucl_object_tostring_forced(cur), 1); } /* load the repositories */ load_repositories(reposdir, flags); setenv("HTTP_USER_AGENT", "pkg/"PKGVERSION, 1); /* bypass resolv.conf with specified NAMESERVER if any */ nsname = pkg_object_string(pkg_config_get("NAMESERVER")); if (nsname != NULL) set_nameserver(ucl_object_tostring_forced(o)); return (EPKG_OK); }
char * t_rename_eval(struct t_tune *tune, const struct t_rename_pattern *pattern) { struct t_rename_token *token; struct sbuf *sb = NULL; struct t_taglist *tlist = NULL, *l = NULL; char *s = NULL, *ret; assert(tune != NULL); assert(pattern != NULL); sb = sbuf_new_auto(); if (sb == NULL) goto error; tlist = t_tune_tags(tune); if (tlist == NULL) goto error; TAILQ_FOREACH(token, pattern, entries) { if (token->is_tag) { l = t_taglist_find_all(tlist, token->value); if (l == NULL) goto error; if (l->count > 0) { /* tag exist */ if ((s = t_taglist_join(l, " + ")) == NULL) goto error; if (l->count > 1) { warnx("%s: has many `%s' tags, joined with `+'", t_tune_path(tune), token->value); } } t_taglist_delete(l); l = NULL; if (s != NULL) { char *slash = strchr(s, '/'); /* check for slash in tag value */ if (slash != NULL) { warnx("%s: tag `%s' has / in value, replacing by `-'", t_tune_path(tune), token->value); do { *slash = '-'; slash = strchr(slash, '/'); } while (slash != NULL); } } } if (s != NULL) { (void)sbuf_cat(sb, s); free(s); s = NULL; } else (void)sbuf_cat(sb, token->value); } ret = NULL; if (sbuf_len(sb) > MAXPATHLEN) warnx("t_rename_eval result is too long (>MAXPATHLEN)"); else { if (sbuf_finish(sb) != -1) ret = strdup(sbuf_data(sb)); } sbuf_delete(sb); t_taglist_delete(tlist); return (ret); error: free(s); t_taglist_delete(l); sbuf_delete(sb); t_taglist_delete(tlist); return (NULL); }
static int pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archive) { char fpath[MAXPATHLEN]; struct pkg_file *file = NULL; struct pkg_dir *dir = NULL; int ret; struct stat st; int64_t flatsize = 0; int64_t nfiles; const char *relocation; hardlinks_t *hardlinks; if (pkg_is_valid(pkg) != EPKG_OK) { pkg_emit_error("the package is not valid"); return (EPKG_FATAL); } relocation = pkg_kv_get(&pkg->annotations, "relocated"); if (relocation == NULL) relocation = ""; if (pkg_rootdir != NULL) relocation = pkg_rootdir; /* * Get / compute size / checksum if not provided in the manifest */ nfiles = kh_count(pkg->filehash); counter_init("file sizes/checksums", nfiles); hardlinks = kh_init_hardlinks(); while (pkg_files(pkg, &file) == EPKG_OK) { snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "", relocation, file->path); if (lstat(fpath, &st) == -1) { pkg_emit_error("file '%s' is missing", fpath); return (EPKG_FATAL); } if (file->size == 0) file->size = (int64_t)st.st_size; if (st.st_nlink == 1 || !check_for_hardlink(hardlinks, &st)) { flatsize += file->size; } file->sum = pkg_checksum_generate_file(fpath, PKG_HASH_TYPE_SHA256_HEX); if (file->sum == NULL) return (EPKG_FATAL); counter_count(); } kh_destroy_hardlinks(hardlinks); counter_end(); pkg->flatsize = flatsize; if (pkg->type == PKG_OLD_FILE) { pkg_emit_error("Cannot create an old format package"); return (EPKG_FATAL); } else { /* * Register shared libraries used by the package if * SHLIBS enabled in conf. Deletes shlib info if not. */ struct sbuf *b = sbuf_new_auto(); pkg_analyse_files(NULL, pkg, root); pkg_emit_manifest_sbuf(pkg, b, PKG_MANIFEST_EMIT_COMPACT, NULL); packing_append_buffer(pkg_archive, sbuf_data(b), "+COMPACT_MANIFEST", sbuf_len(b)); sbuf_clear(b); pkg_emit_manifest_sbuf(pkg, b, 0, NULL); sbuf_finish(b); packing_append_buffer(pkg_archive, sbuf_data(b), "+MANIFEST", sbuf_len(b)); sbuf_delete(b); } counter_init("packing files", nfiles); while (pkg_files(pkg, &file) == EPKG_OK) { snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "", relocation, file->path); ret = packing_append_file_attr(pkg_archive, fpath, file->path, file->uname, file->gname, file->perm, file->fflags); if (developer_mode && ret != EPKG_OK) return (ret); counter_count(); } counter_end(); nfiles = kh_count(pkg->dirhash); counter_init("packing directories", nfiles); while (pkg_dirs(pkg, &dir) == EPKG_OK) { snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "", relocation, dir->path); ret = packing_append_file_attr(pkg_archive, fpath, dir->path, dir->uname, dir->gname, dir->perm, dir->fflags); if (developer_mode && ret != EPKG_OK) return (ret); counter_count(); } counter_end(); return (EPKG_OK); }
static int scan(FILE *fp, const char *name, bool quiet) { int c; bool hasid = false; bool subversion = false; analyzer_states state = INIT; struct sbuf *id = sbuf_new_auto(); locale_t l; l = newlocale(LC_ALL_MASK, "C", NULL); if (name != NULL) printf("%s:\n", name); while ((c = fgetc(fp)) != EOF) { switch (state) { case INIT: if (c == '$') { /* Transit to DELIM_SEEN if we see $ */ state = DELIM_SEEN; } else { /* Otherwise, stay in INIT state */ continue; } break; case DELIM_SEEN: if (isalpha_l(c, l)) { /* Transit to KEYWORD if we see letter */ sbuf_clear(id); sbuf_putc(id, '$'); sbuf_putc(id, c); state = KEYWORD; continue; } else if (c == '$') { /* Or, stay in DELIM_SEEN if more $ */ continue; } else { /* Otherwise, transit back to INIT */ state = INIT; } break; case KEYWORD: sbuf_putc(id, c); if (isalpha_l(c, l)) { /* * Stay in KEYWORD if additional letter is seen */ continue; } else if (c == ':') { /* * See ':' for the first time, transit to * PUNC_SEEN. */ state = PUNC_SEEN; subversion = false; } else if (c == '$') { /* * Incomplete ident. Go back to DELIM_SEEN * state because we see a '$' which could be * the beginning of a keyword. */ state = DELIM_SEEN; } else { /* * Go back to INIT state otherwise. */ state = INIT; } break; case PUNC_SEEN: case PUNC_SEEN_SVN: sbuf_putc(id, c); switch (c) { case ':': /* * If we see '::' (seen : in PUNC_SEEN), * activate subversion treatment and transit * to PUNC_SEEN_SVN state. * * If more than two :'s were seen, the ident * is invalid and we would therefore go back * to INIT state. */ if (state == PUNC_SEEN) { state = PUNC_SEEN_SVN; subversion = true; } else { state = INIT; } break; case ' ': /* * A space after ':' or '::' indicates we are at the * last component of potential ident. */ state = TEXT; break; default: /* All other characters are invalid */ state = INIT; break; } break; case TEXT: sbuf_putc(id, c); if (iscntrl_l(c, l)) { /* Control characters are not allowed in this state */ state = INIT; } else if (c == '$') { sbuf_finish(id); /* * valid ident should end with a space. * * subversion extension uses '#' to indicate that * the keyword expansion have exceeded the fixed * width, so it is also permitted if we are in * subversion mode. No length check is enforced * because GNU RCS ident(1) does not do it either. */ c = sbuf_data(id)[sbuf_len(id) - 2]; if (c == ' ' || (subversion && c == '#')) { printf(" %s\n", sbuf_data(id)); hasid = true; } state = INIT; } /* Other characters: stay in the state */ break; } } sbuf_delete(id); freelocale(l); if (!hasid) { if (!quiet) fprintf(stderr, "%s warning: no id keywords in %s\n", getprogname(), name ? name : "standard input"); return (EXIT_FAILURE); } return (EXIT_SUCCESS); }
static int pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archive) { char fpath[MAXPATHLEN]; struct pkg_file *file = NULL; struct pkg_dir *dir = NULL; char *m; int ret; const char *mtree; bool developer; struct stat st; char sha256[SHA256_DIGEST_LENGTH * 2 + 1]; int64_t flatsize = 0; ucl_object_t *obj; if (pkg_is_valid(pkg) != EPKG_OK) { pkg_emit_error("the package is not valid"); return (EPKG_FATAL); } obj = pkg_annotation_lookup(pkg, "relocated"); /* * Get / compute size / checksum if not provided in the manifest */ while (pkg_files(pkg, &file) == EPKG_OK) { const char *pkg_path = pkg_file_path(file); const char *pkg_sum = pkg_file_cksum(file); snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "", obj ? pkg_object_string(obj) : "", pkg_path); if (lstat(fpath, &st) != 0 || S_ISLNK(st.st_mode)) continue; if (file->size == 0) file->size = (int64_t)st.st_size; flatsize += file->size; if (pkg_sum == NULL || pkg_sum[0] == '\0') { if (pkg->type == PKG_OLD_FILE) { if (md5_file(fpath, sha256) != EPKG_OK) return (EPKG_FATAL); } else { if (sha256_file(fpath, sha256) != EPKG_OK) return (EPKG_FATAL); } strlcpy(file->sum, sha256, sizeof(file->sum)); } } pkg_set(pkg, PKG_FLATSIZE, flatsize); if (pkg->type == PKG_OLD_FILE) { const char *desc, *display, *comment; char oldcomment[BUFSIZ]; pkg_old_emit_content(pkg, &m); packing_append_buffer(pkg_archive, m, "+CONTENTS", strlen(m)); free(m); pkg_get(pkg, PKG_DESC, &desc, PKG_MESSAGE, &display, PKG_COMMENT, &comment); packing_append_buffer(pkg_archive, desc, "+DESC", strlen(desc)); packing_append_buffer(pkg_archive, display, "+DISPLAY", strlen(display)); snprintf(oldcomment, sizeof(oldcomment), "%s\n", comment); packing_append_buffer(pkg_archive, oldcomment, "+COMMENT", strlen(oldcomment)); } else { /* * Register shared libraries used by the package if * SHLIBS enabled in conf. Deletes shlib info if not. */ struct sbuf *b = sbuf_new_auto(); pkg_register_shlibs(pkg, root); pkg_emit_manifest_sbuf(pkg, b, PKG_MANIFEST_EMIT_COMPACT, NULL); packing_append_buffer(pkg_archive, sbuf_data(b), "+COMPACT_MANIFEST", sbuf_len(b)); sbuf_clear(b); pkg_emit_manifest_sbuf(pkg, b, 0, NULL); sbuf_finish(b); packing_append_buffer(pkg_archive, sbuf_data(b), "+MANIFEST", sbuf_len(b)); sbuf_delete(b); } pkg_get(pkg, PKG_MTREE, &mtree); if (mtree != NULL) packing_append_buffer(pkg_archive, mtree, "+MTREE_DIRS", strlen(mtree)); while (pkg_files(pkg, &file) == EPKG_OK) { const char *pkg_path = pkg_file_path(file); snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "", obj ? pkg_object_string(obj) : "", pkg_path); ret = packing_append_file_attr(pkg_archive, fpath, pkg_path, file->uname, file->gname, file->perm); developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE")); if (developer && ret != EPKG_OK) return (ret); } while (pkg_dirs(pkg, &dir) == EPKG_OK) { const char *pkg_path = pkg_dir_path(dir); snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "", obj ? pkg_object_string(obj) : "", pkg_path); ret = packing_append_file_attr(pkg_archive, fpath, pkg_path, dir->uname, dir->gname, dir->perm); developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE")); if (developer && ret != EPKG_OK) return (ret); } return (EPKG_OK); }
int exec_check(int argc, char **argv) { struct pkg *pkg = NULL; struct pkgdb_it *it = NULL; struct pkgdb *db = NULL; struct sbuf *msg = NULL; match_t match = MATCH_EXACT; int flags = PKG_LOAD_BASIC; int ret, rc = EX_OK; int ch; bool dcheck = false; bool checksums = false; bool recompute = false; bool reanalyse_shlibs = false; bool noinstall = false; int nbpkgs = 0; int i, processed, total = 0; int verbose = 0; struct option longopts[] = { { "all", no_argument, NULL, 'a' }, { "shlibs", no_argument, NULL, 'B' }, { "case-sensitive", no_argument, NULL, 'C' }, { "dependencies", no_argument, NULL, 'd' }, { "glob", no_argument, NULL, 'g' }, { "case-insensitive", no_argument, NULL, 'i' }, { "dry-run", no_argument, NULL, 'n' }, { "recompute", no_argument, NULL, 'r' }, { "checksums", no_argument, NULL, 's' }, { "verbose", no_argument, NULL, 'v' }, { "quiet", no_argument, NULL, 'q' }, { "regex", no_argument, NULL, 'x' }, { "yes", no_argument, NULL, 'y' }, { NULL, 0, NULL, 0 }, }; struct deps_head dh = STAILQ_HEAD_INITIALIZER(dh); processed = 0; while ((ch = getopt_long(argc, argv, "+aBCdginqrsvxy", longopts, NULL)) != -1) { switch (ch) { case 'a': match = MATCH_ALL; break; case 'B': reanalyse_shlibs = true; flags |= PKG_LOAD_FILES; break; case 'C': pkgdb_set_case_sensitivity(true); break; case 'd': dcheck = true; flags |= PKG_LOAD_DEPS; break; case 'g': match = MATCH_GLOB; break; case 'i': pkgdb_set_case_sensitivity(false); break; case 'n': noinstall = true; break; case 'q': quiet = true; break; case 'r': recompute = true; flags |= PKG_LOAD_FILES; break; case 's': checksums = true; flags |= PKG_LOAD_FILES; break; case 'v': verbose = 1; break; case 'x': match = MATCH_REGEX; break; case 'y': yes = true; break; default: usage_check(); return (EX_USAGE); } } argc -= optind; argv += optind; /* Default to all packages if no pkg provided */ if (argc == 0 && (dcheck || checksums || recompute || reanalyse_shlibs)) { match = MATCH_ALL; } else if ((argc == 0 && match != MATCH_ALL) || !(dcheck || checksums || recompute || reanalyse_shlibs)) { usage_check(); return (EX_USAGE); } if (recompute || reanalyse_shlibs) ret = pkgdb_access(PKGDB_MODE_READ|PKGDB_MODE_WRITE, PKGDB_DB_LOCAL); else ret = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_LOCAL); if (ret == EPKG_ENODB) { if (!quiet) warnx("No packages installed. Nothing to do!"); return (EX_OK); } else if (ret == EPKG_ENOACCESS) { warnx("Insufficient privileges to access the package database"); return (EX_NOPERM); } else if (ret != EPKG_OK) { warnx("Error accessing the package database"); return (EX_SOFTWARE); } if (pkgdb_access(PKGDB_MODE_WRITE, PKGDB_DB_LOCAL) == EPKG_ENOACCESS) { warnx("Insufficient privileges"); return (EX_NOPERM); } ret = pkgdb_open(&db, PKGDB_DEFAULT); if (ret != EPKG_OK) return (EX_IOERR); if (pkgdb_obtain_lock(db, PKGDB_LOCK_ADVISORY) != EPKG_OK) { pkgdb_close(db); warnx("Cannot get an advisory lock on a database, it is locked by another process"); return (EX_TEMPFAIL); } i = 0; nbdone = 0; do { /* XXX: This is really quirky, it would be cleaner to pass * in multiple matches and only run this top-loop once. */ if ((it = pkgdb_query(db, argv[i], match)) == NULL) { rc = EX_IOERR; goto cleanup; } if (msg == NULL) msg = sbuf_new_auto(); if (!verbose) { if (!quiet) { if (match == MATCH_ALL) progressbar_start("Checking all packages"); else { sbuf_printf(msg, "Checking %s", argv[i]); sbuf_finish(msg); progressbar_start(sbuf_data(msg)); } } processed = 0; total = pkgdb_it_count(it); } else { if (match == MATCH_ALL) nbactions = pkgdb_it_count(it); else nbactions = argc; } struct sbuf *out = sbuf_new_auto(); while (pkgdb_it_next(it, &pkg, flags) == EPKG_OK) { if (!quiet) { if (!verbose) progressbar_tick(processed, total); else { ++nbdone; job_status_begin(msg); pkg_sbuf_printf(msg, "Checking %n-%v:", pkg, pkg); sbuf_flush(msg); } } /* check for missing dependencies */ if (dcheck) { if (!quiet && verbose) printf(" dependencies..."); nbpkgs += check_deps(db, pkg, &dh, noinstall, out); if (noinstall && nbpkgs > 0) { rc = EX_UNAVAILABLE; } } if (checksums) { if (!quiet && verbose) printf(" checksums..."); if (pkg_test_filesum(pkg) != EPKG_OK) { rc = EX_DATAERR; } } if (recompute) { if (pkgdb_upgrade_lock(db, PKGDB_LOCK_ADVISORY, PKGDB_LOCK_EXCLUSIVE) == EPKG_OK) { if (!quiet && verbose) printf(" recomputing..."); if (pkg_recompute(db, pkg) != EPKG_OK) { rc = EX_DATAERR; } pkgdb_downgrade_lock(db, PKGDB_LOCK_EXCLUSIVE, PKGDB_LOCK_ADVISORY); } else { rc = EX_TEMPFAIL; } } if (reanalyse_shlibs) { if (pkgdb_upgrade_lock(db, PKGDB_LOCK_ADVISORY, PKGDB_LOCK_EXCLUSIVE) == EPKG_OK) { if (!quiet && verbose) printf(" shared libraries..."); if (pkgdb_reanalyse_shlibs(db, pkg) != EPKG_OK) { pkg_fprintf(stderr, "Failed to " "reanalyse for shlibs: " "%n-%v\n", pkg, pkg); rc = EX_UNAVAILABLE; } pkgdb_downgrade_lock(db, PKGDB_LOCK_EXCLUSIVE, PKGDB_LOCK_ADVISORY); } else { rc = EX_TEMPFAIL; } } if (!quiet) { if (!verbose) ++processed; else printf(" done\n"); } } if (!quiet && !verbose) progressbar_tick(processed, total); if (sbuf_len(out) > 0) { sbuf_finish(out); printf("%s", sbuf_data(out)); } sbuf_delete(out); if (msg != NULL) { sbuf_delete(msg); msg = NULL; } if (dcheck && nbpkgs > 0 && !noinstall) { printf("\n>>> Missing package dependencies were detected.\n"); printf(">>> Found %d issue(s) in the package database.\n\n", nbpkgs); if (pkgdb_upgrade_lock(db, PKGDB_LOCK_ADVISORY, PKGDB_LOCK_EXCLUSIVE) == EPKG_OK) { ret = fix_deps(db, &dh, nbpkgs); if (ret == EPKG_OK) check_summary(db, &dh); else if (ret == EPKG_ENODB) { db = NULL; rc = EX_IOERR; } if (rc == EX_IOERR) goto cleanup; pkgdb_downgrade_lock(db, PKGDB_LOCK_EXCLUSIVE, PKGDB_LOCK_ADVISORY); } else { rc = EX_TEMPFAIL; goto cleanup; } } pkgdb_it_free(it); i++; } while (i < argc); cleanup: if (!verbose) progressbar_stop(); if (msg != NULL) sbuf_delete(msg); deps_free(&dh); pkg_free(pkg); pkgdb_release_lock(db, PKGDB_LOCK_ADVISORY); pkgdb_close(db); return (rc); }