/*	$OpenBSD: getcap.c,v 1.34 2016/09/21 04:38:56 guenther Exp $	*/

/*-

 * Copyright (c) 1992, 1993

 *	The Regents of the University of California.  All rights reserved.

 *

 * This code is derived from software contributed to Berkeley by

 * Casey Leedom of Lawrence Livermore National Laboratory.

 *

 * 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.

 */

#include <sys/types.h>

#include <ctype.h>

#include <db.h>

#include <errno.h>

#include <fcntl.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#define	BFRAG		1024

#define	BSIZE		1024

#define	ESC		('[' & 037)	/* ASCII ESC */

#define	MAX_RECURSION	32		/* maximum getent recursion */

#define	SFRAG		100		/* cgetstr mallocs in SFRAG chunks */

#define RECOK	(char)0

#define TCERR	(char)1

#define	SHADOW	(char)2

static size_t	 topreclen;	/* toprec length */

static char	*toprec;	/* Additional record specified by cgetset() */

static int	 gottoprec;	/* Flag indicating retrieval of toprecord */

static int	cdbget(DB *, char **, const char *);

static int 	getent(char **, u_int *, char **, FILE *, const char *, int, char *);

static int	nfcmp(const char *, char *);

static int	usedb = 1;

/*

 * Cgetusedb() allows the user to specify whether or not to use a .db

 * version of the database file (if it exists) in preference to the

 * text version.  By default, the getcap(3) routines will use a .db file.

 */

int

cgetusedb(int new_usedb)

{

}

DEF_WEAK(cgetusedb);

/*

 * Cgetset() allows the addition of a user specified buffer to be added

 * to the database array, in effect "pushing" the buffer on top of the

 * virtual database. 0 is returned on success, -1 on failure.

 */

int

cgetset(const char *ent)

{

	}

}

DEF_WEAK(cgetset);

/*

 * Cgetcap searches the capability record buf for the capability cap with

 * type `type'.  A pointer to the value of cap is returned on success, NULL

 * if the requested capability couldn't be found.

 *

 * Specifying a type of ':' means that nothing should follow cap (:cap:).

 * In this case a pointer to the terminating ':' or NUL will be returned if

 * cap is found.

 *

 * If (cap, '@') or (cap, terminator, '@') is found before (cap, terminator)

 * return NULL.

 */

char *

cgetcap(char *buf, const char *cap, int type)

{

	char *bp;

	const char *cp;

	bp = buf;

		/*

		 * Skip past the current capability field - it's either the

		 * name field if this is the first time through the loop, or

		 * the remainder of a field whose name failed to match cap.

		 */

			else

					break;

		/*

		 * Try to match (cap, type) in buf.

		 */

			continue;

			continue;

				continue;

		}

			continue;

	}

	/* NOTREACHED */

}

DEF_WEAK(cgetcap);

/*

 * Cgetent extracts the capability record name from the NULL terminated file

 * array db_array and returns a pointer to a malloc'd copy of it in buf.

 * Buf must be retained through all subsequent calls to cgetcap, cgetnum,

 * cgetflag, and cgetstr, but may then be free'd.  0 is returned on success,

 * -1 if the requested record couldn't be found, -2 if a system error was

 * encountered (couldn't open/read a file, etc.), and -3 if a potential

 * reference loop is detected.

 */

int

cgetent(char **buf, char **db_array, const char *name)

{

}

DEF_WEAK(cgetent);

/*

 * Getent implements the functions of cgetent.  If fp is non-NULL,

 * *db_array has already been opened and fp is the open file descriptor.  We

 * do this to save time and avoid using up file descriptors for tc=

 * recursions.

 *

 * Getent returns the same success/failure codes as cgetent.  On success, a

 * pointer to a malloc'ed capability record with all tc= capabilities fully

 * expanded and its length (not including trailing ASCII NUL) are left in

 * *cap and *len.

 *

 * Basic algorithm:

 *	+ Allocate memory incrementally as needed in chunks of size BFRAG

 *	  for capability buffer.

 *	+ Recurse for each tc=name and interpolate result.  Stop when all

 *	  names interpolated, a name can't be found, or depth exceeds

 *	  MAX_RECURSION.

 */

static int

getent(char **cap, u_int *len, char **db_array, FILE *fp,

	const char *name, int depth, char *nfield)

