/usr/src/usr.sbin/config/sem.c

Bug Summary

File:	src/usr.sbin/config/sem.c
Warning:	line 875, column 14 Assigned value is garbage or undefined
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name sem.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.sbin/config/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/usr.sbin/config -I . -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.sbin/config/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/usr.sbin/config/sem.c
1/*	$OpenBSD: sem.c,v 1.38 2021/11/28 19:26:03 deraadt Exp $	*/
2/*	$NetBSD: sem.c,v 1.10 1996/11/11 23:40:11 gwr Exp $	*/

4/*
* Copyright (c) 1992, 1993
*	The Regents of the University of California.  All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* 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, Lawrence Berkeley Laboratories.
*
* 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: @(#)sem.c	8.1 (Berkeley) 6/6/93
*/

44#include <sys/types.h>
45#include <ctype.h>
46#include <err.h>
47#include <stdio.h>
48#include <stdlib.h>
49#include <string.h>

51#include "config.h"
52#include "sem.h"

54/*
* config semantics.
*/

58#define	NAMESIZE100	100	/* local name buffers */

60const char *s_generic;
61const char *s_nfs;

63static struct hashtab *attrtab;		/* for attribute lookup */
64static struct hashtab *cfhashtab;	/* for config lookup */
65static struct hashtab *devitab;		/* etc */

67static struct attr errattr;
68static struct devbase errdev;
69static struct deva errdeva;
70static struct devbase **nextbase;
71static struct deva **nextdeva;
72static struct config **nextcf;
73static struct devi **nextdevi;
74static struct devi **nextpseudo;

76static int has_errobj(struct nvlist *, void *);
77static struct nvlist *addtoattr(struct nvlist *, struct devbase *);
78static int exclude(struct nvlist *, const char *, const char *);
79static int resolve(struct nvlist **, const char *, const char *,
  struct nvlist *, int);
81static int lresolve(struct nvlist **, const char *, const char *,
  struct nvlist *, int);
83static struct devi *newdevi(const char *, int, struct devbase *d);
84static struct devi *getdevi(const char *);
85static const char *concat(const char *, int);
86static char *extend(char *, const char *);
87static int split(const char *, size_t, char *, size_t, int *);
88static void selectbase(struct devbase *, struct deva *);
89static int onlist(struct nvlist *, void *);
90static const char **fixloc(const char *, struct attr *, struct nvlist *);

92void
93initsem(void)
94{

attrtab = ht_new();
errattr.a_name = "<internal>";

allbases = NULL((void *)0);
nextbase = &allbases;

alldevas = NULL((void *)0);
nextdeva = &alldevas;

cfhashtab = ht_new();
allcf = NULL((void *)0);
nextcf = &allcf;

devitab = ht_new();
alldevi = NULL((void *)0);
nextdevi = &alldevi;
errdev.d_name = "<internal>";

allpseudo = NULL((void *)0);
nextpseudo = &allpseudo;

s_generic = intern("generic");
s_nfs = intern("nfs");
119}

121/* Name of include file just ended (set in scan.l) */
122extern const char *lastfile;

124void
125enddefs(void)
126{
struct devbase *dev;

for (dev = allbases; dev != NULL((void *)0); dev = dev->d_next) {
if (!dev->d_isdef) {
	(void)fprintf(stderr(&__sF[2]),
	    "%s: device `%s' used but not defined\n",
	    lastfile, dev->d_name);
	errors++;
	continue;
}
}
if (errors) {
(void)fprintf(stderr(&__sF[2]), "*** Stop.\n");
exit(1);
}
142}

144void
145setdefmaxusers(int min, int def, int max)
146{

if (min < 1 || min > def || def > max)
error("maxusers must have 1 <= min <= default <= max");
else {
minmaxusers = min;
defmaxusers = def;
maxmaxusers = max;
}
155}

157void
158setmaxusers(int n)
159{

if (maxusers != 0) {
warnx("warning: duplicate maxusers parameter, will use latest definition (%d)", n);
}
maxusers = n;
if (n < minmaxusers) {
warnx("warning: minimum of %d maxusers assumed", minmaxusers);
maxusers = minmaxusers;
} else if (n > maxmaxusers) {
warnx("warning: maxusers (%d) > %d", n, maxmaxusers);
}
171}

