static int doIcon(Spec spec, Header h) /*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/ /*@modifies h, rpmGlobalMacroContext, fileSystem, internalState @*/ { static size_t iconsize = 0; HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he)); const char *fn, *Lurlfn = NULL; struct Source *sp; size_t nb; rpmuint8_t * icon; FD_t fd = NULL; int rc = RPMRC_FAIL; /* assume error */ int urltype; int xx; if (iconsize == 0) { iconsize = rpmExpandNumeric("%{?_build_iconsize}"); if (iconsize < 2048) iconsize = 2048; } icon = alloca(iconsize+1); for (sp = spec->sources; sp != NULL; sp = sp->next) { if (sp->flags & RPMFILE_ICON) break; } if (sp == NULL) { rpmlog(RPMLOG_ERR, _("No icon file in sources\n")); goto exit; } #if defined(RPM_VENDOR_OPENPKG) /* splitted-source-directory */ /* support splitted source directories, i.e., source files which are alternatively placed into the .spec directory and picked up from there, too. */ Lurlfn = rpmGenPath(NULL, "%{_specdir}/", sp->source); if (access(Lurlfn, F_OK) == -1) { Lurlfn = _free(Lurlfn); Lurlfn = rpmGenPath(NULL, "%{_icondir}/", sp->source); } #else Lurlfn = rpmGenPath(NULL, "%{_icondir}/", sp->source); #endif fn = NULL; urltype = urlPath(Lurlfn, &fn); switch (urltype) { case URL_IS_HTTPS: case URL_IS_HTTP: case URL_IS_FTP: case URL_IS_PATH: case URL_IS_UNKNOWN: break; case URL_IS_DASH: case URL_IS_HKP: case URL_IS_MONGO: /* XXX FIXME */ rpmlog(RPMLOG_ERR, _("Invalid icon URL: %s\n"), Lurlfn); goto exit; /*@notreached@*/ break; } fd = Fopen(fn, "r%{?_rpmgio}"); if (fd == NULL || Ferror(fd)) { rpmlog(RPMLOG_ERR, _("Unable to open icon %s: %s\n"), fn, Fstrerror(fd)); rc = RPMRC_FAIL; goto exit; } *icon = '\0'; nb = Fread(icon, sizeof(icon[0]), iconsize, fd); if (Ferror(fd) || nb == 0) { rpmlog(RPMLOG_ERR, _("Unable to read icon %s: %s\n"), fn, Fstrerror(fd)); goto exit; } if (nb >= iconsize) { rpmlog(RPMLOG_ERR, _("Icon %s is too big (max. %d bytes)\n"), fn, (int)iconsize); goto exit; } if (icon[0] == 'G' && icon[1] == 'I' && icon[2] == 'F') he->tag = RPMTAG_GIF; else if (icon[0] == '/' && icon[1] == '*' && icon[2] == ' ' && icon[3] == 'X' && icon[4] == 'P' && icon[5] == 'M') he->tag = RPMTAG_XPM; else he->tag = tagValue("Icon"); he->t = RPM_BIN_TYPE; he->p.ui8p = icon; he->c = (rpmTagCount)nb; xx = headerPut(h, he, 0); rc = 0; exit: if (fd) { (void) Fclose(fd); fd = NULL; } Lurlfn = _free(Lurlfn); return rc; }
static void _sparseIntegerSet_free(struct diana *diana, struct _sparseIntegerSet *is) { _free(diana, is->dense); _free(diana, is->sparse); memset(is, 0, sizeof(*is)); }
rpmfi rpmfiFree(rpmfi fi) { if (fi == NULL) return NULL; if (fi->nrefs > 1) return rpmfiUnlink(fi); if (fi->fc > 0) { fi->bnl = _free(fi->bnl); fi->dnl = _free(fi->dnl); fi->flinkcache = strcacheFree(fi->flinkcache); fi->flinks = _free(fi->flinks); fi->flangs = _free(fi->flangs); fi->digests = _free(fi->digests); fi->fcapcache = strcacheFree(fi->fcapcache); fi->fcaps = _free(fi->fcaps); fi->cdict = _free(fi->cdict); fi->fuser = _free(fi->fuser); fi->fgroup = _free(fi->fgroup); fi->fstates = _free(fi->fstates); fi->fps = _free(fi->fps); /* these point to header memory if KEEPHEADER is used, dont free */ if (!(fi->fiflags & RPMFI_KEEPHEADER) && fi->h == NULL) { fi->fmtimes = _free(fi->fmtimes); fi->fmodes = _free(fi->fmodes); fi->fflags = _free(fi->fflags); fi->vflags = _free(fi->vflags); fi->fsizes = _free(fi->fsizes); fi->frdevs = _free(fi->frdevs); fi->finodes = _free(fi->finodes); fi->dil = _free(fi->dil); fi->fcolors = _free(fi->fcolors); fi->fcdictx = _free(fi->fcdictx); fi->ddict = _free(fi->ddict); fi->fddictx = _free(fi->fddictx); fi->fddictn = _free(fi->fddictn); } } fi->fn = _free(fi->fn); fi->apath = _free(fi->apath); fi->replacedSizes = _free(fi->replacedSizes); fi->h = headerFree(fi->h); (void) rpmfiUnlink(fi); memset(fi, 0, sizeof(*fi)); /* XXX trash and burn */ fi = _free(fi); return NULL; }
/*@-boundswrite@*/ static int buildForTarget(rpmts ts, BTA_t ba) /*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/ /*@modifies ts, rpmGlobalMacroContext, fileSystem, internalState @*/ { const char * passPhrase = ba->passPhrase; const char * cookie = ba->cookie; int buildAmount = ba->buildAmount; const char * specFile = NULL; const char * specURL = NULL; int specut; const char * s; char * se; const char * arg = ba->specFile; size_t nb = strlen(arg) + BUFSIZ; char * buf = alloca(nb); Spec spec = NULL; int verify = ((ba->buildAmount & RPMBUILD_TRACK) ? 0 : 1); int xx; int rc; if (ba->buildMode == 't') { static const char * sfpats[] = { "Specfile", "\\*.spec", NULL }; static const char _specfn[] = "%{mkstemp:%{_specdir}/rpm-spec.XXXXXX}"; char * tmpSpecFile = (char *) rpmGetPath(_specfn, NULL); FILE *fp; int bingo = 0; int i; for (i = 0; sfpats[i]; i++) { se = rpmExpand("%{uncompress: %{u2p:", arg, "}}", " | %{__tar} -xOvf - %{?__tar_wildcards} ", sfpats[i], " 2>&1 > '", tmpSpecFile, "'", NULL); fp = popen(se, "r"); se = _free(se); if (fp== NULL) continue; s = fgets(buf, nb - 1, fp); xx = pclose(fp); if (!s || !*s || strstr(s, ": Not found in archive")) continue; bingo = 1; break; } if (!bingo) { rpmlog(RPMLOG_ERR, _("Failed to read spec file from %s\n"), arg); xx = Unlink(tmpSpecFile); tmpSpecFile = _free(tmpSpecFile); return 1; } s = se = basename(buf); se += strlen(se); while (--se > s && strchr("\r\n", *se) != NULL) *se = '\0'; specURL = rpmGetPath("%{_specdir}/", s, NULL); specut = urlPath(specURL, &specFile); xx = Rename(tmpSpecFile, specFile); if (xx) { rpmlog(RPMLOG_ERR, _("Failed to rename %s to %s: %m\n"), tmpSpecFile, s); (void) Unlink(tmpSpecFile); } tmpSpecFile = _free(tmpSpecFile); if (xx) return 1; se = buf; *se = '\0'; se = stpcpy(se, "_sourcedir "); (void) urlPath(arg, &s); if (*s != '/') { if (getcwd(se, nb - sizeof("_sourcedir ")) != NULL) se += strlen(se); else se = stpcpy(se, "."); } else se = stpcpy(se, dirname(strcpy(se, s))); while (se > buf && se[-1] == '/') *se-- = '0'; rpmCleanPath(buf + sizeof("_sourcedir ") - 1); rpmDefineMacro(NULL, buf, RMIL_TARBALL); } else { specut = urlPath(arg, &s); se = buf; *se = '\0'; if (*s != '/') { if (getcwd(se, nb - sizeof("_sourcedir ")) != NULL) se += strlen(se); else se = stpcpy(se, "."); *se++ = '/'; se += strlen(strcpy(se,strcpy(se, s))); } else se = stpcpy(se, s); specURL = rpmGetPath(buf, NULL); specut = urlPath(specURL, &specFile); } if (specut != URL_IS_DASH) { struct stat sb; if (Stat(specURL, &sb) < 0) { rpmlog(RPMLOG_ERR, _("failed to stat %s: %m\n"), specURL); rc = 1; goto exit; } if (! S_ISREG(sb.st_mode)) { rpmlog(RPMLOG_ERR, _("File %s is not a regular file.\n"), specURL); rc = 1; goto exit; } /* Try to verify that the file is actually a specfile */ if (!isSpecFile(specURL)) { rpmlog(RPMLOG_ERR, _("File %s does not appear to be a specfile.\n"), specURL); rc = 1; goto exit; } } /* Parse the spec file */ #define _anyarch(_f) \ (((_f)&(RPMBUILD_PREP|RPMBUILD_BUILD|RPMBUILD_INSTALL|RPMBUILD_PACKAGEBINARY)) == 0) if (parseSpec(ts, specURL, ba->rootdir, 0, passPhrase, cookie, _anyarch(buildAmount), 0, verify)) { rc = 1; goto exit; } #undef _anyarch if ((spec = rpmtsSetSpec(ts, NULL)) == NULL) { rc = 1; goto exit; } /* Assemble source header from parsed components */ xx = initSourceHeader(spec, NULL); /* Check build prerequisites */ if (!ba->noDeps && checkSpec(ts, spec->sourceHeader)) { rc = 1; goto exit; } if (buildSpec(ts, spec, buildAmount, ba->noBuild)) { rc = 1; goto exit; } if (ba->buildMode == 't') (void) Unlink(specURL); rc = 0; exit: spec = freeSpec(spec); specURL = _free(specURL); return rc; }
/* still in the dev stage. * return values, perhaps 1== file erro * 2== line to long * 3== umm.... more? */ int poptConfigFileToString(FILE *fp, char ** argstrp, /*@unused@*/ UNUSED(int flags)) { size_t nline = 8192; /* XXX configurable? */ char * line = (char*) alloca(nline); char * argstr; char * q; char * x; size_t t; size_t argvlen = 0; size_t maxargvlen = (size_t)480; if (argstrp) *argstrp = NULL; /* | this_is = our_line * p q x */ if (fp == NULL) return POPT_ERROR_NULLARG; argstr = (char*) xmalloc(maxargvlen * sizeof(*argstr)); assert(argstr); /* XXX can't happen */ if (argstr == NULL) return POPT_ERROR_MALLOC; argstr[0] = '\0'; while (fgets(line, (int)nline, fp) != NULL) { char * l = line; size_t nl; /* loop until first non-space char or EOL */ while( *l != '\0' && _isspaceptr(l) ) l++; nl = strlen(l); if (nl >= nline-1) { argstr = _free(argstr); return POPT_ERROR_OVERFLOW; /* XXX line too long */ } if (*l == '\0' || *l == '\n') continue; /* line is empty */ if (*l == '#') continue; /* comment line */ q = l; while (*q != '\0' && (!_isspaceptr(q)) && *q != '=') q++; if (_isspaceptr(q)) { /* a space after the name, find next non space */ *q++='\0'; while( *q != '\0' && _isspaceptr(q) ) q++; } if (*q == '\0') { /* single command line option (ie, no name=val, just name) */ q[-1] = '\0'; /* kill off newline from fgets() call */ argvlen += (t = (size_t)(q - l)) + (sizeof(" --")-1); if (argvlen >= maxargvlen) { maxargvlen = (t > maxargvlen) ? t*2 : maxargvlen*2; argstr = (char*) xrealloc(argstr, maxargvlen); assert(argstr); /* XXX can't happen */ if (argstr == NULL) return POPT_ERROR_MALLOC; } strcat(argstr, " --"); /* XXX stpcpy */ strcat(argstr, l); /* XXX stpcpy */ continue; } if (*q != '=') continue; /* XXX for now, silently ignore bogus line */ /* *q is an equal sign. */ *q++ = '\0'; /* find next non-space letter of value */ while (*q != '\0' && _isspaceptr(q)) q++; if (*q == '\0') continue; /* XXX silently ignore missing value */ /* now, loop and strip all ending whitespace */ x = l + nl; while (_isspaceptr(--x)) *x = '\0'; /* null out last char if space (including fgets() NL) */ /* rest of line accept */ t = (size_t)(x - l); argvlen += t + (sizeof("' --='")-1); if (argvlen >= maxargvlen) { maxargvlen = (t > maxargvlen) ? t*2 : maxargvlen*2; argstr = (char*) xrealloc(argstr, maxargvlen); assert(argstr); /* XXX can't happen */ if (argstr == NULL) return POPT_ERROR_MALLOC; } strcat(argstr, " --"); /* XXX stpcpy */ strcat(argstr, l); /* XXX stpcpy */ strcat(argstr, "=\""); /* XXX stpcpy */ strcat(argstr, q); /* XXX stpcpy */ strcat(argstr, "\""); /* XXX stpcpy */ } *argstrp = argstr; return 0; }
/* returns 'val' element, -1 on last item, POPT_ERROR_* on error */ int poptGetNextOpt(poptContext con) { const struct poptOption * opt = NULL; int done = 0; if (con == NULL) return -1; while (!done) { const char * origOptString = NULL; poptCallbackType cb = NULL; const void * cbData = NULL; const char * longArg = NULL; int canstrip = 0; int shorty = 0; while (!con->os->nextCharArg && con->os->next == con->os->argc && con->os > con->optionStack) { cleanOSE(con->os--); } if (!con->os->nextCharArg && con->os->next == con->os->argc) { /*@-internalglobs@*/ invokeCallbacksPOST(con, con->options); /*@=internalglobs@*/ if (con->doExec) return execCommand(con); return -1; } /* Process next long option */ if (!con->os->nextCharArg) { char * localOptString, * optString; int thisopt; /*@-sizeoftype@*/ if (con->os->argb && PBM_ISSET(con->os->next, con->os->argb)) { con->os->next++; continue; } /*@=sizeoftype@*/ thisopt = con->os->next; if (con->os->argv != NULL) /* XXX can't happen */ origOptString = con->os->argv[con->os->next++]; if (origOptString == NULL) /* XXX can't happen */ return POPT_ERROR_BADOPT; if (con->restLeftover || *origOptString != '-') { if (con->flags & POPT_CONTEXT_POSIXMEHARDER) con->restLeftover = 1; if (con->flags & POPT_CONTEXT_ARG_OPTS) { con->os->nextArg = xstrdup(origOptString); return 0; } if (con->leftovers != NULL) /* XXX can't happen */ con->leftovers[con->numLeftovers++] = origOptString; continue; } /* Make a copy we can hack at */ localOptString = optString = strcpy(alloca(strlen(origOptString) + 1), origOptString); if (optString[0] == '\0') return POPT_ERROR_BADOPT; if (optString[1] == '-' && !optString[2]) { con->restLeftover = 1; continue; } else { char *oe; int singleDash; optString++; if (*optString == '-') singleDash = 0, optString++; else singleDash = 1; /* XXX aliases with arg substitution need "--alias=arg" */ if (handleAlias(con, optString, '\0', NULL)) continue; if (handleExec(con, optString, '\0')) continue; /* Check for "--long=arg" option. */ for (oe = optString; *oe && *oe != '='; oe++) {}; if (*oe == '=') { *oe++ = '\0'; /* XXX longArg is mapped back to persistent storage. */ longArg = origOptString + (oe - localOptString); } opt = findOption(con->options, optString, '\0', &cb, &cbData, singleDash); if (!opt && !singleDash) return POPT_ERROR_BADOPT; } if (!opt) { con->os->nextCharArg = origOptString + 1; } else { if (con->os == con->optionStack && opt->argInfo & POPT_ARGFLAG_STRIP) { canstrip = 1; poptStripArg(con, thisopt); } shorty = 0; } } /* Process next short option */ /*@-branchstate@*/ /* FIX: W2DO? */ if (con->os->nextCharArg) { origOptString = con->os->nextCharArg; con->os->nextCharArg = NULL; if (handleAlias(con, NULL, *origOptString, origOptString + 1)) continue; if (handleExec(con, NULL, *origOptString)) { /* Restore rest of short options for further processing */ origOptString++; if (*origOptString != '\0') con->os->nextCharArg = origOptString; continue; } opt = findOption(con->options, NULL, *origOptString, &cb, &cbData, 0); if (!opt) return POPT_ERROR_BADOPT; shorty = 1; origOptString++; if (*origOptString != '\0') con->os->nextCharArg = origOptString; } /*@=branchstate@*/ if (opt == NULL) return POPT_ERROR_BADOPT; /* XXX can't happen */ if (opt->arg && (opt->argInfo & POPT_ARG_MASK) == POPT_ARG_NONE) { if (poptSaveInt((int *)opt->arg, opt->argInfo, 1L)) return POPT_ERROR_BADOPERATION; } else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_VAL) { if (opt->arg) { if (poptSaveInt((int *)opt->arg, opt->argInfo, (long)opt->val)) return POPT_ERROR_BADOPERATION; } } else if ((opt->argInfo & POPT_ARG_MASK) != POPT_ARG_NONE) { con->os->nextArg = _free(con->os->nextArg); /*@-usedef@*/ /* FIX: W2DO? */ if (longArg) { /*@=usedef@*/ longArg = expandNextArg(con, longArg); con->os->nextArg = longArg; } else if (con->os->nextCharArg) { longArg = expandNextArg(con, con->os->nextCharArg); con->os->nextArg = longArg; con->os->nextCharArg = NULL; } else { while (con->os->next == con->os->argc && con->os > con->optionStack) { cleanOSE(con->os--); } if (con->os->next == con->os->argc) { if (!(opt->argInfo & POPT_ARGFLAG_OPTIONAL)) /*@-compdef@*/ /* FIX: con->os->argv not defined */ return POPT_ERROR_NOARG; /*@=compdef@*/ con->os->nextArg = NULL; } else { /* * Make sure this isn't part of a short arg or the * result of an alias expansion. */ if (con->os == con->optionStack && (opt->argInfo & POPT_ARGFLAG_STRIP) && canstrip) { poptStripArg(con, con->os->next); } if (con->os->argv != NULL) { /* XXX can't happen */ /* XXX watchout: subtle side-effects live here. */ longArg = con->os->argv[con->os->next++]; longArg = expandNextArg(con, longArg); con->os->nextArg = longArg; } } } longArg = NULL; if (opt->arg) { switch (opt->argInfo & POPT_ARG_MASK) { case POPT_ARG_STRING: /* XXX memory leak, hard to plug */ *((const char **) opt->arg) = (con->os->nextArg) ? xstrdup(con->os->nextArg) : NULL; /*@switchbreak@*/ break; case POPT_ARG_INT: case POPT_ARG_LONG: { long aLong = 0; char *end; if (con->os->nextArg) { aLong = strtol(con->os->nextArg, &end, 0); if (!(end && *end == '\0')) return POPT_ERROR_BADNUMBER; } if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_LONG) { if (aLong == LONG_MIN || aLong == LONG_MAX) return POPT_ERROR_OVERFLOW; if (poptSaveLong((long *)opt->arg, opt->argInfo, aLong)) return POPT_ERROR_BADOPERATION; } else { if (aLong > INT_MAX || aLong < INT_MIN) return POPT_ERROR_OVERFLOW; if (poptSaveInt((int *)opt->arg, opt->argInfo, aLong)) return POPT_ERROR_BADOPERATION; } } /*@switchbreak@*/ break; case POPT_ARG_FLOAT: case POPT_ARG_DOUBLE: { double aDouble = 0.0; char *end; if (con->os->nextArg) { /*@-mods@*/ int saveerrno = errno; errno = 0; aDouble = strtod(con->os->nextArg, &end); if (errno == ERANGE) return POPT_ERROR_OVERFLOW; errno = saveerrno; /*@=mods@*/ if (*end != '\0') return POPT_ERROR_BADNUMBER; } if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_DOUBLE) { *((double *) opt->arg) = aDouble; } else { #define _ABS(a) ((((a) - 0.0) < DBL_EPSILON) ? -(a) : (a)) if ((_ABS(aDouble) - FLT_MAX) > DBL_EPSILON) return POPT_ERROR_OVERFLOW; if ((FLT_MIN - _ABS(aDouble)) > DBL_EPSILON) return POPT_ERROR_OVERFLOW; *((float *) opt->arg) = aDouble; } } /*@switchbreak@*/ break; default: fprintf(stdout, POPT_("option type (%d) not implemented in popt\n"), (opt->argInfo & POPT_ARG_MASK)); exit(EXIT_FAILURE); /*@notreached@*/ /*@switchbreak@*/ break; } } } if (cb) { /*@-internalglobs@*/ invokeCallbacksOPTION(con, con->options, opt, cbData, shorty); /*@=internalglobs@*/ } else if (opt->val && ((opt->argInfo & POPT_ARG_MASK) != POPT_ARG_VAL)) done = 1; if ((con->finalArgvCount + 2) >= (con->finalArgvAlloced)) { con->finalArgvAlloced += 10; con->finalArgv = realloc(con->finalArgv, sizeof(*con->finalArgv) * con->finalArgvAlloced); } if (con->finalArgv != NULL) { char *s = malloc((opt->longName ? strlen(opt->longName) : 0) + 3); if (s != NULL) { /* XXX can't happen */ if (opt->longName) sprintf(s, "%s%s", ((opt->argInfo & POPT_ARGFLAG_ONEDASH) ? "-" : "--"), opt->longName); else sprintf(s, "-%c", opt->shortName); con->finalArgv[con->finalArgvCount++] = s; } else con->finalArgv[con->finalArgvCount++] = NULL; } if (opt->arg && (opt->argInfo & POPT_ARG_MASK) == POPT_ARG_NONE) /*@-ifempty@*/ ; /*@=ifempty@*/ else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_VAL) /*@-ifempty@*/ ; /*@=ifempty@*/ else if ((opt->argInfo & POPT_ARG_MASK) != POPT_ARG_NONE) { if (con->finalArgv != NULL && con->os->nextArg) con->finalArgv[con->finalArgvCount++] = /*@-nullpass@*/ /* LCL: con->os->nextArg != NULL */ xstrdup(con->os->nextArg); /*@=nullpass@*/ } } return (opt ? opt->val : -1); /* XXX can't happen */ }
/** * Display help text for an option. * @param fp output file handle * @param maxLeftCol largest argument display width * @param opt option(s) * @param translation_domain translation domain */ static void singleOptionHelp(FILE * fp, size_t maxLeftCol, const struct poptOption * opt, /*@null@*/ UNUSED(const char * translation_domain)) /*@globals fileSystem @*/ /*@modifies *fp, fileSystem @*/ { size_t indentLength = maxLeftCol + 5; size_t lineLength = 79 - indentLength; const char * help = D_(translation_domain, opt->descrip); const char * argDescrip = getArgDescrip(opt, translation_domain); size_t helpLength; char * defs = NULL; char * left; size_t lelen, limit; size_t nb = maxLeftCol + 1; int displaypad = 0; /* Make sure there's more than enough room in target buffer. */ if (opt->longName) nb += strlen(opt->longName); if (argDescrip) nb += strlen(argDescrip); /*@-boundswrite@*/ left = malloc(nb); if (left == NULL) return; /* XXX can't happen */ left[0] = '\0'; left[maxLeftCol] = '\0'; if (opt->longName && opt->shortName) snprintf(left, nb, "-%c, %s%s", opt->shortName, ((opt->argInfo & POPT_ARGFLAG_ONEDASH) ? "-" : "--"), opt->longName); else if (opt->shortName != '\0') snprintf(left, nb, "-%c", opt->shortName); else if (opt->longName) snprintf(left, nb, "%s%s", ((opt->argInfo & POPT_ARGFLAG_ONEDASH) ? "-" : "--"), opt->longName); if (!*left) goto out; if (argDescrip) { char * le = left + strlen(left); if (opt->argInfo & POPT_ARGFLAG_OPTIONAL) *le++ = '['; /* Choose type of output */ /*@-branchstate@*/ if (opt->argInfo & POPT_ARGFLAG_SHOW_DEFAULT) { defs = singleOptionDefaultValue(lineLength, opt, translation_domain); if (defs) { size_t bufsize = (help ? strlen(help) : 0) + sizeof " " + strlen(defs); char * t = malloc(bufsize); if (t) { snprintf(t, bufsize, "%s %s", help ? help : "", defs); defs = _free(defs); } defs = t; } } /*@=branchstate@*/ if (opt->argDescrip == NULL) { switch (opt->argInfo & POPT_ARG_MASK) { case POPT_ARG_NONE: break; case POPT_ARG_VAL: #ifdef NOTNOW /* XXX pug ugly nerdy output */ { long aLong = opt->val; int ops = (opt->argInfo & POPT_ARGFLAG_LOGICALOPS); int negate = (opt->argInfo & POPT_ARGFLAG_NOT); /* Don't bother displaying typical values */ if (!ops && (aLong == 0L || aLong == 1L || aLong == -1L)) break; *le++ = '['; switch (ops) { case POPT_ARGFLAG_OR: *le++ = '|'; /*@innerbreak@*/ break; case POPT_ARGFLAG_AND: *le++ = '&'; /*@innerbreak@*/ break; case POPT_ARGFLAG_XOR: *le++ = '^'; /*@innerbreak@*/ break; default: /*@innerbreak@*/ break; } *le++ = (opt->longName != NULL ? '=' : ' '); if (negate) *le++ = '~'; /*@-formatconst@*/ limit = nb - (le - left); lelen = snprintf(le, limit, (ops ? "0x%lx" : "%ld"), aLong); le += lelen >= limit ? limit - 1 : lelen; /*@=formatconst@*/ *le++ = ']'; } #endif break; case POPT_ARG_INT: case POPT_ARG_LONG: case POPT_ARG_FLOAT: case POPT_ARG_DOUBLE: case POPT_ARG_STRING: *le++ = (opt->longName != NULL ? '=' : ' '); limit = nb - (le - left); lelen = strlcpy(le, argDescrip, limit); le += lelen >= limit ? limit - 1 : lelen; break; default: break; } } else { *le++ = '='; limit = nb - (le - left); lelen = strlcpy(le, argDescrip, limit); if (lelen >= limit) lelen = limit - 1; le += lelen; #ifdef POPT_WCHAR_HACK { const char * scopy = argDescrip; mbstate_t t; size_t n; memset ((void *)&t, '\0', sizeof (t)); /* In initial state. */ /* Determine number of characters. */ n = mbsrtowcs (NULL, &scopy, strlen(scopy), &t); displaypad = (int) (lelen-n); } #endif } if (opt->argInfo & POPT_ARGFLAG_OPTIONAL) *le++ = ']'; *le = '\0'; } /*@=boundswrite@*/ if (help) fprintf(fp," %-*s ", (int)maxLeftCol+displaypad, left); else { fprintf(fp," %s\n", left); goto out; } left = _free(left); /*@-branchstate@*/ if (defs) { help = defs; defs = NULL; } /*@=branchstate@*/ helpLength = strlen(help); /*@-boundsread@*/ while (helpLength > lineLength) { const char * ch; char format[16]; ch = help + lineLength - 1; while (ch > help && !isSpace(ch)) ch--; if (ch == help) break; /* give up */ while (ch > (help + 1) && isSpace(ch)) ch--; ch++; snprintf(format, sizeof format, "%%.%ds\n%%%ds", (int) (ch - help), (int) indentLength); /*@-formatconst@*/ fprintf(fp, format, help, " "); /*@=formatconst@*/ help = ch; while (isSpace(help) && *help) help++; helpLength = strlen(help); } /*@=boundsread@*/ if (helpLength) fprintf(fp, "%s\n", help); out: /*@-dependenttrans@*/ defs = _free(defs); /*@=dependenttrans@*/ left = _free(left); }
void AlignedBuilder::kill() { _free(_p._allocationAddress); _p._allocationAddress = 0; _p._data = 0; }
/**@todo Infinite loops through manifest files exist, operator error for now. */ rpmRC rpmReadPackageManifest(FD_t fd, int * argcPtr, char *** argvPtr) { StringBuf sb = newStringBuf(); char * s = NULL; char * se; int ac = 0; char ** av = NULL; int argc = (argcPtr ? *argcPtr : 0); char ** argv = (argvPtr ? *argvPtr : NULL); FILE * f = fdGetFILE(fd); rpmRC rpmrc = RPMRC_OK; int i, j, next, npre; if (f != NULL) while (1) { char line[BUFSIZ]; /* Read next line. */ s = fgets(line, sizeof(line) - 1, f); if (s == NULL) { /* XXX Ferror check needed */ break; } /* Skip comments. */ if ((se = strchr(s, '#')) != NULL) *se = '\0'; /* Trim white space. */ se = s + strlen(s); while (se > s && (se[-1] == '\n' || se[-1] == '\r')) *(--se) = '\0'; while (*s && strchr(" \f\n\r\t\v", *s) != NULL) s++; if (*s == '\0') continue; /* Sanity checks: skip obviously binary lines and dash (for stdin) */ if (*s < 32 || rstreq(s, "-")) { rpmrc = RPMRC_NOTFOUND; goto exit; } /* Concatenate next line in buffer. */ *se++ = ' '; *se = '\0'; appendStringBuf(sb, s); } if (s == NULL) /* XXX always true */ s = getStringBuf(sb); if (!(s && *s)) { rpmrc = RPMRC_NOTFOUND; goto exit; } /* Glob manifest items. */ rpmrc = rpmGlob(s, &ac, &av); if (rpmrc != RPMRC_OK) goto exit; rpmlog(RPMLOG_DEBUG, "adding %d args from manifest.\n", ac); /* Count non-NULL args, keeping track of 1st arg after last NULL. */ npre = 0; next = 0; if (argv != NULL) for (i = 0; i < argc; i++) { if (argv[i] != NULL) npre++; else if (i >= next) next = i + 1; } /* Copy old arg list, inserting manifest before argv[next]. */ if (argv != NULL) { int nac = npre + ac; char ** nav = xcalloc((nac + 1), sizeof(*nav)); for (i = 0, j = 0; i < next; i++) { if (argv[i] != NULL) nav[j++] = argv[i]; } if (ac) memcpy(nav + j, av, ac * sizeof(*nav)); if ((argc - next) > 0) memcpy(nav + j + ac, argv + next, (argc - next) * sizeof(*nav)); nav[nac] = NULL; if (argvPtr) *argvPtr = argv = _free(argv); av = _free(av); av = nav; ac = nac; } /* Save new argc/argv list. */ if (argvPtr) { *argvPtr = _free(*argvPtr); *argvPtr = av; } if (argcPtr) *argcPtr = ac; exit: if (argvPtr == NULL || (rpmrc != RPMRC_OK && av)) { if (av) for (i = 0; i < ac; i++) av[i] = _free(av[i]); av = _free(av); } sb = freeStringBuf(sb); /* FIX: *argvPtr may be NULL. */ return rpmrc; }
/** * Display help text for an option. * @param fp output file handle * @param columns output display width control * @param opt option(s) * @param translation_domain translation domain */ static void singleOptionHelp(FILE * fp, columns_t columns, const struct poptOption * opt, /*@null@*/ const char * translation_domain) /*@globals fileSystem @*/ /*@modifies fp, fileSystem @*/ { size_t maxLeftCol = columns->cur; size_t indentLength = maxLeftCol + 5; size_t lineLength = columns->max - indentLength; const char * help = D_(translation_domain, opt->descrip); const char * argDescrip = getArgDescrip(opt, translation_domain); /* Display shortName iff printable non-space. */ int prtshort = (int)(isprint((int)opt->shortName) && opt->shortName != ' '); size_t helpLength; char * defs = NULL; char * left; size_t nb = maxLeftCol + 1; int displaypad = 0; int xx; /* Make sure there's more than enough room in target buffer. */ if (opt->longName) nb += strlen(opt->longName); if (F_ISSET(opt, TOGGLE)) nb += sizeof("[no]") - 1; if (argDescrip) nb += strlen(argDescrip); left = malloc(nb); if (left == NULL) return; /* XXX can't happen */ left[0] = '\0'; left[maxLeftCol] = '\0'; #define prtlong (opt->longName != NULL) /* XXX splint needs a clue */ if (!(prtshort || prtlong)) goto out; if (prtshort && prtlong) { char *dash = F_ISSET(opt, ONEDASH) ? "-" : "--"; left[0] = '-'; left[1] = opt->shortName; (void) stpcpy(stpcpy(stpcpy(left+2, ", "), dash), opt->longName); } else if (prtshort) { left[0] = '-'; left[1] = opt->shortName; left[2] = '\0'; } else if (prtlong) { /* XXX --long always padded for alignment with/without "-X, ". */ char *dash = poptArgType(opt) == POPT_ARG_MAINCALL ? "" : (F_ISSET(opt, ONEDASH) ? "-" : "--"); const char *longName = opt->longName; const char *toggle; if (F_ISSET(opt, TOGGLE)) { toggle = "[no]"; if (longName[0] == 'n' && longName[1] == 'o') { longName += sizeof("no") - 1; if (longName[0] == '-') longName++; } } else toggle = ""; (void) stpcpy(stpcpy(stpcpy(stpcpy(left, " "), dash), toggle), longName); } #undef prtlong if (argDescrip) { char * le = left + strlen(left); if (F_ISSET(opt, OPTIONAL)) *le++ = '['; /* Choose type of output */ if (F_ISSET(opt, SHOW_DEFAULT)) { defs = singleOptionDefaultValue(lineLength, opt, translation_domain); if (defs) { char * t = malloc((help ? strlen(help) : 0) + strlen(defs) + sizeof(" ")); if (t) { char * te = t; if (help) te = stpcpy(te, help); *te++ = ' '; strcpy(te, defs); defs = _free(defs); defs = t; } } } if (opt->argDescrip == NULL) { switch (poptArgType(opt)) { case POPT_ARG_NONE: break; case POPT_ARG_VAL: #ifdef NOTNOW /* XXX pug ugly nerdy output */ { long aLong = opt->val; int ops = F_ISSET(opt, LOGICALOPS); int negate = F_ISSET(opt, NOT); /* Don't bother displaying typical values */ if (!ops && (aLong == 0L || aLong == 1L || aLong == -1L)) break; *le++ = '['; switch (ops) { case POPT_ARGFLAG_OR: *le++ = '|'; /*@innerbreak@*/ break; case POPT_ARGFLAG_AND: *le++ = '&'; /*@innerbreak@*/ break; case POPT_ARGFLAG_XOR: *le++ = '^'; /*@innerbreak@*/ break; default: /*@innerbreak@*/ break; } *le++ = (opt->longName != NULL ? '=' : ' '); if (negate) *le++ = '~'; /*@-formatconst@*/ le += sprintf(le, (ops ? "0x%lx" : "%ld"), aLong); /*@=formatconst@*/ *le++ = ']'; } #endif break; case POPT_ARG_INT: case POPT_ARG_SHORT: case POPT_ARG_LONG: case POPT_ARG_LONGLONG: case POPT_ARG_FLOAT: case POPT_ARG_DOUBLE: case POPT_ARG_STRING: *le++ = (opt->longName != NULL ? '=' : ' '); le = stpcpy(le, argDescrip); break; default: break; } } else { char *leo; /* XXX argDescrip[0] determines "--foo=bar" or "--foo bar". */ if (!strchr(" =(", argDescrip[0])) *le++ = ((poptArgType(opt) == POPT_ARG_MAINCALL) ? ' ' : (poptArgType(opt) == POPT_ARG_ARGV) ? ' ' : '='); le = stpcpy(leo = le, argDescrip); /* Adjust for (possible) wide characters. */ displaypad = (int)((le - leo) - stringDisplayWidth(argDescrip)); } if (F_ISSET(opt, OPTIONAL)) *le++ = ']'; *le = '\0'; } if (help) xx = POPT_fprintf(fp," %-*s ", (int)(maxLeftCol+displaypad), left); else { xx = POPT_fprintf(fp," %s\n", left); goto out; } left = _free(left); if (defs) help = defs; helpLength = strlen(help); while (helpLength > lineLength) { const char * ch; char format[16]; ch = help + lineLength - 1; while (ch > help && !_isspaceptr(ch)) ch = POPT_prev_char(ch); if (ch == help) break; /* give up */ while (ch > (help + 1) && _isspaceptr(ch)) ch = POPT_prev_char (ch); ch = POPT_next_char(ch); /* * XXX strdup is necessary to add NUL terminator so that an unknown * no. of (possible) multi-byte characters can be displayed. */ { char * fmthelp = xstrdup(help); if (fmthelp) { fmthelp[ch - help] = '\0'; sprintf(format, "%%s\n%%%ds", (int) indentLength); /*@-formatconst@*/ xx = POPT_fprintf(fp, format, fmthelp, " "); /*@=formatconst@*/ free(fmthelp); } } help = ch; while (_isspaceptr(help) && *help) help = POPT_next_char(help); helpLength = strlen(help); } if (helpLength) fprintf(fp, "%s\n", help); help = NULL; out: /*@-dependenttrans@*/ defs = _free(defs); /*@=dependenttrans@*/ left = _free(left); }
/*@-globs -mods@*/ /* XXX hide rpmGlobalMacroContext mods for now. */ rpmlua rpmluaNew(void) { rpmlua lua = rpmluaGetPool(_rpmluaPool); lua_State *L = luaL_newstate(); /*@-readonlytrans -nullassign @*/ /*@observer@*/ /*@unchecked@*/ static const luaL_Reg lualibs[] = { #ifdef WITH_SYCK {"lsyck", luaopen_syck}, #endif /* WITH_SYCK */ /* local LUA libraries (RPM only) */ #ifdef WITH_LUA_INTERNAL {"posix", luaopen_posix_c}, {"rex_posix", luaopen_rex_posix}, {"rex_pcre", luaopen_rex_pcre}, {"uuid", luaopen_uuid}, #ifdef DYING /* XXX not currently internal */ {"wrs", luaopen_wrs}, #endif #ifdef USE_LUA_CRYPTO /* XXX external lua modules instead. */ {"crypto", luaopen_crypto}, {"lxp", luaopen_lxp}, #endif #ifdef USE_LUA_SOCKET /* XXX external lua modules instead. */ {"socket", luaopen_socket_core}, #endif {"local", luaopen_local}, #endif {"rpm", luaopen_rpm}, {NULL, NULL}, }; /*@=readonlytrans =nullassign @*/ /*@observer@*/ /*@unchecked@*/ const luaL_Reg *lib = lualibs; char *path_buf; char *path_next; char *path; lua->L = L; lua->pushsize = 0; lua->storeprint = 0; /* XXX TODO: use an rpmiob here. */ lua->printbufsize = 0; lua->printbufused = 0; lua->printbuf = NULL; luaL_openlibs(L); for (; lib->name; lib++) { luaL_requiref(L, lib->name, lib->func, 1); } { const char * _lua_path = rpmGetPath(rpmluaPath, NULL); if (_lua_path != NULL) { lua_pushliteral(L, "LUA_PATH"); lua_pushstring(L, _lua_path); _lua_path = _free(_lua_path); } } #if defined(LUA_GLOBALSINDEX) lua_rawset(L, LUA_GLOBALSINDEX); #else lua_pushglobaltable(L); #endif lua_pushliteral(L, "print"); lua_pushcfunction(L, rpm_print); #if defined(LUA_GLOBALSINDEX) lua_rawset(L, LUA_GLOBALSINDEX); #else lua_pushglobaltable(L); #endif rpmluaSetData(lua, "lua", lua); /* load all standard RPM Lua script files */ path_buf = xstrdup(rpmluaFiles); for (path = path_buf; path != NULL && *path != '\0'; path = path_next) { const char **av; struct stat st; int ac, i; /* locate start of next path element */ path_next = strchr(path, ':'); if (path_next != NULL && *path_next == ':') *path_next++ = '\0'; else path_next = path + strlen(path); /* glob-expand the path element */ ac = 0; av = NULL; if ((i = rpmGlob(path, &ac, &av)) != 0) continue; /* work-off each resulting file from the path element */ for (i = 0; i < ac; i++) { const char *fn = av[i]; if (fn[0] == '@' /* attention */) { fn++; #if defined(RPM_VENDOR_OPENPKG) /* stick-with-rpm-file-sanity-checking */ || \ !defined(POPT_ERROR_BADCONFIG) /* XXX POPT 1.15 retrofit */ if (!rpmSecuritySaneFile(fn)) #else if (!poptSaneFile(fn)) #endif { rpmlog(RPMLOG_WARNING, "existing RPM Lua script file \"%s\" considered INSECURE -- not loaded\n", fn); /*@innercontinue@*/ continue; } } if (Stat(fn, &st) != -1) (void)rpmluaRunScriptFile(lua, fn); av[i] = _free(av[i]); } av = _free(av); } path_buf = _free(path_buf); return ((rpmlua)rpmioLinkPoolItem((rpmioItem)lua, __FUNCTION__, __FILE__, __LINE__)); }
/** * Display default value for an option. * @param lineLength display positions remaining * @param opt option(s) * @param translation_domain translation domain * @return */ static /*@only@*/ /*@null@*/ char * singleOptionDefaultValue(size_t lineLength, const struct poptOption * opt, /*@-paramuse@*/ /* FIX: i18n macros disabled with lclint */ /*@null@*/ const char * translation_domain) /*@=paramuse@*/ /*@*/ { const char * defstr = D_(translation_domain, "default"); char * le = malloc(4*lineLength + 1); char * l = le; if (le == NULL) return NULL; /* XXX can't happen */ *le = '\0'; *le++ = '('; le = stpcpy(le, defstr); *le++ = ':'; *le++ = ' '; if (opt->arg) { /* XXX programmer error */ poptArg arg = { .ptr = opt->arg }; switch (poptArgType(opt)) { case POPT_ARG_VAL: case POPT_ARG_INT: le += sprintf(le, "%d", arg.intp[0]); break; case POPT_ARG_SHORT: le += sprintf(le, "%hd", arg.shortp[0]); break; case POPT_ARG_LONG: le += sprintf(le, "%ld", arg.longp[0]); break; case POPT_ARG_LONGLONG: le += sprintf(le, "%lld", arg.longlongp[0]); break; case POPT_ARG_FLOAT: { double aDouble = (double) arg.floatp[0]; le += sprintf(le, "%g", aDouble); } break; case POPT_ARG_DOUBLE: le += sprintf(le, "%g", arg.doublep[0]); break; case POPT_ARG_MAINCALL: le += sprintf(le, "%p", opt->arg); break; case POPT_ARG_ARGV: le += sprintf(le, "%p", opt->arg); break; case POPT_ARG_STRING: { const char * s = arg.argv[0]; if (s == NULL) le = stpcpy(le, "null"); else { size_t limit = 4*lineLength - (le - l) - sizeof("\"\")"); size_t slen; *le++ = '"'; strncpy(le, s, limit); le[limit] = '\0'; le += (slen = strlen(le)); if (slen == limit && s[limit]) le[-1] = le[-2] = le[-3] = '.'; *le++ = '"'; } } break; case POPT_ARG_NONE: default: l = _free(l); return NULL; /*@notreached@*/ break; } } *le++ = ')'; *le = '\0'; return l; }
static int findPreambleTag(Spec spec, /*@out@*/rpmTag * tagp, /*@null@*/ /*@out@*/ const char ** macro, /*@out@*/ char * lang) /*@modifies *tagp, *macro, *lang @*/ { PreambleRec p; char *s; size_t len = 0; /* Search for defined tags. */ for (p = preambleList; p->token != NULL; p++) { len = strlen(p->token); if (!(p->token && !xstrncasecmp(spec->line, p->token, len))) continue; if (p->obsolete) { rpmlog(RPMLOG_ERR, _("Legacy syntax is unsupported: %s\n"), p->token); p = NULL; } break; } if (p == NULL) return 1; /* Search for arbitrary tags. */ if (tagp && p->token == NULL) { ARGV_t aTags = NULL; int rc = 1; /* assume failure */ /*@-noeffect@*/ (void) tagName(0); /* XXX force arbitrary tags to be initialized. */ /*@=noeffect@*/ aTags = rpmTags->aTags; if (aTags != NULL && aTags[0] != NULL) { ARGV_t av; s = tagCanonicalize(spec->line); #if defined(RPM_VENDOR_OPENPKG) /* wildcard-matching-arbitrary-tagnames */ av = argvSearchLinear(aTags, s, argvFnmatchCasefold); #else av = argvSearch(aTags, s, argvStrcasecmp); #endif if (av != NULL) { *tagp = tagGenerate(s); rc = 0; } s = _free(s); } return rc; } s = spec->line + len; SKIPSPACE(s); switch (p->multiLang) { default: case 0: /* Unless this is a source or a patch, a ':' better be next */ if (p->tag != RPMTAG_SOURCE && p->tag != RPMTAG_PATCH) { if (*s != ':') return 1; } *lang = '\0'; break; case 1: /* Parse optional ( <token> ). */ if (*s == ':') { strcpy(lang, RPMBUILD_DEFAULT_LANG); break; } if (*s != '(') return 1; s++; SKIPSPACE(s); while (!xisspace(*s) && *s != ')') *lang++ = *s++; *lang = '\0'; SKIPSPACE(s); if (*s != ')') return 1; s++; SKIPSPACE(s); if (*s != ':') return 1; break; } if (tagp) *tagp = p->tag; if (macro) /*@-onlytrans -observertrans -dependenttrans@*/ /* FIX: double indirection. */ *macro = p->token; /*@=onlytrans =observertrans =dependenttrans@*/ return 0; }
static rpmRC handlePreambleTag(Spec spec, Package pkg, rpmTag tag, const char *macro, const char *lang) /*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/ /*@modifies spec->macros, spec->st, spec->sources, spec->numSources, spec->noSource, spec->sourceHeader, spec->BANames, spec->BACount, spec->line, pkg->header, pkg->autoProv, pkg->autoReq, pkg->noarch, rpmGlobalMacroContext, fileSystem, internalState @*/ { HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he)); char * field = spec->line; char * end; int multiToken = 0; rpmsenseFlags tagflags; int len; rpmuint32_t num; int rc; int xx; if (field == NULL) return RPMRC_FAIL; /* XXX can't happen */ /* Find the start of the "field" and strip trailing space */ while ((*field) && (*field != ':')) field++; if (*field != ':') { rpmlog(RPMLOG_ERR, _("line %d: Malformed tag: %s\n"), spec->lineNum, spec->line); return RPMRC_FAIL; } field++; SKIPSPACE(field); if (!*field) { /* Empty field */ rpmlog(RPMLOG_ERR, _("line %d: Empty tag: %s\n"), spec->lineNum, spec->line); return RPMRC_FAIL; } end = findLastChar(field); /* Validate tag data content. */ if (tagValidate(spec, tag, field) != RPMRC_OK) return RPMRC_FAIL; /* See if this is multi-token */ end = field; SKIPNONSPACE(end); if (*end != '\0') multiToken = 1; switch (tag) { case RPMTAG_NAME: case RPMTAG_VERSION: case RPMTAG_RELEASE: case RPMTAG_DISTEPOCH: case RPMTAG_URL: case RPMTAG_DISTTAG: case RPMTAG_REPOTAG: case RPMTAG_CVSID: case RPMTAG_BUGURL: SINGLE_TOKEN_ONLY; /* These macros are for backward compatibility */ if (tag == RPMTAG_VERSION) { if (strchr(field, '-') != NULL) { rpmlog(RPMLOG_ERR, _("line %d: Illegal char '-' in %s: %s\n"), spec->lineNum, "version", spec->line); return RPMRC_FAIL; } addMacro(spec->macros, "PACKAGE_VERSION", NULL, field, RMIL_OLDSPEC); } else if (tag == RPMTAG_RELEASE) { if (strchr(field, '-') != NULL) { rpmlog(RPMLOG_ERR, _("line %d: Illegal char '-' in %s: %s\n"), spec->lineNum, "release", spec->line); return RPMRC_FAIL; } addMacro(spec->macros, "PACKAGE_RELEASE", NULL, field, RMIL_OLDSPEC-1); } he->tag = tag; he->t = RPM_STRING_TYPE; he->p.str = field; he->c = 1; xx = headerPut(pkg->header, he, 0); break; case RPMTAG_GROUP: case RPMTAG_SUMMARY: #if defined(RPM_VENDOR_OPENPKG) /* make-class-available-as-macro */ case RPMTAG_CLASS: #endif (void) stashSt(spec, pkg->header, tag, lang); /*@fallthrough@*/ case RPMTAG_DISTRIBUTION: case RPMTAG_VENDOR: case RPMTAG_LICENSE: case RPMTAG_PACKAGER: if (!*lang) { he->tag = tag; he->t = RPM_STRING_TYPE; he->p.str = field; he->c = 1; xx = headerPut(pkg->header, he, 0); } else if (!(noLang && strcmp(lang, RPMBUILD_DEFAULT_LANG))) { (void) headerAddI18NString(pkg->header, tag, field, lang); } break; /* XXX silently ignore BuildRoot: */ case RPMTAG_BUILDROOT: SINGLE_TOKEN_ONLY; macro = NULL; #ifdef DYING buildRootURL = rpmGenPath(spec->rootURL, "%{?buildroot}", NULL); (void) urlPath(buildRootURL, &buildRoot); if (*buildRoot == '\0') buildRoot = "/"; if (!strcmp(buildRoot, "/")) { rpmlog(RPMLOG_ERR, _("BuildRoot can not be \"/\": %s\n"), spec->buildRootURL); buildRootURL = _free(buildRootURL); return RPMRC_FAIL; } buildRootURL = _free(buildRootURL); #endif break; case RPMTAG_KEYWORDS: case RPMTAG_VARIANTS: case RPMTAG_PREFIXES: addOrAppendListEntry(pkg->header, tag, field); he->tag = tag; xx = headerGet(pkg->header, he, 0); if (tag == RPMTAG_PREFIXES) while (he->c--) { if (he->p.argv[he->c][0] != '/') { rpmlog(RPMLOG_ERR, _("line %d: Prefixes must begin with \"/\": %s\n"), spec->lineNum, spec->line); he->p.ptr = _free(he->p.ptr); return RPMRC_FAIL; } len = (int)strlen(he->p.argv[he->c]); if (he->p.argv[he->c][len - 1] == '/' && len > 1) { rpmlog(RPMLOG_ERR, _("line %d: Prefixes must not end with \"/\": %s\n"), spec->lineNum, spec->line); he->p.ptr = _free(he->p.ptr); return RPMRC_FAIL; } } he->p.ptr = _free(he->p.ptr); break; case RPMTAG_DOCDIR: SINGLE_TOKEN_ONLY; if (field[0] != '/') { rpmlog(RPMLOG_ERR, _("line %d: Docdir must begin with '/': %s\n"), spec->lineNum, spec->line); return RPMRC_FAIL; } macro = NULL; delMacro(NULL, "_docdir"); addMacro(NULL, "_docdir", NULL, field, RMIL_SPEC); break; case RPMTAG_XMAJOR: case RPMTAG_XMINOR: case RPMTAG_EPOCH: SINGLE_TOKEN_ONLY; if (parseNum(field, &num)) { rpmlog(RPMLOG_ERR, _("line %d: %s takes an integer value: %s\n"), spec->lineNum, tagName(tag), spec->line); return RPMRC_FAIL; } he->tag = tag; he->t = RPM_UINT32_TYPE; he->p.ui32p = # he->c = 1; xx = headerPut(pkg->header, he, 0); break; case RPMTAG_AUTOREQPROV: pkg->autoReq = parseYesNo(field); pkg->autoProv = pkg->autoReq; break; case RPMTAG_AUTOREQ: pkg->autoReq = parseYesNo(field); break; case RPMTAG_AUTOPROV: pkg->autoProv = parseYesNo(field); break; case RPMTAG_SOURCE: case RPMTAG_PATCH: SINGLE_TOKEN_ONLY; macro = NULL; if ((rc = addSource(spec, pkg, field, tag))) return rc; break; case RPMTAG_ICON: SINGLE_TOKEN_ONLY; macro = NULL; if ((rc = addSource(spec, pkg, field, tag))) return rc; /* XXX the fetch/load of icon needs to be elsewhere. */ if ((rc = doIcon(spec, pkg->header))) return rc; break; case RPMTAG_NOSOURCE: case RPMTAG_NOPATCH: spec->noSource = 1; if ((rc = parseNoSource(spec, field, tag))) return rc; break; case RPMTAG_BUILDPREREQ: case RPMTAG_BUILDREQUIRES: if ((rc = parseBits(lang, buildScriptBits, &tagflags))) { rpmlog(RPMLOG_ERR, _("line %d: Bad %s: qualifiers: %s\n"), spec->lineNum, tagName(tag), spec->line); return rc; } if ((rc = parseRCPOT(spec, pkg, field, tag, 0, tagflags))) return rc; break; case RPMTAG_PREREQ: case RPMTAG_REQUIREFLAGS: if ((rc = parseBits(lang, installScriptBits, &tagflags))) { rpmlog(RPMLOG_ERR, _("line %d: Bad %s: qualifiers: %s\n"), spec->lineNum, tagName(tag), spec->line); return rc; } if ((rc = parseRCPOT(spec, pkg, field, tag, 0, tagflags))) return rc; break; /* Aliases for BuildRequires(hint): */ case RPMTAG_BUILDSUGGESTS: case RPMTAG_BUILDENHANCES: tagflags = RPMSENSE_MISSINGOK; if ((rc = parseRCPOT(spec, pkg, field, tag, 0, tagflags))) return rc; break; /* Aliases for Requires(hint): */ case RPMTAG_SUGGESTSFLAGS: case RPMTAG_ENHANCESFLAGS: tag = RPMTAG_REQUIREFLAGS; tagflags = RPMSENSE_MISSINGOK; if ((rc = parseRCPOT(spec, pkg, field, tag, 0, tagflags))) return rc; break; case RPMTAG_BUILDOBSOLETES: case RPMTAG_BUILDPROVIDES: case RPMTAG_BUILDCONFLICTS: case RPMTAG_CONFLICTFLAGS: case RPMTAG_OBSOLETEFLAGS: case RPMTAG_PROVIDEFLAGS: tagflags = RPMSENSE_ANY; if ((rc = parseRCPOT(spec, pkg, field, tag, 0, tagflags))) return rc; break; case RPMTAG_BUILDPLATFORMS: /* XXX needs pattern parsing */ case RPMTAG_EXCLUDEARCH: case RPMTAG_EXCLUSIVEARCH: case RPMTAG_EXCLUDEOS: case RPMTAG_EXCLUSIVEOS: addOrAppendListEntry(spec->sourceHeader, tag, field); break; case RPMTAG_BUILDARCHS: { const char ** BANames = NULL; int BACount = 0; if ((rc = poptParseArgvString(field, &BACount, &BANames))) { rpmlog(RPMLOG_ERR, _("line %d: Bad BuildArchitecture format: %s\n"), spec->lineNum, spec->line); return RPMRC_FAIL; } if (spec->toplevel) { if (BACount > 0 && BANames != NULL) { spec->BACount = BACount; spec->BANames = BANames; BANames = NULL; /* XXX don't free. */ } } else { if (BACount != 1 || strcmp(BANames[0], "noarch")) { rpmlog(RPMLOG_ERR, _("line %d: Only \"noarch\" sub-packages are supported: %s\n"), spec->lineNum, spec->line); BANames = _free(BANames); return RPMRC_FAIL; } pkg->noarch = 1; } BANames = _free(BANames); } break; default: macro = NULL; he->tag = tag; he->t = RPM_STRING_ARRAY_TYPE; he->p.argv= (const char **) &field; /* XXX NOCAST */ he->c = 1; he->append = 1; xx = headerPut(pkg->header, he, 0); he->append = 0; break; } /*@-usereleased@*/ if (macro) addMacro(spec->macros, macro, NULL, field, RMIL_SPEC); /*@=usereleased@*/ return RPMRC_OK; }
int parseFiles(rpmSpec spec) { int nextPart, res = PART_ERROR; Package pkg; int rc, argc; int arg; const char ** argv = NULL; const char *name = NULL; const char *file = NULL; int flag = PART_SUBNAME; poptContext optCon = NULL; struct poptOption optionsTable[] = { { NULL, 'n', POPT_ARG_STRING, &name, 'n', NULL, NULL}, { NULL, 'f', POPT_ARG_STRING, &file, 'f', NULL, NULL}, { 0, 0, 0, 0, 0, NULL, NULL} }; if ((rc = poptParseArgvString(spec->line, &argc, &argv))) { rpmlog(RPMLOG_ERR, _("line %d: Error parsing %%files: %s\n"), spec->lineNum, poptStrerror(rc)); goto exit; } optCon = poptGetContext(NULL, argc, argv, optionsTable, 0); while ((arg = poptGetNextOpt(optCon)) > 0) { if (arg == 'n') { flag = PART_NAME; } } if (arg < -1) { rpmlog(RPMLOG_ERR, _("line %d: Bad option %s: %s\n"), spec->lineNum, poptBadOption(optCon, POPT_BADOPTION_NOALIAS), spec->line); goto exit; } if (poptPeekArg(optCon)) { if (name == NULL) name = poptGetArg(optCon); if (poptPeekArg(optCon)) { rpmlog(RPMLOG_ERR, _("line %d: Too many names: %s\n"), spec->lineNum, spec->line); goto exit; } } if (lookupPackage(spec, name, flag, &pkg)) { rpmlog(RPMLOG_ERR, _("line %d: Package does not exist: %s\n"), spec->lineNum, spec->line); goto exit; } if (pkg->fileList != NULL) { rpmlog(RPMLOG_ERR, _("line %d: Second %%files list\n"), spec->lineNum); goto exit; } if (file) { /* XXX not necessary as readline has expanded already, but won't hurt. */ pkg->fileFile = rpmGetPath(file, NULL); } pkg->fileList = newStringBuf(); if ((rc = readLine(spec, STRIP_COMMENTS)) > 0) { nextPart = PART_NONE; } else if (rc < 0) { goto exit; } else { while (! (nextPart = isPart(spec->line))) { appendStringBuf(pkg->fileList, spec->line); if ((rc = readLine(spec, STRIP_COMMENTS)) > 0) { nextPart = PART_NONE; break; } else if (rc < 0) { goto exit; } } } res = nextPart; exit: argv = _free(argv); optCon = poptFreeContext(optCon); return res; }
static rpmRC rpmpkgRead(rpmKeyring keyring, rpmVSFlags vsflags, FD_t fd, const char * fn, Header * hdrp) { pgpDigParams sig = NULL; char buf[8*BUFSIZ]; ssize_t count; Header sigh = NULL; rpmTagVal sigtag; struct rpmtd_s sigtd; Header h = NULL; char * msg = NULL; rpmRC rc = RPMRC_FAIL; /* assume failure */ int leadtype = -1; headerGetFlags hgeflags = HEADERGET_DEFAULT; DIGEST_CTX ctx = NULL; if (hdrp) *hdrp = NULL; if (fn == NULL) fn = Fdescr(fd); rpmtdReset(&sigtd); if ((rc = rpmLeadRead(fd, NULL, &leadtype, &msg)) != RPMRC_OK) { /* Avoid message spew on manifests */ if (rc != RPMRC_NOTFOUND) rpmlog(RPMLOG_ERR, "%s: %s\n", fn, msg); free(msg); goto exit; } /* Read the signature header. */ rc = rpmReadSignature(fd, &sigh, RPMSIGTYPE_HEADERSIG, &msg); switch (rc) { default: rpmlog(RPMLOG_ERR, _("%s: rpmReadSignature failed: %s"), fn, (msg && *msg ? msg : "\n")); msg = _free(msg); goto exit; break; case RPMRC_OK: if (sigh == NULL) { rpmlog(RPMLOG_ERR, _("%s: No signature available\n"), fn); rc = RPMRC_FAIL; goto exit; } break; } msg = _free(msg); #define _chk(_mask, _tag) \ (sigtag == 0 && !(vsflags & (_mask)) && headerIsEntry(sigh, (_tag))) /* * Figger the most effective available signature. * Prefer signatures over digests, then header-only over header+payload. * DSA will be preferred over RSA if both exist because tested first. * Note that NEEDPAYLOAD prevents header+payload signatures and digests. */ sigtag = 0; if (_chk(RPMVSF_NODSAHEADER, RPMSIGTAG_DSA)) { sigtag = RPMSIGTAG_DSA; } else if (_chk(RPMVSF_NORSAHEADER, RPMSIGTAG_RSA)) { sigtag = RPMSIGTAG_RSA; } else if (_chk(RPMVSF_NODSA|RPMVSF_NEEDPAYLOAD, RPMSIGTAG_GPG)) { sigtag = RPMSIGTAG_GPG; fdInitDigest(fd, PGPHASHALGO_SHA1, 0); } else if (_chk(RPMVSF_NORSA|RPMVSF_NEEDPAYLOAD, RPMSIGTAG_PGP)) { sigtag = RPMSIGTAG_PGP; fdInitDigest(fd, PGPHASHALGO_MD5, 0); } else if (_chk(RPMVSF_NOSHA1HEADER, RPMSIGTAG_SHA1)) { sigtag = RPMSIGTAG_SHA1; } else if (_chk(RPMVSF_NOMD5|RPMVSF_NEEDPAYLOAD, RPMSIGTAG_MD5)) { sigtag = RPMSIGTAG_MD5; fdInitDigest(fd, PGPHASHALGO_MD5, 0); } /* Read the metadata, computing digest(s) on the fly. */ h = NULL; msg = NULL; rc = rpmpkgReadHeader(keyring, vsflags, fd, &h, &msg); if (rc != RPMRC_OK || h == NULL) { rpmlog(RPMLOG_ERR, _("%s: headerRead failed: %s"), fn, (msg && *msg ? msg : "\n")); msg = _free(msg); goto exit; } msg = _free(msg); /* Any digests or signatures to check? */ if (sigtag == 0) { rc = RPMRC_OK; goto exit; } /* Retrieve the tag parameters from the signature header. */ if (!headerGet(sigh, sigtag, &sigtd, hgeflags)) { rc = RPMRC_FAIL; goto exit; } switch (sigtag) { case RPMSIGTAG_RSA: case RPMSIGTAG_DSA: if (parsePGPSig(&sigtd, "package", fn, &sig)) goto exit; /* fallthrough */ case RPMSIGTAG_SHA1: { struct rpmtd_s utd; unsigned int hashalgo = (sigtag == RPMSIGTAG_SHA1) ? PGPHASHALGO_SHA1 : pgpDigParamsAlgo(sig, PGPVAL_HASHALGO); if (!headerGet(h, RPMTAG_HEADERIMMUTABLE, &utd, hgeflags)) break; ctx = rpmDigestInit(hashalgo, RPMDIGEST_NONE); (void) rpmDigestUpdate(ctx, rpm_header_magic, sizeof(rpm_header_magic)); (void) rpmDigestUpdate(ctx, utd.data, utd.count); rpmtdFreeData(&utd); } break; case RPMSIGTAG_GPG: case RPMSIGTAG_PGP5: /* XXX legacy */ case RPMSIGTAG_PGP: if (parsePGPSig(&sigtd, "package", fn, &sig)) goto exit; /* fallthrough */ case RPMSIGTAG_MD5: /* Legacy signatures need the compressed payload in the digest too. */ while ((count = Fread(buf, sizeof(buf[0]), sizeof(buf), fd)) > 0) {} if (count < 0) { rpmlog(RPMLOG_ERR, _("%s: Fread failed: %s\n"), fn, Fstrerror(fd)); rc = RPMRC_FAIL; goto exit; } ctx = rpmDigestBundleDupCtx(fdGetBundle(fd),(sigtag == RPMSIGTAG_MD5) ? PGPHASHALGO_MD5 : pgpDigParamsAlgo(sig, PGPVAL_HASHALGO)); break; default: break; } /** @todo Implement disable/enable/warn/error/anal policy. */ rc = rpmVerifySignature(keyring, &sigtd, sig, ctx, &msg); switch (rc) { case RPMRC_OK: /* Signature is OK. */ rpmlog(RPMLOG_DEBUG, "%s: %s", fn, msg); break; case RPMRC_NOTTRUSTED: /* Signature is OK, but key is not trusted. */ case RPMRC_NOKEY: /* Public key is unavailable. */ /* XXX Print NOKEY/NOTTRUSTED warning only once. */ { int lvl = (stashKeyid(sig) ? RPMLOG_DEBUG : RPMLOG_WARNING); rpmlog(lvl, "%s: %s", fn, msg); } break; case RPMRC_NOTFOUND: /* Signature is unknown type. */ rpmlog(RPMLOG_WARNING, "%s: %s", fn, msg); break; default: case RPMRC_FAIL: /* Signature does not verify. */ rpmlog(RPMLOG_ERR, "%s: %s", fn, msg); break; } free(msg); exit: if (rc != RPMRC_FAIL && h != NULL && hdrp != NULL) { /* Retrofit RPMTAG_SOURCEPACKAGE to srpms for compatibility */ if (leadtype == RPMLEAD_SOURCE && headerIsSource(h)) { if (!headerIsEntry(h, RPMTAG_SOURCEPACKAGE)) { uint32_t one = 1; headerPutUint32(h, RPMTAG_SOURCEPACKAGE, &one, 1); } } /* * Try to make sure binary rpms have RPMTAG_SOURCERPM set as that's * what we use for differentiating binary vs source elsewhere. */ if (!headerIsEntry(h, RPMTAG_SOURCEPACKAGE) && headerIsSource(h)) { headerPutString(h, RPMTAG_SOURCERPM, "(none)"); } /* * Convert legacy headers on the fly. Not having "new" style compressed * filenames is close enough estimate for legacy indication... */ if (!headerIsEntry(h, RPMTAG_DIRNAMES)) { headerConvert(h, HEADERCONV_RETROFIT_V3); } /* Append (and remap) signature tags to the metadata. */ headerMergeLegacySigs(h, sigh); /* Bump reference count for return. */ *hdrp = headerLink(h); } rpmtdFreeData(&sigtd); rpmDigestFinal(ctx, NULL, NULL, 0); h = headerFree(h); pgpDigParamsFree(sig); sigh = rpmFreeSignature(sigh); return rc; }
poptContext poptFreeContext(poptContext con) { poptItem item; int i; if (con == NULL) return con; poptResetContext(con); con->os->argb = _free(con->os->argb); if (con->aliases != NULL) for (i = 0; i < con->numAliases; i++) { item = con->aliases + i; /*@-modobserver -observertrans -dependenttrans@*/ item->option.longName = _free(item->option.longName); item->option.descrip = _free(item->option.descrip); item->option.argDescrip = _free(item->option.argDescrip); /*@=modobserver =observertrans =dependenttrans@*/ item->argv = _free(item->argv); } con->aliases = _free(con->aliases); if (con->execs != NULL) for (i = 0; i < con->numExecs; i++) { item = con->execs + i; /*@-modobserver -observertrans -dependenttrans@*/ item->option.longName = _free(item->option.longName); item->option.descrip = _free(item->option.descrip); item->option.argDescrip = _free(item->option.argDescrip); /*@=modobserver =observertrans =dependenttrans@*/ item->argv = _free(item->argv); } con->execs = _free(con->execs); con->leftovers = _free(con->leftovers); con->finalArgv = _free(con->finalArgv); con->appName = _free(con->appName); con->otherHelp = _free(con->otherHelp); con->execPath = _free(con->execPath); con->arg_strip = PBM_FREE(con->arg_strip); con = _free(con); return con; }
/** * Clear an allocated growing array. */ void ga_clear(garray_T *gap) { _free(gap->ga_data); ga_init(gap); }
/** * Display default value for an option. * @param lineLength display positions remaining * @param opt option(s) * @param translation_domain translation domain * @return */ static /*@only@*/ /*@null@*/ char * singleOptionDefaultValue(size_t lineLength, const struct poptOption * opt, /*@-paramuse@*/ /* FIX: i18n macros disabled with lclint */ /*@null@*/ UNUSED(const char * translation_domain)) /*@=paramuse@*/ /*@*/ { const char * defstr = D_(translation_domain, "default"); size_t limit, bufsize = 4*lineLength + 1; char * le = malloc(bufsize); char * l = le; if (le == NULL) return NULL; /* XXX can't happen */ /*@-boundswrite@*/ *le++ = '('; le += strlcpy(le, defstr, bufsize - 3); *le++ = ':'; *le++ = ' '; limit = bufsize - (le - l) - 1; /* -1 for closing paren */ if (opt->arg) /* XXX programmer error */ switch (opt->argInfo & POPT_ARG_MASK) { case POPT_ARG_VAL: case POPT_ARG_INT: { long aLong = *((int *)opt->arg); le += snprintf(le, limit, "%ld", aLong); } break; case POPT_ARG_LONG: { long aLong = *((long *)opt->arg); le += snprintf(le, limit, "%ld", aLong); } break; case POPT_ARG_FLOAT: { double aDouble = *((float *)opt->arg); le += snprintf(le, limit, "%g", aDouble); } break; case POPT_ARG_DOUBLE: { double aDouble = *((double *)opt->arg); le += snprintf(le, limit, "%g", aDouble); } break; case POPT_ARG_STRING: { const char * s = *(const char **)opt->arg; if (s == NULL) { le += strlcpy(le, "null", limit); } else { size_t len; limit -= 2; /* make room for quotes */ *le++ = '"'; len = strlcpy(le, s, limit); if (len >= limit) { le += limit - 3 - 1; *le++ = '.'; *le++ = '.'; *le++ = '.'; } else le += len; *le++ = '"'; } } break; case POPT_ARG_NONE: default: l = _free(l); return NULL; /*@notreached@*/ break; } *le++ = ')'; *le = '\0'; /*@=boundswrite@*/ return l; }
void free(void *p) { if(exmem_heap && (p >= exmem_heap)) suba_free(exmem_heap,p); else _free(p); }
void poptSetOtherOptionHelp(poptContext con, const char * text) { con->otherHelp = _free(con->otherHelp); con->otherHelp = xstrdup(text); }
void free(void *p) { return _free(p); }
static int rpmtsSetupCollections(rpmts ts) { /* seenCollectionsPost and TEs are basically a key-value pair. each item in * seenCollectionsPost is a collection that has been seen from any package, * and the associated index in the TEs is the last transaction element * where that collection was seen. */ ARGV_t seenCollectionsPost = NULL; rpmte *TEs = NULL; int numSeenPost = 0; /* seenCollectionsPre is a list of collections that have been seen from * only removed packages */ ARGV_t seenCollectionsPre = NULL; int numSeenPre = 0; ARGV_const_t collname; int installing = 1; int i; rpmte p; rpmtsi pi = rpmtsiInit(ts); while ((p = rpmtsiNext(pi, 0)) != NULL) { /* detect when we switch from installing to removing packages, and * update the lastInCollectionAdd lists */ if (installing && rpmteType(p) == TR_REMOVED) { installing = 0; for (i = 0; i < numSeenPost; i++) { rpmteAddToLastInCollectionAdd(TEs[i], seenCollectionsPost[i]); } } rpmteSetupCollectionPlugins(p); for (collname = rpmteCollections(p); collname && *collname; collname++) { /* figure out if we've seen this collection in post before */ for (i = 0; i < numSeenPost && strcmp(*collname, seenCollectionsPost[i]); i++) { } if (i < numSeenPost) { /* we've seen the collection, update the index */ TEs[i] = p; } else { /* haven't seen the collection yet, add it */ argvAdd(&seenCollectionsPost, *collname); TEs = xrealloc(TEs, sizeof(*TEs) * (numSeenPost + 1)); TEs[numSeenPost] = p; numSeenPost++; } /* figure out if we've seen this collection in pre remove before */ if (installing == 0) { for (i = 0; i < numSeenPre && strcmp(*collname, seenCollectionsPre[i]); i++) { } if (i >= numSeenPre) { /* haven't seen this collection, add it */ rpmteAddToFirstInCollectionRemove(p, *collname); argvAdd(&seenCollectionsPre, *collname); numSeenPre++; } } } } pi = rpmtsiFree(pi); /* we've looked at all the rpmte's, update the lastInCollectionAny lists */ for (i = 0; i < numSeenPost; i++) { rpmteAddToLastInCollectionAny(TEs[i], seenCollectionsPost[i]); if (installing == 1) { /* lastInCollectionAdd is only updated above if packages were * removed. if nothing is removed in the transaction, we need to * update that list here */ rpmteAddToLastInCollectionAdd(TEs[i], seenCollectionsPost[i]); } } argvFree(seenCollectionsPost); argvFree(seenCollectionsPre); _free(TEs); return 0; }
int main(int argc, char *argv[]) { rpmts ts = NULL; QVA_t qva = &rpmQVKArgs; poptContext optCon; int ec = 0; optCon = rpmcliInit(argc, argv, optionsTable); if (rpmcliPipeOutput && initPipe()) exit(EXIT_FAILURE); if (target) { rpmFreeMacros(NULL); rpmFreeRpmrc(); rpmReadConfigFiles(rpmcliRcfile, target); } ts = rpmtsCreate(); switch (mode) { case MODE_QUERY: if (!poptPeekArg(optCon)) argerror(_("no arguments given for query")); qva->qva_queryFormat = queryformat; qva->qva_source = source; qva->qva_specQuery = rpmspecQuery; ec = rpmcliQuery(ts, qva, (ARGV_const_t) poptGetArgs(optCon)); break; case MODE_PARSE: { const char * spath; if (!poptPeekArg(optCon)) argerror(_("no arguments given for parse")); while ((spath = poptGetArg(optCon)) != NULL) { rpmSpec spec = rpmSpecParse(spath, 0, NULL); if (spec == NULL) { ec++; continue; } fprintf(stdout, "%s", rpmSpecGetSection(spec, RPMBUILD_NONE)); rpmSpecFree(spec); } break; } case MODE_UNKNOWN: if (poptPeekArg(optCon) != NULL || argc <= 1 || rpmIsVerbose()) { printUsage(optCon, stderr, 0); ec = argc; } break; } ts = rpmtsFree(ts); finishPipe(); qva->qva_queryFormat = _free(qva->qva_queryFormat); rpmcliFini(optCon); return RETVAL(ec); }
int poptParseArgvString(const char * s, int * argcPtr, const char *** argvPtr) { const char * se; char quote = '\0'; size_t argvAlloced = POPT_ARGV_ARRAY_GROW_DELTA; const char ** argv = (const char**) xmalloc(sizeof(*argv) * argvAlloced); unsigned int argc = 0; size_t ns = strlen(s); char * t = NULL; char * te; int rc = POPT_ERROR_MALLOC; assert(argv); /* XXX can't happen */ if (argv == NULL) return rc; te = t = (char*) xmalloc(ns + 1); assert(te); /* XXX can't happen */ if (te == NULL) { argv = _free(argv); return rc; } *te = '\0'; argv[argc] = te; for (se = s; *se != '\0'; se++) { if (quote == *se) { quote = '\0'; } else if (quote != '\0') { if (*se == '\\') { se++; if (*se == '\0') { rc = POPT_ERROR_BADQUOTE; goto exit; } if (*se != quote) *te++ = '\\'; } *te++ = *se; } else if (_isspaceptr(se)) { if (*argv[argc] != '\0') { *te++ = '\0', argc++; if (argc == argvAlloced) { argvAlloced += POPT_ARGV_ARRAY_GROW_DELTA; argv = (const char**) xrealloc(argv, sizeof(*argv) * argvAlloced); assert(argv); /* XXX can't happen */ if (argv == NULL) goto exit; } *te = '\0'; argv[argc] = te; } } else switch (*se) { case '"': case '\'': quote = *se; /*@switchbreak@*/ break; case '\\': se++; if (*se == '\0') { rc = POPT_ERROR_BADQUOTE; goto exit; } /*@fallthrough@*/ default: *te++ = *se; /*@switchbreak@*/ break; } } if (strlen(argv[argc])) { argc++, *te++ = '\0'; } rc = poptDupArgv(argc, argv, argcPtr, argvPtr); exit: t = _free(t); argv = _free(argv); return rc; }
/* * @todo Single use by %%doc in files.c prevents static. */ rpmRC doScript(rpmSpec spec, rpmBuildFlags what, const char *name, const char *sb, int test) { const char * rootDir = spec->rootDir; char *scriptName = NULL; char * buildDir = rpmGenPath(rootDir, "%{_builddir}", ""); char * buildCmd = NULL; char * buildTemplate = NULL; char * buildPost = NULL; const char * mTemplate = NULL; const char * mCmd = NULL; const char * mPost = NULL; int argc = 0; const char **argv = NULL; FILE * fp = NULL; FD_t fd; FD_t xfd; pid_t pid; pid_t child; int status; rpmRC rc; switch (what) { case RPMBUILD_PREP: mTemplate = "%{__spec_prep_template}"; mPost = "%{__spec_prep_post}"; mCmd = "%{__spec_prep_cmd}"; break; case RPMBUILD_BUILD: mTemplate = "%{__spec_build_template}"; mPost = "%{__spec_build_post}"; mCmd = "%{__spec_build_cmd}"; break; case RPMBUILD_INSTALL: mTemplate = "%{__spec_install_template}"; mPost = "%{__spec_install_post}"; mCmd = "%{__spec_install_cmd}"; break; case RPMBUILD_CHECK: mTemplate = "%{__spec_check_template}"; mPost = "%{__spec_check_post}"; mCmd = "%{__spec_check_cmd}"; break; case RPMBUILD_CLEAN: mTemplate = "%{__spec_clean_template}"; mPost = "%{__spec_clean_post}"; mCmd = "%{__spec_clean_cmd}"; break; case RPMBUILD_RMBUILD: mTemplate = "%{__spec_clean_template}"; mPost = "%{__spec_clean_post}"; mCmd = "%{__spec_clean_cmd}"; break; case RPMBUILD_STRINGBUF: default: mTemplate = "%{___build_template}"; mPost = "%{___build_post}"; mCmd = "%{___build_cmd}"; break; } if ((what != RPMBUILD_RMBUILD) && sb == NULL) { rc = RPMRC_OK; goto exit; } fd = rpmMkTempFile(rootDir, &scriptName); if (fd == NULL || Ferror(fd)) { rpmlog(RPMLOG_ERR, _("Unable to open temp file.\n")); rc = RPMRC_FAIL; goto exit; } if (fdGetFILE(fd) == NULL) xfd = Fdopen(fd, "w.fpio"); else xfd = fd; if ((fp = fdGetFILE(xfd)) == NULL) { rc = RPMRC_FAIL; goto exit; } if (*rootDir == '\0') rootDir = "/"; buildTemplate = rpmExpand(mTemplate, NULL); buildPost = rpmExpand(mPost, NULL); (void) fputs(buildTemplate, fp); if (what != RPMBUILD_PREP && what != RPMBUILD_RMBUILD && spec->buildSubdir) fprintf(fp, "cd '%s'\n", spec->buildSubdir); if (what == RPMBUILD_RMBUILD) { if (spec->buildSubdir) fprintf(fp, "rm -rf '%s'\n", spec->buildSubdir); } else if (sb != NULL) fprintf(fp, "%s", sb); (void) fputs(buildPost, fp); (void) Fclose(xfd); if (test) { rc = RPMRC_OK; goto exit; } if (buildDir && buildDir[0] != '/') { rc = RPMRC_FAIL; goto exit; } buildCmd = rpmExpand(mCmd, " ", scriptName, NULL); (void) poptParseArgvString(buildCmd, &argc, &argv); rpmlog(RPMLOG_NOTICE, _("Executing(%s): %s\n"), name, buildCmd); if (!(child = fork())) { /* NSPR messes with SIGPIPE, reset to default for the kids */ signal(SIGPIPE, SIG_DFL); errno = 0; (void) execvp(argv[0], (char *const *)argv); rpmlog(RPMLOG_ERR, _("Exec of %s failed (%s): %s\n"), scriptName, name, strerror(errno)); _exit(127); /* exit 127 for compatibility with bash(1) */ } pid = waitpid(child, &status, 0); if (!WIFEXITED(status) || WEXITSTATUS(status)) { rpmlog(RPMLOG_ERR, _("Bad exit status from %s (%s)\n"), scriptName, name); rc = RPMRC_FAIL; } else rc = RPMRC_OK; exit: if (scriptName) { if (rc == RPMRC_OK) (void) unlink(scriptName); scriptName = _free(scriptName); } argv = _free(argv); buildCmd = _free(buildCmd); buildTemplate = _free(buildTemplate); buildPost = _free(buildPost); buildDir = _free(buildDir); return rc; }
void speed() { int keyboard = _open("/dev/keyboard", 0, 0); int stdin = _open("/dev/stdin", 0, 0); char ch; int fd = _open(active_proc->name, 0, 0); int size = _seek(fd, 0, SEEK_END); size++; //terminating '\0' _seek(fd, 0, SEEK_SET); char* str = _malloc(size); bzero(str, size); _read(fd, str, size); line *startline = _malloc(sizeof(line)); startline->num_chars=0; startline->offset=0; startline->next = NULL; startline->prev = NULL; line * actualline = startline; int pos = 0; while (str[pos]!='\0') { _printf("%c", str[pos]); if(str[pos] == '\n' || str[pos] == '\t') { NEXT_LINE } else { actualline->num_chars++; } pos++; if(pos == size - 1) { //terminating \0 size*=2; str = resize_buf(size, str); } } _close(fd); //flush stdin while (_read(stdin, &ch, sizeof(ch)) != 0) ; while (!keydown(ESCAPE, keyboard)) { if(pos == size - 1) { //terminating \0 size *= 2; str = resize_buf(size, str); } ch = _fgetch(stdin); switch(ch){ case '\a': break; case '\b': if(actualline == startline && startline->num_chars == 0) { //nothing to erase break; } if(str[pos - 1]=='\n' || str[pos - 1]=='\t') { //erase '\n' or '\t' PREV_LINE } else { //erase 1 character actualline->num_chars--; _printf("%c", ch); } str[--pos] = '\0'; if (pos == size / 4 - 1) { size /= 2; str = resize_buf(size, str); } break; default: _printf("%c", ch); str[pos] = ch; if(ch == '\n' || ch == '\t') { NEXT_LINE } else { actualline->num_chars++; } pos++; } } //flush stdin while (_read(stdin, &ch, sizeof(ch)) != 0) ; //DUMP_LINES _unlink(active_proc->name); // fd = _open(active_proc->name, 0, 0); // int fsize = _seek(fd, 0, SEEK_END); // _close(fd); // fd = _open(active_proc->name, 0, 0); // char* nullstring = _malloc(fsize); // bzero(nullstring, fsize); // _free(nullstring); // _write(fd, nullstring, fsize); // _close(fd); fd = _open(active_proc->name, O_CREAT, 0); _write(fd, str, strlen(str)); for(line *temp = startline; temp != NULL; temp = temp->next) { _free(temp); } _free(str); _close(keyboard); _close(stdin); _close(fd); _exit(0); }
ret_t fdpoll_port_new (cherokee_fdpoll_t **fdp, int sys_limit, int limit) { int re; cuint_t i; cherokee_fdpoll_t *nfd; CHEROKEE_CNEW_STRUCT (1, n, fdpoll_port); nfd = FDPOLL(n); /* Init base class properties */ nfd->type = cherokee_poll_port; nfd->nfiles = limit; nfd->system_nfiles = sys_limit; nfd->npollfds = 0; /* Init base class virtual methods */ nfd->free = (fdpoll_func_free_t) _free; nfd->add = (fdpoll_func_add_t) _add; nfd->del = (fdpoll_func_del_t) _del; nfd->reset = (fdpoll_func_reset_t) _reset; nfd->set_mode = (fdpoll_func_set_mode_t) _set_mode; nfd->check = (fdpoll_func_check_t) _check; nfd->watch = (fdpoll_func_watch_t) _watch; /* Allocate data */ n->port = -1; n->port_readyfds = 0; n->port_events = (port_event_t *) calloc(nfd->nfiles, sizeof(port_event_t)); n->port_activefd = (int *) calloc(nfd->system_nfiles, sizeof(int)); if ( n->port_events == NULL || n->port_activefd == NULL ) { _free( n ); return ret_nomem; } for (i=0; i < nfd->system_nfiles; i++) { n->port_activefd[i] = -1; } n->port = port_create(); if (n->port == -1 ) { _free( n ); return ret_error; } re = fcntl (n->port, F_SETFD, FD_CLOEXEC); if (re < 0) { LOG_ERRNO (errno, cherokee_err_error, CHEROKEE_ERROR_FDPOLL_EPOLL_CLOEXEC); _free (n); return ret_error; } /* Return the object */ *fdp = nfd; return ret_ok; }
bool dbmerge_merge (FILE *fd_h, FILE *fd_d, void(*progress_callback)(int, int)) { char tmp[256]; unsigned char revision; int channels_count, i, j, aliases_groups_count, indexes_count; time_t now = time (NULL); /* read headers */ fread (tmp, strlen (MAGIC_HEADERS), 1, fd_h); if (memcmp (tmp, MAGIC_HEADERS, strlen (MAGIC_HEADERS)) != 0) { log_add ("Bad magic header"); return false; } fread (&revision, sizeof (unsigned char), 1, fd_h); if (revision != DB_REVISION) { log_add ("Bad db revision"); return false; } fseek (fd_h, 22, SEEK_SET); fread (&channels_count, sizeof (int), 1, fd_h); for (i=0; i<channels_count; i++) { int titles_count; epgdb_channel_t *tmp; epgdb_channel_t *channel, *channel_tmp; channel_tmp = _malloc (sizeof (epgdb_channel_t)); fread (channel_tmp, sizeof (epgdb_channel_header_t), 1, fd_h); channel = epgdb_channels_add (channel_tmp->nid, channel_tmp->tsid, channel_tmp->sid); _free (channel_tmp); fread (&titles_count, sizeof (int), 1, fd_h); for (j=0; j<titles_count; j++) { char *desc, *ldesc; epgdb_title_t *title = _malloc (sizeof (epgdb_title_t)); fread (title, sizeof (epgdb_title_header_t), 1, fd_h); desc = dbmerge_read_description (fd_d, title); ldesc = dbmerge_read_long_description (fd_d, title); title = epgdb_titles_add (channel, title); epgdb_titles_set_description(title, desc); epgdb_titles_set_long_description(title, ldesc); _free (desc); _free (ldesc); } if (progress_callback) progress_callback (i, channels_count); } return true; }
/* XXX should return rpmParseState, but RPMRC_FAIL forces int return. */ int parsePreamble(Spec spec, int initialPackage) { HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he)); rpmParseState nextPart; int xx; char *linep; Package pkg; char NVR[BUFSIZ]; char lang[BUFSIZ]; rpmRC rc; strcpy(NVR, "(main package)"); pkg = newPackage(spec); if (spec->packages == NULL) { spec->packages = pkg; assert(initialPackage); } else if (! initialPackage) { char *name = NULL; rpmParseState flag; Package lastpkg; /* There is one option to %package: <pkg> or -n <pkg> */ flag = PART_NONE; if (parseSimplePart(spec, &name, &flag)) { rpmlog(RPMLOG_ERR, _("Bad package specification: %s\n"), spec->line); pkg = freePackages(pkg); return RPMRC_FAIL; } lastpkg = NULL; if (lookupPackage(spec, name, flag, &lastpkg) == RPMRC_OK) { pkg->next = lastpkg->next; } else { /* Add package to end of list */ for (lastpkg = spec->packages; lastpkg->next != NULL; lastpkg = lastpkg->next) {}; } assert(lastpkg != NULL); lastpkg->next = pkg; /* Construct the package */ if (flag == PART_SUBNAME) { he->tag = RPMTAG_NAME; xx = headerGet(spec->packages->header, he, 0); sprintf(NVR, "%s-%s", he->p.str, name); he->p.ptr = _free(he->p.ptr); } else strcpy(NVR, name); name = _free(name); he->tag = RPMTAG_NAME; he->t = RPM_STRING_TYPE; he->p.str = NVR; he->c = 1; xx = headerPut(pkg->header, he, 0); } if ((rc = readLine(spec, STRIP_TRAILINGSPACE | STRIP_COMMENTS)) > 0) { nextPart = PART_NONE; } else { if (rc) return rc; while ((nextPart = isPart(spec)) == PART_NONE) { const char * macro = NULL; rpmTag tag = 0; /* Skip blank lines */ linep = spec->line; SKIPSPACE(linep); if (*linep != '\0') { if (findPreambleTag(spec, &tag, ¯o, lang)) { rpmlog(RPMLOG_ERR, _("line %d: Unknown tag: %s\n"), spec->lineNum, spec->line); return RPMRC_FAIL; } if (handlePreambleTag(spec, pkg, tag, macro, lang)) return RPMRC_FAIL; if (spec->BANames && !spec->recursing && spec->toplevel) return PART_BUILDARCHITECTURES; } if ((rc = readLine(spec, STRIP_TRAILINGSPACE | STRIP_COMMENTS)) > 0) { nextPart = PART_NONE; break; } if (rc) return rc; } } /* Do some final processing on the header */ /* * Expand buildroot one more time to get %{version} and the like * from the main package. */ if (initialPackage) { const char *s = rpmExpand("%{?buildroot}", NULL); if (s && *s) (void) addMacro(NULL, "buildroot", NULL, s, -1); s = _free(s); } /* XXX Skip valid arch check if not building binary package */ if (!spec->anyarch && checkForValidArchitectures(spec)) return RPMRC_FAIL; if (pkg == spec->packages) fillOutMainPackage(pkg->header); if (checkForDuplicates(pkg->header, NVR) != RPMRC_OK) return RPMRC_FAIL; if (pkg != spec->packages) headerCopyTags(spec->packages->header, pkg->header, (void *)copyTagsDuringParse); #ifdef RPM_VENDOR_PLD /* rpm-epoch0 */ /* Add Epoch: 0 to package header if it was not set by spec */ he->tag = RPMTAG_NAME; if (headerGet(spec->packages->header, he, 0) == 0) { rpmuint32_t num = 0; he->tag = RPMTAG_EPOCH; he->t = RPM_UINT32_TYPE; he->p.ui32p = # he->c = 1; xx = headerPut(pkg->header, he, 0); /* also declare %{epoch} to be same */ addMacro(spec->macros, "epoch", NULL, "0", RMIL_SPEC); } #endif /* RPM_VENDOR_PLD rpm-epoch0 */ if (checkForRequired(pkg->header, NVR) != RPMRC_OK) return RPMRC_FAIL; return nextPart; }