{

	DB *capdbp;

	char *r_end, *rp, **db_p;

	int myfd, eof, foundit, opened, retval, clen;

	char *record, *cbuf;

	int tc_not_resolved;

	/*

	 * Return with ``loop detected'' error if we've recursed more than

	 * MAX_RECURSION times.

	 */

	opened = 0;

	/*

	 * Check if we have a top record from cgetset().

	 */

		opened++;

		myfd = 0;

		db_p = db_array;

	}

	/*

	 * Allocate first chunk of memory.

	 */

	foundit = 0;

	/*

	 * Loop through database array until finding the record.

	 */

		eof = 0;

		/*

		 * Open database if not already open.

		 */

			myfd = 0;

					/* no record available */

				}

				/* save the data; close frees it */

				}

				/* assume tc='s have been expanded??? */

			} else {

					/* No error on unfound file. */

				}

				myfd = 1;

			}

		}

		/*

		 * Find the requested capability record ...

		 */

		{

		    char *b_end, *bp;

		    int c;

		    /*

		     * Loop invariants:

		     *	There is always room for one more character in record.

		     *	R_end always points just past end of record.

		     *	Rp always points just past last character in record.

		     *	B_end always points just past last character in buf.

		     *	Bp always points at next character in buf.

		     */

		    bp = buf;

			/*

			 * Read in a line implementing (\, newline)

			 * line continuation.

			 */

			rp = record;

					size_t n;

							fp = NULL;

						}

					}

					bp = buf;

				}

					} else

						break;

				}

				/*

				 * Enforce loop invariant: if no room

				 * left in record buffer, try to get

				 * some more.

				 */

					size_t pos;

					size_t newsize;

					char *nrecord;

					}

					record = nrecord;

				}

			}

				/* loop invariant lets us do this */

			/*

			 * If encountered EOF check next file.

			 */

				break;

			/*

			 * Toss blank lines and comments.

			 */

				continue;

			/*

			 * See if this is the record we want ...

			 */

					foundit = 1;

				}

			}

		    }

		}

			break;

	}

	}

	/*

	 * Got the capability record, but now we have to expand all tc=name

	 * references in it ...

	 */

tc_exp:	{

		char *s;

		int diff, iret, tclen;

		/*

		 * Loop invariants:

		 *	There is room for one more character in record.

		 *	R_end points just past end of record.

		 *	Rp points just past last character in record.

		 *	Scan points at remainder of record that needs to be

		 *	scanned for tc=name constructs.

		 */

		scan = record;

		tc_not_resolved = 0;

				break;

			/*

			 * Find end of tc=name and stomp on the trailing `:'

			 * (if present) so we can use it to call ourselves.

			 */

			s = tc;

					break;

				else

					}

			}

			tcend = s;

				      NULL);

				/* an error */

				}

				/* couldn't resolve tc */

					scan = s - 1;

					tc_not_resolved = 1;

				}

			}

			/* not interested in name field of tc'ed record */

					break;

				else

						break;

			/* make sure interpolated record is `:'-terminated */

			}

			/*

			 * Make sure there's enough room to insert the

			 * new record.

			 */

				u_int pos, tcpos, tcposend;

				size_t newsize;

				char *nrecord;

				}

				record = nrecord;

			}

			/*

			 * Insert tc'ed record into our record.

			 */

			/*

			 * Start scan on `:' so next cgetcap works properly

			 * (cgetcap always skips first field).

			 */

		}

	}

	/*

	 * Close file (if we opened it), give back any extra memory, and

	 * return capability, length and success.

	 */

		char *nrecord;

		}

		record = nrecord;

	}

}

static int

cdbget(DB *capdbp, char **bp, const char *name)

{

		/* Get the reference. */

		case -1:

		case 1:

		}

		/* If not an index to another record, leave. */

			break;

	}

}

/*

 * Cgetmatch will return 0 if name is one of the names of the capability

 * record buf, -1 if not.

 */

int

cgetmatch(char *buf, const char *name)

{

	char *bp;

	const char *np;

	/*

	 * Start search at beginning of record.

	 */

	bp = buf;

		/*

		 * Try to match a record name.

		 */

		np = name;

				else

					break;

			} else

					break;

		/*

		 * Match failed, skip to next name in record.

		 */

			else

					break;	/* found next name */

	}

}

DEF_WEAK(cgetmatch);

int

cgetfirst(char **buf, char **db_array)

{

}

DEF_WEAK(cgetfirst);

static FILE *pfp;

static int slash;

static char **dbp;

int

cgetclose(void)

{

	}

}

DEF_WEAK(cgetclose);

/*

 * Cgetnext() gets either the first or next entry in the logical database

 * specified by db_array.  It returns 0 upon completion of the database, 1

 * upon returning an entry with more remaining, and -1 if an error occurs.

 */