173/*
* Define an attribute, optionally with an interface (a locator list).
* Since an empty locator list is logically different from "no interface",
* all locator lists include a dummy head node, which we discard here.
*/
178int
179defattr(const char *name, struct nvlist *locs)
180{
struct attr *a;
struct nvlist *nv;
int len;

a = emalloc(sizeof *a);
if (ht_insert(attrtab, name, a)ht_insrep(attrtab, name, a, 0)) {
free(a);
error("attribute `%s' already defined", name);
nvfreel(locs);
return (1);
}
a->a_name = name;
if (locs != NULL((void *)0)) {
a->a_iattr = 1;
a->a_locs = locs->nv_next;
nvfree(locs);
} else {
a->a_iattr = 0;
a->a_locs = NULL((void *)0);
}
len = 0;
for (nv = a->a_locs; nv != NULL((void *)0); nv = nv->nv_next)
len++;
a->a_loclen = len;
a->a_devs = NULL((void *)0);
a->a_refs = NULL((void *)0);
return (0);
208}

210/*
* Return true if the given `error object' is embedded in the given
* pointer list.
*/
214static int
215has_errobj(struct nvlist *nv, void *obj)
216{

for (; nv != NULL((void *)0); nv = nv->nv_next)
if (nv->nv_ptrnv_un.un_ptr == obj)
	return (1);
return (0);
222}

224/*
* Add a device base to a list in an attribute (actually, to any list).
* Note that this does not check for duplicates, and does reverse the
* list order, but no one cares anyway.
*/
229static struct nvlist *
230addtoattr(struct nvlist *l, struct devbase *dev)
231{
struct nvlist *n;

n = newnv(NULL((void *)0), NULL((void *)0), dev, 0, l);
return (n);
236}

238/*
* Define a device.  This may (or may not) also define an interface
* attribute and/or refer to existing attributes.
*/
242void
243defdev(struct devbase *dev, int ispseudo, struct nvlist *loclist,
  struct nvlist *attrs)
245{
struct nvlist *nv;
struct attr *a;

if (dev == &errdev)
goto bad;
if (dev->d_isdef) {
error("redefinition of `%s'", dev->d_name);
goto bad;
}
dev->d_isdef = 1;
if (has_errobj(attrs, &errattr))
goto bad;

/*
* Handle implicit attribute definition from locator list.  Do
* this before scanning the `at' list so that we can have, e.g.:
*	device foo at other, foo { slot = -1 }
* (where you can plug in a foo-bus extender to a foo-bus).
*/
if (loclist != NULL((void *)0)) {
nv = loclist;
loclist = NULL((void *)0);	/* defattr disposes of them for us */
if (defattr(dev->d_name, nv))
	goto bad;
attrs = newnv(dev->d_name, NULL((void *)0), getattr(dev->d_name), 0,
    attrs);
}

/* Committed!  Set up fields. */
dev->d_ispseudo = ispseudo;
dev->d_attrs = attrs;

/*
* For each interface attribute this device refers to, add this
* device to its reference list.  This makes, e.g., finding all
* "scsi"s easier.
*/
for (nv = attrs; nv != NULL((void *)0); nv = nv->nv_next) {
a = nv->nv_ptrnv_un.un_ptr;
if (a->a_iattr)
	a->a_refs = addtoattr(a->a_refs, dev);
}
return;
289bad:
nvfreel(loclist);
nvfreel(attrs);
292}

294/*
* Look up a devbase.  Also makes sure it is a reasonable name,
* i.e., does not end in a digit or contain special characters.
*/
298struct devbase *
299getdevbase(char *name)
300{
u_char *p;
struct devbase *dev;

p = (u_char *)name;
if (!isalpha(*p))
goto badname;
while (*++p) {
if (!isalnum(*p) && *p != '_')
	goto badname;
}
if (isdigit(*--p)) {
312badname:
error("bad device base name `%s'", name);
return (&errdev);
}
dev = ht_lookup(devbasetab, name);
if (dev == NULL((void *)0)) {
dev = emalloc(sizeof *dev);
dev->d_name = name;
dev->d_next = NULL((void *)0);
dev->d_isdef = 0;
dev->d_major = nodev;
dev->d_attrs = NULL((void *)0);
dev->d_ihead = NULL((void *)0);
dev->d_ipp = &dev->d_ihead;
dev->d_ahead = NULL((void *)0);
dev->d_app = &dev->d_ahead;
dev->d_umax = 0;
*nextbase = dev;
nextbase = &dev->d_next;
if (ht_insert(devbasetab, name, dev)ht_insrep(devbasetab, name, dev, 0))
	panic("getdevbase(%s)", name);
}
return (dev);
335}

