1N/A/***********************************************************************
1N/A* *
1N/A* This software is part of the ast package *
1N/A* Copyright (c) 1985-2011 AT&T Intellectual Property *
1N/A* and is licensed under the *
1N/A* Common Public License, Version 1.0 *
1N/A* by AT&T Intellectual Property *
1N/A* *
1N/A* A copy of the License is available at *
1N/A* http://www.opensource.org/licenses/cpl1.0.txt *
1N/A* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *
1N/A* *
1N/A* Information and Software Systems Research *
1N/A* AT&T Research *
1N/A* Florham Park NJ *
1N/A* *
1N/A* Glenn Fowler <gsf@research.att.com> *
1N/A* David Korn <dgk@research.att.com> *
1N/A* Phong Vo <kpv@research.att.com> *
1N/A* *
1N/A***********************************************************************/
1N/A#pragma prototyped
1N/A
1N/A/*
1N/A * string interface to confstr(),pathconf(),sysconf(),sysinfo()
1N/A * extended to allow some features to be set per-process
1N/A */
1N/A
1N/Astatic const char id[] = "\n@(#)$Id: getconf (AT&T Research) 2010-11-30 $\0\n";
1N/A
1N/A#include "univlib.h"
1N/A
1N/A#include <ast.h>
1N/A#include <error.h>
1N/A#include <fs3d.h>
1N/A#include <ctype.h>
1N/A#include <regex.h>
1N/A#include <proc.h>
1N/A
1N/A#include "conftab.h"
1N/A#include "FEATURE/libpath"
1N/A
1N/A#ifndef DEBUG_astconf
1N/A#define DEBUG_astconf 0
1N/A#endif
1N/A
1N/A#ifndef _pth_getconf
1N/A#undef ASTCONF_system
1N/A#define ASTCONF_system 0
1N/A#endif
1N/A
1N/A#if _sys_systeminfo
1N/A# if !_lib_sysinfo
1N/A# if _lib_systeminfo
1N/A# define _lib_sysinfo 1
1N/A# define sysinfo(a,b,c) systeminfo(a,b,c)
1N/A# else
1N/A# if _lib_syscall && _sys_syscall
1N/A# include <sys/syscall.h>
1N/A# if defined(SYS_systeminfo)
1N/A# define _lib_sysinfo 1
1N/A# define sysinfo(a,b,c) syscall(SYS_systeminfo,a,b,c)
1N/A# endif
1N/A# endif
1N/A# endif
1N/A# endif
1N/A#else
1N/A# undef _lib_sysinfo
1N/A#endif
1N/A
1N/A#define CONF_ERROR (CONF_USER<<0)
1N/A#define CONF_READONLY (CONF_USER<<1)
1N/A#define CONF_ALLOC (CONF_USER<<2)
1N/A#define CONF_GLOBAL (CONF_USER<<3)
1N/A
1N/A#define DEFAULT(o) ((state.std||!dynamic[o].ast)?dynamic[o].std:dynamic[o].ast)
1N/A#define INITIALIZE() do{if(!state.data)synthesize(NiL,NiL,NiL);}while(0)
1N/A#define STANDARD(v) (streq(v,"standard")||streq(v,"strict")||streq(v,"posix")||streq(v,"xopen"))
1N/A
1N/A#define MAXVAL 256
1N/A
1N/A#if MAXVAL <= UNIV_SIZE
1N/A#undef MAXVAL
1N/A#define MAXVAL (UNIV_SIZE+1)
1N/A#endif
1N/A
1N/A#ifndef _UNIV_DEFAULT
1N/A#define _UNIV_DEFAULT "att"
1N/A#endif
1N/A
1N/Astatic char null[1];
1N/Astatic char root[2] = "/";
1N/A
1N/Atypedef struct Feature_s
1N/A{
1N/A struct Feature_s*next;
1N/A const char* name;
1N/A char* value;
1N/A char* std;
1N/A char* ast;
1N/A short length;
1N/A short standard;
1N/A unsigned int flags;
1N/A short op;
1N/A} Feature_t;
1N/A
1N/Atypedef struct Lookup_s
1N/A{
1N/A Conf_t* conf;
1N/A const char* name;
1N/A unsigned int flags;
1N/A short call;
1N/A short standard;
1N/A short section;
1N/A} Lookup_t;
1N/A
1N/Astatic Feature_t dynamic[] =
1N/A{
1N/A#define OP_conformance 0
1N/A {
1N/A &dynamic[OP_conformance+1],
1N/A "CONFORMANCE",
1N/A "ast",
1N/A "standard",
1N/A "ast",
1N/A 11,
1N/A CONF_AST,
1N/A 0,
1N/A OP_conformance
1N/A },
1N/A#define OP_fs_3d 1
1N/A {
1N/A &dynamic[OP_fs_3d+1],
1N/A "FS_3D",
1N/A &null[0],
1N/A "0",
1N/A 0,
1N/A 5,
1N/A CONF_AST,
1N/A 0,
1N/A OP_fs_3d
1N/A },
1N/A#define OP_getconf 2
1N/A {
1N/A &dynamic[OP_getconf+1],
1N/A "GETCONF",
1N/A#ifdef _pth_getconf
1N/A _pth_getconf,
1N/A#else
1N/A &null[0],
1N/A#endif
1N/A 0,
1N/A 0,
1N/A 7,
1N/A CONF_AST,
1N/A CONF_READONLY,
1N/A OP_getconf
1N/A },
1N/A#define OP_hosttype 3
1N/A {
1N/A &dynamic[OP_hosttype+1],
1N/A "HOSTTYPE",
1N/A HOSTTYPE,
1N/A 0,
1N/A 0,
1N/A 8,
1N/A CONF_AST,
1N/A CONF_READONLY,
1N/A OP_hosttype
1N/A },
1N/A#define OP_libpath 4
1N/A {
1N/A &dynamic[OP_libpath+1],
1N/A "LIBPATH",
1N/A#ifdef CONF_LIBPATH
1N/A CONF_LIBPATH,
1N/A#else
1N/A &null[0],
1N/A#endif
1N/A 0,
1N/A 0,
1N/A 7,
1N/A CONF_AST,
1N/A 0,
1N/A OP_libpath
1N/A },
1N/A#define OP_libprefix 5
1N/A {
1N/A &dynamic[OP_libprefix+1],
1N/A "LIBPREFIX",
1N/A#ifdef CONF_LIBPREFIX
1N/A CONF_LIBPREFIX,
1N/A#else
1N/A "lib",
1N/A#endif
1N/A 0,
1N/A 0,
1N/A 9,
1N/A CONF_AST,
1N/A 0,
1N/A OP_libprefix
1N/A },
1N/A#define OP_libsuffix 6
1N/A {
1N/A &dynamic[OP_libsuffix+1],
1N/A "LIBSUFFIX",
1N/A#ifdef CONF_LIBSUFFIX
1N/A CONF_LIBSUFFIX,
1N/A#else
1N/A ".so",
1N/A#endif
1N/A 0,
1N/A 0,
1N/A 9,
1N/A CONF_AST,
1N/A 0,
1N/A OP_libsuffix
1N/A },
1N/A#define OP_path_attributes 7
1N/A {
1N/A &dynamic[OP_path_attributes+1],
1N/A "PATH_ATTRIBUTES",
1N/A#if _WINIX
1N/A "c",
1N/A#else
1N/A &null[0],
1N/A#endif
1N/A &null[0],
1N/A 0,
1N/A 15,
1N/A CONF_AST,
1N/A CONF_READONLY,
1N/A OP_path_attributes
1N/A },
1N/A#define OP_path_resolve 8
1N/A {
1N/A &dynamic[OP_path_resolve+1],
1N/A "PATH_RESOLVE",
1N/A &null[0],
1N/A "physical",
1N/A "metaphysical",
1N/A 12,
1N/A CONF_AST,
1N/A 0,
1N/A OP_path_resolve
1N/A },
1N/A#define OP_universe 9
1N/A {
1N/A 0,
1N/A "UNIVERSE",
1N/A &null[0],
1N/A "att",
1N/A 0,
1N/A 8,
1N/A CONF_AST,
1N/A 0,
1N/A OP_universe
1N/A },
1N/A {
1N/A 0
1N/A }
1N/A};
1N/A
1N/Atypedef struct State_s
1N/A{
1N/A
1N/A const char* id;
1N/A const char* name;
1N/A const char* standard;
1N/A const char* strict;
1N/A Feature_t* features;
1N/A
1N/A int std;
1N/A
1N/A /* default initialization from here down */
1N/A
1N/A int prefix;
1N/A int synthesizing;
1N/A
1N/A char* data;
1N/A char* last;
1N/A
1N/A Feature_t* recent;
1N/A
1N/A Ast_confdisc_f notify;
1N/A
1N/A} State_t;
1N/A
1N/Astatic State_t state = { "getconf", "_AST_FEATURES", "CONFORMANCE = standard", "POSIXLY_CORRECT", dynamic, -1 };
1N/A
1N/Astatic char* feature(Feature_t*, const char*, const char*, const char*, unsigned int, Error_f);
1N/A
1N/A/*
1N/A * return fmtbuf() copy of s
1N/A */
1N/A
1N/Astatic char*
1N/Abuffer(char* s)
1N/A{
1N/A return strcpy(fmtbuf(strlen(s) + 1), s);
1N/A}
1N/A
1N/A/*
1N/A * synthesize state for fp
1N/A * fp==0 initializes from getenv(state.name)
1N/A * value==0 just does lookup
1N/A * otherwise state is set to value
1N/A */
1N/A
1N/Astatic char*
1N/Asynthesize(register Feature_t* fp, const char* path, const char* value)
1N/A{
1N/A register char* s;
1N/A register char* d;
1N/A register char* v;
1N/A register char* p;
1N/A register int n;
1N/A
1N/A#if DEBUG_astconf
1N/A if (fp)
1N/A error(-2, "astconf synthesize name=%s path=%s value=%s fp=%p%s", fp->name, path, value, fp, state.synthesizing ? " SYNTHESIZING" : "");
1N/A#endif
1N/A if (state.synthesizing)
1N/A return null;
1N/A if (!state.data)
1N/A {
1N/A char* se;
1N/A char* de;
1N/A char* ve;
1N/A
1N/A state.prefix = strlen(state.name) + 1;
1N/A n = state.prefix + 3 * MAXVAL;
1N/A if ((s = getenv(state.name)) || getenv(state.strict) && (s = (char*)state.standard))
1N/A n += strlen(s) + 1;
1N/A n = roundof(n, 32);
1N/A if (!(state.data = newof(0, char, n, 0)))
1N/A return 0;
1N/A state.last = state.data + n - 1;
1N/A strcpy(state.data, state.name);
1N/A state.data += state.prefix - 1;
1N/A *state.data++ = '=';
1N/A if (s)
1N/A strcpy(state.data, s);
1N/A ve = state.data;
1N/A state.synthesizing = 1;
1N/A for (;;)
1N/A {
1N/A for (s = ve; isspace(*s); s++);
1N/A for (d = s; *d && !isspace(*d); d++);
1N/A for (se = d; isspace(*d); d++);
1N/A for (v = d; *v && !isspace(*v); v++);
1N/A for (de = v; isspace(*v); v++);
1N/A if (!*v)
1N/A break;
1N/A for (ve = v; *ve && !isspace(*ve); ve++);
1N/A if (*ve)
1N/A *ve = 0;
1N/A else
1N/A ve = 0;
1N/A *de = 0;
1N/A *se = 0;
1N/A feature(0, s, d, v, 0, 0);
1N/A *se = ' ';
1N/A *de = ' ';
1N/A if (!ve)
1N/A break;
1N/A *ve++ = ' ';
1N/A }
1N/A state.synthesizing = 0;
1N/A }
1N/A if (!fp)
1N/A return state.data;
1N/A if (!state.last)
1N/A {
1N/A if (!value)
1N/A return 0;
1N/A n = strlen(value);
1N/A goto ok;
1N/A }
1N/A s = (char*)fp->name;
1N/A n = fp->length;
1N/A d = state.data;
1N/A for (;;)
1N/A {
1N/A while (isspace(*d))
1N/A d++;
1N/A if (!*d)
1N/A break;
1N/A if (strneq(d, s, n) && isspace(d[n]))
1N/A {
1N/A if (!value)
1N/A {
1N/A for (d += n + 1; *d && !isspace(*d); d++);
1N/A for (; isspace(*d); d++);
1N/A for (s = d; *s && !isspace(*s); s++);
1N/A n = s - d;
1N/A value = (const char*)d;
1N/A goto ok;
1N/A }
1N/A for (s = p = d + n + 1; *s && !isspace(*s); s++);
1N/A for (; isspace(*s); s++);
1N/A for (v = s; *s && !isspace(*s); s++);
1N/A n = s - v;
1N/A if ((!path || *path == *p && strlen(path) == (v - p - 1) && !memcmp(path, p, v - p - 1)) && strneq(v, value, n))
1N/A goto ok;
1N/A for (; isspace(*s); s++);
1N/A if (*s)
1N/A for (; *d = *s++; d++);
1N/A else if (d != state.data)
1N/A d--;
1N/A break;
1N/A }
1N/A for (; *d && !isspace(*d); d++);
1N/A for (; isspace(*d); d++);
1N/A for (; *d && !isspace(*d); d++);
1N/A for (; isspace(*d); d++);
1N/A for (; *d && !isspace(*d); d++);
1N/A }
1N/A if (!value)
1N/A {
1N/A if (!fp->op)
1N/A {
1N/A if (fp->flags & CONF_ALLOC)
1N/A fp->value[0] = 0;
1N/A else
1N/A fp->value = null;
1N/A }
1N/A return 0;
1N/A }
1N/A if (!value[0])
1N/A value = "0";
1N/A if (!path || !path[0] || path[0] == '/' && !path[1])
1N/A path = "-";
1N/A n += strlen(path) + strlen(value) + 3;
1N/A if (d + n >= state.last)
1N/A {
1N/A int c;
1N/A int i;
1N/A
1N/A i = d - state.data;
1N/A state.data -= state.prefix;
1N/A c = n + state.last - state.data + 3 * MAXVAL;
1N/A c = roundof(c, 32);
1N/A if (!(state.data = newof(state.data, char, c, 0)))
1N/A return 0;
1N/A state.last = state.data + c - 1;
1N/A state.data += state.prefix;
1N/A d = state.data + i;
1N/A }
1N/A if (d != state.data)
1N/A *d++ = ' ';
1N/A for (s = (char*)fp->name; *d = *s++; d++);
1N/A *d++ = ' ';
1N/A for (s = (char*)path; *d = *s++; d++);
1N/A *d++ = ' ';
1N/A for (s = (char*)value; *d = *s++; d++);
1N/A#if DEBUG_astconf
1N/A error(-3, "astconf synthesize %s", state.data - state.prefix);
1N/A#endif
1N/A setenviron(state.data - state.prefix);
1N/A if (state.notify)
1N/A (*state.notify)(NiL, NiL, state.data - state.prefix);
1N/A n = s - (char*)value - 1;
1N/A ok:
1N/A if (!(fp->flags & CONF_ALLOC))
1N/A fp->value = 0;
1N/A if (n == 1 && (*value == '0' || *value == '-'))
1N/A n = 0;
1N/A if (!(fp->value = newof(fp->value, char, n, 1)))
1N/A fp->value = null;
1N/A else
1N/A {
1N/A fp->flags |= CONF_ALLOC;
1N/A memcpy(fp->value, value, n);
1N/A fp->value[n] = 0;
1N/A }
1N/A return fp->value;
1N/A}
1N/A
1N/A/*
1N/A * initialize the value for fp
1N/A * if command!=0 then it is checked for on $PATH
1N/A * synthesize(fp,path,succeed) called on success
1N/A * otherwise synthesize(fp,path,fail) called
1N/A */
1N/A
1N/Astatic void
1N/Ainitialize(register Feature_t* fp, const char* path, const char* command, const char* succeed, const char* fail)
1N/A{
1N/A register char* p;
1N/A register int ok = 1;
1N/A
1N/A#if DEBUG_astconf
1N/A error(-2, "astconf initialize name=%s path=%s command=%s succeed=%s fail=%s fp=%p%s", fp->name, path, command, succeed, fail, fp, state.synthesizing ? " SYNTHESIZING" : "");
1N/A#endif
1N/A switch (fp->op)
1N/A {
1N/A case OP_conformance:
1N/A ok = getenv(state.strict) != 0;
1N/A break;
1N/A case OP_hosttype:
1N/A ok = 1;
1N/A break;
1N/A case OP_path_attributes:
1N/A ok = 1;
1N/A break;
1N/A case OP_path_resolve:
1N/A ok = fs3d(FS3D_TEST);
1N/A break;
1N/A case OP_universe:
1N/A ok = streq(_UNIV_DEFAULT, DEFAULT(OP_universe));
1N/A /*FALLTHROUGH...*/
1N/A default:
1N/A if (p = getenv("PATH"))
1N/A {
1N/A register int r = 1;
1N/A register char* d = p;
1N/A Sfio_t* tmp;
1N/A
1N/A#if DEBUG_astconf
1N/A error(-2, "astconf initialize name=%s ok=%d PATH=%s", fp->name, ok, p);
1N/A#endif
1N/A if (tmp = sfstropen())
1N/A {
1N/A for (;;)
1N/A {
1N/A switch (*p++)
1N/A {
1N/A case 0:
1N/A break;
1N/A case ':':
1N/A if (command && fp->op != OP_universe)
1N/A {
1N/A if (r = p - d - 1)
1N/A {
1N/A sfwrite(tmp, d, r);
1N/A sfputc(tmp, '/');
1N/A sfputr(tmp, command, 0);
1N/A if ((d = sfstruse(tmp)) && !eaccess(d, X_OK))
1N/A {
1N/A ok = 1;
1N/A if (fp->op != OP_universe)
1N/A break;
1N/A }
1N/A }
1N/A d = p;
1N/A }
1N/A r = 1;
1N/A continue;
1N/A case '/':
1N/A if (r)
1N/A {
1N/A r = 0;
1N/A if (fp->op == OP_universe)
1N/A {
1N/A if (p[0] == 'u' && p[1] == 's' && p[2] == 'r' && p[3] == '/')
1N/A for (p += 4; *p == '/'; p++);
1N/A if (p[0] == 'b' && p[1] == 'i' && p[2] == 'n')
1N/A {
1N/A for (p += 3; *p == '/'; p++);
1N/A if (!*p || *p == ':')
1N/A break;
1N/A }
1N/A }
1N/A }
1N/A if (fp->op == OP_universe)
1N/A {
1N/A if (strneq(p, "xpg", 3))
1N/A {
1N/A ok = 1;
1N/A break;
1N/A }
1N/A if (strneq(p, "bsd", 3) || strneq(p, "ucb", 3))
1N/A {
1N/A ok = 0;
1N/A break;
1N/A }
1N/A }
1N/A continue;
1N/A default:
1N/A r = 0;
1N/A continue;
1N/A }
1N/A break;
1N/A }
1N/A sfclose(tmp);
1N/A }
1N/A else
1N/A ok = 1;
1N/A }
1N/A break;
1N/A }
1N/A#if DEBUG_astconf
1N/A error(-1, "AHA#%d state.std=%d %s [%s] std=%s ast=%s value=%s ok=%d", __LINE__, state.std, fp->name, ok ? succeed : fail, fp->std, fp->ast, fp->value, ok);
1N/A#endif
1N/A synthesize(fp, path, ok ? succeed : fail);
1N/A}
1N/A
1N/A/*
1N/A * format synthesized value
1N/A */
1N/A
1N/Astatic char*
1N/Aformat(register Feature_t* fp, const char* path, const char* value, unsigned int flags, Error_f conferror)
1N/A{
1N/A register Feature_t* sp;
1N/A register int n;
1N/A
1N/A#if DEBUG_astconf
1N/A error(-2, "astconf format name=%s path=%s value=%s flags=%04x fp=%p%s", fp->name, path, value, flags, fp, state.synthesizing ? " SYNTHESIZING" : "");
1N/A#endif
1N/A if (value)
1N/A fp->flags &= ~CONF_GLOBAL;
1N/A else if (fp->flags & CONF_GLOBAL)
1N/A return fp->value;
1N/A switch (fp->op)
1N/A {
1N/A
1N/A case OP_conformance:
1N/A if (value && STANDARD(value))
1N/A value = fp->std;
1N/A state.std = streq(fp->value, fp->std);
1N/A#if DEBUG_astconf
1N/A error(-1, "AHA#%d state.std=%d %s [%s] std=%s ast=%s value=%s", __LINE__, state.std, fp->name, value, fp->std, fp->ast, fp->value);
1N/A#endif
1N/A if (state.synthesizing && value == (char*)fp->std)
1N/A fp->value = (char*)value;
1N/A else if (!synthesize(fp, path, value))
1N/A initialize(fp, path, NiL, fp->std, fp->value);
1N/A#if DEBUG_astconf
1N/A error(-1, "AHA#%d state.std=%d %s [%s] std=%s ast=%s value=%s", __LINE__, state.std, fp->name, value, fp->std, fp->ast, fp->value);
1N/A#endif
1N/A if (!state.std && value == fp->std)
1N/A {
1N/A state.std = 1;
1N/A for (sp = state.features; sp; sp = sp->next)
1N/A if (sp->std && sp->op && sp->op != OP_conformance)
1N/A feature(sp, 0, path, sp->std, 0, 0);
1N/A }
1N/A#if DEBUG_astconf
1N/A error(-1, "AHA#%d state.std=%d %s [%s] std=%s ast=%s value=%s", __LINE__, state.std, fp->name, value, fp->std, fp->ast, fp->value);
1N/A#endif
1N/A break;
1N/A
1N/A case OP_fs_3d:
1N/A fp->value = fs3d(value ? value[0] ? FS3D_ON : FS3D_OFF : FS3D_TEST) ? "1" : null;
1N/A break;
1N/A
1N/A case OP_hosttype:
1N/A break;
1N/A
1N/A case OP_path_attributes:
1N/A#ifdef _PC_PATH_ATTRIBUTES
1N/A {
1N/A register char* s;
1N/A register char* e;
1N/A intmax_t v;
1N/A
1N/A /*
1N/A * _PC_PATH_ATTRIBUTES is a bitmap for 'a' to 'z'
1N/A */
1N/A
1N/A if ((v = pathconf(path, _PC_PATH_ATTRIBUTES)) == -1L)
1N/A return 0;
1N/A s = fp->value;
1N/A e = s + sizeof(fp->value) - 1;
1N/A for (n = 'a'; n <= 'z'; n++)
1N/A if (v & (1 << (n - 'a')))
1N/A {
1N/A *s++ = n;
1N/A if (s >= e)
1N/A break;
1N/A }
1N/A *s = 0;
1N/A }
1N/A#endif
1N/A break;
1N/A
1N/A case OP_path_resolve:
1N/A if (state.synthesizing && value == (char*)fp->std)
1N/A fp->value = (char*)value;
1N/A else if (!synthesize(fp, path, value))
1N/A initialize(fp, path, NiL, "logical", DEFAULT(OP_path_resolve));
1N/A break;
1N/A
1N/A case OP_universe:
1N/A#if _lib_universe
1N/A if (getuniverse(fp->value) < 0)
1N/A strcpy(fp->value, DEFAULT(OP_universe));
1N/A if (value)
1N/A setuniverse(value);
1N/A#else
1N/A#ifdef UNIV_MAX
1N/A n = 0;
1N/A if (value)
1N/A {
1N/A while (n < univ_max && !streq(value, univ_name[n])
1N/A n++;
1N/A if (n >= univ_max)
1N/A {
1N/A if (conferror)
1N/A (*conferror)(&state, &state, 2, "%s: %s: universe value too large", fp->name, value);
1N/A return 0;
1N/A }
1N/A }
1N/A#ifdef ATT_UNIV
1N/A n = setuniverse(n + 1);
1N/A if (!value && n > 0)
1N/A setuniverse(n);
1N/A#else
1N/A n = universe(value ? n + 1 : U_GET);
1N/A#endif
1N/A if (n <= 0 || n >= univ_max)
1N/A n = 1;
1N/A strcpy(fp->value, univ_name[n - 1]);
1N/A#else
1N/A if (value && streq(path, "="))
1N/A {
1N/A if (state.synthesizing)
1N/A {
1N/A if (!(fp->flags & CONF_ALLOC))
1N/A fp->value = 0;
1N/A n = strlen(value);
1N/A if (!(fp->value = newof(fp->value, char, n, 1)))
1N/A fp->value = null;
1N/A else
1N/A {
1N/A fp->flags |= CONF_ALLOC;
1N/A memcpy(fp->value, value, n);
1N/A fp->value[n] = 0;
1N/A }
1N/A }
1N/A else
1N/A synthesize(fp, path, value);
1N/A }
1N/A else
1N/A initialize(fp, path, "echo", DEFAULT(OP_universe), "ucb");
1N/A#endif
1N/A#endif
1N/A break;
1N/A
1N/A default:
1N/A if (state.synthesizing && value == (char*)fp->std)
1N/A fp->value = (char*)value;
1N/A else
1N/A synthesize(fp, path, value);
1N/A break;
1N/A
1N/A }
1N/A if (streq(path, "="))
1N/A fp->flags |= CONF_GLOBAL;
1N/A return fp->value;
1N/A}
1N/A
1N/A/*
1N/A * value==0 get feature name
1N/A * value!=0 set feature name
1N/A * 0 returned if error or not defined; otherwise previous value
1N/A */
1N/A
1N/Astatic char*
1N/Afeature(register Feature_t* fp, const char* name, const char* path, const char* value, unsigned int flags, Error_f conferror)
1N/A{
1N/A register int n;
1N/A
1N/A if (value && (streq(value, "-") || streq(value, "0")))
1N/A value = null;
1N/A if (!fp)
1N/A for (fp = state.features; fp && !streq(fp->name, name); fp = fp->next);
1N/A#if DEBUG_astconf
1N/A error(-2, "astconf feature name=%s path=%s value=%s flags=%04x fp=%p%s", name, path, value, flags, fp, state.synthesizing ? " SYNTHESIZING" : "");
1N/A#endif
1N/A if (!fp)
1N/A {
1N/A if (!value)
1N/A return 0;
1N/A if (state.notify && !(*state.notify)(name, path, value))
1N/A return 0;
1N/A n = strlen(name);
1N/A if (!(fp = newof(0, Feature_t, 1, n + 1)))
1N/A {
1N/A if (conferror)
1N/A (*conferror)(&state, &state, 2, "%s: out of space", name);
1N/A return 0;
1N/A }
1N/A fp->op = -1;
1N/A fp->name = (const char*)fp + sizeof(Feature_t);
1N/A strcpy((char*)fp->name, name);
1N/A fp->length = n;
1N/A fp->std = &null[0];
1N/A fp->next = state.features;
1N/A state.features = fp;
1N/A }
1N/A else if (value)
1N/A {
1N/A if (fp->flags & CONF_READONLY)
1N/A {
1N/A if (conferror)
1N/A (*conferror)(&state, &state, 2, "%s: cannot set readonly symbol", fp->name);
1N/A return 0;
1N/A }
1N/A if (state.notify && !streq(fp->value, value) && !(*state.notify)(name, path, value))
1N/A return 0;
1N/A }
1N/A else
1N/A state.recent = fp;
1N/A return format(fp, path, value, flags, conferror);
1N/A}
1N/A
1N/A/*
1N/A * binary search for name in conf[]
1N/A */
1N/A
1N/Astatic int
1N/Alookup(register Lookup_t* look, const char* name, unsigned int flags)
1N/A{
1N/A register Conf_t* mid = (Conf_t*)conf;
1N/A register Conf_t* lo = mid;
1N/A register Conf_t* hi = mid + conf_elements;
1N/A register int v;
1N/A register int c;
1N/A char* e;
1N/A const Prefix_t* p;
1N/A
1N/A static Conf_t num;
1N/A
1N/A look->flags = 0;
1N/A look->call = -1;
1N/A look->standard = (flags & ASTCONF_AST) ? CONF_AST : -1;
1N/A look->section = -1;
1N/A while (*name == '_')
1N/A name++;
1N/A again:
1N/A for (p = prefix; p < &prefix[prefix_elements]; p++)
1N/A if (strneq(name, p->name, p->length) && ((c = name[p->length] == '_' || name[p->length] == '(' || name[p->length] == '#') || (v = isdigit(name[p->length]) && name[p->length + 1] == '_')))
1N/A {
1N/A if (p->call < 0)
1N/A {
1N/A if (look->standard >= 0)
1N/A break;
1N/A look->standard = p->standard;
1N/A }
1N/A else
1N/A {
1N/A if (look->call >= 0)
1N/A break;
1N/A look->call = p->call;
1N/A }
1N/A if (name[p->length] == '(' || name[p->length] == '#')
1N/A {
1N/A look->conf = &num;
1N/A strlcpy((char*)num.name, name, sizeof(num.name));
1N/A num.call = p->call;
1N/A num.flags = *name == 'C' ? CONF_STRING : 0;
1N/A num.op = (short)strtol(name + p->length + 1, &e, 10);
1N/A if (name[p->length] == '(' && *e == ')')
1N/A e++;
1N/A if (*e)
1N/A break;
1N/A return 1;
1N/A }
1N/A name += p->length + c;
1N/A if (look->section < 0 && !c && v)
1N/A {
1N/A look->section = name[0] - '0';
1N/A name += 2;
1N/A }
1N/A goto again;
1N/A }
1N/A#if HUH_2006_02_10
1N/A if (look->section < 0)
1N/A look->section = 1;
1N/A#endif
1N/A look->name = name;
1N/A#if DEBUG_astconf
1N/A error(-2, "astconf normal name=%s standard=%d section=%d call=%d flags=%04x elements=%d", look->name, look->standard, look->section, look->call, flags, conf_elements);
1N/A#endif
1N/A c = *((unsigned char*)name);
1N/A while (lo <= hi)
1N/A {
1N/A mid = lo + (hi - lo) / 2;
1N/A#if DEBUG_astconf
1N/A error(-3, "astconf lookup name=%s mid=%s", name, mid->name);
1N/A#endif
1N/A if (!(v = c - *((unsigned char*)mid->name)) && !(v = strcmp(name, mid->name)))
1N/A {
1N/A hi = mid;
1N/A lo = (Conf_t*)conf;
1N/A do
1N/A {
1N/A if ((look->standard < 0 || look->standard == mid->standard) &&
1N/A (look->section < 0 || look->section == mid->section) &&
1N/A (look->call < 0 || look->call == mid->call))
1N/A goto found;
1N/A } while (mid-- > lo && streq(mid->name, look->name));
1N/A mid = hi;
1N/A hi = lo + conf_elements - 1;
1N/A while (++mid < hi && streq(mid->name, look->name))
1N/A {
1N/A if ((look->standard < 0 || look->standard == mid->standard) &&
1N/A (look->section < 0 || look->section == mid->section) &&
1N/A (look->call < 0 || look->call == mid->call))
1N/A goto found;
1N/A }
1N/A break;
1N/A }
1N/A else if (v > 0)
1N/A lo = mid + 1;
1N/A else
1N/A hi = mid - 1;
1N/A }
1N/A return 0;
1N/A found:
1N/A if (look->call < 0 && look->standard >= 0 && (look->section <= 1 || (mid->flags & CONF_MINMAX)))
1N/A look->flags |= CONF_MINMAX;
1N/A look->conf = mid;
1N/A#if DEBUG_astconf
1N/A error(-2, "astconf lookup name=%s standard=%d:%d section=%d:%d call=%d:%d", look->name, look->standard, mid->standard, look->section, mid->section, look->call, mid->call);
1N/A#endif
1N/A return 1;
1N/A}
1N/A
1N/A/*
1N/A * return a tolower'd copy of s
1N/A */
1N/A
1N/Astatic char*
1N/Afmtlower(register const char* s)
1N/A{
1N/A register int c;
1N/A register char* t;
1N/A char* b;
1N/A
1N/A b = t = fmtbuf(strlen(s) + 1);
1N/A while (c = *s++)
1N/A {
1N/A if (isupper(c))
1N/A c = tolower(c);
1N/A *t++ = c;
1N/A }
1N/A *t = 0;
1N/A return b;
1N/A}
1N/A
1N/A/*
1N/A * print value line for p
1N/A * if !name then value prefixed by "p->name="
1N/A * if (flags & CONF_MINMAX) then default minmax value used
1N/A */
1N/A
1N/Astatic char*
1N/Aprint(Sfio_t* sp, register Lookup_t* look, const char* name, const char* path, int listflags, Error_f conferror)
1N/A{
1N/A register Conf_t* p = look->conf;
1N/A register unsigned int flags = look->flags;
1N/A char* call;
1N/A char* f;
1N/A const char* s;
1N/A int i;
1N/A int n;
1N/A int olderrno;
1N/A int drop;
1N/A int defined;
1N/A intmax_t v;
1N/A char buf[PATH_MAX];
1N/A char flg[16];
1N/A
1N/A if (!name && !(p->flags & CONF_STRING) && (p->flags & (CONF_FEATURE|CONF_LIMIT|CONF_MINMAX)) && (p->flags & (CONF_LIMIT|CONF_PREFIXED)) != CONF_LIMIT)
1N/A flags |= CONF_PREFIXED;
1N/A olderrno = errno;
1N/A errno = 0;
1N/A#if DEBUG_astconf
1N/A error(-1, "astconf name=%s:%s:%s standard=%d section=%d call=%s op=%d flags=|%s%s%s%s%s:|%s%s%s%s%s%s%s%s%s%s"
1N/A , name, look->name, p->name, p->standard, p->section, prefix[p->call + CONF_call].name, p->op
1N/A , (flags & CONF_FEATURE) ? "FEATURE|" : ""
1N/A , (flags & CONF_LIMIT) ? "LIMIT|" : ""
1N/A , (flags & CONF_MINMAX) ? "MINMAX|" : ""
1N/A , (flags & CONF_PREFIXED) ? "PREFIXED|" : ""
1N/A , (flags & CONF_STRING) ? "STRING|" : ""
1N/A , (p->flags & CONF_DEFER_CALL) ? "DEFER_CALL|" : ""
1N/A , (p->flags & CONF_DEFER_MM) ? "DEFER_MM|" : ""
1N/A , (p->flags & CONF_FEATURE) ? "FEATURE|" : ""
1N/A , (p->flags & CONF_LIMIT_DEF) ? "LIMIT_DEF|" : (p->flags & CONF_LIMIT) ? "LIMIT|" : ""
1N/A , (p->flags & CONF_MINMAX_DEF) ? "MINMAX_DEF|" : (p->flags & CONF_MINMAX) ? "MINMAX|" : ""
1N/A , (p->flags & CONF_NOUNDERSCORE) ? "NOUNDERSCORE|" : ""
1N/A , (p->flags & CONF_PREFIXED) ? "PREFIXED|" : ""
1N/A , (p->flags & CONF_PREFIX_ONLY) ? "PREFIX_ONLY|" : ""
1N/A , (p->flags & CONF_STANDARD) ? "STANDARD|" : ""
1N/A , (p->flags & CONF_STRING) ? "STRING|" : ""
1N/A , (p->flags & CONF_UNDERSCORE) ? "UNDERSCORE|" : ""
1N/A );
1N/A#endif
1N/A flags |= CONF_LIMIT_DEF|CONF_MINMAX_DEF;
1N/A if (conferror && name)
1N/A {
1N/A if ((p->flags & CONF_PREFIX_ONLY) && look->standard < 0)
1N/A goto bad;
1N/A if (!(flags & CONF_MINMAX) || !(p->flags & CONF_MINMAX))
1N/A {
1N/A switch (p->call)
1N/A {
1N/A case CONF_pathconf:
1N/A if (path == root)
1N/A {
1N/A (*conferror)(&state, &state, 2, "%s: path expected", name);
1N/A goto bad;
1N/A }
1N/A break;
1N/A default:
1N/A if (path != root)
1N/A {
1N/A (*conferror)(&state, &state, 2, "%s: path not expected", name);
1N/A goto bad;
1N/A }
1N/A break;
1N/A }
1N/A#ifdef _pth_getconf
1N/A if (p->flags & CONF_DEFER_CALL)
1N/A goto bad;
1N/A#endif
1N/A }
1N/A else
1N/A {
1N/A if (path != root)
1N/A {
1N/A (*conferror)(&state, &state, 2, "%s: path not expected", name);
1N/A goto bad;
1N/A }
1N/A#ifdef _pth_getconf
1N/A if ((p->flags & CONF_DEFER_MM) || !(p->flags & CONF_MINMAX_DEF))
1N/A goto bad;
1N/A#endif
1N/A }
1N/A if (look->standard >= 0 && (name[0] != '_' && ((p->flags & CONF_UNDERSCORE) || look->section <= 1) || name[0] == '_' && (p->flags & CONF_NOUNDERSCORE)) || look->standard < 0 && name[0] == '_')
1N/A goto bad;
1N/A }
1N/A s = 0;
1N/A defined = 1;
1N/A switch (i = (p->op < 0 || (flags & CONF_MINMAX) && (p->flags & CONF_MINMAX_DEF)) ? 0 : p->call)
1N/A {
1N/A case CONF_confstr:
1N/A call = "confstr";
1N/A#if _lib_confstr
1N/A if (!(v = confstr(p->op, buf, sizeof(buf))))
1N/A {
1N/A defined = 0;
1N/A v = -1;
1N/A errno = EINVAL;
1N/A }
1N/A else if (v > 0)
1N/A {
1N/A buf[sizeof(buf) - 1] = 0;
1N/A s = (const char*)buf;
1N/A }
1N/A else
1N/A defined = 0;
1N/A break;
1N/A#else
1N/A goto predef;
1N/A#endif
1N/A case CONF_pathconf:
1N/A call = "pathconf";
1N/A#if _lib_pathconf
1N/A if ((v = pathconf(path, p->op)) < 0)
1N/A defined = 0;
1N/A break;
1N/A#else
1N/A goto predef;
1N/A#endif
1N/A case CONF_sysconf:
1N/A call = "sysconf";
1N/A#if _lib_sysconf
1N/A if ((v = sysconf(p->op)) < 0)
1N/A defined = 0;
1N/A break;
1N/A#else
1N/A goto predef;
1N/A#endif
1N/A case CONF_sysinfo:
1N/A call = "sysinfo";
1N/A#if _lib_sysinfo
1N/A if ((v = sysinfo(p->op, buf, sizeof(buf))) >= 0)
1N/A {
1N/A buf[sizeof(buf) - 1] = 0;
1N/A s = (const char*)buf;
1N/A }
1N/A else
1N/A defined = 0;
1N/A break;
1N/A#else
1N/A goto predef;
1N/A#endif
1N/A default:
1N/A call = "synthesis";
1N/A errno = EINVAL;
1N/A v = -1;
1N/A defined = 0;
1N/A break;
1N/A case 0:
1N/A call = 0;
1N/A if (p->standard == CONF_AST)
1N/A {
1N/A if (streq(p->name, "RELEASE") && (i = open("/proc/version", O_RDONLY)) >= 0)
1N/A {
1N/A n = read(i, buf, sizeof(buf) - 1);
1N/A close(i);
1N/A if (n > 0 && buf[n - 1] == '\n')
1N/A n--;
1N/A if (n > 0 && buf[n - 1] == '\r')
1N/A n--;
1N/A buf[n] = 0;
1N/A if (buf[0])
1N/A {
1N/A v = 0;
1N/A s = buf;
1N/A break;
1N/A }
1N/A }
1N/A }
1N/A if (p->flags & CONF_MINMAX_DEF)
1N/A {
1N/A if (!((p->flags & CONF_LIMIT_DEF)))
1N/A flags |= CONF_MINMAX;
1N/A listflags &= ~ASTCONF_system;
1N/A }
1N/A predef:
1N/A if (look->standard == CONF_AST)
1N/A {
1N/A if (streq(p->name, "VERSION"))
1N/A {
1N/A v = ast.version;
1N/A break;
1N/A }
1N/A }
1N/A if (flags & CONF_MINMAX)
1N/A {
1N/A if ((p->flags & CONF_MINMAX_DEF) && (!(listflags & ASTCONF_system) || !(p->flags & CONF_DEFER_MM)))
1N/A {
1N/A v = p->minmax.number;
1N/A s = p->minmax.string;
1N/A break;
1N/A }
1N/A }
1N/A else if ((p->flags & CONF_LIMIT_DEF) && (!(listflags & ASTCONF_system) || !(p->flags & CONF_DEFER_CALL)))
1N/A {
1N/A v = p->limit.number;
1N/A s = p->limit.string;
1N/A break;
1N/A }
1N/A flags &= ~(CONF_LIMIT_DEF|CONF_MINMAX_DEF);
1N/A v = -1;
1N/A errno = EINVAL;
1N/A defined = 0;
1N/A break;
1N/A }
1N/A if (!defined)
1N/A {
1N/A if (!errno)
1N/A {
1N/A if ((p->flags & CONF_FEATURE) || !(p->flags & (CONF_LIMIT|CONF_MINMAX)))
1N/A flags &= ~(CONF_LIMIT_DEF|CONF_MINMAX_DEF);
1N/A }
1N/A else if (flags & CONF_PREFIXED)
1N/A flags &= ~(CONF_LIMIT_DEF|CONF_MINMAX_DEF);
1N/A else if (errno != EINVAL || !i)
1N/A {
1N/A if (!sp)
1N/A {
1N/A if (conferror)
1N/A {
1N/A if (call)
1N/A (*conferror)(&state, &state, ERROR_SYSTEM|2, "%s: %s error", p->name, call);
1N/A else if (!(listflags & ASTCONF_system))
1N/A (*conferror)(&state, &state, 2, "%s: unknown name", p->name);
1N/A }
1N/A goto bad;
1N/A }
1N/A else
1N/A {
1N/A flags &= ~(CONF_LIMIT_DEF|CONF_MINMAX_DEF);
1N/A flags |= CONF_ERROR;
1N/A }
1N/A }
1N/A }
1N/A errno = olderrno;
1N/A if ((listflags & ASTCONF_defined) && !(flags & (CONF_LIMIT_DEF|CONF_MINMAX_DEF)))
1N/A goto bad;
1N/A if ((drop = !sp) && !(sp = sfstropen()))
1N/A goto bad;
1N/A if (listflags & ASTCONF_table)
1N/A {
1N/A f = flg;
1N/A if (p->flags & CONF_DEFER_CALL)
1N/A *f++ = 'C';
1N/A if (p->flags & CONF_DEFER_MM)
1N/A *f++ = 'D';
1N/A if (p->flags & CONF_FEATURE)
1N/A *f++ = 'F';
1N/A if (p->flags & CONF_LIMIT)
1N/A *f++ = 'L';
1N/A if (p->flags & CONF_MINMAX)
1N/A *f++ = 'M';
1N/A if (p->flags & CONF_NOSECTION)
1N/A *f++ = 'N';
1N/A if (p->flags & CONF_PREFIXED)
1N/A *f++ = 'P';
1N/A if (p->flags & CONF_STANDARD)
1N/A *f++ = 'S';
1N/A if (p->flags & CONF_UNDERSCORE)
1N/A *f++ = 'U';
1N/A if (p->flags & CONF_NOUNDERSCORE)
1N/A *f++ = 'V';
1N/A if (p->flags & CONF_PREFIX_ONLY)
1N/A *f++ = 'W';
1N/A if (f == flg)
1N/A *f++ = 'X';
1N/A *f = 0;
1N/A sfprintf(sp, "%*s %*s %d %2s %4d %6s ", sizeof(p->name), p->name, sizeof(prefix[p->standard].name), prefix[p->standard].name, p->section, prefix[p->call + CONF_call].name, p->op, flg);
1N/A if (p->flags & CONF_LIMIT_DEF)
1N/A {
1N/A if (p->limit.string)
1N/A sfprintf(sp, "L[%s] ", (listflags & ASTCONF_quote) ? fmtquote(p->limit.string, "\"", "\"", strlen(p->limit.string), FMT_SHELL) : p->limit.string);
1N/A else
1N/A sfprintf(sp, "L[%I*d] ", sizeof(p->limit.number), p->limit.number);
1N/A }
1N/A if (p->flags & CONF_MINMAX_DEF)
1N/A {
1N/A if (p->minmax.string)
1N/A sfprintf(sp, "M[%s] ", (listflags & ASTCONF_quote) ? fmtquote(p->minmax.string, "\"", "\"", strlen(p->minmax.string), FMT_SHELL) : p->minmax.string);
1N/A else
1N/A sfprintf(sp, "M[%I*d] ", sizeof(p->minmax.number), p->minmax.number);
1N/A }
1N/A if (flags & CONF_ERROR)
1N/A sfprintf(sp, "error");
1N/A else if (defined)
1N/A {
1N/A if (s)
1N/A sfprintf(sp, "%s", (listflags & ASTCONF_quote) ? fmtquote(s, "\"", "\"", strlen(s), FMT_SHELL) : s);
1N/A else if (v != -1)
1N/A sfprintf(sp, "%I*d", sizeof(v), v);
1N/A else
1N/A sfprintf(sp, "%I*u", sizeof(v), v);
1N/A }
1N/A sfprintf(sp, "\n");
1N/A }
1N/A else
1N/A {
1N/A if (!(flags & CONF_PREFIXED) || (listflags & ASTCONF_base))
1N/A {
1N/A if (!name)
1N/A {
1N/A if ((p->flags & (CONF_PREFIXED|CONF_STRING)) == (CONF_PREFIXED|CONF_STRING) && (!(listflags & ASTCONF_base) || p->standard != CONF_POSIX))
1N/A {
1N/A if ((p->flags & CONF_UNDERSCORE) && !(listflags & ASTCONF_base))
1N/A sfprintf(sp, "_");
1N/A sfprintf(sp, "%s", (listflags & ASTCONF_lower) ? fmtlower(prefix[p->standard].name) : prefix[p->standard].name);
1N/A if (p->section > 1)
1N/A sfprintf(sp, "%d", p->section);
1N/A sfprintf(sp, "_");
1N/A }
1N/A sfprintf(sp, "%s=", (listflags & ASTCONF_lower) ? fmtlower(p->name) : p->name);
1N/A }
1N/A if (flags & CONF_ERROR)
1N/A sfprintf(sp, "error");
1N/A else if (defined)
1N/A {
1N/A if (s)
1N/A sfprintf(sp, "%s", (listflags & ASTCONF_quote) ? fmtquote(s, "\"", "\"", strlen(s), FMT_SHELL) : s);
1N/A else if (v != -1)
1N/A sfprintf(sp, "%I*d", sizeof(v), v);
1N/A else
1N/A sfprintf(sp, "%I*u", sizeof(v), v);
1N/A }
1N/A else
1N/A sfprintf(sp, "undefined");
1N/A if (!name)
1N/A sfprintf(sp, "\n");
1N/A }
1N/A if (!name && !(listflags & ASTCONF_base) && !(p->flags & CONF_STRING) && (p->flags & (CONF_FEATURE|CONF_MINMAX)))
1N/A {
1N/A if (p->flags & CONF_UNDERSCORE)
1N/A sfprintf(sp, "_");
1N/A sfprintf(sp, "%s", (listflags & ASTCONF_lower) ? fmtlower(prefix[p->standard].name) : prefix[p->standard].name);
1N/A if (p->section > 1)
1N/A sfprintf(sp, "%d", p->section);
1N/A sfprintf(sp, "_%s=", (listflags & ASTCONF_lower) ? fmtlower(p->name) : p->name);
1N/A if (v != -1)
1N/A sfprintf(sp, "%I*d", sizeof(v), v);
1N/A else if (defined)
1N/A sfprintf(sp, "%I*u", sizeof(v), v);
1N/A else
1N/A sfprintf(sp, "undefined");
1N/A sfprintf(sp, "\n");
1N/A }
1N/A }
1N/A if (drop)
1N/A {
1N/A if (call = sfstruse(sp))
1N/A call = buffer(call);
1N/A else
1N/A call = "[ out of space ]";
1N/A sfclose(sp);
1N/A return call;
1N/A }
1N/A bad:
1N/A return (listflags & ASTCONF_error) ? (char*)0 : null;
1N/A}
1N/A
1N/A/*
1N/A * return read stream to native getconf utility
1N/A */
1N/A
1N/Astatic Sfio_t*
1N/Anativeconf(Proc_t** pp, const char* operand)
1N/A{
1N/A#ifdef _pth_getconf
1N/A Sfio_t* sp;
1N/A char* cmd[3];
1N/A long ops[2];
1N/A
1N/A#if DEBUG_astconf
1N/A error(-2, "astconf defer %s %s", _pth_getconf, operand);
1N/A#endif
1N/A cmd[0] = (char*)state.id;
1N/A cmd[1] = (char*)operand;
1N/A cmd[2] = 0;
1N/A ops[0] = PROC_FD_DUP(open("/dev/null",O_WRONLY,0), 2, PROC_FD_CHILD);
1N/A ops[1] = 0;
1N/A if (*pp = procopen(_pth_getconf, cmd, environ, ops, PROC_READ))
1N/A {
1N/A if (sp = sfnew(NiL, NiL, SF_UNBOUND, (*pp)->rfd, SF_READ))
1N/A {
1N/A sfdisc(sp, SF_POPDISC);
1N/A return sp;
1N/A }
1N/A procclose(*pp);
1N/A }
1N/A#endif
1N/A return 0;
1N/A}
1N/A
1N/A/*
1N/A * value==0 gets value for name
1N/A * value!=0 sets value for name and returns previous value
1N/A * path==0 implies path=="/"
1N/A *
1N/A * settable return values are in permanent store
1N/A * non-settable return values copied to a tmp fmtbuf() buffer
1N/A *
1N/A * if (streq(astgetconf("PATH_RESOLVE", NiL, NiL, 0, 0), "logical"))
1N/A * our_way();
1N/A *
1N/A * universe = astgetconf("UNIVERSE", NiL, "att", 0, 0);
1N/A * astgetconf("UNIVERSE", NiL, universe, 0, 0);
1N/A *
1N/A * if (flags&ASTCONF_error)!=0 then error return value is 0
1N/A * otherwise 0 not returned
1N/A */
1N/A
1N/A#define ALT 16
1N/A
1N/Achar*
1N/Aastgetconf(const char* name, const char* path, const char* value, int flags, Error_f conferror)
1N/A{
1N/A register char* s;
1N/A int n;
1N/A Lookup_t look;
1N/A Sfio_t* tmp;
1N/A
1N/A#if __OBSOLETE__ < 20080101
1N/A if (pointerof(flags) == (void*)errorf)
1N/A {
1N/A conferror = errorf;
1N/A flags = ASTCONF_error;
1N/A }
1N/A else if (conferror && conferror != errorf)
1N/A conferror = 0;
1N/A#endif
1N/A if (!name)
1N/A {
1N/A if (path)
1N/A return null;
1N/A if (!(name = value))
1N/A {
1N/A if (state.data)
1N/A {
1N/A Ast_confdisc_f notify;
1N/A
1N/A#if _HUH20000515 /* doesn't work for shell builtins */
1N/A free(state.data - state.prefix);
1N/A#endif
1N/A state.data = 0;
1N/A notify = state.notify;
1N/A state.notify = 0;
1N/A INITIALIZE();
1N/A state.notify = notify;
1N/A }
1N/A return null;
1N/A }
1N/A value = 0;
1N/A }
1N/A INITIALIZE();
1N/A if (!path)
1N/A path = root;
1N/A if (state.recent && streq(name, state.recent->name) && (s = format(state.recent, path, value, flags, conferror)))
1N/A return s;
1N/A if (lookup(&look, name, flags))
1N/A {
1N/A if (value)
1N/A {
1N/A ro:
1N/A errno = EINVAL;
1N/A if (conferror)
1N/A (*conferror)(&state, &state, 2, "%s: cannot set value", name);
1N/A return (flags & ASTCONF_error) ? (char*)0 : null;
1N/A }
1N/A return print(NiL, &look, name, path, flags, conferror);
1N/A }
1N/A if ((n = strlen(name)) > 3 && n < (ALT + 3))
1N/A {
1N/A if (streq(name + n - 3, "DEV"))
1N/A {
1N/A if (tmp = sfstropen())
1N/A {
1N/A sfprintf(tmp, "/dev/");
1N/A for (s = (char*)name; s < (char*)name + n - 3; s++)
1N/A sfputc(tmp, isupper(*s) ? tolower(*s) : *s);
1N/A if ((s = sfstruse(tmp)) && !access(s, F_OK))
1N/A {
1N/A if (value)
1N/A goto ro;
1N/A s = buffer(s);
1N/A sfclose(tmp);
1N/A return s;
1N/A }
1N/A sfclose(tmp);
1N/A }
1N/A }
1N/A else if (streq(name + n - 3, "DIR"))
1N/A {
1N/A Lookup_t altlook;
1N/A char altname[ALT];
1N/A
1N/A static const char* dirs[] = { "/usr/lib", "/usr", null };
1N/A
1N/A strcpy(altname, name);
1N/A altname[n - 3] = 0;
1N/A if (lookup(&altlook, altname, flags))
1N/A {
1N/A if (value)
1N/A {
1N/A errno = EINVAL;
1N/A if (conferror)
1N/A (*conferror)(&state, &state, 2, "%s: cannot set value", altname);
1N/A return (flags & ASTCONF_error) ? (char*)0 : null;
1N/A }
1N/A return print(NiL, &altlook, altname, path, flags, conferror);
1N/A }
1N/A for (s = altname; *s; s++)
1N/A if (isupper(*s))
1N/A *s = tolower(*s);
1N/A if (tmp = sfstropen())
1N/A {
1N/A for (n = 0; n < elementsof(dirs); n++)
1N/A {
1N/A sfprintf(tmp, "%s/%s/.", dirs[n], altname);
1N/A if ((s = sfstruse(tmp)) && !access(s, F_OK))
1N/A {
1N/A if (value)
1N/A goto ro;
1N/A s = buffer(s);
1N/A sfclose(tmp);
1N/A return s;
1N/A }
1N/A }
1N/A sfclose(tmp);
1N/A }
1N/A }
1N/A }
1N/A if ((look.standard < 0 || look.standard == CONF_AST) && look.call <= 0 && look.section <= 1 && (s = feature(0, look.name, path, value, flags, conferror)))
1N/A return s;
1N/A errno = EINVAL;
1N/A if (conferror && !(flags & ASTCONF_system))
1N/A (*conferror)(&state, &state, 2, "%s: unknown name", name);
1N/A return (flags & ASTCONF_error) ? (char*)0 : null;
1N/A}
1N/A
1N/A/*
1N/A * astconf() never returns 0
1N/A */
1N/A
1N/Achar*
1N/Aastconf(const char* name, const char* path, const char* value)
1N/A{
1N/A return astgetconf(name, path, value, 0, 0);
1N/A}
1N/A
1N/A/*
1N/A * set discipline function to be called when features change
1N/A * old discipline function returned
1N/A */
1N/A
1N/AAst_confdisc_f
1N/Aastconfdisc(Ast_confdisc_f new_notify)
1N/A{
1N/A Ast_confdisc_f old_notify;
1N/A
1N/A INITIALIZE();
1N/A old_notify = state.notify;
1N/A state.notify = new_notify;
1N/A return old_notify;
1N/A}
1N/A
1N/A/*
1N/A * list all name=value entries on sp
1N/A * path==0 implies path=="/"
1N/A */
1N/A
1N/Avoid
1N/Aastconflist(Sfio_t* sp, const char* path, int flags, const char* pattern)
1N/A{
1N/A char* s;
1N/A char* f;
1N/A char* call;
1N/A Feature_t* fp;
1N/A Lookup_t look;
1N/A regex_t re;
1N/A regdisc_t redisc;
1N/A int olderrno;
1N/A char flg[8];
1N/A#ifdef _pth_getconf_a
1N/A Proc_t* proc;
1N/A Sfio_t* pp;
1N/A#endif
1N/A
1N/A INITIALIZE();
1N/A if (!path)
1N/A path = root;
1N/A else if (access(path, F_OK))
1N/A {
1N/A errorf(&state, &state, 2, "%s: not found", path);
1N/A return;
1N/A }
1N/A olderrno = errno;
1N/A look.flags = 0;
1N/A if (!(flags & (ASTCONF_read|ASTCONF_write|ASTCONF_parse)))
1N/A flags |= ASTCONF_read|ASTCONF_write;
1N/A else if (flags & ASTCONF_parse)
1N/A flags |= ASTCONF_write;
1N/A if (!(flags & (ASTCONF_matchcall|ASTCONF_matchname|ASTCONF_matchstandard)))
1N/A pattern = 0;
1N/A if (pattern)
1N/A {
1N/A memset(&redisc, 0, sizeof(redisc));
1N/A redisc.re_version = REG_VERSION;
1N/A redisc.re_errorf = (regerror_t)errorf;
1N/A re.re_disc = &redisc;
1N/A if (regcomp(&re, pattern, REG_DISCIPLINE|REG_EXTENDED|REG_LENIENT|REG_NULL))
1N/A return;
1N/A }
1N/A if (flags & ASTCONF_read)
1N/A {
1N/A for (look.conf = (Conf_t*)conf; look.conf < (Conf_t*)&conf[conf_elements]; look.conf++)
1N/A {
1N/A if (pattern)
1N/A {
1N/A if (flags & ASTCONF_matchcall)
1N/A {
1N/A if (regexec(&re, prefix[look.conf->call + CONF_call].name, 0, NiL, 0))
1N/A continue;
1N/A }
1N/A else if (flags & ASTCONF_matchname)
1N/A {
1N/A if (regexec(&re, look.conf->name, 0, NiL, 0))
1N/A continue;
1N/A }
1N/A else if (flags & ASTCONF_matchstandard)
1N/A {
1N/A if (regexec(&re, prefix[look.conf->standard].name, 0, NiL, 0))
1N/A continue;
1N/A }
1N/A }
1N/A look.standard = look.conf->standard;
1N/A look.section = look.conf->section;
1N/A print(sp, &look, NiL, path, flags, errorf);
1N/A }
1N/A#ifdef _pth_getconf_a
1N/A if (pp = nativeconf(&proc, _pth_getconf_a))
1N/A {
1N/A call = "GC";
1N/A while (f = sfgetr(pp, '\n', 1))
1N/A {
1N/A for (s = f; *s && *s != '=' && *s != ':' && !isspace(*s); s++);
1N/A if (*s)
1N/A for (*s++ = 0; isspace(*s); s++);
1N/A if (!lookup(&look, f, flags))
1N/A {
1N/A if (flags & ASTCONF_table)
1N/A {
1N/A if (look.standard < 0)
1N/A look.standard = 0;
1N/A if (look.section < 1)
1N/A look.section = 1;
1N/A sfprintf(sp, "%*s %*s %d %2s %4d %5s %s\n", sizeof(conf[0].name), f, sizeof(prefix[look.standard].name), prefix[look.standard].name, look.section, call, 0, "N", s);
1N/A }
1N/A else if (flags & ASTCONF_parse)
1N/A sfprintf(sp, "%s %s - %s\n", state.id, f, s);
1N/A else
1N/A sfprintf(sp, "%s=%s\n", f, (flags & ASTCONF_quote) ? fmtquote(s, "\"", "\"", strlen(s), FMT_SHELL) : s);
1N/A }
1N/A }
1N/A sfclose(pp);
1N/A procclose(proc);
1N/A }
1N/A#endif
1N/A }
1N/A if (flags & ASTCONF_write)
1N/A {
1N/A call = "AC";
1N/A for (fp = state.features; fp; fp = fp->next)
1N/A {
1N/A if (pattern)
1N/A {
1N/A if (flags & ASTCONF_matchcall)
1N/A {
1N/A if (regexec(&re, call, 0, NiL, 0))
1N/A continue;
1N/A }
1N/A else if (flags & ASTCONF_matchname)
1N/A {
1N/A if (regexec(&re, fp->name, 0, NiL, 0))
1N/A continue;
1N/A }
1N/A else if (flags & ASTCONF_matchstandard)
1N/A {
1N/A if (regexec(&re, prefix[fp->standard].name, 0, NiL, 0))
1N/A continue;
1N/A }
1N/A }
1N/A if (!(s = feature(fp, 0, path, NiL, 0, 0)) || !*s)
1N/A s = "0";
1N/A if (flags & ASTCONF_table)
1N/A {
1N/A f = flg;
1N/A if (fp->flags & CONF_ALLOC)
1N/A *f++ = 'A';
1N/A if (fp->flags & CONF_READONLY)
1N/A *f++ = 'R';
1N/A if (f == flg)
1N/A *f++ = 'X';
1N/A *f = 0;
1N/A sfprintf(sp, "%*s %*s %d %2s %4d %5s %s\n", sizeof(conf[0].name), fp->name, sizeof(prefix[fp->standard].name), prefix[fp->standard].name, 1, call, 0, flg, s);
1N/A }
1N/A else if (flags & ASTCONF_parse)
1N/A sfprintf(sp, "%s %s - %s\n", state.id, (flags & ASTCONF_lower) ? fmtlower(fp->name) : fp->name, fmtquote(s, "\"", "\"", strlen(s), FMT_SHELL));
1N/A else
1N/A sfprintf(sp, "%s=%s\n", (flags & ASTCONF_lower) ? fmtlower(fp->name) : fp->name, (flags & ASTCONF_quote) ? fmtquote(s, "\"", "\"", strlen(s), FMT_SHELL) : s);
1N/A }
1N/A }
1N/A if (pattern)
1N/A regfree(&re);
1N/A errno = olderrno;
1N/A}