OpenSolaris_b135/lib/libadm/common/getdev.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* Copyright (c) 1997, by Sun Microsystems, Inc.
* All rights reserved.
*/
#pragma ident "%Z%%M% %I% %E% SMI" /* SVr4.0 1.4 */
/*LINTLIBRARY*/
/*
* getdev.c
*
* Contents:
* getdev() List devices that match certain criteria.
*/
/*
* Header files referenced:
* <sys/types.h> System Data Types
* <errno.h> Error handling
* <fcntl.h> File controlling
* <ctype.h> Character types
* <string.h> String handling
* <devmgmt.h> Global device-management def'ns
* "devtab.h" Local device-management dev'ns
*/
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <ctype.h>
#include <string.h>
#include <devmgmt.h>
#include "devtab.h"
#include <stdlib.h>
/*
* Local definitions
* NULL Nil address
* TRUE Boolean TRUE
* FALSE Boolean FALSE
*/
#ifndef NULL
#define NULL 0
#endif
#ifndef TRUE
#define TRUE ('t')
#endif
#ifndef FALSE
#define FALSE 0
#endif
/*
* Comparison values. These values are placed in the struct srch
* structure by buildsearchlist() and are used to compare values
* in matches().
* EQUAL Attribute must equal this value
* NOTEQUAL Attribute must not equal this value
* EXISTS Attribute must exist
* NOEXISTS Attribute must not exist
* IGNORE Ignore this entry
* ENDLIST This entry ends the list
*/
#define EQUAL 1
#define NOTEQUAL 2
#define EXISTS 3
#define NOEXISTS 4
#define IGNORE 5
#define ENDLIST 0
/*
* Structure definitions:
* deviceent Defines a device that matches criteria
* srch Describes a criteria
*/
struct deviceent {
struct deviceent *next; /* Pointer to next item in the list */
char *name; /* Presentation name of the device */
};
struct srch {
char *name; /* Name of field to compare */
char *cmp; /* Value to compare against */
int fcn; /* Type of comparison (see above) */
};
/*
* Local functions referenced
* oktoaddtolist() Determines if device can be added to the
* list by examining the devices list and
* the options governing the search
* initdevicelist() Initializes the linked list of devices
* to be included in the list-to-return
* freedevicelist() Frees the resources allocated to the linked
* list of devices
* addtodevicelist() Adds an entry to the linked list of devices
* buildsearchlist() Builds a list of struct srch structures from
* the criteria strings
* freesearchlist() Frees the resources allocated to the list of
* struct srch structures
* buildreturnlist() Builds the list of devices to return from the
* linked list of devices we've accumulated
* makealiaslist() Builds a list of aliases from the list of
* devices presented by the caller
* freealiaslist() Frees the resources allocated to the list of
* devices aliases
* getnextmatch() Get the next device that matches the search
* criteria
* matchallcriteria() See if the device attributes match all of the
* search criteria
* matchanycriteria() See if the device attributes match any of the
* search criteria
* matches() See if the criteria and attribute match
*/
static char *oktoaddtolist(char *, char **, char **, int);
static void initdevicelist(void);
static void freedevicelist(void);
static int addtodevicelist(char *);
static struct srch *buildsearchlist(char **);
static void freesearchlist(struct srch *);
static char **buildreturnlist(void);
static char **makealiaslist(char **);
static void freealiaslist(char **);
static char *getnextmatch(struct srch *, int);
static int matchallcriteria(struct devtabent *, struct srch *);
static int matchanycriteria(struct devtabent *, struct srch *);
static int matches(char *, char *, int);
/*
* Global Data
*/
/*
* Static Data
* devicelisthead The first item (dummy) in the linked list of devices
* we're building
* devicelist Structure describing the linked list of devices
*/
static struct deviceent devicelisthead;
static struct {
struct deviceent *head;
int count;
} devicelist = {&devicelisthead, 0};
/*
* char **getdev(devices, criteria, options)
* char **devices
* char **criteria
* int options
*
* This function builds a list of devices that match criteria,
* governed by the device list.
*
* Arguments:
* devices The list of devices to select from or the list of
* devices to exclude, depending on the value of
* "options"
* criteria The list of criteria governing the device selection
* Of the form <attr><op><val>
* options Options controlling the device selection. May require
* that a device meet all of the criteria (default is
* any one of the criteria), or may require that the
* devices in the list of devices be excluded from the
* generated list (default is to select only those
* devices in the list)
*
* Returns: char **
* The address of the first item in the list of devices that meet
* the selection criteria
*/
char **
getdev(
char **devices, /* List of devices to constrain */
char **criteria, /* List of selection criteria */
int options) /* Options governing the search */
{
/* Automatic data */
char **aliases; /* List of constraining devices */
char **returnlist; /* List of ptrs to aliases to return */
struct srch *searchlist; /* Pointer to searching criteria */
char *entry; /* Pointer to alias in record */
int errflag; /* FLAG: TRUE if error */
/*
* Initializations
*/
/* Make sure the exclude/include list is all aliases */
aliases = makealiaslist(devices);
if (devices && !aliases)
return (NULL);
/* Build the search list */
if (criteria) {
if (!(searchlist = buildsearchlist(criteria)))
return (NULL);
} else searchlist = NULL;
/* Initialize searching */
initdevicelist();
_setdevtab();
/*
* Keep on going until we get no more matches
*/
errflag = FALSE;
while (!errflag && (entry = getnextmatch(searchlist, options))) {
if (entry = oktoaddtolist(entry, devices, aliases, options)) {
errflag = addtodevicelist(entry);
}
}
/*
* Clean up:
* - Free the entry space we've allocated.
* - Close the device table.
* - Build the list to return to the caller.
* - Free the accumulate device space (but not the strings!)
* - Free the alias list
* - Return the built list to the caller.
*/
returnlist = buildreturnlist();
freedevicelist();
freealiaslist(aliases);
_enddevtab();
return (returnlist);
}
/*
* char *oktoaddtolist(devtabentry, devices, aliases, options)
* char *devtabentry
* char **devices
* char **aliases
* int options
*
* This function determines the device "devtabentry" can be
* added to the list of devices we're accumulating. If so,
* it returns the device name (not the alias).
*
* Arguments:
* devtabentry The device alias that may or may not belong in the
* list we're building.
* devices The devices specified by the caller
* aliases The aliases of the devices specified by the caller
* (1-1 correspondence with "devices")
* options Options controlling the search
*/
static char *
oktoaddtolist(
char *devtabentry, /* Alias to check against list */
char **devices, /* List of devices to check against */
char **aliases, /* List of alias of those devices */
int options) /* Options governing search */
{
/* Automatic data */
char *rtnval; /* Value to return */
int found; /* Flag: TRUE if found */
/* If there's a constraint list, is this device in it? */
if (devices && aliases) {
/* Set "found" to TRUE if the device is in the list */
found = FALSE;
while (!found && *aliases) {
if (strcmp(devtabentry, *aliases) == 0) found = TRUE;
else {
devices++;
aliases++;
}
}
/* Set value to return */
if (found)
rtnval = (options & DTAB_EXCLUDEFLAG) ?
NULL : *devices;
else
rtnval = (options & DTAB_EXCLUDEFLAG) ?
devtabentry : NULL;
} else rtnval = devtabentry; /* No constraint list */
return (rtnval);
}
/*
* void initdevicelist()
*
* This function initializes the list of accumulated devices.
*
* Arguments: None
*
* Returns: Void.
*
* Notes:
*/
static void
initdevicelist(void)
{
/* Make the list a null list */
(devicelist.head)->next = NULL;
devicelist.count = 0;
}
/*
* void freedevicelist()
*
* This function frees the resources allocated to the linked list of
* devices we've been accumulating.
*
* Arguments: none
*
* Returns: void
*/
static void
freedevicelist(void)
{
/* Automatic data */
struct deviceent *pdevice; /* Pointer to current entry */
char *freeblk; /* Pointer space to free */
/* List has a dummy head node */
pdevice = (devicelist.head)->next;
while (pdevice) {
freeblk = (char *) pdevice;
pdevice = pdevice->next;
free(freeblk);
}
}
/*
* int addtodevicelist(deventry)
* char *deventry
*
* This function adds the device <deventry> to the list of devices already
* accumulated. It will not add the device if that device already exists
* in the list. The function returns 0 if successful, -1 if not with
* "errno" set (by functions called) to indicate the error.
*
* Arguments:
* deventry char *
* The name of the device to add to the list of
* accumulated devices
*
* Returns:
* 0 If successful
* -1 If failed. "errno" will be set to a value that indicates the
* error.
*
* Notes:
* - The memory allocation scheme has the potential to fragment the memory
* in the malloc heap. We're allocating space for a local structure,
* which will be freed by getdev(), then allocating space for the device
* name, which will be freed (maybe) by the application using getdev().
* Not worrying about this at the moment.
*/
static int
addtodevicelist(char *deventry)
{
/* Automatic data */
struct deviceent *p; /* Pointer to current device */
struct deviceent *q; /* Pointer to next device */
struct deviceent *new; /* Pointer to the alloc'd new node */
char *str; /* Pointer to alloc'd space for name */
int rtncd; /* Value to return to the caller */
int cmpcd; /* strcmp() value, comparing names */
int done; /* Loop control, TRUE if done */
/* Initializations */
rtncd = FALSE;
/*
* Find the place in the found device list devicelist where this
* device is to reside
*/
p = devicelist.head;
done = FALSE;
while (!done) {
q = p->next;
if (!q) done = TRUE;
else if ((cmpcd = strcmp(deventry, q->name)) <= 0) done = TRUE;
else p = q;
}
/*
* If the device is not already in the list, insert it in the list
*/
if (!q || (cmpcd != 0)) {
/* Alloc space for the new node */
if (new = malloc(sizeof (struct deviceent))) {
/* Alloc space for the device character string */
if (str = malloc(strlen(deventry)+1)) {
/*
* Insert an entry in the found device list containing
* this device name
*/
new->next = q;
p->next = new;
new->name = strcpy(str, deventry);
devicelist.count++;
}
/* Couldn't alloc space for the device name. Error. */
else rtncd = TRUE;
}
/* Couldn't alloc space for new node in the found list. Error. */
else rtncd = TRUE;
}
/* Return an value indicating success or failure */
return (rtncd);
}
/*
* struct srch *buildsearchlist(criteria)
* char **criteria
*
* This function builds a list of search criteria structures from the
* criteria strings in the list of criteria whose first argument is
* specified by "criteria".
*
* Arguments:
* criteria The address of the first item in a list of
* character-strings specifying search criteria
*
* Returns: struct srch *
* The address of the structure in the list of structures describing the
* search criteria.
*
* Notes:
* - The only "regular expression" currently supported by the
* kywd:exp and kywd!:exp forms is exp=*. This function assumes
* that kywd:exp means "if kywd exist" and that kywd!:exp means
* "if kywd doesn't exist".
*/
static struct srch *
buildsearchlist(char **criteria) /* Criteria from caller */
{
/* Automatic data */
struct srch *rtnbuf; /* Value to return */
struct srch *psrch; /* Running pointer */
char *str; /* Ptr to malloc()ed string space */
char *p; /* Temp pointer to char */
int noerror; /* TRUE if all's well */
int n; /* Temp counter */
char **pp; /* Running ptr to (char *) */
/* Initializations */
rtnbuf = NULL; /* Nothing to return yet */
noerror = TRUE; /* No errors (yet) */
/* If we were given any criteria ... */
if (criteria) {
/* Count the number of criteria in the list */
for (n = 1, pp = criteria; *pp++; n++)
;
/* Allocate space for structures describing the criteria */
if (rtnbuf = malloc(n*sizeof (struct srch))) {
/* Build structures describing the criteria */
pp = criteria;
psrch = rtnbuf;
while (noerror && *pp) {
/* Keep list sane for cleanup if necessary */
psrch->fcn = ENDLIST;
/* Alloc space for strings referenced by the structure */
if (str = malloc(strlen(*pp)+1)) {
/* Extract field name, function, and compare string */
(void) strcpy(str, *pp);
/* If criteria contains an equal sign ('=') ... */
if (p = strchr(str+1, '=')) {
if (*(p-1) == '!') {
*(p-1) = '\0';
psrch->fcn = NOTEQUAL;
} else {
*p = '\0';
psrch->fcn = EQUAL;
}
psrch->cmp = p+1;
psrch->name = str;
psrch++;
}
/* If criteria contains a colon (':') ... */
else if (p = strchr(str+1, ':')) {
if (*(p-1) == '!') {
*(p-1) = '\0';
psrch->fcn = NOEXISTS;
} else {
*p = '\0';
psrch->fcn = EXISTS;
}
psrch->cmp = p+1;
psrch->name = str;
psrch++;
}
} else {
/* Unable to malloc() string space. Clean up */
freesearchlist(rtnbuf);
noerror = FALSE;
}
/* Next criteria */
pp++;
}
/* Terminate list */
if (noerror) psrch->fcn = ENDLIST;
}
}
/* Return a pointer to allocated space (if any) */
return (rtnbuf);
}
/*
* void freesearchlist(list)
* struct srch *list
*
* This function frees the resources allocated to the searchlist <list>.
*
* Arguments:
* list The list whose resources are to be released.
*
* Returns: void
*/
static void
freesearchlist(struct srch *list)
{
/* Automatic data */
struct srch *psrch; /* Running ptr to structs */
/* Free all of the string space allocated for the structure elememts */
for (psrch = list; psrch->fcn != ENDLIST; psrch++) {
free(psrch->name);
}
/* Free the list space */
free(list);
}
/*
* char **buildreturnlist()
*
* This function builds a list of addresses of character-strings
* to be returned from the linked-list of devices we've been
* building. It returns a pointer to the first item in that list.
*
* Arguments: none
*
* Returns: char **
* The address of the first item in the return list
*/
static char **
buildreturnlist(void)
{
/* Automatic data */
char **list;
char **q;
struct deviceent *p;
/*
* Allocate space for the return list,
* with space for the terminating node
*/
if (list = malloc((devicelist.count+1)*sizeof (char *))) {
/*
* Walk the list of accumulated devices, putting pointers to
* device names in the list to return
*/
q = list;
for (p = devicelist.head->next; p; p = p->next) *q++ = p->name;
/* End the list with a null-pointer */
*q = NULL;
}
/* Return a pointer to the list we've built */
return (list);
}
/*
* char **makealiaslist(devices)
* char **devices List of aliases
*
* Builds a list of aliases of the devices in the "devices"
* list. This list will be terminated by (char *) NULL and
* will have the same number of elements as "devices". If
* a device couldn't be found, that alias will be "". There
* will be a one-to-one correspondence of devices to aliases
* in the device list "devices" and the generated list.
*
* Arguments:
* devices The list of devices to derive aliases from
*
* Returns: char **
* The address of the list of addresses of aliases. The list
* and aliases will be allocated using the malloc() function.
*/
static char **
makealiaslist(char **devices)
{
/* Automatic data */
char **pp; /* Running ptr to (char *) */
char **qq; /* Running ptr to (char *) */
char **aliases; /* List being returned */
char *alias; /* Alias of current device */
int olderrno; /* Value of errno on entry */
int noerror; /* Flag, TRUE if all's well */
int n; /* Count of entries in "devices" */
noerror = TRUE;
olderrno = errno;
if (devices) {
/* Get the number of entries in the constaint list */
for (n = 1, pp = devices; *pp; pp++) n++;
/* Get space for the alias list */
if (aliases = malloc(n*sizeof (char *))) {
/* Build the alias list */
qq = aliases;
for (pp = devices; noerror && *pp; pp++) {
/* Get the device's alias and put it in the list */
if (alias = devattr(*pp, DTAB_ALIAS)) *qq++ = alias;
else {
errno = olderrno;
if (alias = malloc(strlen("")+1))
*qq++ = strcpy(alias, "");
else {
/* No space for a null string? Yeech... */
for (qq = aliases; *qq; qq++) free(*qq);
free(aliases);
aliases = NULL;
noerror = FALSE;
}
}
}
if (noerror)
*qq = NULL;
}
} else
aliases = NULL; /* No constraint list */
/* Return ptr to generated list or NULL if none or error */
return (aliases);
}
/*
* void freealiaslist(aliaslist)
* char **aliaslist;
*
* Free the space allocated to the aliaslist. It frees the space
* allocated to the character-strings referenced by the list then
* it frees the list.
*
* Arguments:
* aliaslist The address of the first item in the list of
* aliases that is to be freed
*
* Returns: void
*/
static void
freealiaslist(char **aliaslist) /* Ptr to new device list */
{
/* Automatic Data */
char **pp; /* Running pointer */
/* If there's a list ... */
if (aliaslist) {
/* For each entry in the old list, free the entry */
for (pp = aliaslist; *pp; pp++) free(*pp);
/* Free the list */
free(aliaslist);
}
}
/*
* char *getnextmatch(criteria, options)
* struct srch *criteria
* int options
*
* Gets the next device in the device table that matches the criteria.
* Returns the alias of that device.
*
* Arguments:
* criteria The linked list of criteria to use to match a device
* options Options modifying the criteria (only one that's really
* important is the DTAB_ANDCRITERIA flag)
*
* Returns: char *
* A pointer to a malloc()ed string containing the alias of the next
* device that matches the criteria, or (char *) NULL if none.
*/
static char *
getnextmatch(struct srch *criteria, int options)
{
/* Automatic data */
struct devtabent *devtabent; /* Ptr to current record */
char *alias; /* Alias of device found */
int notdone; /* Flag, done yet? */
int noerror; /* Flag, had an error yet? */
/*
* Initializations:
* - No alias yet
* - Not finished yet
* - Make sure there are criteria we're to use
*/
alias = NULL;
notdone = TRUE;
noerror = TRUE;
/* If we're to "and" the criteria... */
if (options & DTAB_ANDCRITERIA) {
/*
* Search the device table until we've got a record that matches
* all of the criteria or we run out of records
*/
while (notdone && (devtabent = _getdevtabent())) {
if (!devtabent->comment) {
if (!criteria || matchallcriteria(devtabent, criteria)) {
if (alias = malloc(strlen(devtabent->alias)+1))
(void) strcpy(alias, devtabent->alias);
else noerror = FALSE;
notdone = FALSE;
}
}
_freedevtabent(devtabent);
}
} else {
/*
* Search the device table until we've got a record that matches
* any of the criteria or we run out of records
*/
while (notdone && (devtabent = _getdevtabent())) {
if (!devtabent->comment) {
if (!criteria || matchanycriteria(devtabent, criteria)) {
if (alias = malloc(strlen(devtabent->alias)+1))
(void) strcpy(alias, devtabent->alias);
else noerror = FALSE;
notdone = FALSE;
}
}
_freedevtabent(devtabent);
}
}
/* Return pointer to extracted alias (or NULL if none) */
if ((alias == NULL) && noerror) errno = ENOENT;
return (alias);
}
/*
* int matchallcriteria(devtabent, criteria)
*
* This function examines the record contained in "devtabent" and
* determines if that record meets all of the criteria specified by
* "criteria".
*
* Arguments:
* struct devtabent *devtabent The device table entry to examine.
* struct srch *criteria The criteria to match.
*
* Returns: int
* Returns TRUE if the record matches criteria, FALSE otherwise.
*/
static int
matchallcriteria(
struct devtabent *ent, /* Entry to check */
struct srch *criteria) /* Criteria governing match */
{
/* Automatic data */
struct srch *p; /* Pointer to current criteria */
struct attrval *q; /* Pointer to current attr/val pair */
int notfound; /* TRUE if attr found in list */
int failed; /* TRUE if record failed to match */
/* Test only if there's criteria to test against */
if (criteria && (criteria->fcn != ENDLIST)) {
failed = FALSE;
for (p = criteria; !failed && (p->fcn != ENDLIST); p++) {
/*
* Don't compare against this criteria if it's function is
* "IGNORE"
*/
if (p->fcn != IGNORE) {
if (p->fcn != NOEXISTS) {
/* Alias? */
if (strcmp(p->name, DTAB_ALIAS) == 0)
failed = !matches(ent->alias, p->cmp, p->fcn);
/* Char special device? */
else if (strcmp(p->name, DTAB_CDEVICE) == 0)
failed = !matches(ent->cdevice, p->cmp, p->fcn);
/* Block special device? */
else if (strcmp(p->name, DTAB_BDEVICE) == 0)
failed = !matches(ent->bdevice, p->cmp, p->fcn);
/* Pathname? */
else if (strcmp(p->name, DTAB_PATHNAME) == 0)
failed = !matches(ent->pathname, p->cmp, p->fcn);
/* Check other attributes... */
else {
notfound = TRUE;
q = ent->attrlist;
while (notfound && q) {
if (strcmp(p->name, q->attr) == 0) {
notfound = FALSE;
if (!matches(q->val, p->cmp, p->fcn))
failed = TRUE;
} else q = q->next;
}
if (notfound) failed = TRUE;
}
} else {
if (strcmp(p->name, DTAB_ALIAS) == 0) failed = TRUE;
else if (strcmp(p->name, DTAB_CDEVICE) == 0)
failed = FALSE;
else if (strcmp(p->name, DTAB_BDEVICE) == 0)
failed = FALSE;
else if (strcmp(p->name, DTAB_PATHNAME) == 0)
failed = FALSE;
else {
q = ent->attrlist;
while (!failed && q) {
if (strcmp(p->name, q->attr) == 0)
failed = TRUE;
else q = q->next;
}
}
}
} /* Search function is not "IGNORE" */
} /* for loop, checking each criteria */
} /* if (criteria) */
else failed = FALSE; /* No criteria specified, it's a match */
/* Return a value indicating if the record matches all criteria */
return (!failed);
}
/*
* int matchanycriteria(devtabent, criteria)
*
* This function examines the record contained in "devtabent" and
* determines if that record meets any of the criteria specified by
* "criteria".
*
* Arguments:
* struct devtabent *devtabent The device table entry to examine.
* struct srch *criteria The criteria to match.
*
* Returns: int
* Returns TRUE if the record matches criteria, FALSE otherwise.
*/
static int
matchanycriteria(
struct devtabent *ent, /* Entry to check */
struct srch *criteria) /* Criteria governing match */
{
/* Automatic data */
struct srch *p; /* Pointer to current criteria */
struct attrval *q; /* Pointer to current attr/val pair */
int matched; /* FLAG: TRUE if record matched */
int found; /* FLAG: TRUE if attribute found */
/* Test only if there's criteria to test against */
if (criteria && (criteria->fcn != ENDLIST)) {
matched = FALSE;
for (p = criteria; !matched && (p->fcn != ENDLIST); p++) {
/*
* Don't compare against this criteria if it's function is
* "IGNORE"
*/
if (p->fcn != IGNORE) {
if (p->fcn != NOEXISTS) {
/* Alias? */
if (strcmp(p->name, DTAB_ALIAS) == 0)
matched = matches(ent->alias, p->cmp, p->fcn);
/* Char special device? */
else if (strcmp(p->name, DTAB_CDEVICE) == 0)
matched = matches(ent->cdevice, p->cmp, p->fcn);
/* Block special device? */
else if (strcmp(p->name, DTAB_BDEVICE) == 0)
matched = matches(ent->bdevice, p->cmp, p->fcn);
/* Pathname? */
else if (strcmp(p->name, DTAB_PATHNAME) == 0)
matched = matches(ent->pathname, p->cmp, p->fcn);
/* Check other attributes... */
else {
q = ent->attrlist;
found = FALSE;
while (!found && q)
if (strcmp(p->name, q->attr) == 0) {
matched = matches(q->val, p->cmp, p->fcn);
found = TRUE;
} else q = q->next;
}
} else {
if (strcmp(p->name, DTAB_ALIAS) == 0) matched = FALSE;
else if (strcmp(p->name, DTAB_CDEVICE) == 0)
matched = FALSE;
else if (strcmp(p->name, DTAB_BDEVICE) == 0)
matched = FALSE;
else if (strcmp(p->name, DTAB_PATHNAME) == 0)
matched = FALSE;
else {
q = ent->attrlist;
matched = TRUE;
while (matched && q) {
if (strcmp(p->name, q->attr) == 0)
matched = FALSE;
else q = q->next;
}
}
}
} /* Search function is not "IGNORE" */
} /* for loop, checking each criteria */
} /* if (criteria) */
else matched = TRUE; /* No criteria specified, it's a match */
/* Return a value indicating if the record matches all criteria */
return (matched);
}
/*
* int matches(value, compare, function)
* char *value
* char *compare
* int function
*
* This function sees if the operation <function> is satisfied by
* comparing the value <value> with <compare>. It returns TRUE
* if so, FALSE otherwise.
*
* Arguments:
* value Value to compare
* compare Value to compare against
* function Function to be satisfied
*
* Returns: int
* TRUE if the function is satisfied, FALSE otherwise
*/
static int
matches(char *value, char *compare, int function)
{
/* Automatic data */
int rtn; /* Value to return */
if (value == NULL)
value = "";
/* Do case depending on the function */
switch (function) {
/* attr=val */
case EQUAL:
rtn = (strcmp(value, compare) == 0);
break;
/* attr!=val */
case NOTEQUAL:
rtn = (strcmp(value, compare) != 0);
break;
/* attr:* */
case EXISTS:
rtn = TRUE;
break;
/* attr!:* */
case NOEXISTS:
rtn = FALSE;
break;
/* Shouldn't get here... */
default:
rtn = FALSE;
break;
}
/* Return a value indicating if the match was made */
return (rtn);
}