337/*
* Define some of a device's allowable parent attachments.
* There may be a list of (plain) attributes.
*/
341void
342defdevattach(struct deva *deva, struct devbase *dev, struct nvlist *atlist,
  struct nvlist *attrs)
344{
struct nvlist *nv;
struct attr *a;
struct deva *da;

if (dev == &errdev)
goto bad;
if (deva == NULL((void *)0))
deva = getdevattach(dev->d_name);
if (deva == &errdeva)
goto bad;
if (!dev->d_isdef) {
error("attaching undefined device `%s'", dev->d_name);
goto bad;
}
if (deva->d_isdef) {
error("redefinition of `%s'", deva->d_name);
goto bad;
}
if (dev->d_ispseudo) {
error("pseudo-devices can't attach");
goto bad;
}

deva->d_isdef = 1;
if (has_errobj(attrs, &errattr))
goto bad;
for (nv = attrs; nv != NULL((void *)0); nv = nv->nv_next) {
a = nv->nv_ptrnv_un.un_ptr;
if (a == &errattr)
	continue;		/* already complained */
if (a->a_iattr)
	error("`%s' is not a plain attribute", a->a_name);
}

/* Committed!  Set up fields. */
deva->d_attrs = attrs;
deva->d_atlist = atlist;
deva->d_devbase = dev;

/*
* Turn the `at' list into interface attributes (map each
* nv_name to an attribute, or to NULL for root), and add
* this device to those attributes, so that children can
* be listed at this particular device if they are supported
* by that attribute.
*/
for (nv = atlist; nv != NULL((void *)0); nv = nv->nv_next) {
if (nv->nv_name == NULL((void *)0))
	nv->nv_ptrnv_un.un_ptr = a = NULL((void *)0);	/* at root */
else
	nv->nv_ptrnv_un.un_ptr = a = getattr(nv->nv_name);
if (a == &errattr)
	continue;		/* already complained */

/*
 * Make sure that an attachment spec doesn't
 * already say how to attach to this attribute.
 */
for (da = dev->d_ahead; da != NULL((void *)0); da = da->d_bsame)
	if (onlist(da->d_atlist, a))
		error("attach at `%s' already done by `%s'",
		    a ? a->a_name : "root", da->d_name);

if (a == NULL((void *)0))
	continue;		/* at root; don't add */
if (!a->a_iattr)
	error("%s cannot be at plain attribute `%s'",
	    dev->d_name, a->a_name);
else
	a->a_devs = addtoattr(a->a_devs, dev);
}

/* attach to parent */
*dev->d_app = deva;
dev->d_app = &deva->d_bsame;
return;
421bad:
nvfreel(atlist);
nvfreel(attrs);
424}

426/*
* Look up a device attachment.  Also makes sure it is a reasonable
* name, i.e., does not contain digits or special characters.
*/
430struct deva *
431getdevattach(const char *name)
432{
u_char *p;
struct deva *deva;

p = (u_char *)name;
if (!isalpha(*p))
goto badname;
while (*++p) {
if (!isalnum(*p) && *p != '_')
	goto badname;
}
if (isdigit((unsigned char)*--p)) {
444badname:
error("bad device attachment name `%s'", name);
return (&errdeva);
}
deva = ht_lookup(devatab, name);
if (deva == NULL((void *)0)) {
deva = emalloc(sizeof *deva);
deva->d_name = name;
deva->d_next = NULL((void *)0);
deva->d_bsame = NULL((void *)0);
deva->d_isdef = 0;
deva->d_devbase = NULL((void *)0);
deva->d_atlist = NULL((void *)0);
deva->d_attrs = NULL((void *)0);
deva->d_ihead = NULL((void *)0);
deva->d_ipp = &deva->d_ihead;
*nextdeva = deva;
nextdeva = &deva->d_next;
if (ht_insert(devatab, name, deva)ht_insrep(devatab, name, deva, 0))
	panic("getdeva(%s)", name);
}
return (deva);
466}

468/*
* Look up an attribute.
*/
471struct attr *
472getattr(const char *name)
473{
struct attr *a;

if ((a = ht_lookup(attrtab, name)) == NULL((void *)0)) {
error("undefined attribute `%s'", name);
a = &errattr;
}
return (a);
481}