int

cgetnext(char **cap, char **db_array)

{

	int c, serrno, status = -1;

	char *b_end, *bp, *r_end, *rp;

	char *record = NULL;

	off_t pos;

		goto done;

	/*

	 * Check if we have an unused top record from cgetset().

	 */

	}

	/*

	 * Allocate first chunk of memory.

	 */

		goto done;

	/*

	 * Find the next capability record

	 */

	/*

	 * Loop invariants:

	 *	There is always room for one more character in record.

	 *	R_end always points just past end of record.

	 *	Rp always points just past last character in record.

	 *	B_end always points just past last character in buf.

	 *	Bp always points at next character in buf.

	 */

	bp = buf;

		/*

		 * Read in a line implementing (\, newline)

		 * line continuation.

		 */

		rp = record;

				size_t n;

						status = 0;

					} else

				}

				bp = buf;

			}

				} else

					break;

			}

			/*

			 * Enforce loop invariant: if no room

			 * left in record buffer, try to get

			 * some more.

			 */

				size_t newsize, off;

				char *nrecord;

				record = nrecord;

			}

		}

		/* loop invariant lets us do this */

		/*

		 * If not blank or comment, set toprec and topreclen so

		 * getent() doesn't have to re-parse the file to find it.

		 */

			/* Rewind to end of record */

			break;

		}

	}

lookup:

	/* extract name from record */

	/* return value of getent() is one less than cgetnext() */

done:

	}

}

DEF_WEAK(cgetnext);

/*

 * Cgetstr retrieves the value of the string capability cap from the

 * capability record pointed to by buf.  A pointer to a decoded, NUL

 * terminated, malloc'd copy of the string is returned in the char *

 * pointed to by str.  The length of the string not including the trailing

 * NUL is returned on success, -1 if the requested string capability

 * couldn't be found, -2 if a system error was encountered (storage

 * allocation failure).

 */

int

cgetstr(char *buf, const char *cap, char **str)

{

	u_int m_room;

	char *bp, *mp;

	int len;

	char *mem;

	/*

	 * Find string capability cap

	 */

	/*

	 * Conversion / storage allocation loop ...  Allocate memory in

	 * chunks SFRAG in size.

	 */

	m_room = SFRAG;

	mp = mem;

		/*

		 * Loop invariants:

		 *	There is always room for one more character in mem.

		 *	Mp always points just past last character in mem.

		 *	Bp always points at next character in buf.

		 */

				break;	/* drop unfinished escape */

			bp++;

				break;	/* drop unfinished escape */

				int n, i;

				n = 0;

				i = 3;	/* maximum of three octal digits */

			}

				case 'b': case 'B':

				case 't': case 'T':

				case 'n': case 'N':

				case 'f': case 'F':

				case 'r': case 'R':

				case 'e': case 'E':

				case 'c': case 'C':

				default:

					/*

					 * Catches '\', '^', and

					 *  everything else.

					 */

			}

		} else

		/*

		 * Enforce loop invariant: if no room left in current

		 * buffer, try to get some more.

		 */

			char *nmem;

			}

			mem = nmem;

			m_room = SFRAG;

		}

	}

	/*

	 * Give back any extra memory and return value and success.

	 */

		char *nmem;

		}

		mem = nmem;

	}

}

DEF_WEAK(cgetstr);

/*

 * Cgetustr retrieves the value of the string capability cap from the

 * capability record pointed to by buf.  The difference between cgetustr()

 * and cgetstr() is that cgetustr does not decode escapes but rather treats

 * all characters literally.  A pointer to a  NUL terminated malloc'd

 * copy of the string is returned in the char pointed to by str.  The

 * length of the string not including the trailing NUL is returned on success,

 * -1 if the requested string capability couldn't be found, -2 if a system

 * error was encountered (storage allocation failure).

 */

int

cgetustr(char *buf, const char *cap, char **str)

{

	u_int m_room;

	char *bp, *mp;

	int len;

	char *mem;

	/*

	 * Find string capability cap

	 */

	/*

	 * Conversion / storage allocation loop ...  Allocate memory in

	 * chunks SFRAG in size.

	 */

	m_room = SFRAG;

	mp = mem;

		/*

		 * Loop invariants:

		 *	There is always room for one more character in mem.

		 *	Mp always points just past last character in mem.

		 *	Bp always points at next character in buf.

		 */

		/*

		 * Enforce loop invariant: if no room left in current

		 * buffer, try to get some more.

		 */

			char *nmem;

			}

			mem = nmem;

			m_room = SFRAG;