match.c revision 131275 
1/*
2 * FreeBSD install - a package for the installation and maintainance
3 * of non-core utilities.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * Maxim Sobolev
15 * 24 February 2001
16 *
17 * Routines used to query installed packages.
18 *
19 */
20
21#include <sys/cdefs.h>
22__FBSDID("$FreeBSD: head/usr.sbin/pkg_install/lib/match.c 131275 2004-06-29 18:54:47Z eik $");
23
24#include "lib.h"
25#include <err.h>
26#include <fnmatch.h>
27#include <fts.h>
28#include <regex.h>
29
30/*
31 * Simple structure representing argv-like
32 * NULL-terminated list.
33 */
34struct store {
35    int currlen;
36    int used;
37    char **store;
38};
39
40static int rex_match(const char *, const char *, int);
41static int csh_match(const char *, const char *, int);
42struct store *storecreate(struct store *);
43static int storeappend(struct store *, const char *);
44static int fname_cmp(const FTSENT * const *, const FTSENT * const *);
45
46/*
47 * Function to query names of installed packages.
48 * MatchType	- one of MATCH_ALL, MATCH_EREGEX, MATCH_REGEX, MATCH_GLOB, MATCH_NGLOB;
49 * patterns	- NULL-terminated list of glob or regex patterns
50 *		  (could be NULL for MATCH_ALL);
51 * retval	- return value (could be NULL if you don't want/need
52 *		  return value).
53 * Returns NULL-terminated list with matching names.
54 * Names in list returned are dynamically allocated and should
55 * not be altered by the caller.
56 */
57char **
58matchinstalled(match_t MatchType, char **patterns, int *retval)
59{
60    int i, errcode, len;
61    char *matched;
62    const char *paths[2] = {LOG_DIR, NULL};
63    static struct store *store = NULL;
64    FTS *ftsp;
65    FTSENT *f;
66    Boolean *lmatched;
67
68    store = storecreate(store);
69    if (store == NULL) {
70	if (retval != NULL)
71	    *retval = 1;
72	return NULL;
73    }
74
75    if (retval != NULL)
76	*retval = 0;
77
78    if (!isdir(paths[0])) {
79	if (retval != NULL)
80	    *retval = 1;
81	return NULL;
82	/* Not reached */
83    }
84
85    /* Count number of patterns */
86    if (patterns != NULL) {
87	for (len = 0; patterns[len]; len++) {}
88	lmatched = alloca(sizeof(*lmatched) * len);
89	if (lmatched == NULL) {
90	    warnx("%s(): alloca() failed", __func__);
91	    if (retval != NULL)
92		*retval = 1;
93	    return NULL;
94    	}
95    } else
96	len = 0;
97
98    for (i = 0; i < len; i++)
99	lmatched[i] = FALSE;
100
101    ftsp = fts_open((char * const *)(uintptr_t)paths, FTS_LOGICAL | FTS_NOCHDIR | FTS_NOSTAT, fname_cmp);
102    if (ftsp != NULL) {
103	while ((f = fts_read(ftsp)) != NULL) {
104	    if (f->fts_info == FTS_D && f->fts_level == 1) {
105		fts_set(ftsp, f, FTS_SKIP);
106		matched = NULL;
107		errcode = 0;
108		if (MatchType == MATCH_ALL)
109		    matched = f->fts_name;
110		else
111		    for (i = 0; patterns[i]; i++) {
112			errcode = pattern_match(MatchType, patterns[i], f->fts_name);
113			if (errcode == 1) {
114			    matched = f->fts_name;
115			    lmatched[i] = TRUE;
116			    errcode = 0;
117			}
118			if (matched != NULL || errcode != 0)
119			    break;
120		    }
121		if (errcode == 0 && matched != NULL)
122		    errcode = storeappend(store, matched);
123		if (errcode != 0) {
124		    if (retval != NULL)
125			*retval = 1;
126		    return NULL;
127		    /* Not reached */
128		}
129	    }
130	}
131	fts_close(ftsp);
132    }
133
134    if (MatchType == MATCH_GLOB) {
135	for (i = 0; i < len; i++)
136	    if (lmatched[i] == FALSE)
137		storeappend(store, patterns[i]);
138    }
139
140    if (store->used == 0)
141	return NULL;
142    else
143	return store->store;
144}
145
146int
147pattern_match(match_t MatchType, char *pattern, const char *pkgname)
148{
149    int errcode = 0;
150    const char *fname = pkgname;
151    char basefname[PATH_MAX];
152    char condchar = '\0';
153    char *condition;
154
155    /* do we have an appended condition? */
156    condition = strpbrk(pattern, "<>=");
157    if (condition) {
158	const char *ch;
159	/* yes, isolate the pattern from the condition ... */
160	if (condition > pattern && condition[-1] == '!')
161	    condition--;
162	condchar = *condition;
163	*condition = '\0';
164	/* ... and compare the name without version */
165	ch = strrchr(fname, '-');
166	if (ch && ch - fname < PATH_MAX) {
167	    strlcpy(basefname, fname, ch - fname + 1);
168	    fname = basefname;
169	}
170    }
171
172    switch (MatchType) {
173    case MATCH_EREGEX:
174    case MATCH_REGEX:
175	errcode = rex_match(pattern, fname, MatchType == MATCH_EREGEX ? 1 : 0);
176	break;
177    case MATCH_NGLOB:
178    case MATCH_GLOB:
179	errcode = (csh_match(pattern, fname, 0) == 0) ? 1 : 0;
180	break;
181    case MATCH_EXACT:
182	errcode = (strcmp(pattern, fname) == 0) ? 1 : 0;
183	break;
184    case MATCH_ALL:
185	errcode = 1;
186	break;
187    default:
188	break;
189    }
190
191    /* loop over all appended conditions */
192    while (condition) {
193	/* restore the pattern */
194	*condition = condchar;
195	/* parse the condition (fun with bits) */
196	if (errcode == 1) {
197	    char *nextcondition;
198	    /* compare version numbers */
199	    int match = 0;
200	    if (*++condition == '=') {
201		match = 2;
202		condition++;
203	    }
204	    switch(condchar) {
205	    case '<':
206		match |= 1;
207		break;
208	    case '>':
209		match |= 4;
210		break;
211	    case '=':
212		match |= 2;
213		break;
214	    case '!':
215		match = 5;
216		break;
217	    }
218	    /* isolate the version number from the next condition ... */
219	    nextcondition = strpbrk(condition, "<>=!");
220	    if (nextcondition) {
221		condchar = *nextcondition;
222		*nextcondition = '\0';
223	    }
224	    /* and compare the versions (version_cmp removes the filename for us) */
225	    if ((match & (1 << (version_cmp(pkgname, condition) + 1))) == 0)
226		errcode = 0;
227	    condition = nextcondition;
228	} else {
229	    break;
230	}
231    }
232
233    return errcode;
234}
235
236/*
237 * Synopsis is similar to matchinstalled(), but use origin
238 * as a key for matching packages.
239 */
240char **
241matchbyorigin(const char *origin, int *retval)
242{
243    char **installed;
244    int i;
245    static struct store *store = NULL;
246
247    store = storecreate(store);
248    if (store == NULL) {
249	if (retval != NULL)
250	    *retval = 1;
251	return NULL;
252    }
253
254    if (retval != NULL)
255	*retval = 0;
256
257    installed = matchinstalled(MATCH_ALL, NULL, retval);
258    if (installed == NULL)
259	return NULL;
260
261    for (i = 0; installed[i] != NULL; i++) {
262	FILE *fp;
263	char *cp, tmp[PATH_MAX];
264	int cmd;
265
266	snprintf(tmp, PATH_MAX, "%s/%s", LOG_DIR, installed[i]);
267	/*
268	 * SPECIAL CASE: ignore empty dirs, since we can can see them
269	 * during port installation.
270	 */
271	if (isemptydir(tmp))
272	    continue;
273	snprintf(tmp, PATH_MAX, "%s/%s", tmp, CONTENTS_FNAME);
274	fp = fopen(tmp, "r");
275	if (fp == NULL) {
276	    warnx("the package info for package '%s' is corrupt", installed[i]);
277	    continue;
278	}
279
280	cmd = -1;
281	while (fgets(tmp, sizeof(tmp), fp)) {
282	    int len = strlen(tmp);
283
284	    while (len && isspace(tmp[len - 1]))
285		tmp[--len] = '\0';
286	    if (!len)
287		continue;
288	    cp = tmp;
289	    if (tmp[0] != CMD_CHAR)
290		continue;
291	    cmd = plist_cmd(tmp + 1, &cp);
292	    if (cmd == PLIST_ORIGIN) {
293		if (csh_match(origin, cp, FNM_PATHNAME) == 0)
294		    storeappend(store, installed[i]);
295		break;
296	    }
297	}
298	if (cmd != PLIST_ORIGIN)
299	    warnx("package %s has no origin recorded", installed[i]);
300	fclose(fp);
301    }
302
303    if (store->used == 0)
304	return NULL;
305    else
306	return store->store;
307}
308
309/*
310 * Return TRUE if the specified package is installed,
311 * or FALSE otherwise.
312 */
313int
314isinstalledpkg(const char *name)
315{
316    char buf[FILENAME_MAX];
317    char buf2[FILENAME_MAX];
318
319    snprintf(buf, sizeof(buf), "%s/%s", LOG_DIR, name);
320    if (!isdir(buf) || access(buf, R_OK) == FAIL)
321	return FALSE;
322
323    snprintf(buf2, sizeof(buf2), "%s/%s", buf, CONTENTS_FNAME);
324    if (!isfile(buf2) || access(buf2, R_OK) == FAIL)
325	return FALSE;
326
327    return TRUE;
328}
329
330/*
331 * Returns 1 if specified pkgname matches RE pattern.
332 * Otherwise returns 0 if doesn't match or -1 if RE
333 * engine reported an error (usually invalid syntax).
334 */
335static int
336rex_match(const char *pattern, const char *pkgname, int extended)
337{
338    char errbuf[128];
339    int errcode;
340    int retval;
341    regex_t rex;
342
343    retval = 0;
344
345    errcode = regcomp(&rex, pattern, (extended ? REG_EXTENDED : REG_BASIC) | REG_NOSUB);
346    if (errcode == 0)
347	errcode = regexec(&rex, pkgname, 0, NULL, 0);
348
349    if (errcode == 0) {
350	retval = 1;
351    } else if (errcode != REG_NOMATCH) {
352	regerror(errcode, &rex, errbuf, sizeof(errbuf));
353	warnx("%s: %s", pattern, errbuf);
354	retval = -1;
355    }
356
357    regfree(&rex);
358
359    return retval;
360}
361
362/*
363 * Match string by a csh-style glob pattern. Returns 0 on
364 * match and FNM_NOMATCH otherwise, to be compatible with
365 * fnmatch(3).
366 */
367static int
368csh_match(const char *pattern, const char *string, int flags)
369{
370    int ret = FNM_NOMATCH;
371
372
373    const char *nextchoice = pattern;
374    const char *current = NULL;
375
376    int prefixlen = -1;
377    int currentlen = 0;
378
379    int level = 0;
380
381    do {
382	const char *pos = nextchoice;
383	const char *postfix = NULL;
384
385	Boolean quoted = FALSE;
386
387	nextchoice = NULL;
388
389	do {
390	    const char *eb;
391	    if (!*pos) {
392		postfix = pos;
393	    } else if (quoted) {
394		quoted = FALSE;
395	    } else {
396		switch (*pos) {
397		case '{':
398		    ++level;
399		    if (level == 1) {
400			current = pos+1;
401			prefixlen = pos-pattern;
402		    }
403		    break;
404		case ',':
405		    if (level == 1 && !nextchoice) {
406			nextchoice = pos+1;
407			currentlen = pos-current;
408		    }
409		    break;
410		case '}':
411		    if (level == 1) {
412			postfix = pos+1;
413			if (!nextchoice)
414			    currentlen = pos-current;
415		    }
416		    level--;
417		    break;
418		case '[':
419		    eb = pos+1;
420		    if (*eb == '!' || *eb == '^')
421			eb++;
422		    if (*eb == ']')
423			eb++;
424		    while(*eb && *eb != ']')
425			eb++;
426		    if (*eb)
427			pos=eb;
428		    break;
429		case '\\':
430		    quoted = TRUE;
431		    break;
432		default:
433		    ;
434		}
435	    }
436	    pos++;
437	} while (!postfix);
438
439	if (current) {
440	    char buf[FILENAME_MAX];
441	    snprintf(buf, sizeof(buf), "%.*s%.*s%s", prefixlen, pattern, currentlen, current, postfix);
442	    ret = csh_match(buf, string, flags);
443	    if (ret) {
444		current = nextchoice;
445		level = 1;
446	    } else
447		current = NULL;
448	} else
449	    ret = fnmatch(pattern, string, flags);
450    } while (current);
451
452    return ret;
453}
454
455/*
456 * Create an empty store, optionally deallocating
457 * any previously allocated space if store != NULL.
458 */
459struct store *
460storecreate(struct store *store)
461{
462    int i;
463
464    if (store == NULL) {
465	store = malloc(sizeof *store);
466	if (store == NULL) {
467	    warnx("%s(): malloc() failed", __func__);
468	    return NULL;
469	}
470	store->currlen = 0;
471	store->store = NULL;
472    } else if (store->store != NULL) {
473	    /* Free previously allocated memory */
474	    for (i = 0; store->store[i] != NULL; i++)
475		free(store->store[i]);
476	    store->store[0] = NULL;
477    }
478    store->used = 0;
479
480    return store;
481}
482
483/*
484 * Append specified element to the provided store.
485 */
486static int
487storeappend(struct store *store, const char *item)
488{
489    if (store->used + 2 > store->currlen) {
490	store->currlen += 16;
491	store->store = reallocf(store->store,
492				store->currlen * sizeof(*(store->store)));
493	if (store->store == NULL) {
494	    store->currlen = 0;
495	    warnx("%s(): reallocf() failed", __func__);
496	    return 1;
497	}
498    }
499
500    asprintf(&(store->store[store->used]), "%s", item);
501    if (store->store[store->used] == NULL) {
502	warnx("%s(): malloc() failed", __func__);
503	return 1;
504    }
505    store->used++;
506    store->store[store->used] = NULL;
507
508    return 0;
509}
510
511static int
512fname_cmp(const FTSENT * const *a, const FTSENT * const *b)
513{
514    return strcmp((*a)->fts_name, (*b)->fts_name);
515}
516