483/*
* Set the major device number for a device, so that it can be used
* as a root/swap/dumps "on" device in a configuration.
*/
487void
488setmajor(struct devbase *d, int n)
489{

if (d != &errdev && d->d_major != nodev)
error("device `%s' is already major %d",
    d->d_name, d->d_major);
else
d->d_major = n;
496}

498static int
499exclude(struct nvlist *nv, const char *name, const char *what)
500{

if (nv != NULL((void *)0)) {
error("%s: swap generic must not specify %s", name, what);
return (1);
}
return (0);
507}

509/*
* Map things like "ra0b" => makedev(major("ra"), 0*maxpartitions + 'b'-'a').
* Handle the case where the device number is given but there is no
* corresponding name, and map NULL to the default.
*/
514static int
515resolve(struct nvlist **nvp, const char *name, const char *what,
  struct nvlist *dflt, int part)
517{
struct nvlist *nv;
struct devbase *dev;
const char *cp;
int maj, min, l;
int unit;
char buf[NAMESIZE100];

part -= 'a';
if ((part >= maxpartitions) || (part < 0))
panic("resolve");
if ((nv = *nvp) == NULL((void *)0)) {
dev_t	d = nodev;
/*
 * Apply default.  Easiest to do this by number.
 * Make sure to retain NODEVness, if this is dflt's disposition.
 */
if (dflt->nv_int != nodev) {
	maj = major(dflt->nv_int)(((unsigned)(dflt->nv_int) >> 8) & 0xff);
	min = (minor(dflt->nv_int)((unsigned)((dflt->nv_int) & 0xff) | (((dflt->nv_int
) & 0xffff0000) >> 8)) / maxpartitions) + part;
	d = makedev(maj, min)((dev_t)((((maj) & 0xff) << 8) | ((min) & 0xff)
 | (((min) & 0xffff00) << 8)));
}
*nvp = nv = newnv(NULL((void *)0), NULL((void *)0), NULL((void *)0), d, NULL((void *)0));
}
if (nv->nv_int != nodev) {
/*
 * By the numbers.  Find the appropriate major number
 * to make a name.
 */
maj = major(nv->nv_int)(((unsigned)(nv->nv_int) >> 8) & 0xff);
min = minor(nv->nv_int)((unsigned)((nv->nv_int) & 0xff) | (((nv->nv_int) &
 0xffff0000) >> 8));
for (dev = allbases; dev != NULL((void *)0); dev = dev->d_next)
	if (dev->d_major == maj)
		break;
if (dev == NULL((void *)0))
	(void)snprintf(buf, sizeof buf, "<%u/%u>",
	    maj, min);
else
	(void)snprintf(buf, sizeof buf, "%s%u%c",
	    dev->d_name, min / maxpartitions,
	    (min % maxpartitions) + 'a');
nv->nv_strnv_un.un_str = intern(buf);
return (0);
}

if (nv->nv_strnv_un.un_str == NULL((void *)0) || nv->nv_strnv_un.un_str == s_nfs)
/*
 * NFS spec. Leave as NODEV.
 */
return (0);

/*
* The normal case: things like "ra2b".  Check for partition
* suffix, remove it if there, and split into name ("ra") and
* unit (2).
*/
l = strlen(nv->nv_strnv_un.un_str);
cp = &nv->nv_strnv_un.un_str[l];
if (l > 1 && *--cp >= 'a' && *cp <= 'a'+maxpartitions &&
   isdigit((unsigned char)cp[-1])) {
l--;
part = *cp - 'a';
}
cp = nv->nv_strnv_un.un_str;
if (split(cp, l, buf, sizeof buf, &unit)) {
error("%s: invalid %s device name `%s'", name, what, cp);
return (1);
}
dev = ht_lookup(devbasetab, intern(buf));
if (dev == NULL((void *)0) || dev->d_major == nodev) {
error("%s: can't make %s device from `%s'",
    name, what, nv->nv_strnv_un.un_str);
return (1);
}
nv->nv_name = dev->d_name;
nv->nv_int = makedev(dev->d_major, unit * maxpartitions + part)((dev_t)((((dev->d_major) & 0xff) << 8) | ((unit
 * maxpartitions + part) & 0xff) | (((unit * maxpartitions
 + part) & 0xffff00) << 8)));
return (0);
594}

