From: David van Moolenbroek Date: Mon, 20 Feb 2017 14:43:53 +0000 (+0000) Subject: Import NetBSD rcorder(8) X-Git-Url: http://zhaoyanbai.com/repos/man.dnssec-keyfromlabel.html?a=commitdiff_plain;h=045e0ed35ce62cdaaec13869c12d6745bf07a525;p=minix.git Import NetBSD rcorder(8) Change-Id: Id2ed4959f8089189929fc56401d1c70add5ad323 --- diff --git a/distrib/sets/lists/minix-base/mi b/distrib/sets/lists/minix-base/mi index 0f4ba2d25..116256723 100644 --- a/distrib/sets/lists/minix-base/mi +++ b/distrib/sets/lists/minix-base/mi @@ -196,6 +196,7 @@ ./sbin/ping minix-base ./sbin/poweroff minix-base ./sbin/printconfig minix-base +./sbin/rcorder minix-base ./sbin/reboot minix-base ./sbin/shutdown minix-base ./sbin/sysctl minix-base diff --git a/distrib/sets/lists/minix-debug/mi b/distrib/sets/lists/minix-debug/mi index 7ca9a7265..be5e6ee07 100644 --- a/distrib/sets/lists/minix-debug/mi +++ b/distrib/sets/lists/minix-debug/mi @@ -169,6 +169,7 @@ ./usr/libdata/debug/sbin/newfs_v7fs.debug minix-debug debug ./usr/libdata/debug/sbin/ping.debug minix-debug debug ./usr/libdata/debug/sbin/printconfig.debug minix-debug debug +./usr/libdata/debug/sbin/rcorder.debug minix-debug debug ./usr/libdata/debug/sbin/reboot.debug minix-debug debug ./usr/libdata/debug/sbin/shutdown.debug minix-debug debug ./usr/libdata/debug/sbin/sysctl.debug minix-debug debug diff --git a/distrib/sets/lists/minix-man/mi b/distrib/sets/lists/minix-man/mi index 62dcffccd..17122db78 100644 --- a/distrib/sets/lists/minix-man/mi +++ b/distrib/sets/lists/minix-man/mi @@ -3428,6 +3428,7 @@ ./usr/man/man8/pwdauth.8 minix-man obsolete ./usr/man/man8/rarpd.8 minix-man ./usr/man/man8/rawspeed.8 minix-man +./usr/man/man8/rcorder.8 minix-man ./usr/man/man8/rdate.8 minix-man ./usr/man/man8/readclock.8 minix-man ./usr/man/man8/reboot.8 minix-man diff --git a/sbin/Makefile b/sbin/Makefile index 40f8cea7c..d8907c231 100644 --- a/sbin/Makefile +++ b/sbin/Makefile @@ -11,7 +11,7 @@ SUBDIR= \ fsck init \ mknod nologin \ ping \ - reboot \ + reboot rcorder \ shutdown sysctl \ # support for various file systems diff --git a/sbin/rcorder/Makefile b/sbin/rcorder/Makefile new file mode 100644 index 000000000..86bd72e65 --- /dev/null +++ b/sbin/rcorder/Makefile @@ -0,0 +1,10 @@ +# $NetBSD: Makefile,v 1.8 2008/08/03 07:50:54 lukem Exp $ + +PROG= rcorder +SRCS= hash.c rcorder.c +MAN= rcorder.8 + +LDADD+=-lutil +DPADD+=${LIBUTIL} + +.include diff --git a/sbin/rcorder/hash.c b/sbin/rcorder/hash.c new file mode 100644 index 000000000..caebde1af --- /dev/null +++ b/sbin/rcorder/hash.c @@ -0,0 +1,468 @@ +/* $NetBSD: hash.c,v 1.5 2007/03/03 00:09:30 simonb Exp $ */ + +/* + * Copyright (c) 1988, 1989, 1990 The Regents of the University of California. + * All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Adam de Boor. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * Copyright (c) 1988, 1989 by Adam de Boor + * Copyright (c) 1989 by Berkeley Softworks + * All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Adam de Boor. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifdef MAKE_BOOTSTRAP +static char rcsid[] = "$NetBSD: hash.c,v 1.5 2007/03/03 00:09:30 simonb Exp $"; +#else +#include +#ifndef lint +#if 0 +static char sccsid[] = "@(#)hash.c 8.1 (Berkeley) 6/6/93"; +#else +__RCSID("$NetBSD: hash.c,v 1.5 2007/03/03 00:09:30 simonb Exp $"); +#endif +#endif /* not lint */ +#endif + +#include + +#include +#include +#include +#include +#include + +/* hash.c -- + * + * This module contains routines to manipulate a hash table. + * See hash.h for a definition of the structure of the hash + * table. Hash tables grow automatically as the amount of + * information increases. + */ +#include "hash.h" + +/* + * Forward references to local procedures that are used before they're + * defined: + */ + +static void RebuildTable(Hash_Table *); + +/* + * The following defines the ratio of # entries to # buckets + * at which we rebuild the table to make it larger. + */ + +#define rebuildLimit 8 + +/* + *--------------------------------------------------------- + * + * Hash_InitTable -- + * + * This routine just sets up the hash table. + * + * Input: + * t Structure to use to hold table. + * numBuckets How many buckets to create for starters. This number + * is rounded up to a power of two. If <= 0, a reasonable + * default is chosen. The table will grow in size later + * as needed. + * + * Results: + * None. + * + * Side Effects: + * Memory is allocated for the initial bucket area. + * + *--------------------------------------------------------- + */ + +void +Hash_InitTable(Hash_Table *t, int numBuckets) +{ + int i; + struct Hash_Entry **hp; + + /* + * Round up the size to a power of two. + */ + if (numBuckets <= 0) + i = 16; + else { + for (i = 2; i < numBuckets; i <<= 1) + continue; + } + t->numEntries = 0; + t->size = i; + t->mask = i - 1; + t->bucketPtr = hp = (struct Hash_Entry **)emalloc(sizeof(*hp) * i); + while (--i >= 0) + *hp++ = NULL; +} + +/* + *--------------------------------------------------------- + * + * Hash_DeleteTable -- + * + * This routine removes everything from a hash table + * and frees up the memory space it occupied (except for + * the space in the Hash_Table structure). + * + * Results: + * None. + * + * Side Effects: + * Lots of memory is freed up. + * + *--------------------------------------------------------- + */ + +void +Hash_DeleteTable(Hash_Table *t) +{ + struct Hash_Entry **hp, *h, *nexth; + int i; + + nexth = NULL; + for (hp = t->bucketPtr, i = t->size; --i >= 0;) { + for (h = *hp++; h != NULL; h = nexth) { + nexth = h->next; + free(h); + } + } + free(t->bucketPtr); + + /* + * Set up the hash table to cause memory faults on any future access + * attempts until re-initialization. + */ + t->bucketPtr = NULL; +} + +/* + *--------------------------------------------------------- + * + * Hash_FindEntry -- + * + * Searches a hash table for an entry corresponding to key. + * + * Input: + * t Hash table to search. + * key A hash key. + * + * Results: + * The return value is a pointer to the entry for key, + * if key was present in the table. If key was not + * present, NULL is returned. + * + * Side Effects: + * None. + * + *--------------------------------------------------------- + */ + +Hash_Entry * +Hash_FindEntry(Hash_Table *t, char *key) +{ + Hash_Entry *e; + unsigned h; + char *p; + + for (h = 0, p = key; *p;) + h = (h << 5) - h + *p++; + p = key; + for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next) + if (e->namehash == h && strcmp(e->name, p) == 0) + return (e); + return (NULL); +} + +/* + *--------------------------------------------------------- + * + * Hash_CreateEntry -- + * + * Searches a hash table for an entry corresponding to + * key. If no entry is found, then one is created. + * + * Input: + * t Hash table to search. + * key A hash key. + * newPtr Filled in with 1 if new entry created, 0 otherwise. + * + * Results: + * The return value is a pointer to the entry. If *newPtr + * isn't NULL, then *newPtr is filled in with TRUE if a + * new entry was created, and FALSE if an entry already existed + * with the given key. + * + * Side Effects: + * Memory may be allocated, and the hash buckets may be modified. + *--------------------------------------------------------- + */ + +Hash_Entry * +Hash_CreateEntry(Hash_Table *t, char *key, int *newPtr) +{ + Hash_Entry *e; + unsigned h; + char *p; + int keylen; + struct Hash_Entry **hp; + + /* + * Hash the key. As a side effect, save the length (strlen) of the + * key in case we need to create the entry. + */ + for (h = 0, p = key; *p;) + h = (h << 5) - h + *p++; + keylen = p - key; + p = key; + for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next) { + if (e->namehash == h && strcmp(e->name, p) == 0) { + if (newPtr != NULL) + *newPtr = 0; + return (e); + } + } + + /* + * The desired entry isn't there. Before allocating a new entry, + * expand the table if necessary (and this changes the resulting + * bucket chain). + */ + if (t->numEntries >= rebuildLimit * t->size) + RebuildTable(t); + e = (Hash_Entry *) emalloc(sizeof(*e) + keylen); + hp = &t->bucketPtr[h & t->mask]; + e->next = *hp; + *hp = e; + e->clientData = NULL; + e->namehash = h; + (void) strcpy(e->name, p); + t->numEntries++; + + if (newPtr != NULL) + *newPtr = 1; + return (e); +} + +/* + *--------------------------------------------------------- + * + * Hash_DeleteEntry -- + * + * Delete the given hash table entry and free memory associated with + * it. + * + * Results: + * None. + * + * Side Effects: + * Hash chain that entry lives in is modified and memory is freed. + * + *--------------------------------------------------------- + */ + +void +Hash_DeleteEntry(Hash_Table *t, Hash_Entry *e) +{ + Hash_Entry **hp, *p; + + if (e == NULL) + return; + for (hp = &t->bucketPtr[e->namehash & t->mask]; + (p = *hp) != NULL; hp = &p->next) { + if (p == e) { + *hp = p->next; + free(p); + t->numEntries--; + return; + } + } + (void)write(2, "bad call to Hash_DeleteEntry\n", 29); + abort(); +} + +/* + *--------------------------------------------------------- + * + * Hash_EnumFirst -- + * This procedure sets things up for a complete search + * of all entries recorded in the hash table. + * + * Input: + * t Table to be searched. + * searchPtr Area in which to keep state about search. + * + * Results: + * The return value is the address of the first entry in + * the hash table, or NULL if the table is empty. + * + * Side Effects: + * The information in searchPtr is initialized so that successive + * calls to Hash_Next will return successive HashEntry's + * from the table. + * + *--------------------------------------------------------- + */ + +Hash_Entry * +Hash_EnumFirst(Hash_Table *t, Hash_Search *searchPtr) +{ + + searchPtr->tablePtr = t; + searchPtr->nextIndex = 0; + searchPtr->hashEntryPtr = NULL; + return Hash_EnumNext(searchPtr); +} + +/* + *--------------------------------------------------------- + * + * Hash_EnumNext -- + * This procedure returns successive entries in the hash table. + * + * Results: + * The return value is a pointer to the next HashEntry + * in the table, or NULL when the end of the table is + * reached. + * + * Side Effects: + * The information in searchPtr is modified to advance to the + * next entry. + * + *--------------------------------------------------------- + */ + +Hash_Entry * +Hash_EnumNext(Hash_Search *searchPtr) +{ + Hash_Entry *e; + Hash_Table *t = searchPtr->tablePtr; + + /* + * The hashEntryPtr field points to the most recently returned + * entry, or is nil if we are starting up. If not nil, we have + * to start at the next one in the chain. + */ + e = searchPtr->hashEntryPtr; + if (e != NULL) + e = e->next; + /* + * If the chain ran out, or if we are starting up, we need to + * find the next nonempty chain. + */ + while (e == NULL) { + if (searchPtr->nextIndex >= t->size) + return (NULL); + e = t->bucketPtr[searchPtr->nextIndex++]; + } + searchPtr->hashEntryPtr = e; + return (e); +} + +/* + *--------------------------------------------------------- + * + * RebuildTable -- + * This local routine makes a new hash table that + * is larger than the old one. + * + * Results: + * None. + * + * Side Effects: + * The entire hash table is moved, so any bucket numbers + * from the old table are invalid. + * + *--------------------------------------------------------- + */ + +static void +RebuildTable(Hash_Table *t) +{ + Hash_Entry *e, *next, **hp, **xp; + int i, mask; + Hash_Entry **oldhp; + int oldsize; + + next = NULL; + oldhp = t->bucketPtr; + oldsize = i = t->size; + i <<= 1; + t->size = i; + t->mask = mask = i - 1; + t->bucketPtr = hp = (struct Hash_Entry **) emalloc(sizeof(*hp) * i); + while (--i >= 0) + *hp++ = NULL; + for (hp = oldhp, i = oldsize; --i >= 0;) { + for (e = *hp++; e != NULL; e = next) { + next = e->next; + xp = &t->bucketPtr[e->namehash & mask]; + e->next = *xp; + *xp = e; + } + } + free(oldhp); +} diff --git a/sbin/rcorder/hash.h b/sbin/rcorder/hash.h new file mode 100644 index 000000000..60c79e847 --- /dev/null +++ b/sbin/rcorder/hash.h @@ -0,0 +1,161 @@ +/* $NetBSD: hash.h,v 1.3 2003/08/07 10:04:37 agc Exp $ */ + +/* + * Copyright (c) 1988, 1989, 1990 The Regents of the University of California. + * All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Adam de Boor. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * from: @(#)hash.h 8.1 (Berkeley) 6/6/93 + */ + +/* + * Copyright (c) 1988, 1989 by Adam de Boor + * Copyright (c) 1989 by Berkeley Softworks + * All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Adam de Boor. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * from: @(#)hash.h 8.1 (Berkeley) 6/6/93 + */ + +/* hash.h -- + * + * This file contains definitions used by the hash module, + * which maintains hash tables. + */ + +#ifndef _HASH +#define _HASH + +/* + * The following defines one entry in the hash table. + */ + +typedef struct Hash_Entry { + struct Hash_Entry *next; /* Used to link together all the + * entries associated with the same + * bucket. */ + void *clientData; /* Arbitrary piece of data associated + * with key. */ + unsigned namehash; /* hash value of key */ + char name[1]; /* key string */ +} Hash_Entry; + +typedef struct Hash_Table { + struct Hash_Entry **bucketPtr; + /* Pointers to Hash_Entry, one + * for each bucket in the table. */ + int size; /* Actual size of array. */ + int numEntries; /* Number of entries in the table. */ + int mask; /* Used to select bits for hashing. */ +} Hash_Table; + +/* + * The following structure is used by the searching routines + * to record where we are in the search. + */ + +typedef struct Hash_Search { + Hash_Table *tablePtr; /* Table being searched. */ + int nextIndex; /* Next bucket to check (after + * current). */ + Hash_Entry *hashEntryPtr; /* Next entry to check in current + * bucket. */ +} Hash_Search; + +/* + * Macros. + */ + +/* + * void *Hash_GetValue(h) + * Hash_Entry *h; + */ + +#define Hash_GetValue(h) ((h)->clientData) + +/* + * Hash_SetValue(h, val); + * Hash_Entry *h; + * char *val; + */ + +#define Hash_SetValue(h, val) ((h)->clientData = (void *) (val)) + +/* + * Hash_GetKey(h); + * Hash_Entry *h; + */ + +#define Hash_GetKey(h) ((h)->name) + +/* + * Hash_Size(n) returns the number of words in an object of n bytes + */ + +#define Hash_Size(n) (((n) + sizeof (int) - 1) / sizeof (int)) + +void Hash_InitTable(Hash_Table *, int); +void Hash_DeleteTable(Hash_Table *); +Hash_Entry *Hash_FindEntry(Hash_Table *, char *); +Hash_Entry *Hash_CreateEntry(Hash_Table *, char *, int *); +void Hash_DeleteEntry(Hash_Table *, Hash_Entry *); +Hash_Entry *Hash_EnumFirst(Hash_Table *, Hash_Search *); +Hash_Entry *Hash_EnumNext(Hash_Search *); + +#endif /* _HASH */ diff --git a/sbin/rcorder/rcorder-visualize.sh b/sbin/rcorder/rcorder-visualize.sh new file mode 100644 index 000000000..763b5abc6 --- /dev/null +++ b/sbin/rcorder/rcorder-visualize.sh @@ -0,0 +1,30 @@ +#!/bin/sh +# $NetBSD: rcorder-visualize.sh,v 1.5 2009/08/09 17:08:53 apb Exp $ +# +# Written by Joerg Sonnenberger. You may freely use and redistribute +# this script. +# +# Simple script to show the dependency graph for rc scripts. +# Output is in the dot(1) language and can be rendered using +# sh rcorder-visualize | dot -T svg -o rcorder.svg +# dot(1) can be found in graphics/graphviz in pkgsrc. + +rc_files=${*:-/etc/rc.d/*} + +{ +echo ' digraph {' +for f in $rc_files; do +< $f awk ' +/# PROVIDE: / { provide = $3 } +/# REQUIRE: / { for (i = 3; i <= NF; i++) requires[$i] = $i } +/# BEFORE: / { for (i = 3; i <= NF; i++) befores[$i] = $i } + +END { + print " \"" provide "\";" + for (x in requires) print " \"" provide "\"->\"" x "\";" + for (x in befores) print " \"" x "\"->\"" provide "\";" +} +' +done +echo '}' +} diff --git a/sbin/rcorder/rcorder.8 b/sbin/rcorder/rcorder.8 new file mode 100644 index 000000000..855eabc19 --- /dev/null +++ b/sbin/rcorder/rcorder.8 @@ -0,0 +1,171 @@ +.\" $NetBSD: rcorder.8,v 1.10 2014/03/18 18:20:39 riastradh Exp $ +.\" +.\" Copyright (c) 1998 +.\" Perry E. Metzger. All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" 3. All advertising materials mentioning features or use of this software +.\" must display the following acknowledgment: +.\" This product includes software developed for the NetBSD Project +.\" by Perry E. Metzger. +.\" 4. The name of the author may not be used to endorse or promote products +.\" derived from this software without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +.\" IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +.\" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +.\" IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +.\" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +.\" NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +.\" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +.\" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +.\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +.\" THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +.\" +.\" +.Dd April 23, 2003 +.Dt RCORDER 8 +.Os +.Sh NAME +.Nm rcorder +.Nd print a dependency ordering of interdependent files +.Sh SYNOPSIS +.Nm +.Op Fl k Ar keep +.Op Fl s Ar skip +.Ar +.Sh DESCRIPTION +.Nm +is designed to print out a dependency ordering of a set of +interdependent files. +Typically it is used to find an execution sequence for a set of +shell scripts in which certain files must be executed before others. +.Pp +Each file passed to +.Nm +should be annotated with special lines (which look like comments to the +shell) which indicate the dependencies the files have upon certain +points in the sequence, known as +.Dq conditions , +and which indicate, for each file, which +.Dq conditions +may be expected to be filled by that file. +.Pp +Within each file, a block containing a series of +.Dq REQUIRE , +.Dq PROVIDE , +.Dq BEFORE +and +.Dq KEYWORD +lines should appear. +The format of the lines is rigid. +Each line must begin with a single +.Dq # , +followed by a single space, followed by +.Dq PROVIDE: , +.Dq REQUIRE: , +.Dq BEFORE: , +or +.Dq KEYWORD: . +No deviation is permitted. +Each dependency line is then followed by a series of conditions, +separated by whitespace. +Multiple +.Dq PROVIDE , +.Dq REQUIRE , +.Dq BEFORE +and +.Dq KEYWORD +lines may appear, but all such lines must appear in a sequence without +any intervening lines, as once a line that does not follow the format +is reached, parsing stops. +.Pp +The options are as follows: +.Bl -tag -width Ds +.It Fl k +Add the specified keyword to the +.Dq keep list . +If any +.Fl k +option is given, only those files containing the matching keyword are listed. +.It Fl s +Add the specified keyword to the +.Dq skip list . +If any +.Fl s +option is given, files containing the matching keyword are not listed. +.El +.Pp + An example block follows: +.Bd -literal -offset indent +# REQUIRE: networking syslog +# REQUIRE: usr +# PROVIDE: dns nscd +.Ed +.Pp +This block states that the file in which it appears depends upon the +.Dq networking , +.Dq syslog , +and +.Dq usr +conditions, and provides the +.Dq dns +and +.Dq nscd +conditions. +.Pp +A file may contain zero +.Dq PROVIDE +lines, in which case it provides no conditions, and may contain zero +.Dq REQUIRE +lines, in which case it has no dependencies. +A file containing no +.Dq PROVIDE , +.Dq REQUIRE , +or +.Dq BEFORE +lines may be output at an arbitrary position in the dependency +ordering. +.Pp +There must be at least one file with no dependencies in the set of +arguments passed to +.Nm +in order for it to find a starting place in the dependency ordering. +.Sh DIAGNOSTICS +.Nm +may print one of the following error messages and exit with a non-zero +status if it encounters an error while processing the file list. +.Bl -diag +.It "Requirement %s has no providers, aborting." +No file has a +.Dq PROVIDE +line corresponding to a condition present in a +.Dq REQUIRE +line in another file. +.It "Circular dependency on provision %s, aborting." +A set of files has a circular dependency which was detected while +processing the stated condition. +.It "Circular dependency on file %s, aborting." +A set of files has a circular dependency which was detected while +processing the stated file. +.El +.Sh SEE ALSO +.Xr rc 8 +.Sh HISTORY +The +.Nm +program first appeared in +.Nx 1.5 . +.Sh AUTHORS +.An -nosplit +Written by +.An Perry E. Metzger Aq Mt perry@piermont.com +and +.An Matthew R. Green Aq Mt mrg@eterna.com.au . diff --git a/sbin/rcorder/rcorder.c b/sbin/rcorder/rcorder.c new file mode 100644 index 000000000..9bf404bae --- /dev/null +++ b/sbin/rcorder/rcorder.c @@ -0,0 +1,772 @@ +/* $NetBSD: rcorder.c,v 1.17 2013/10/19 01:09:59 christos Exp $ */ + +/* + * Copyright (c) 1998, 1999 Matthew R. Green + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Copyright (c) 1998 + * Perry E. Metzger. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed for the NetBSD Project + * by Perry E. Metzger. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "hash.h" + +#ifdef DEBUG +int debug = 0; +# define DPRINTF(args) if (debug) { fflush(stdout); fprintf args; } +#else +# define DPRINTF(args) +#endif + +#define REQUIRE_STR "# REQUIRE:" +#define REQUIRE_LEN (sizeof(REQUIRE_STR) - 1) +#define REQUIRES_STR "# REQUIRES:" +#define REQUIRES_LEN (sizeof(REQUIRES_STR) - 1) +#define PROVIDE_STR "# PROVIDE:" +#define PROVIDE_LEN (sizeof(PROVIDE_STR) - 1) +#define PROVIDES_STR "# PROVIDES:" +#define PROVIDES_LEN (sizeof(PROVIDES_STR) - 1) +#define BEFORE_STR "# BEFORE:" +#define BEFORE_LEN (sizeof(BEFORE_STR) - 1) +#define KEYWORD_STR "# KEYWORD:" +#define KEYWORD_LEN (sizeof(KEYWORD_STR) - 1) +#define KEYWORDS_STR "# KEYWORDS:" +#define KEYWORDS_LEN (sizeof(KEYWORDS_STR) - 1) + +int exit_code; +int file_count; +char **file_list; + +enum { + RESET = 0, + SET = 1, +}; + +Hash_Table provide_hash_s, *provide_hash; + +typedef struct provnode provnode; +typedef struct filenode filenode; +typedef struct f_provnode f_provnode; +typedef struct f_reqnode f_reqnode; +typedef struct strnodelist strnodelist; + +struct provnode { + int head; + int in_progress; + filenode *fnode; + provnode *next, *last; +}; + +struct f_provnode { + provnode *pnode; + f_provnode *next; +}; + +struct f_reqnode { + Hash_Entry *entry; + f_reqnode *next; +}; + +struct strnodelist { + filenode *node; + strnodelist *next; + char s[1]; +}; + +struct filenode { + char *filename; + int in_progress; + filenode *next, *last; + f_reqnode *req_list; + f_provnode *prov_list; + strnodelist *keyword_list; +}; + +filenode fn_head_s, *fn_head; + +strnodelist *bl_list; +strnodelist *keep_list; +strnodelist *skip_list; + +void do_file(filenode *fnode); +void strnode_add(strnodelist **, char *, filenode *); +int skip_ok(filenode *fnode); +int keep_ok(filenode *fnode); +void satisfy_req(f_reqnode *rnode, char *); +void crunch_file(char *); +void parse_line(filenode *, char *, void (*)(filenode *, char *)); +filenode *filenode_new(char *); +void add_require(filenode *, char *); +void add_provide(filenode *, char *); +void add_before(filenode *, char *); +void add_keyword(filenode *, char *); +void insert_before(void); +Hash_Entry *make_fake_provision(filenode *); +void crunch_all_files(void); +void initialize(void); +void generate_ordering(void); +int main(int, char *[]); + +int +main(int argc, char *argv[]) +{ + int ch; + + while ((ch = getopt(argc, argv, "dk:s:")) != -1) + switch (ch) { + case 'd': +#ifdef DEBUG + debug = 1; +#else + warnx("debugging not compiled in, -d ignored"); +#endif + break; + case 'k': + strnode_add(&keep_list, optarg, 0); + break; + case 's': + strnode_add(&skip_list, optarg, 0); + break; + default: + /* XXX should crunch it? */ + break; + } + argc -= optind; + argv += optind; + + file_count = argc; + file_list = argv; + + DPRINTF((stderr, "parse_args\n")); + initialize(); + DPRINTF((stderr, "initialize\n")); + crunch_all_files(); + DPRINTF((stderr, "crunch_all_files\n")); + generate_ordering(); + DPRINTF((stderr, "generate_ordering\n")); + + exit(exit_code); +} + +/* + * initialise various variables. + */ +void +initialize(void) +{ + + fn_head = &fn_head_s; + + provide_hash = &provide_hash_s; + Hash_InitTable(provide_hash, file_count); +} + +/* generic function to insert a new strnodelist element */ +void +strnode_add(strnodelist **listp, char *s, filenode *fnode) +{ + strnodelist *ent; + + ent = emalloc(sizeof *ent + strlen(s)); + ent->node = fnode; + strcpy(ent->s, s); + ent->next = *listp; + *listp = ent; +} + +/* + * below are the functions that deal with creating the lists + * from the filename's given and the dependancies and provisions + * in each of these files. no ordering or checking is done here. + */ + +/* + * we have a new filename, create a new filenode structure. + * fill in the bits, and put it in the filenode linked list + */ +filenode * +filenode_new(char *filename) +{ + filenode *temp; + + temp = emalloc(sizeof(*temp)); + memset(temp, 0, sizeof(*temp)); + temp->filename = estrdup(filename); + temp->req_list = NULL; + temp->prov_list = NULL; + temp->keyword_list = NULL; + temp->in_progress = RESET; + /* + * link the filenode into the list of filenodes. + * note that the double linking means we can delete a + * filenode without searching for where it belongs. + */ + temp->next = fn_head->next; + if (temp->next != NULL) + temp->next->last = temp; + temp->last = fn_head; + fn_head->next = temp; + return (temp); +} + +/* + * add a requirement to a filenode. + */ +void +add_require(filenode *fnode, char *s) +{ + Hash_Entry *entry; + f_reqnode *rnode; + int new; + + entry = Hash_CreateEntry(provide_hash, s, &new); + if (new) + Hash_SetValue(entry, NULL); + rnode = emalloc(sizeof(*rnode)); + rnode->entry = entry; + rnode->next = fnode->req_list; + fnode->req_list = rnode; +} + +/* + * add a provision to a filenode. if this provision doesn't + * have a head node, create one here. + */ +void +add_provide(filenode *fnode, char *s) +{ + Hash_Entry *entry; + f_provnode *f_pnode; + provnode *pnode, *head; + int new; + + entry = Hash_CreateEntry(provide_hash, s, &new); + head = Hash_GetValue(entry); + + /* create a head node if necessary. */ + if (head == NULL) { + head = emalloc(sizeof(*head)); + head->head = SET; + head->in_progress = RESET; + head->fnode = NULL; + head->last = head->next = NULL; + Hash_SetValue(entry, head); + } +#if 0 + /* + * Don't warn about this. We want to be able to support + * scripts that do two complex things: + * + * - Two independent scripts which both provide the + * same thing. Both scripts must be executed in + * any order to meet the barrier. An example: + * + * Script 1: + * + * PROVIDE: mail + * REQUIRE: LOGIN + * + * Script 2: + * + * PROVIDE: mail + * REQUIRE: LOGIN + * + * - Two interdependent scripts which both provide the + * same thing. Both scripts must be executed in + * graph order to meet the barrier. An example: + * + * Script 1: + * + * PROVIDE: nameservice dnscache + * REQUIRE: SERVERS + * + * Script 2: + * + * PROVIDE: nameservice nscd + * REQUIRE: dnscache + */ + else if (new == 0) { + warnx("file `%s' provides `%s'.", fnode->filename, s); + warnx("\tpreviously seen in `%s'.", + head->next->fnode->filename); + } +#endif + + pnode = emalloc(sizeof(*pnode)); + pnode->head = RESET; + pnode->in_progress = RESET; + pnode->fnode = fnode; + pnode->next = head->next; + pnode->last = head; + head->next = pnode; + if (pnode->next != NULL) + pnode->next->last = pnode; + + f_pnode = emalloc(sizeof(*f_pnode)); + f_pnode->pnode = pnode; + f_pnode->next = fnode->prov_list; + fnode->prov_list = f_pnode; +} + +/* + * put the BEFORE: lines to a list and handle them later. + */ +void +add_before(filenode *fnode, char *s) +{ + + strnode_add(&bl_list, s, fnode); +} + +/* + * add a key to a filenode. + */ +void +add_keyword(filenode *fnode, char *s) +{ + + strnode_add(&fnode->keyword_list, s, fnode); +} + +/* + * loop over the rest of a line, giving each word to + * add_func() to do the real work. + */ +void +parse_line(filenode *node, char *buffer, void (*add_func)(filenode *, char *)) +{ + char *s; + + while ((s = strsep(&buffer, " \t\n")) != NULL) + if (*s != '\0') + (*add_func)(node, s); +} + +/* + * given a file name, create a filenode for it, read in lines looking + * for provision and requirement lines, building the graphs as needed. + */ +void +crunch_file(char *filename) +{ + FILE *fp; + char *buf; + int require_flag, provide_flag, before_flag, keyword_flag; + enum { BEFORE_PARSING, PARSING, PARSING_DONE } state; + filenode *node; + char delims[3] = { '\\', '\\', '\0' }; + struct stat st; + + if ((fp = fopen(filename, "r")) == NULL) { + warn("could not open %s", filename); + return; + } + + if (fstat(fileno(fp), &st) == -1) { + warn("could not stat %s", filename); + fclose(fp); + return; + } + + if (!S_ISREG(st.st_mode)) { +#if 0 + warnx("%s is not a file", filename); +#endif + fclose(fp); + return; + } + + node = filenode_new(filename); + + /* + * we don't care about length, line number, don't want # for comments, + * and have no flags. + */ + for (state = BEFORE_PARSING; state != PARSING_DONE && + (buf = fparseln(fp, NULL, NULL, delims, 0)) != NULL; free(buf)) { + require_flag = provide_flag = before_flag = keyword_flag = 0; + if (strncmp(REQUIRE_STR, buf, REQUIRE_LEN) == 0) + require_flag = REQUIRE_LEN; + else if (strncmp(REQUIRES_STR, buf, REQUIRES_LEN) == 0) + require_flag = REQUIRES_LEN; + else if (strncmp(PROVIDE_STR, buf, PROVIDE_LEN) == 0) + provide_flag = PROVIDE_LEN; + else if (strncmp(PROVIDES_STR, buf, PROVIDES_LEN) == 0) + provide_flag = PROVIDES_LEN; + else if (strncmp(BEFORE_STR, buf, BEFORE_LEN) == 0) + before_flag = BEFORE_LEN; + else if (strncmp(KEYWORD_STR, buf, KEYWORD_LEN) == 0) + keyword_flag = KEYWORD_LEN; + else if (strncmp(KEYWORDS_STR, buf, KEYWORDS_LEN) == 0) + keyword_flag = KEYWORDS_LEN; + else { + if (state == PARSING) + state = PARSING_DONE; + continue; + } + + state = PARSING; + if (require_flag) + parse_line(node, buf + require_flag, add_require); + else if (provide_flag) + parse_line(node, buf + provide_flag, add_provide); + else if (before_flag) + parse_line(node, buf + before_flag, add_before); + else if (keyword_flag) + parse_line(node, buf + keyword_flag, add_keyword); + } + fclose(fp); +} + +Hash_Entry * +make_fake_provision(filenode *node) +{ + Hash_Entry *entry; + f_provnode *f_pnode; + provnode *head, *pnode; + static int i = 0; + int new; + char buffer[30]; + + do { + snprintf(buffer, sizeof buffer, "fake_prov_%08d", i++); + entry = Hash_CreateEntry(provide_hash, buffer, &new); + } while (new == 0); + head = emalloc(sizeof(*head)); + head->head = SET; + head->in_progress = RESET; + head->fnode = NULL; + head->last = head->next = NULL; + Hash_SetValue(entry, head); + + pnode = emalloc(sizeof(*pnode)); + pnode->head = RESET; + pnode->in_progress = RESET; + pnode->fnode = node; + pnode->next = head->next; + pnode->last = head; + head->next = pnode; + if (pnode->next != NULL) + pnode->next->last = pnode; + + f_pnode = emalloc(sizeof(*f_pnode)); + f_pnode->pnode = pnode; + f_pnode->next = node->prov_list; + node->prov_list = f_pnode; + + return (entry); +} + +/* + * go through the BEFORE list, inserting requirements into the graph(s) + * as required. in the before list, for each entry B, we have a file F + * and a string S. we create a "fake" provision (P) that F provides. + * for each entry in the provision list for S, add a requirement to + * that provisions filenode for P. + */ +void +insert_before(void) +{ + Hash_Entry *entry, *fake_prov_entry; + provnode *pnode; + f_reqnode *rnode; + strnodelist *bl; + int new; + + while (bl_list != NULL) { + bl = bl_list->next; + + fake_prov_entry = make_fake_provision(bl_list->node); + + entry = Hash_CreateEntry(provide_hash, bl_list->s, &new); + if (new == 1) + warnx("file `%s' is before unknown provision `%s'", + bl_list->node->filename, bl_list->s); + + for (pnode = Hash_GetValue(entry); pnode; pnode = pnode->next) { + if (pnode->head) + continue; + + rnode = emalloc(sizeof(*rnode)); + rnode->entry = fake_prov_entry; + rnode->next = pnode->fnode->req_list; + pnode->fnode->req_list = rnode; + } + + free(bl_list); + bl_list = bl; + } +} + +/* + * loop over all the files calling crunch_file() on them to do the + * real work. after we have built all the nodes, insert the BEFORE: + * lines into graph(s). + */ +void +crunch_all_files(void) +{ + int i; + + for (i = 0; i < file_count; i++) + crunch_file(file_list[i]); + insert_before(); +} + +/* + * below are the functions that traverse the graphs we have built + * finding out the desired ordering, printing each file in turn. + * if missing requirements, or cyclic graphs are detected, a + * warning will be issued, and we will continue on.. + */ + +/* + * given a requirement node (in a filename) we attempt to satisfy it. + * we do some sanity checking first, to ensure that we have providers, + * aren't already satisfied and aren't already being satisfied (ie, + * cyclic). if we pass all this, we loop over the provision list + * calling do_file() (enter recursion) for each filenode in this + * provision. + */ +void +satisfy_req(f_reqnode *rnode, char *filename) +{ + Hash_Entry *entry; + provnode *head; + + entry = rnode->entry; + head = Hash_GetValue(entry); + + if (head == NULL) { + warnx("requirement `%s' in file `%s' has no providers.", + Hash_GetKey(entry), filename); + exit_code = 1; + return; + } + + /* return if the requirement is already satisfied. */ + if (head->next == NULL) + return; + + /* + * if list is marked as in progress, + * print that there is a circular dependency on it and abort + */ + if (head->in_progress == SET) { + warnx("Circular dependency on provision `%s' in file `%s'.", + Hash_GetKey(entry), filename); + exit_code = 1; + return; + } + + head->in_progress = SET; + + /* + * while provision_list is not empty + * do_file(first_member_of(provision_list)); + */ + while (head->next != NULL) + do_file(head->next->fnode); +} + +int +skip_ok(filenode *fnode) +{ + strnodelist *s; + strnodelist *k; + + for (s = skip_list; s; s = s->next) + for (k = fnode->keyword_list; k; k = k->next) + if (strcmp(k->s, s->s) == 0) + return (0); + + return (1); +} + +int +keep_ok(filenode *fnode) +{ + strnodelist *s; + strnodelist *k; + + for (s = keep_list; s; s = s->next) + for (k = fnode->keyword_list; k; k = k->next) + if (strcmp(k->s, s->s) == 0) + return (1); + + /* an empty keep_list means every one */ + return (!keep_list); +} + +/* + * given a filenode, we ensure we are not a cyclic graph. if this + * is ok, we loop over the filenodes requirements, calling satisfy_req() + * for each of them.. once we have done this, remove this filenode + * from each provision table, as we are now done. + * + * NOTE: do_file() is called recursively from several places and cannot + * safely free() anything related to items that may be recursed on. + * Circular dependancies will cause problems if we do. + */ +void +do_file(filenode *fnode) +{ + f_reqnode *r; + f_provnode *p, *p_tmp; + provnode *pnode; + int was_set; + + DPRINTF((stderr, "do_file on %s.\n", fnode->filename)); + + /* + * if fnode is marked as in progress, + * print that fnode; is circularly depended upon and abort. + */ + if (fnode->in_progress == SET) { + warnx("Circular dependency on file `%s'.", + fnode->filename); + was_set = exit_code = 1; + } else + was_set = 0; + + /* mark fnode */ + fnode->in_progress = SET; + + /* + * for each requirement of fnode -> r + * satisfy_req(r, filename) + */ + r = fnode->req_list; + while (r != NULL) { +#if 0 + f_reqnode *r_tmp = r; +#endif + satisfy_req(r, fnode->filename); + r = r->next; +#if 0 + free(r_tmp); +#endif + } + fnode->req_list = NULL; + + /* + * for each provision of fnode -> p + * remove fnode from provision list for p in hash table + */ + p = fnode->prov_list; + while (p != NULL) { + p_tmp = p; + pnode = p->pnode; + if (pnode->next != NULL) { + pnode->next->last = pnode->last; + } + if (pnode->last != NULL) { + pnode->last->next = pnode->next; + } + free(pnode); + p = p->next; + free(p_tmp); + } + fnode->prov_list = NULL; + + /* do_it(fnode) */ + DPRINTF((stderr, "next do: ")); + + /* if we were already in progress, don't print again */ + if (was_set == 0 && skip_ok(fnode) && keep_ok(fnode)) + printf("%s\n", fnode->filename); + + if (fnode->next != NULL) { + fnode->next->last = fnode->last; + } + if (fnode->last != NULL) { + fnode->last->next = fnode->next; + } + + DPRINTF((stderr, "nuking %s\n", fnode->filename)); +#if 0 + free(fnode->filename); + free(fnode); +#endif +} + +void +generate_ordering(void) +{ + + /* + * while there remain undone files{f}, + * pick an arbitrary f, and do_file(f) + * Note that the first file in the file list is perfectly + * arbitrary, and easy to find, so we use that. + */ + + /* + * N.B.: the file nodes "self delete" after they execute, so + * after each iteration of the loop, the head will be pointing + * to something totally different. The loop ends up being + * executed only once for every strongly connected set of + * nodes. + */ + while (fn_head->next != NULL) { + DPRINTF((stderr, "generate on %s\n", fn_head->next->filename)); + do_file(fn_head->next); + } +}