/* This file is part of "reprepro" * Copyright (C) 2004,2005,2007,2009 Bernhard R. Link * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02111-1301 USA */ #include #include #include #include #include #include #include #include #include "error.h" #include "mprintf.h" #include "strlist.h" #include "names.h" #include "chunks.h" #include "globmatch.h" #include "dpkgversions.h" #include "terms.h" #include "termdecide.h" static inline bool check_field(enum term_comparison c, const char *value, const char *with) { if (c == tc_none) { return true; } else if (c == tc_globmatch) { return globmatch(value, with); } else if (c == tc_notglobmatch) { return !globmatch(value, with); } else { int i; i = strcmp(value, with); if (i < 0) return c == tc_strictless || c == tc_lessorequal || c == tc_notequal; else if (i > 0) return c == tc_strictmore || c == tc_moreorequal || c == tc_notequal; else return c == tc_lessorequal || c == tc_moreorequal || c == tc_equal; } } retvalue term_decidechunk(const term *condition, const char *controlchunk, const void *privdata) { const struct term_atom *atom = condition; while (atom != NULL) { bool correct; char *value; enum term_comparison c = atom->comparison; retvalue r; if (atom->isspecial) { correct = atom->special.type->compare(c, &atom->special.comparewith, controlchunk, privdata); } else { r = chunk_getvalue(controlchunk, atom->generic.key, &value); if (RET_WAS_ERROR(r)) return r; if (r == RET_NOTHING) { correct = (c == tc_notequal || c == tc_notglobmatch); } else { correct = check_field(c, value, atom->generic.comparewith); free(value); } } if (atom->negated) correct = !correct; if (correct) { atom = atom->nextiftrue; } else { atom = atom->nextiffalse; if (atom == NULL) { /* do not include */ return RET_NOTHING; } } } /* do include */ return RET_OK; } static retvalue parsestring(enum term_comparison c, const char *value, size_t len, struct compare_with *v) { if (c == tc_none) { fprintf(stderr, "Error: Special formula predicates (those starting with '$') are always\n" "defined, thus specifying them without parameter to compare against\n" "makes not sense!\n"); return RET_ERROR; } v->pointer = strndup(value, len); if (FAILEDTOALLOC(v->pointer)) return RET_ERROR_OOM; return RET_OK; } // TODO: check for well-formed versions #define parseversion parsestring static bool comparesource(enum term_comparison c, const struct compare_with *v, const void *d1, const void *d2) { const char *control = d1; const struct target *target = d2; char *package, *source, *version; retvalue r; bool matches; // TODO: make more efficient r = chunk_getvalue(control, "Package", &package); if (!RET_IS_OK(r)) return false; r = target->getsourceandversion(control, package, &source, &version); free(package); if (!RET_IS_OK(r)) return false; free(version); matches = check_field(c, source, v->pointer); free(source); return matches; } static inline bool compare_dpkgversions(enum term_comparison c, const char *version, const char *param) { if (c != tc_globmatch && c != tc_notglobmatch) { int cmp; retvalue r; r = dpkgversions_cmp(version, param, &cmp); if (RET_IS_OK(r)) { if (cmp < 0) return c == tc_strictless || c == tc_lessorequal || c == tc_notequal; else if (cmp > 0) return c == tc_strictmore || c == tc_moreorequal || c == tc_notequal; else return c == tc_lessorequal || c == tc_moreorequal || c == tc_equal; } else return false; } else return check_field(c, version, param); } static bool compareversion(enum term_comparison c, const struct compare_with *v, const void *d1, const void *d2) { const char *control = d1; const struct target *target = d2; char *version; retvalue r; bool matches; r = target->getversion(control, &version); if (!RET_IS_OK(r)) return false; matches = compare_dpkgversions(c, version, v->pointer); free(version); return matches; } static bool comparesourceversion(enum term_comparison c, const struct compare_with *v, const void *d1, const void *d2) { const char *control = d1; const struct target *target = d2; char *package, *source, *version; retvalue r; bool matches; // TODO: make more efficient r = chunk_getvalue(control, "Package", &package); if (!RET_IS_OK(r)) return false; r = target->getsourceandversion(control, package, &source, &version); free(package); if (!RET_IS_OK(r)) return false; free(source); matches = compare_dpkgversions(c, version, v->pointer); free(version); return matches; } static void freestring(UNUSED(enum term_comparison c), struct compare_with *d) { free(d->pointer); } static void freeatom(enum term_comparison c, struct compare_with *d) { if (c != tc_equal && c != tc_notequal) free(d->pointer); } static retvalue parsetype(enum term_comparison c, const char *value, size_t len, struct compare_with *v) { if (c == tc_none) { fprintf(stderr, "Error: $Type is always defined, it does not make sense without parameter\n" "to compare against!\n"); return RET_ERROR; } if (c != tc_equal && c != tc_notequal) { v->pointer = strndup(value, len); if (FAILEDTOALLOC(v->pointer)) return RET_ERROR_OOM; return RET_OK; } v->number = packagetype_find_l(value, len); if (atom_defined(v->number)) return RET_OK; fprintf(stderr, "Unknown package type '%.*s' in formula!\n", (int)len, value); return RET_ERROR; } static retvalue parsearchitecture(enum term_comparison c, const char *value, size_t len, struct compare_with *v) { if (c == tc_none) { fprintf(stderr, "Error: $Architecture is always defined, it does not make sense without parameter\n" "to compare against!\n"); return RET_ERROR; } if (c != tc_equal && c != tc_notequal) { v->pointer = strndup(value, len); if (FAILEDTOALLOC(v->pointer)) return RET_ERROR_OOM; return RET_OK; } v->number = architecture_find_l(value, len); if (atom_defined(v->number)) return RET_OK; fprintf(stderr, "Unknown architecture '%.*s' in formula (must be listed in conf/distributions to be known)!\n", (int)len, value); return RET_ERROR; } static retvalue parsecomponent(enum term_comparison c, const char *value, size_t len, struct compare_with *v) { if (c == tc_none) { fprintf(stderr, "Error: $Component is always defined, it does not make sense without parameter\n" "to compare against!\n"); return RET_ERROR; } if (c != tc_equal && c != tc_notequal) { v->pointer = strndup(value, len); if (FAILEDTOALLOC(v->pointer)) return RET_ERROR_OOM; return RET_OK; } v->number = component_find_l(value, len); if (atom_defined(v->number)) return RET_OK; fprintf(stderr, "Unknown component '%.*s' in formula (must be listed in conf/distributions to be known)!\n", (int)len, value); return RET_ERROR; } static bool comparetype(enum term_comparison c, const struct compare_with *v, UNUSED(const void *d1), const void *d2) { const struct target *target = d2; if (c == tc_equal) return v->number == target->packagetype; else if (c == tc_notequal) return v->number != target->packagetype; else return check_field(c, atoms_packagetypes[target->packagetype], v->pointer); } static bool comparearchitecture(enum term_comparison c, const struct compare_with *v, UNUSED(const void *d1), const void *d2) { const struct target *target = d2; if (c == tc_equal) return v->number == target->architecture; else if (c == tc_notequal) return v->number != target->architecture; else return check_field(c, atoms_architectures[target->architecture], v->pointer); } static bool comparecomponent(enum term_comparison c, const struct compare_with *v, UNUSED(const void *d1), const void *d2) { const struct target *target = d2; if (c == tc_equal) return v->number == target->component; else if (c == tc_notequal) return v->number != target->component; else return check_field(c, atoms_components[target->component], v->pointer); } static struct term_special targetdecisionspecial[] = { {"$Source", parsestring, comparesource, freestring}, {"$SourceVersion", parseversion, comparesourceversion, freestring}, {"$Version", parseversion, compareversion, freestring}, {"$Architecture", parsearchitecture, comparearchitecture, freeatom}, {"$Component", parsecomponent, comparecomponent, freeatom}, {"$Type", parsetype, comparetype, freeatom}, {"$PackageType", parsetype, comparetype, freeatom}, {NULL, NULL, NULL, NULL} }; retvalue term_compilefortargetdecision(term **term_p, const char *formula) { return term_compile(term_p, formula, T_GLOBMATCH|T_OR|T_BRACKETS|T_NEGATION|T_VERSION|T_NOTEQUAL, targetdecisionspecial); } retvalue term_decidechunktarget(const term *condition, const char *controlchunk, const struct target *target) { return term_decidechunk(condition, controlchunk, target); }