596static int
597lresolve(struct nvlist **nvp, const char *name, const char *what,
  struct nvlist *dflt, int part)
599{
int err;

while ((err = resolve(nvp, name, what, dflt, part)) == 0 &&
   (*nvp)->nv_next != NULL((void *)0))
nvp = &(*nvp)->nv_next;
return (err);
606}

608/*
* Add a completed configuration to the list.
*/
611void
612addconf(struct config *cf0)
613{
struct config *cf;
struct nvlist *nv;
const char *name;

name = cf0->cf_name;
cf = emalloc(sizeof *cf);
if (ht_insert(cfhashtab, name, cf)ht_insrep(cfhashtab, name, cf, 0)) {
error("configuration `%s' already defined", name);
free(cf);
goto bad;
}
*cf = *cf0;

/*
* Look for "swap generic".
*/
for (nv = cf->cf_swap; nv != NULL((void *)0); nv = nv->nv_next)
   if (nv->nv_strnv_un.un_str == s_generic)
break;
if (nv != NULL((void *)0)) {
/*
 * Make sure no root or dump device specified, and no
 * other swap devices.  Note single | here (check all).
 */
nv = cf->cf_swap;
if (exclude(cf->cf_root, name, "root device") |
    exclude(nv->nv_next, name, "additional swap devices") |
    exclude(cf->cf_dump, name, "dump device"))
	goto bad;
} else {
nv = cf->cf_root;
if (nv == NULL((void *)0)) {
	error("%s: no root device specified", name);
	goto bad;
}
if (resolve(&cf->cf_root, name, "root", nv, 'a') |
    lresolve(&cf->cf_swap, name, "swap", nv, 'b') |
    resolve(&cf->cf_dump, name, "dumps", nv, 'b'))
	goto bad;
}
*nextcf = cf;
nextcf = &cf->cf_next;
return;
657bad:
nvfreel(cf0->cf_root);
nvfreel(cf0->cf_swap);
nvfreel(cf0->cf_dump);
661}

663void
664setconf(struct nvlist **npp, const char *what, struct nvlist *v)
665{

if (*npp != NULL((void *)0)) {
error("duplicate %s specification", what);
nvfreel(v);
} else
*npp = v;
672}

674static struct devi *
675newdevi(const char *name, int unit, struct devbase *d)
676{
struct devi *i;

i = emalloc(sizeof *i);
i->i_name = name;
i->i_unit = unit;
i->i_base = d;
i->i_next = NULL((void *)0);
i->i_bsame = NULL((void *)0);
i->i_asame = NULL((void *)0);
i->i_alias = NULL((void *)0);
i->i_at = NULL((void *)0);
i->i_atattr = NULL((void *)0);
i->i_atdev = NULL((void *)0);
i->i_atdeva = NULL((void *)0);
i->i_locs = NULL((void *)0);
i->i_cfflags = 0;
i->i_cfindex = -1;
i->i_lineno = currentline();
if (unit >= d->d_umax)
d->d_umax = unit + 1;
return (i);
698}

700/*
* Enable an already declared but disabled device.
*/
703void
704enabledev(const char *name, const char *at)
705{
struct devbase *ib, *ab;
char atbuf[NAMESIZE100];
struct attr *attr;
struct nvlist *nv;
struct devi *i;
const char *cp;
int atunit;

i = ht_lookup(devitab, name);
if (i == NULL((void *)0)) {
error("invalid device `%s'", name);
return;
}
ib = i->i_base;

if (split(at, strlen(at), atbuf, sizeof atbuf, &atunit)) {
error("invalid attachment name `%s'", at);
return;
}
cp = intern(atbuf);
ab = ht_lookup(devbasetab, cp);
if (ab == NULL((void *)0)) {
error("invalid attachment device `%s'", cp);
return;
}
for (nv = ab->d_attrs; nv != NULL((void *)0); nv = nv->nv_next) {
attr = nv->nv_ptrnv_un.un_ptr;
if (onlist(attr->a_devs, ib))
	goto foundattachment;
}
error("%s's cannot attach to %s's", ib->d_name, atbuf);
return;

739foundattachment:
while (i && i->i_atdev != ab)
i = i->i_alias;
if (i == NULL((void *)0)) {
error("%s at %s not found", name, at);
return;
} else
i->i_disable = 0; /* Enable */
747}

