1/*	$NetBSD: getcap.c,v 1.29 1999/03/29 09:27:29 abs Exp $	*/
2
3/*-
4 * Copyright (c) 1992, 1993
5 *	The Regents of the University of California.  All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Casey Leedom of Lawrence Livermore National Laboratory.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 *    may be used to endorse or promote products derived from this software
20 *    without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35#ifdef HAVE_CONFIG_H
36#include <config.h>
37#endif
38#include "roken.h"
39RCSID("$Id: getcap.c 22071 2007-11-14 20:04:50Z lha $");
40
41#include <sys/types.h>
42#include <ctype.h>
43#if defined(HAVE_DB_185_H)
44#include <db_185.h>
45#elif defined(HAVE_DB_H)
46#include <db.h>
47#endif
48#include <errno.h>
49#include <fcntl.h>
50#include <limits.h>
51#include <stdio.h>
52#include <stdlib.h>
53#include <string.h>
54#include <unistd.h>
55
56#define	BFRAG		1024
57#if 0
58#define	BSIZE		1024
59#endif
60#define	ESC		('[' & 037)	/* ASCII ESC */
61#define	MAX_RECURSION	32		/* maximum getent recursion */
62#define	SFRAG		100		/* cgetstr mallocs in SFRAG chunks */
63
64#define RECOK	(char)0
65#define TCERR	(char)1
66#define	SHADOW	(char)2
67
68static size_t	 topreclen;	/* toprec length */
69static char	*toprec;	/* Additional record specified by cgetset() */
70static int	 gottoprec;	/* Flag indicating retrieval of toprecord */
71
72#if 0 /*
73       * Don't use db support unless it's build into libc but we don't
74       * check for that now, so just disable the code.
75       */
76#if defined(HAVE_DBOPEN) && defined(HAVE_DB_H)
77#define USE_DB
78#endif
79#endif
80
81#ifdef USE_DB
82static int	cdbget (DB *, char **, const char *);
83#endif
84static int 	getent (char **, size_t *, char **, int, const char *, int, char *);
85static int	nfcmp (char *, char *);
86
87
88int ROKEN_LIB_FUNCTION cgetset(const char *ent);
89char *ROKEN_LIB_FUNCTION cgetcap(char *buf, const char *cap, int type);
90int ROKEN_LIB_FUNCTION cgetent(char **buf, char **db_array, const char *name);
91int ROKEN_LIB_FUNCTION cgetmatch(const char *buf, const char *name);
92int ROKEN_LIB_FUNCTION cgetclose(void);
93#if 0
94int cgetfirst(char **buf, char **db_array);
95int cgetnext(char **bp, char **db_array);
96#endif
97int ROKEN_LIB_FUNCTION cgetstr(char *buf, const char *cap, char **str);
98int ROKEN_LIB_FUNCTION cgetustr(char *buf, const char *cap, char **str);
99int ROKEN_LIB_FUNCTION cgetnum(char *buf, const char *cap, long *num);
100/*
101 * Cgetset() allows the addition of a user specified buffer to be added
102 * to the database array, in effect "pushing" the buffer on top of the
103 * virtual database. 0 is returned on success, -1 on failure.
104 */
105int ROKEN_LIB_FUNCTION
106cgetset(const char *ent)
107{
108    const char *source, *check;
109    char *dest;
110
111    if (ent == NULL) {
112	if (toprec)
113	    free(toprec);
114	toprec = NULL;
115	topreclen = 0;
116	return (0);
117    }
118    topreclen = strlen(ent);
119    if ((toprec = malloc (topreclen + 1)) == NULL) {
120	errno = ENOMEM;
121	return (-1);
122    }
123    gottoprec = 0;
124
125    source=ent;
126    dest=toprec;
127    while (*source) { /* Strip whitespace */
128	*dest++ = *source++; /* Do not check first field */
129	while (*source == ':') {
130	    check=source+1;
131	    while (*check && (isspace((unsigned char)*check) ||
132			      (*check=='\\' && isspace((unsigned char)check[1]))))
133		++check;
134	    if( *check == ':' )
135		source=check;
136	    else
137		break;
138
139	}
140    }
141    *dest=0;
142
143    return (0);
144}
145
146/*
147 * Cgetcap searches the capability record buf for the capability cap with
148 * type `type'.  A pointer to the value of cap is returned on success, NULL
149 * if the requested capability couldn't be found.
150 *
151 * Specifying a type of ':' means that nothing should follow cap (:cap:).
152 * In this case a pointer to the terminating ':' or NUL will be returned if
153 * cap is found.
154 *
155 * If (cap, '@') or (cap, terminator, '@') is found before (cap, terminator)
156 * return NULL.
157 */
158char * ROKEN_LIB_FUNCTION
159cgetcap(char *buf, const char *cap, int type)
160{
161    char *bp;
162    const char *cp;
163
164    bp = buf;
165    for (;;) {
166	/*
167	 * Skip past the current capability field - it's either the
168	 * name field if this is the first time through the loop, or
169	 * the remainder of a field whose name failed to match cap.
170	 */
171	for (;;)
172	    if (*bp == '\0')
173		return (NULL);
174	    else
175		if (*bp++ == ':')
176		    break;
177
178	/*
179	 * Try to match (cap, type) in buf.
180	 */
181	for (cp = cap; *cp == *bp && *bp != '\0'; cp++, bp++)
182	    continue;
183	if (*cp != '\0')
184	    continue;
185	if (*bp == '@')
186	    return (NULL);
187	if (type == ':') {
188	    if (*bp != '\0' && *bp != ':')
189		continue;
190	    return(bp);
191	}
192	if (*bp != type)
193	    continue;
194	bp++;
195	return (*bp == '@' ? NULL : bp);
196    }
197    /* NOTREACHED */
198}
199
200/*
201 * Cgetent extracts the capability record name from the NULL terminated file
202 * array db_array and returns a pointer to a malloc'd copy of it in buf.
203 * Buf must be retained through all subsequent calls to cgetcap, cgetnum,
204 * cgetflag, and cgetstr, but may then be free'd.  0 is returned on success,
205 * -1 if the requested record couldn't be found, -2 if a system error was
206 * encountered (couldn't open/read a file, etc.), and -3 if a potential
207 * reference loop is detected.
208 */
209int ROKEN_LIB_FUNCTION
210cgetent(char **buf, char **db_array, const char *name)
211{
212    size_t dummy;
213
214    return (getent(buf, &dummy, db_array, -1, name, 0, NULL));
215}
216
217/*
218 * Getent implements the functions of cgetent.  If fd is non-negative,
219 * *db_array has already been opened and fd is the open file descriptor.  We
220 * do this to save time and avoid using up file descriptors for tc=
221 * recursions.
222 *
223 * Getent returns the same success/failure codes as cgetent.  On success, a
224 * pointer to a malloc'ed capability record with all tc= capabilities fully
225 * expanded and its length (not including trailing ASCII NUL) are left in
226 * *cap and *len.
227 *
228 * Basic algorithm:
229 *	+ Allocate memory incrementally as needed in chunks of size BFRAG
230 *	  for capability buffer.
231 *	+ Recurse for each tc=name and interpolate result.  Stop when all
232 *	  names interpolated, a name can't be found, or depth exceeds
233 *	  MAX_RECURSION.
234 */
235static int
236getent(char **cap, size_t *len, char **db_array, int fd,
237       const char *name, int depth, char *nfield)
238{
239    char *r_end, *rp = NULL, **db_p;	/* pacify gcc */
240    int myfd = 0, eof, foundit;
241    char *record;
242    int tc_not_resolved;
243
244    /*
245     * Return with ``loop detected'' error if we've recursed more than
246     * MAX_RECURSION times.
247     */
248    if (depth > MAX_RECURSION)
249	return (-3);
250
251    /*
252     * Check if we have a top record from cgetset().
253     */
254    if (depth == 0 && toprec != NULL && cgetmatch(toprec, name) == 0) {
255	size_t len = topreclen + BFRAG;
256	if ((record = malloc (len)) == NULL) {
257	    errno = ENOMEM;
258	    return (-2);
259	}
260	(void)strlcpy(record, toprec, len);
261	db_p = db_array;
262	rp = record + topreclen + 1;
263	r_end = rp + BFRAG;
264	goto tc_exp;
265    }
266    /*
267     * Allocate first chunk of memory.
268     */
269    if ((record = malloc(BFRAG)) == NULL) {
270	errno = ENOMEM;
271	return (-2);
272    }
273    r_end = record + BFRAG;
274    foundit = 0;
275    /*
276     * Loop through database array until finding the record.
277     */
278
279    for (db_p = db_array; *db_p != NULL; db_p++) {
280	eof = 0;
281
282	/*
283	 * Open database if not already open.
284	 */
285
286	if (fd >= 0) {
287	    (void)lseek(fd, (off_t)0, SEEK_SET);
288	} else {
289#ifdef USE_DB
290	    char pbuf[_POSIX_PATH_MAX];
291	    char *cbuf;
292	    size_t clen;
293	    int retval;
294	    DB *capdbp;
295
296	    (void)snprintf(pbuf, sizeof(pbuf), "%s.db", *db_p);
297	    if ((capdbp = dbopen(pbuf, O_RDONLY, 0, DB_HASH, 0))
298		!= NULL) {
299		free(record);
300		retval = cdbget(capdbp, &record, name);
301		if (retval < 0) {
302		    /* no record available */
303		    (void)capdbp->close(capdbp);
304		    return (retval);
305		}
306				/* save the data; close frees it */
307		clen = strlen(record);
308		cbuf = malloc(clen + 1);
309		if (cbuf == NULL)
310		    return (-2);
311		memmove(cbuf, record, clen + 1);
312		if (capdbp->close(capdbp) < 0) {
313		    free(cbuf);
314		    return (-2);
315		}
316		*len = clen;
317		*cap = cbuf;
318		return (retval);
319	    } else
320#endif
321	    {
322		fd = open(*db_p, O_RDONLY, 0);
323		if (fd < 0) {
324		    /* No error on unfound file. */
325		    continue;
326		}
327		myfd = 1;
328	    }
329	}
330	/*
331	 * Find the requested capability record ...
332	 */
333	{
334	    char buf[BUFSIZ];
335	    char *b_end, *bp, *cp;
336	    int c, slash;
337
338	    /*
339	     * Loop invariants:
340	     *	There is always room for one more character in record.
341	     *	R_end always points just past end of record.
342	     *	Rp always points just past last character in record.
343	     *	B_end always points just past last character in buf.
344	     *	Bp always points at next character in buf.
345	     *	Cp remembers where the last colon was.
346	     */
347	    b_end = buf;
348	    bp = buf;
349	    cp = 0;
350	    slash = 0;
351	    for (;;) {
352
353		/*
354		 * Read in a line implementing (\, newline)
355		 * line continuation.
356		 */
357		rp = record;
358		for (;;) {
359		    if (bp >= b_end) {
360			int n;
361
362			n = read(fd, buf, sizeof(buf));
363			if (n <= 0) {
364			    if (myfd)
365				(void)close(fd);
366			    if (n < 0) {
367				free(record);
368				return (-2);
369			    } else {
370				fd = -1;
371				eof = 1;
372				break;
373			    }
374			}
375			b_end = buf+n;
376			bp = buf;
377		    }
378
379		    c = *bp++;
380		    if (c == '\n') {
381			if (slash) {
382			    slash = 0;
383			    rp--;
384			    continue;
385			} else
386			    break;
387		    }
388		    if (slash) {
389			slash = 0;
390			cp = 0;
391		    }
392		    if (c == ':') {
393			/*
394			 * If the field was `empty' (i.e.
395			 * contained only white space), back up
396			 * to the colon (eliminating the
397			 * field).
398			 */
399			if (cp)
400			    rp = cp;
401			else
402			    cp = rp;
403		    } else if (c == '\\') {
404			slash = 1;
405		    } else if (c != ' ' && c != '\t') {
406			/*
407			 * Forget where the colon was, as this
408			 * is not an empty field.
409			 */
410			cp = 0;
411		    }
412		    *rp++ = c;
413
414				/*
415				 * Enforce loop invariant: if no room
416				 * left in record buffer, try to get
417				 * some more.
418				 */
419		    if (rp >= r_end) {
420			u_int pos;
421			size_t newsize;
422
423			pos = rp - record;
424			newsize = r_end - record + BFRAG;
425			record = realloc(record, newsize);
426			if (record == NULL) {
427			    errno = ENOMEM;
428			    if (myfd)
429				(void)close(fd);
430			    return (-2);
431			}
432			r_end = record + newsize;
433			rp = record + pos;
434		    }
435		}
436		/* Eliminate any white space after the last colon. */
437		if (cp)
438		    rp = cp + 1;
439		/* Loop invariant lets us do this. */
440		*rp++ = '\0';
441
442		/*
443		 * If encountered eof check next file.
444		 */
445		if (eof)
446		    break;
447
448		/*
449		 * Toss blank lines and comments.
450		 */
451		if (*record == '\0' || *record == '#')
452		    continue;
453
454		/*
455		 * See if this is the record we want ...
456		 */
457		if (cgetmatch(record, name) == 0) {
458		    if (nfield == NULL || !nfcmp(nfield, record)) {
459			foundit = 1;
460			break;	/* found it! */
461		    }
462		}
463	    }
464	}
465	if (foundit)
466	    break;
467    }
468
469    if (!foundit)
470	return (-1);
471
472    /*
473     * Got the capability record, but now we have to expand all tc=name
474     * references in it ...
475     */
476 tc_exp:	{
477	char *newicap, *s;
478	size_t ilen, newilen;
479	int diff, iret, tclen;
480	char *icap, *scan, *tc, *tcstart, *tcend;
481
482	/*
483	 * Loop invariants:
484	 *	There is room for one more character in record.
485	 *	R_end points just past end of record.
486	 *	Rp points just past last character in record.
487	 *	Scan points at remainder of record that needs to be
488	 *	scanned for tc=name constructs.
489	 */
490	scan = record;
491	tc_not_resolved = 0;
492	for (;;) {
493	    if ((tc = cgetcap(scan, "tc", '=')) == NULL)
494		break;
495
496	    /*
497	     * Find end of tc=name and stomp on the trailing `:'
498	     * (if present) so we can use it to call ourselves.
499	     */
500	    s = tc;
501	    for (;;)
502		if (*s == '\0')
503		    break;
504		else
505		    if (*s++ == ':') {
506			*(s - 1) = '\0';
507			break;
508		    }
509	    tcstart = tc - 3;
510	    tclen = s - tcstart;
511	    tcend = s;
512
513	    iret = getent(&icap, &ilen, db_p, fd, tc, depth+1,
514			  NULL);
515	    newicap = icap;		/* Put into a register. */
516	    newilen = ilen;
517	    if (iret != 0) {
518				/* an error */
519		if (iret < -1) {
520		    if (myfd)
521			(void)close(fd);
522		    free(record);
523		    return (iret);
524		}
525		if (iret == 1)
526		    tc_not_resolved = 1;
527				/* couldn't resolve tc */
528		if (iret == -1) {
529		    *(s - 1) = ':';
530		    scan = s - 1;
531		    tc_not_resolved = 1;
532		    continue;
533
534		}
535	    }
536	    /* not interested in name field of tc'ed record */
537	    s = newicap;
538	    for (;;)
539		if (*s == '\0')
540		    break;
541		else
542		    if (*s++ == ':')
543			break;
544	    newilen -= s - newicap;
545	    newicap = s;
546
547	    /* make sure interpolated record is `:'-terminated */
548	    s += newilen;
549	    if (*(s-1) != ':') {
550		*s = ':';	/* overwrite NUL with : */
551		newilen++;
552	    }
553
554	    /*
555	     * Make sure there's enough room to insert the
556	     * new record.
557	     */
558	    diff = newilen - tclen;
559	    if (diff >= r_end - rp) {
560		u_int pos, tcpos, tcposend;
561		size_t newsize;
562
563		pos = rp - record;
564		newsize = r_end - record + diff + BFRAG;
565		tcpos = tcstart - record;
566		tcposend = tcend - record;
567		record = realloc(record, newsize);
568		if (record == NULL) {
569		    errno = ENOMEM;
570		    if (myfd)
571			(void)close(fd);
572		    free(icap);
573		    return (-2);
574		}
575		r_end = record + newsize;
576		rp = record + pos;
577		tcstart = record + tcpos;
578		tcend = record + tcposend;
579	    }
580
581	    /*
582	     * Insert tc'ed record into our record.
583	     */
584	    s = tcstart + newilen;
585	    memmove(s, tcend,  (size_t)(rp - tcend));
586	    memmove(tcstart, newicap, newilen);
587	    rp += diff;
588	    free(icap);
589
590	    /*
591	     * Start scan on `:' so next cgetcap works properly
592	     * (cgetcap always skips first field).
593	     */
594	    scan = s-1;
595	}
596
597    }
598    /*
599     * Close file (if we opened it), give back any extra memory, and
600     * return capability, length and success.
601     */
602    if (myfd)
603	(void)close(fd);
604    *len = rp - record - 1;	/* don't count NUL */
605    if (r_end > rp)
606	if ((record =
607	     realloc(record, (size_t)(rp - record))) == NULL) {
608	    errno = ENOMEM;
609	    return (-2);
610	}
611
612    *cap = record;
613    if (tc_not_resolved)
614	return (1);
615    return (0);
616}
617
618#ifdef USE_DB
619static int
620cdbget(DB *capdbp, char **bp, const char *name)
621{
622	DBT key;
623	DBT data;
624
625	/* LINTED key is not modified */
626	key.data = (char *)name;
627	key.size = strlen(name);
628
629	for (;;) {
630		/* Get the reference. */
631		switch(capdbp->get(capdbp, &key, &data, 0)) {
632		case -1:
633			return (-2);
634		case 1:
635			return (-1);
636		}
637
638		/* If not an index to another record, leave. */
639		if (((char *)data.data)[0] != SHADOW)
640			break;
641
642		key.data = (char *)data.data + 1;
643		key.size = data.size - 1;
644	}
645
646	*bp = (char *)data.data + 1;
647	return (((char *)(data.data))[0] == TCERR ? 1 : 0);
648}
649#endif /* USE_DB */
650
651/*
652 * Cgetmatch will return 0 if name is one of the names of the capability
653 * record buf, -1 if not.
654 */
655int
656cgetmatch(const char *buf, const char *name)
657{
658    const char *np, *bp;
659
660    /*
661     * Start search at beginning of record.
662     */
663    bp = buf;
664    for (;;) {
665	/*
666	 * Try to match a record name.
667	 */
668	np = name;
669	for (;;)
670	    if (*np == '\0') {
671		if (*bp == '|' || *bp == ':' || *bp == '\0')
672		    return (0);
673		else
674		    break;
675	    } else
676		if (*bp++ != *np++)
677		    break;
678
679	/*
680	 * Match failed, skip to next name in record.
681	 */
682	bp--;	/* a '|' or ':' may have stopped the match */
683	for (;;)
684	    if (*bp == '\0' || *bp == ':')
685		return (-1);	/* match failed totally */
686	    else
687		if (*bp++ == '|')
688		    break;	/* found next name */
689    }
690}
691
692#if 0
693int
694cgetfirst(char **buf, char **db_array)
695{
696    (void)cgetclose();
697    return (cgetnext(buf, db_array));
698}
699#endif
700
701static FILE *pfp;
702static int slash;
703static char **dbp;
704
705int ROKEN_LIB_FUNCTION
706cgetclose(void)
707{
708    if (pfp != NULL) {
709	(void)fclose(pfp);
710	pfp = NULL;
711    }
712    dbp = NULL;
713    gottoprec = 0;
714    slash = 0;
715    return(0);
716}
717
718#if 0
719/*
720 * Cgetnext() gets either the first or next entry in the logical database
721 * specified by db_array.  It returns 0 upon completion of the database, 1
722 * upon returning an entry with more remaining, and -1 if an error occurs.
723 */
724int
725cgetnext(char **bp, char **db_array)
726{
727    size_t len;
728    int status, done;
729    char *cp, *line, *rp, *np, buf[BSIZE], nbuf[BSIZE];
730    size_t dummy;
731
732    if (dbp == NULL)
733	dbp = db_array;
734
735    if (pfp == NULL && (pfp = fopen(*dbp, "r")) == NULL) {
736	(void)cgetclose();
737	return (-1);
738    }
739    for(;;) {
740	if (toprec && !gottoprec) {
741	    gottoprec = 1;
742	    line = toprec;
743	} else {
744	    line = fgetln(pfp, &len);
745	    if (line == NULL && pfp) {
746		if (ferror(pfp)) {
747		    (void)cgetclose();
748		    return (-1);
749		} else {
750		    (void)fclose(pfp);
751		    pfp = NULL;
752		    if (*++dbp == NULL) {
753			(void)cgetclose();
754			return (0);
755		    } else if ((pfp =
756				fopen(*dbp, "r")) == NULL) {
757			(void)cgetclose();
758			return (-1);
759		    } else
760			continue;
761		}
762	    } else
763		line[len - 1] = '\0';
764	    if (len == 1) {
765		slash = 0;
766		continue;
767	    }
768	    if (isspace((unsigned char)*line) ||
769		*line == ':' || *line == '#' || slash) {
770		if (line[len - 2] == '\\')
771		    slash = 1;
772		else
773		    slash = 0;
774		continue;
775	    }
776	    if (line[len - 2] == '\\')
777		slash = 1;
778	    else
779		slash = 0;
780	}
781
782
783	/*
784	 * Line points to a name line.
785	 */
786	done = 0;
787	np = nbuf;
788	for (;;) {
789	    for (cp = line; *cp != '\0'; cp++) {
790		if (*cp == ':') {
791		    *np++ = ':';
792		    done = 1;
793		    break;
794		}
795		if (*cp == '\\')
796		    break;
797		*np++ = *cp;
798	    }
799	    if (done) {
800		*np = '\0';
801		break;
802	    } else { /* name field extends beyond the line */
803		line = fgetln(pfp, &len);
804		if (line == NULL && pfp) {
805		    if (ferror(pfp)) {
806			(void)cgetclose();
807			return (-1);
808		    }
809		    (void)fclose(pfp);
810		    pfp = NULL;
811		    *np = '\0';
812		    break;
813		} else
814		    line[len - 1] = '\0';
815	    }
816	}
817	rp = buf;
818	for(cp = nbuf; *cp != '\0'; cp++)
819	    if (*cp == '|' || *cp == ':')
820		break;
821	    else
822		*rp++ = *cp;
823
824	*rp = '\0';
825	/*
826	 * XXX
827	 * Last argument of getent here should be nbuf if we want true
828	 * sequential access in the case of duplicates.
829	 * With NULL, getent will return the first entry found
830	 * rather than the duplicate entry record.  This is a
831	 * matter of semantics that should be resolved.
832	 */
833	status = getent(bp, &dummy, db_array, -1, buf, 0, NULL);
834	if (status == -2 || status == -3)
835	    (void)cgetclose();
836
837	return (status + 1);
838    }
839    /* NOTREACHED */
840}
841#endif
842
843/*
844 * Cgetstr retrieves the value of the string capability cap from the
845 * capability record pointed to by buf.  A pointer to a decoded, NUL
846 * terminated, malloc'd copy of the string is returned in the char *
847 * pointed to by str.  The length of the string not including the trailing
848 * NUL is returned on success, -1 if the requested string capability
849 * couldn't be found, -2 if a system error was encountered (storage
850 * allocation failure).
851 */
852int ROKEN_LIB_FUNCTION
853cgetstr(char *buf, const char *cap, char **str)
854{
855    u_int m_room;
856    const char *bp;
857    char *mp;
858    int len;
859    char *mem;
860
861    /*
862     * Find string capability cap
863     */
864    bp = cgetcap(buf, cap, '=');
865    if (bp == NULL)
866	return (-1);
867
868    /*
869     * Conversion / storage allocation loop ...  Allocate memory in
870     * chunks SFRAG in size.
871     */
872    if ((mem = malloc(SFRAG)) == NULL) {
873	errno = ENOMEM;
874	return (-2);	/* couldn't even allocate the first fragment */
875    }
876    m_room = SFRAG;
877    mp = mem;
878
879    while (*bp != ':' && *bp != '\0') {
880	/*
881	 * Loop invariants:
882	 *	There is always room for one more character in mem.
883	 *	Mp always points just past last character in mem.
884	 *	Bp always points at next character in buf.
885	 */
886	if (*bp == '^') {
887	    bp++;
888	    if (*bp == ':' || *bp == '\0')
889		break;	/* drop unfinished escape */
890	    *mp++ = *bp++ & 037;
891	} else if (*bp == '\\') {
892	    bp++;
893	    if (*bp == ':' || *bp == '\0')
894		break;	/* drop unfinished escape */
895	    if ('0' <= *bp && *bp <= '7') {
896		int n, i;
897
898		n = 0;
899		i = 3;	/* maximum of three octal digits */
900		do {
901		    n = n * 8 + (*bp++ - '0');
902		} while (--i && '0' <= *bp && *bp <= '7');
903		*mp++ = n;
904	    }
905	    else switch (*bp++) {
906	    case 'b': case 'B':
907		*mp++ = '\b';
908		break;
909	    case 't': case 'T':
910		*mp++ = '\t';
911		break;
912	    case 'n': case 'N':
913		*mp++ = '\n';
914		break;
915	    case 'f': case 'F':
916		*mp++ = '\f';
917		break;
918	    case 'r': case 'R':
919		*mp++ = '\r';
920		break;
921	    case 'e': case 'E':
922		*mp++ = ESC;
923		break;
924	    case 'c': case 'C':
925		*mp++ = ':';
926		break;
927	    default:
928		/*
929		 * Catches '\', '^', and
930		 *  everything else.
931		 */
932		*mp++ = *(bp-1);
933		break;
934	    }
935	} else
936	    *mp++ = *bp++;
937	m_room--;
938
939	/*
940	 * Enforce loop invariant: if no room left in current
941	 * buffer, try to get some more.
942	 */
943	if (m_room == 0) {
944	    size_t size = mp - mem;
945
946	    if ((mem = realloc(mem, size + SFRAG)) == NULL)
947		return (-2);
948	    m_room = SFRAG;
949	    mp = mem + size;
950	}
951    }
952    *mp++ = '\0';	/* loop invariant let's us do this */
953    m_room--;
954    len = mp - mem - 1;
955
956    /*
957     * Give back any extra memory and return value and success.
958     */
959    if (m_room != 0)
960	if ((mem = realloc(mem, (size_t)(mp - mem))) == NULL)
961	    return (-2);
962    *str = mem;
963    return (len);
964}
965
966/*
967 * Cgetustr retrieves the value of the string capability cap from the
968 * capability record pointed to by buf.  The difference between cgetustr()
969 * and cgetstr() is that cgetustr does not decode escapes but rather treats
970 * all characters literally.  A pointer to a  NUL terminated malloc'd
971 * copy of the string is returned in the char pointed to by str.  The
972 * length of the string not including the trailing NUL is returned on success,
973 * -1 if the requested string capability couldn't be found, -2 if a system
974 * error was encountered (storage allocation failure).
975 */
976int ROKEN_LIB_FUNCTION
977cgetustr(char *buf, const char *cap, char **str)
978{
979    u_int m_room;
980    const char *bp;
981    char *mp;
982    int len;
983    char *mem;
984
985    /*
986     * Find string capability cap
987     */
988    if ((bp = cgetcap(buf, cap, '=')) == NULL)
989	return (-1);
990
991    /*
992     * Conversion / storage allocation loop ...  Allocate memory in
993     * chunks SFRAG in size.
994     */
995    if ((mem = malloc(SFRAG)) == NULL) {
996	errno = ENOMEM;
997	return (-2);	/* couldn't even allocate the first fragment */
998    }
999    m_room = SFRAG;
1000    mp = mem;
1001
1002    while (*bp != ':' && *bp != '\0') {
1003	/*
1004	 * Loop invariants:
1005	 *	There is always room for one more character in mem.
1006	 *	Mp always points just past last character in mem.
1007	 *	Bp always points at next character in buf.
1008	 */
1009	*mp++ = *bp++;
1010	m_room--;
1011
1012	/*
1013	 * Enforce loop invariant: if no room left in current
1014	 * buffer, try to get some more.
1015	 */
1016	if (m_room == 0) {
1017	    size_t size = mp - mem;
1018
1019	    if ((mem = realloc(mem, size + SFRAG)) == NULL)
1020		return (-2);
1021	    m_room = SFRAG;
1022	    mp = mem + size;
1023	}
1024    }
1025    *mp++ = '\0';	/* loop invariant let's us do this */
1026    m_room--;
1027    len = mp - mem - 1;
1028
1029    /*
1030     * Give back any extra memory and return value and success.
1031     */
1032    if (m_room != 0)
1033	if ((mem = realloc(mem, (size_t)(mp - mem))) == NULL)
1034	    return (-2);
1035    *str = mem;
1036    return (len);
1037}
1038
1039/*
1040 * Cgetnum retrieves the value of the numeric capability cap from the
1041 * capability record pointed to by buf.  The numeric value is returned in
1042 * the long pointed to by num.  0 is returned on success, -1 if the requested
1043 * numeric capability couldn't be found.
1044 */
1045int ROKEN_LIB_FUNCTION
1046cgetnum(char *buf, const char *cap, long *num)
1047{
1048    long n;
1049    int base, digit;
1050    const char *bp;
1051
1052    /*
1053     * Find numeric capability cap
1054     */
1055    bp = cgetcap(buf, cap, '#');
1056    if (bp == NULL)
1057	return (-1);
1058
1059    /*
1060     * Look at value and determine numeric base:
1061     *	0x... or 0X...	hexadecimal,
1062     * else	0...		octal,
1063     * else			decimal.
1064     */
1065    if (*bp == '0') {
1066	bp++;
1067	if (*bp == 'x' || *bp == 'X') {
1068	    bp++;
1069	    base = 16;
1070	} else
1071	    base = 8;
1072    } else
1073	base = 10;
1074
1075    /*
1076     * Conversion loop ...
1077     */
1078    n = 0;
1079    for (;;) {
1080	if ('0' <= *bp && *bp <= '9')
1081	    digit = *bp - '0';
1082	else if ('a' <= *bp && *bp <= 'f')
1083	    digit = 10 + *bp - 'a';
1084	else if ('A' <= *bp && *bp <= 'F')
1085	    digit = 10 + *bp - 'A';
1086	else
1087	    break;
1088
1089	if (digit >= base)
1090	    break;
1091
1092	n = n * base + digit;
1093	bp++;
1094    }
1095
1096    /*
1097     * Return value and success.
1098     */
1099    *num = n;
1100    return (0);
1101}
1102
1103
1104/*
1105 * Compare name field of record.
1106 */
1107static int
1108nfcmp(char *nf, char *rec)
1109{
1110    char *cp, tmp;
1111    int ret;
1112
1113    for (cp = rec; *cp != ':'; cp++)
1114	;
1115
1116    tmp = *(cp + 1);
1117    *(cp + 1) = '\0';
1118    ret = strcmp(nf, rec);
1119    *(cp + 1) = tmp;
1120
1121    return (ret);
1122}
1123