749/*
* Add the named device as attaching to the named attribute (or perhaps
* another device instead) plus unit number.
*/
753void
754adddev(const char *name, const char *at, struct nvlist *loclist, int flags,
  int disable)
756{
struct devi *i;	/* the new instance */
struct attr *attr;	/* attribute that allows attach */
struct devbase *ib;	/* i->i_base */
struct devbase *ab;	/* not NULL => at another dev */
struct nvlist *nv;
struct deva *iba;	/* devbase attachment used */
const char *cp;
int atunit;
1
'atunit' declared without an initial value→
char atbuf[NAMESIZE100];
int hit;

ab = NULL((void *)0);
iba = NULL((void *)0);
if (at == NULL((void *)0)) {
2
←
Assuming 'at' is equal to NULL→
3
←
Taking true branch→
/* "at root" */
if ((i = getdevi(name)) == NULL((void *)0))
4
←
Assuming the condition is false→
5
←
Taking false branch→
	goto bad;
/*
 * Must warn about i_unit > 0 later, after taking care of
 * the STAR cases (we could do non-star's here but why
 * bother?).  Make sure this device can be at root.
 */
ib = i->i_base;
hit = 0;
for (iba = ib->d_ahead; iba != NULL((void *)0); iba = iba->d_bsame)
6
←
Assuming 'iba' is not equal to NULL→
7
←
Loop condition is true.  Entering loop body→
	if (onlist(iba->d_atlist, NULL((void *)0))) {
8
←
Assuming the condition is true→
9
←
Taking true branch→
		hit = 1;
		break;
10
←
 Execution continues on line 786→
	}
if (!hit10.1
'hit' is 1
) {
11
←
Taking false branch→
	error("%s's cannot attach to the root", ib->d_name);
	goto bad;
}
attr = &errattr;	/* a convenient "empty" attr */
} else {
if (split(at, strlen(at), atbuf, sizeof atbuf, &atunit)) {
	error("invalid attachment name `%s'", at);
	/* (void)getdevi(name); -- ??? */
	goto bad;
}
if ((i = getdevi(name)) == NULL((void *)0))
	goto bad;
ib = i->i_base;
cp = intern(atbuf);

/*
 * Devices can attach to two types of things: Attributes,
 * and other devices (which have the appropriate attributes
 * to allow attachment).
 *
 * (1) If we're attached to an attribute, then we don't need
 *     look at the parent base device to see what attributes
 *     it has, and make sure that we can attach to them.
 *
 * (2) If we're attached to a real device (i.e. named in
 *     the config file), we want to remember that so that
 *     at cross-check time, if the device we're attached to
 *     is missing but other devices which also provide the
 *     attribute are present, we don't get a false "OK."
 *
 * (3) If the thing we're attached to is an attribute
 *     but is actually named in the config file, we still
 *     have to remember its devbase.
 */

/* Figure out parent's devbase, to satisfy case (3). */
ab = ht_lookup(devbasetab, cp);

/* Find out if it's an attribute. */
attr = ht_lookup(attrtab, cp);

/* Make sure we're _really_ attached to the attr.  Case (1). */
if (attr != NULL((void *)0) && onlist(attr->a_devs, ib))
	goto findattachment;

/*
 * Else a real device, and not just an attribute.  Case (2).
 *
 * Have to work a bit harder to see whether we have
 * something like "tg0 at esp0" (where esp is merely
 * not an attribute) or "tg0 at nonesuch0" (where
 * nonesuch is not even a device).
 */
if (ab == NULL((void *)0)) {
	error("%s at %s: `%s' unknown",
	    name, at, atbuf);
	goto bad;
}

/*
 * See if the named parent carries an attribute
 * that allows it to supervise device ib.
 */
for (nv = ab->d_attrs; nv != NULL((void *)0); nv = nv->nv_next) {
	attr = nv->nv_ptrnv_un.un_ptr;
	if (onlist(attr->a_devs, ib))
		goto findattachment;
}
error("%s's cannot attach to %s's", ib->d_name, atbuf);
goto bad;

858findattachment:
/* find out which attachment it uses */
hit = 0;
for (iba = ib->d_ahead; iba != NULL((void *)0); iba = iba->d_bsame)
	if (onlist(iba->d_atlist, attr)) {
		hit = 1;
		break;
	}
if (!hit)
	panic("adddev: can't figure out attachment");
}
if ((i->i_locs = fixloc(name, attr, loclist)) == NULL((void *)0))
12
←
Assuming the condition is false→
13
←
Taking false branch→
goto bad;
i->i_at = at;
i->i_atattr = attr;
i->i_atdev = ab;
i->i_atdeva = iba;
i->i_atunit = atunit;
14
←
Assigned value is garbage or undefined
i->i_cfflags = flags;
i->i_disable = disable;

*iba->d_ipp = i;
iba->d_ipp = &i->i_asame;

selectbase(ib, iba);
/* all done, fall into ... */
884bad:
nvfreel(loclist);
return;
887}

889void
890addpseudo(const char *name, int number, int disable)
891{
struct devbase *d;
struct devi *i;

d = ht_lookup(devbasetab, name);
if (d == NULL((void *)0)) {
error("undefined pseudo-device %s", name);
return;
}
if (!d->d_ispseudo) {
error("%s is a real device, not a pseudo-device", name);
return;
}
if (ht_lookup(devitab, name) != NULL((void *)0)) {
warnx("warning: duplicate definition of `%s', will use latest definition", name);
d->d_umax = number;
return;
}
i = newdevi(name, number - 1, d);	/* foo 16 => "foo0..foo15" */
if (ht_insert(devitab, name, i)ht_insrep(devitab, name, i, 0))
panic("addpseudo(%s)", name);
i->i_disable = disable;
selectbase(d, NULL((void *)0));
*nextpseudo = i;
nextpseudo = &i->i_next;
npseudo++;
917}

919/*
* Define a new instance of a specific device.
*/
922static struct devi *
923getdevi(const char *name)
924{
struct devi *i, *firsti;
struct devbase *d;
int unit;
char base[NAMESIZE100];

if (split(name, strlen(name), base, sizeof base, &unit)) {
error("invalid device name `%s'", name);
return (NULL((void *)0));
}
d = ht_lookup(devbasetab, intern(base));
if (d == NULL((void *)0)) {
error("%s: unknown device `%s'", name, base);
return (NULL((void *)0));
}
if (d->d_ispseudo) {
error("%s: %s is a pseudo-device", name, base);
return (NULL((void *)0));
}
firsti = ht_lookup(devitab, name);
i = newdevi(name, unit, d);
if (firsti == NULL((void *)0)) {
if (ht_insert(devitab, name, i)ht_insrep(devitab, name, i, 0))
	panic("getdevi(%s)", name);
*d->d_ipp = i;
d->d_ipp = &i->i_bsame;
} else {
while (firsti->i_alias)
	firsti = firsti->i_alias;
firsti->i_alias = i;
}
*nextdevi = i;
nextdevi = &i->i_next;
ndevi++;
return (i);
959}

961static const char *
962concat(const char *name, int c)
963{
size_t len;
char buf[NAMESIZE100];

len = strlen(name);
if (len + 2 > sizeof(buf)) {
error("device name `%s%c' too long", name, c);
len = sizeof(buf) - 2;
}
bcopy(name, buf, len);
buf[len] = c;
buf[len + 1] = 0;
return (intern(buf));
976}

978const char *
979starref(const char *name)
980{

return (concat(name, '*'));
983}

985const char *
986wildref(const char *name)
987{

return (concat(name, '?'));
990}

992/*
* Split a name like "foo0" into base name (foo) and unit number (0).
* Return 0 on success.  To make this useful for names like "foo0a",
* the length of the "foo0" part is one of the arguments.
*/
997static int
998split(const char *name, size_t nlen, char *base, size_t bsize, int *aunit)
999{
const char *cp;
int c;
size_t l;

l = nlen;
if (l < 2 || l >= bsize || isdigit((unsigned char)*name))
return (1);
c = (u_char)name[--l];
if (!isdigit((unsigned char)c)) {
if (c == '*')
	*aunit = STAR(-1);
else if (c == '?')
	*aunit = WILD(-2);
else
	return (1);
} else {
cp = &name[l];
while (isdigit((unsigned char)cp[-1]))
	l--, cp--;
*aunit = atoi(cp);
}
bcopy(name, base, l);
base[l] = 0;
return (0);
1024}

1026/*
* We have an instance of the base foo, so select it and all its
* attributes for "optional foo".
*/
1030static void
1031selectbase(struct devbase *d, struct deva *da)
1032{
struct attr *a;
struct nvlist *nv;

(void)ht_insert(selecttab, d->d_name, (char *)d->d_name)ht_insrep(selecttab, d->d_name, (char *)d->d_name, 0);
for (nv = d->d_attrs; nv != NULL((void *)0); nv = nv->nv_next) {
a = nv->nv_ptrnv_un.un_ptr;
(void)ht_insert(selecttab, a->a_name, (char *)a->a_name)ht_insrep(selecttab, a->a_name, (char *)a->a_name, 0);
}
if (da != NULL((void *)0)) {
(void)ht_insert(selecttab, da->d_name, (char *)da->d_name)ht_insrep(selecttab, da->d_name, (char *)da->d_name, 0);
for (nv = da->d_attrs; nv != NULL((void *)0); nv = nv->nv_next) {
	a = nv->nv_ptrnv_un.un_ptr;
	(void)ht_insert(selecttab, a->a_name,ht_insrep(selecttab, a->a_name, (char *)a->a_name, 0)
	    (char *)a->a_name)ht_insrep(selecttab, a->a_name, (char *)a->a_name, 0);
}
}
1049}

1051/*
* Is the given pointer on the given list of pointers?
*/
1054static int
1055onlist(struct nvlist *nv, void *ptr)
1056{
for (; nv != NULL((void *)0); nv = nv->nv_next)
if (nv->nv_ptrnv_un.un_ptr == ptr)
	return (1);
return (0);
1061}

1063static char *
1064extend(char *p, const char *name)
1065{
int l;

l = strlen(name);
bcopy(name, p, l);
p += l;
*p++ = ',';
*p++ = ' ';
return (p);
1074}

1076/*
* Check that we got all required locators, and default any that are
* given as "?" and have defaults.  Return 0 on success.
*/
1080static const char **
1081fixloc(const char *name, struct attr *attr, struct nvlist *got)
1082{
struct nvlist *m, *n;
int ord;
const char **lp;
int nmissing, nextra, nnodefault;
char *mp, *ep, *ndp;
char missing[1000], extra[1000], nodefault[1000];
static const char *nullvec[1];

/*
* Look for all required locators, and number the given ones
* according to the required order.  While we are numbering,
* set default values for defaulted locators.
*/
if (attr->a_loclen == 0)	/* e.g., "at root" */
lp = nullvec;
else
lp = ereallocarray(NULL((void *)0), attr->a_loclen + 1, 
    sizeof(const char *));
for (n = got; n != NULL((void *)0); n = n->nv_next)
n->nv_int = -1;
nmissing = 0;
mp = missing;
/* yes, this is O(mn), but m and n should be small */
for (ord = 0, m = attr->a_locs; m != NULL((void *)0); m = m->nv_next, ord++) {
for (n = got; n != NULL((void *)0); n = n->nv_next) {
	if (n->nv_name == m->nv_name) {
		n->nv_int = ord;
		break;
	}
}
if (n == NULL((void *)0) && m->nv_int == 0) {
	nmissing++;
	mp = extend(mp, m->nv_name);
}
lp[ord] = m->nv_strnv_un.un_str;
}
if (ord != attr->a_loclen)
panic("fixloc");
lp[ord] = NULL((void *)0);
nextra = 0;
ep = extra;
nnodefault = 0;
ndp = nodefault;
for (n = got; n != NULL((void *)0); n = n->nv_next) {
if (n->nv_int >= 0) {
	if (n->nv_strnv_un.un_str != NULL((void *)0))
		lp[n->nv_int] = n->nv_strnv_un.un_str;
	else if (lp[n->nv_int] == NULL((void *)0)) {
		nnodefault++;
		ndp = extend(ndp, n->nv_name);
	}
} else {
	nextra++;
	ep = extend(ep, n->nv_name);
}
}
if (nextra) {
ep[-2] = 0;	/* kill ", " */
error("%s: extraneous locator%s: %s",
    name, nextra > 1 ? "s" : "", extra);
}
if (nmissing) {
mp[-2] = 0;
error("%s: must specify %s", name, missing);
}
if (nnodefault) {
ndp[-2] = 0;
error("%s: cannot wildcard %s", name, nodefault);
}
if (nmissing || nnodefault) {
free(lp);
lp = NULL((void *)0);
}
return (lp);
1157}