/*
openisis - an open implementation of the CDS/ISIS database
Version 0.8.x (patchlevel see file Version)
Copyright (C) 2001-2003 by Erik Grziwotz, erik@openisis.org
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
see README for more information
EOH */
/*
$Id: lfdt.c,v 1.25 2003/06/15 15:57:43 mawag Exp $
implementation of FDT calls and static FDTs.
*/
#include <limits.h> /* CHAR_MAX,PATH_MAX */
#include <stdio.h>
#include <string.h>
#include "openisis.h"
#include "loi.h"
#include "lfdt.h"
#include "luti.h"
#define FDF_EXT ".fdt"
#define FDF_NAMLEN 30
#define FDF_PATLEN 20 /* format of *.fdt */
#define FDF_TOOLEN 6
#if FDF_NAMLEN >= FD_NAMELEN
fix me
#endif
/* ************************************************************
private types
*/
/* ************************************************************
private data
*/
#define _FD_DFLTDB \
{ OPENISIS_SC_DFLTDB, 0, FTX, 0, 0, DBNLEN, "defaultdb", \
"Name of default db", 0, 0, 0, 0 }
#define _FD_DPATH \
{ OPENISIS_DPATH, 0, FTX, 0, 0, PATH_MAX, "dbpath", \
"Database Path", 0, 0, 0, 0 }
#define _FD_DENC \
{ OPENISIS_DENC, 0, FTX, 0, 0, 32, "encoding", \
"Encoding", 0, 0, 0, 0 }
static Fd _fdsys[] = {
/* 700 ... OpenIsis system parameters */
{ OPENISIS_SPATH, 0, FTX, 0, 0, PATH_MAX, "syspath",
"Global Database Path", 0, 0, 0, 0 },
{ OPENISIS_SLOGF, 0, FTX, 0, 0, PATH_MAX, "logfile",
"Logfile Name", 0, 0, 0, 0 },
{ OPENISIS_SLOGV, 0, FTE, 0, 0, 16, "v",
"Verbosity of Logging", 0, 0, 0, 0 },
{ OPENISIS_SLOGV, 0, FTV, 0, 0, 0, "off",
"don't log anything", 0, 0, 0, 0 },
{ OPENISIS_SLOGV, 0, FTV, 0, 0, 1, "fatal", "", 0, 0, 0, 0 },
{ OPENISIS_SLOGV, 0, FTV, 0, 0, 3, "syserr", "", 0, 0, 0, 0 },
{ OPENISIS_SLOGV, 0, FTV, 0, 0, 4, "error", "", 0, 0, 0, 0 },
{ OPENISIS_SLOGV, 0, FTV, 0, 0, 5, "warn", "", 0, 0, 0, 0 },
{ OPENISIS_SLOGV, 0, FTV, 0, 0, 6, "info", "", 0, 0, 0, 0 },
{ OPENISIS_SLOGV, 0, FTV, 0, 0, 7, "verbose", "", 0, 0, 0, 0 },
{ OPENISIS_SLOGV, 0, FTV, 0, 0, 8, "trace", "", 0, 0, 0, 0 },
{ OPENISIS_SLOGV, 0, FTV, 0, 0, 9, "debug", "", 0, 0, 0, 0 },
{ OPENISIS_SLOGV, 0, FTV, 0, 0, 10, "all", "", 0, 0, 0, 0 },
_FD_DFLTDB,
_FD_DPATH,
_FD_DENC
};
static Fdt _fdtsys = {
sizeof (_fdsys) / sizeof (_fdsys[0]),
_fdsys,
0
};
static Fd _fdsch[] = {
{ OPENISIS_SC_NAME, 0, FTX, 0, 0, SCNLEN, "name",
"Identification of remote scheme", 0, 0, 0, 0 },
{ OPENISIS_SC_HOST, 0, FTX, 0, 0, 64, "host",
"Hostname of remote scheme", 0, 0, 0, 0 },
{ OPENISIS_SC_PORT, 0, FTN, 0, 0, 5, "port",
"Port of remote scheme", 0, 0, 0, 0 },
_FD_DFLTDB,
_FD_DPATH,
_FD_DENC
};
static Fdt _fdtsch = {
sizeof (_fdsch) / sizeof (_fdsch[0]),
_fdsch,
0
};
static Fd _fddb[] = {
{ OPENISIS_DNAME, 0, FTX, 0, 0, DBNLEN, "db",
"Identification of database", 0, 0, 0, 0 },
{ OPENISIS_DTYPE, 0, FTE, 0, 0, 256, "format",
"Database Format", 0, 0, 0, 0 },
{ OPENISIS_DTYPE, 0, FTV, 0, 0, 0, "autoformat",
"Database Format", 0, 0, 0, 0 },
{ OPENISIS_DTYPE, 0, FTV, 0, 0, 1, "naligned",
"Database Format", 0, 0, 0, 0 },
{ OPENISIS_DTYPE, 0, FTV, 0, 0, 2, "aligned",
"Database Format", 0, 0, 0, 0 },
{ OPENISIS_DRO , 0, FTB, 0, 0, 1, "ro",
"Readonly Flag", 0, 0, 0, 0 },
_FD_DPATH,
{ OPENISIS_DDUMP, 0, FTB, 0, 0, 1, "internaldump",
"Internal Dump Flag", 0, 0, 0, 0 },
_FD_DENC,
{ OPENISIS_DFDT, 0, FTX, 0, 0, 256, "fdt",
"Path to fdt", 0, 0, 0, 0 }
};
static Fdt _fdtdb = {
sizeof (_fddb) / sizeof (_fddb[0]),
_fddb,
0
};
static Fd _fdfd[] = {
{ OPENISIS_FDID, 0, FTN, 0, 0, 10, "tag",
"Tag number of field", 0, 0, 0, 0 },
{ OPENISIS_FDSUB, 0, FTX, 0, 0, 1, "subfield",
"Subfield", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTE, 0, 0, 2, "type",
"Field type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTX, "alphanum",
"Field type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTA, "alpha",
"Field type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTN, "numeric",
"Field type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTP, "pattern",
"Field type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTI, "iso",
"Field type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTE, "enum",
"Field type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTB, "boolean",
"Field type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTT, "table",
"Field type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTS, "structure",
"Field type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTF | FTX, "subalphanum",
"Subfield type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTF | FTA, "subalpha",
"Subfield type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTF | FTN, "subnumeric",
"Subfield type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTF | FTP, "subpattern",
"Subfield type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTF | FTI, "subiso",
"Subfield type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTF | FTE, "subenum",
"Subfield type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTF | FTB, "subbool",
"Subfield type", 0, 0, 0, 0 },
{ OPENISIS_FDTYPE, 0, FTV, 0, 0, FTV, "enum value",
"Enumeration value", 0, 0, 0, 0 },
{ OPENISIS_FDREP, 0, FTB, 0, 0, 1, "repeatable",
"Repeatable flag", 0, 0, 0, 0 },
{ OPENISIS_FDNUMC, 0, FTN, 0, 0, 2, "numchilds",
"Number of subfield childs", 0, 0, 0, 0 },
{ OPENISIS_FDLEN, 0, FTN, 0, 0, 10, "length",
"Field length or enum value", 0, 0, 0, 0 },
{ OPENISIS_FDNAME, 0, FTX, 0, 0, 30, "name",
"Field name", 0, 0, 0, 0 },
{ OPENISIS_FDDESC, 0, FTX, 0, 0, 31, "description",
"Description", 0, 0, 0, 0 },
{ OPENISIS_FDPAT, 0, FTX, 0, 0, 128, "pattern",
"Pattern", 0, 0, 0, 0 },
{ OPENISIS_FDDFLT, 0, FTX, 0, 0, 1024, "default",
"Default value", 0, 0, 0, 0 },
{ OPENISIS_FDINFO, 0, FTS, 0, 0, 1, "info",
"Embedded info record", 0, 0, 0, 0 },
{ OPENISIS_FDCHLD, 0, FTX, 1, 0, 1, "children",
"Subfield childs", 0, 0, 0, 0 }
};
static Fdt _fdtfd = {
sizeof (_fdfd) / sizeof (_fdfd[0]),
_fdfd,
0
};
#define _FD_FDT \
{ OPENISIS_FDT_LEN, 0, FTN, 0, 0, 3, "flen", \
"Length of fdt", 0, 0, 0, 0 }, \
{ OPENISIS_FDT_FD, 0, FTS, 1, 0, 1, "fd", \
"Field description", 0, 0, 0, 0 }, \
{ OPENISIS_FDT_REC, 0, FTS, 0, 0, 1, "frec", \
"Embedded info record", 0, 0, 0, 0 }
static Fd _fdfdt[] = {
_FD_FDT
};
static Fdt _fdtfdt = {
sizeof (_fdfdt) / sizeof (_fdfdt[0]),
_fdfdt,
0
};
#define _FD_COM \
{ OPENISIS_COM_SID, 0, FTN, 0, 0, 2, "sid", \
"Client Session Id", 0, 0, 0, 0 }, \
{ OPENISIS_COM_SER, 0, FTN, 0, 0, 5, "ser", \
"Request Serial No.", 0, 0, 0, 0 }, \
{ OPENISIS_COM_DBN, 0, FTX, 0, 0, DBNLEN, "db", \
"DB Identification", 0, 0, 0, 0 }, \
{ OPENISIS_COM_TMS, 0, FTN, 0, 0, 10, "tms", \
"Server Db Timestamp", 0, 0, 0, 0 }, \
{ OPENISIS_COM_ROW, 0, FTN, 0, 0, 10, "rowid", \
"RowId", 0, 0, 0, 0 }, \
_FD_FDT, \
{ OPENISIS_COM_CFG, 0, FTS, 0, 0, 0, "config", \
"Config", 0, 0, 0, 0 }, \
{ OPENISIS_COM_REC, 0, FTS, 1, 0, 0, "rec", \
"Data", 0, 0, 0, 0 }
static Fd _fdrqs[] = {
_FD_COM,
{ OPENISIS_RQS_TYPE, 0, FTE, 0, 0, 32, "type",
"Request type", 0, 0, 0, 0 },
{ OPENISIS_RQS_TYPE, 0, FTV, 0, 0, OPENISIS_RQST_OPEN, "open",
"open db", 0, 0, 0, 0 },
{ OPENISIS_RQS_TYPE, 0, FTV, 0, 0, OPENISIS_RQST_CLOS, "close",
"close db", 0, 0, 0, 0 },
{ OPENISIS_RQS_TYPE, 0, FTV, 0, 0, OPENISIS_RQST_MNT, "mount",
"mount db", 0, 0, 0, 0 },
{ OPENISIS_RQS_TYPE, 0, FTV, 0, 0, OPENISIS_RQST_LSDB, "ls",
"list dbs", 0, 0, 0, 0 },
{ OPENISIS_RQS_TYPE, 0, FTV, 0, 0, OPENISIS_RQST_MROW, "maxrow",
"get maxrowid", 0, 0, 0, 0 },
{ OPENISIS_RQS_TYPE, 0, FTV, 0, 0, OPENISIS_RQST_QRY, "query",
"exec query", 0, 0, 0, 0 },
{ OPENISIS_RQS_TYPE, 0, FTV, 0, 0, OPENISIS_RQST_READ, "read",
"fetch row", 0, 0, 0, 0 },
{ OPENISIS_RQS_TYPE, 0, FTV, 0, 0, OPENISIS_RQST_INS, "insert",
"insert rec", 0, 0, 0, 0 },
{ OPENISIS_RQS_TYPE, 0, FTV, 0, 0, OPENISIS_RQST_UPD, "update",
"update rec", 0, 0, 0, 0 },
{ OPENISIS_RQS_TYPE, 0, FTV, 0, 0, OPENISIS_RQST_DEL, "delete",
"delete row", 0, 0, 0, 0 },
{ OPENISIS_RQS_TYPE, 0, FTV, 0, 0, OPENISIS_RQST_EVAL, "eval",
"evaluate command", 0, 0, 0, 0 },
{ OPENISIS_RQS_FLG, 0, FTN, 0, 0, 4, "flags",
"Request flags", 0, 0, 0, 0 },
{ OPENISIS_RQS_QMOD, 0, FTN, 0, 0, 5, "mode",
"Query Mode", 0, 0, 0, 0 },
{ OPENISIS_RQS_SKIP, 0, FTN, 0, 0, 5, "skip",
"Query Skip", 0, 0, 0, 0 },
{ OPENISIS_RQS_SIZE, 0, FTN, 0, 0, 5, "size",
"Result Length", 0, 0, 0, 0 },
{ OPENISIS_RQS_KEY, 0, FTX, 0, 0, OPENISIS_QRY_KEYLEN, "key",
"Query Key", 0, 0, 0, 0 },
{ OPENISIS_RQS_IDX, 0, FTS, 0, 0, 0, "idx",
"Index to Update", 0, 0, 0, 0 }
};
static Fdt _fdtrqs = {
sizeof (_fdrqs) / sizeof (_fdrqs[0]),
_fdrqs,
0
};
static Fd _fdrsp[] = {
_FD_COM,
{ OPENISIS_RSP_DBID, 0, FTN, 0, 0, 2, "dbid",
"Id of local db", 0, 0, 0, 0 },
{ OPENISIS_RSP_ERR, 0, FTN, 0, 0, 5, "error",
"Error Code", 0, 0, 0, 0 },
{ OPENISIS_RSP_MSG, 0, FTX, 0, 0, OPENISIS_ERRMSGLEN, "msg",
"Error Message", 0, 0, 0, 0 },
{ OPENISIS_RSP_NUMT, 0, FTN, 0, 0, 5, "total",
"Total No. of Records", 0, 0, 0, 0 },
{ OPENISIS_RSP_NUMR, 0, FTN, 0, 0, 5, "size",
"Number of Records", 0, 0, 0, 0 },
{ OPENISIS_RSP_CERR, 0, FTN, 0, 0, 5, "error2",
"Client Side Error", 0, 0, 0, 0 }
};
static Fdt _fdtrsp = {
sizeof (_fdrsp) / sizeof (_fdrsp[0]),
_fdrsp,
0
};
/* ************************************************************
public data
*/
const Fdt *openIsisFdtSyspar = &_fdtsys;
const Fdt *openIsisFdtScheme = &_fdtsch;
const Fdt *openIsisFdtDbpar = &_fdtdb;
const Fdt *openIsisFdtFd = &_fdtfd;
const Fdt *openIsisFdtFdt = &_fdtfdt;
const Fdt *openIsisFdtRqs = &_fdtrqs;
const Fdt *openIsisFdtRsp = &_fdtrsp;
/* ************************************************************
private functions
*/
static char *fFileGets (FILE *fp) {
static char buf[4096];
char *res;
int len;
while (1) {
nxtl:
if (0 == (res = fgets (buf, sizeof(buf) - 1, fp))) {
break;
}
buf[sizeof(buf) - 1] = 0;
if (!(len = strlen (res))) {
continue;
}
--len;
while (0 <= len) {
if ('\n' != res[len] && '\r' != res[len]) {
break;
}
res[len] = 0;
if (0 > --len) {
goto nxtl;
}
}
break;
}
return res;
}
static void strrtrim (char *str) {
char *p = str + strlen (str) - 1;
while (p >= str && (' ' == *p || '\t' == *p)) {
*p-- = 0;
}
}
static void fDesc2Name (char *d, char *n) {
while (1) {
if (!(*n = *d)) {
return;
}
if ('A' <= *n && 'Z' >= *n) {
*n += 'a' - 'A';
++n;
++d;
continue;
}
if ('_' == *n ||
('a' <= *n && 'z' >= *n) ||
('0' <= *n && '9' >= *n)) {
++n;
++d;
continue;
}
while (1) {
++d;
if (!*d) {
*n = 0;
return;
}
if (('A' <= *d && 'Z' >= *d) ||
('a' <= *d && 'z' >= *d) ||
('0' <= *d && '9' >= *d)) {
break;
}
}
*n++ = '_';
}
}
static int fLine2Fd (char *line, Fd **fd, int *num) {
char name[FD_NAMELEN];
char pat[1 + FDF_PATLEN];
Fd buff, bufs;
char *P;
char *L = line;
int tag, len, typ, rep, idx;
if (FDF_NAMLEN + FDF_PATLEN >= strlen (L)) {
return sMsg (ERR_INVAL, "fFileFd: illegal line <%s>", line);
}
strncpy (name, L, FDF_NAMLEN) [FDF_NAMLEN] = 0;
strrtrim (name);
if (! *name) {
return sMsg (ERR_INVAL, "fFileFd: no descr in line <%s>", line);
}
L += FDF_NAMLEN;
strncpy (pat, L, FDF_PATLEN) [FDF_PATLEN] = 0;
strrtrim (pat);
L += FDF_PATLEN;
if (4 != sscanf (L, "%d %d %d %d", &tag, &len, &typ, &rep)) {
return sMsg (ERR_INVAL, "fFileFd: no type in line <%s>", line);
}
switch (typ) {
case 0: typ = FTX; break;
case 1: typ = FTA; break;
case 2: typ = FTN; break;
case 3: typ = FTP; break;
default: return sMsg (ERR_INVAL,
"fFileFd: unrecognized type %d in line <%s>", typ, line);
}
memset (&buff, 0, sizeof (Fd));
buff.id = tag;
buff.type = typ;
buff.rep = 0 != rep;
buff.len = len;
strcpy (buff.desc, name);
fDesc2Name (name, buff.name);
if (! *buff.name) {
return sMsg (ERR_INVAL, "fFileFd: illegal name in line <%s>", line);
}
if (FTP == typ) {
if (! *pat) {
return sMsg (ERR_INVAL, "fFileFd: illegal pat in line <%s>", line);
}
buff.pat = mDup (pat, -1);
if (! buff.pat) {
return sMsg (ERR_NOMEM, "fFileFd: cannot allocate pat");
}
}
idx = luti_ptrincr (fd, num, 1, sizeof(Fd), -1);
if (0 > idx) {
return sMsg (ERR_NOMEM,
"fFileFd: cannot extend fd array %d", *num);
}
memcpy (*fd + idx, &buff, sizeof(Fd));
if (FTP != typ) {
for (P = pat; *P; ++P) {
memcpy (&bufs, &buff, sizeof(Fd));
bufs.subf = *P;
bufs.type = FTX;
idx = luti_ptrincr (fd, num, 1, sizeof(Fd), -1);
if (0 > idx) {
return sMsg (ERR_NOMEM,
"fFileFd: cannot extend fd array %d", *num);
}
memcpy (*fd + idx, &bufs, sizeof(Fd));
}
}
return 0;
}
static int fLine2Tool (char *line, Rec **rec) {
char tool[1 + FDF_TOOLEN];
char *L = line;
int len, typ;
switch (*L) {
case 'w':
case 'W':
typ = OPENISIS_DFMT;
break;
case 'f':
case 'F':
typ = OPENISIS_DPFT;
break;
case 's':
case 'S':
typ = OPENISIS_DFST;
break;
default:
return sMsg (ERR_INVAL, "fLine2Tool: illegal line <%s>", line);
}
L += 2;
len = strlen (L);
while (0 < len) {
strncpy (tool, L, FDF_TOOLEN) [FDF_TOOLEN] = 0;
strrtrim (tool);
RADDS (*rec, typ, tool, !0);
if (! *rec) {
return sMsg (ERR_NOMEM, "fLine2Tool: cannot extend rec");
}
L += FDF_TOOLEN;
len -= FDF_TOOLEN;
}
return 0;
}
static int fResolveChilds (Fd *fd, int len) {
char msg[256] = { 0 };
Fd *buf[CHAR_MAX];
Fd **C;
Fd *F, *G;
int numc;
int err = 0;
for (F = fd + len; --F >= fd; ) {
if (! F->subf) {
numc = 0;
C = buf;
for (G = fd + len; --G >= fd; ) {
if (G->subf && (! G->id || G->id == F->id)) {
if (CHAR_MAX == numc) {
err = ERR_INVAL;
sprintf (msg,
"fResolveChilds: too many childs for %s",
F->name);
break;
}
*C++ = G;
++numc;
}
}
if (numc) {
C = mAlloc (numc * sizeof(Fd));
if (! C) {
return sMsg (ERR_NOMEM, "fResolveChilds");
}
F->subs = (Fd**) memcpy (C, buf, numc * sizeof(Fd));
F->slen = numc;
}
}
}
if (err) {
return sMsg (err, msg);
}
return 0;
}
static void fFreeFd (Fd *fd) {
if (fd) {
if (fd->pat) {
mFree (fd->pat);
}
if (fd->dflt) {
mFree (fd->dflt);
}
if (fd->info) {
mFree (fd->info);
}
if (fd->subs) {
mFree (fd->subs);
}
}
}
static Fdt* fCleanupArr (Fdt *fdt, Fd *arr, int len) {
Fd *F;
for (F = arr + len; --F >= arr; ) {
fFreeFd (F);
}
mFree (arr);
mFree (fdt);
return 0;
}
/* ************************************************************
package functions
*/
/* ************************************************************
public functions
*/
Fd* fById ( const Fdt *fdt, int id, int subf )
{
Fd *f, *e;
if (! fdt) {
return 0;
}
for (e = (f = fdt->fd) + fdt->len; --e >= f; ) {
if (id == e->id && subf == e->subf && ! (0xf0 & e->type)) {
return e;
}
}
return 0;
}
Fd* fByName ( const Fdt *fdt, const char *name )
{
Fd *f, *e, *g;
const char *p;
int l, cnt;
if (! fdt || ! name) {
return 0;
}
f = fdt->fd;
e = f + fdt->len;
if ( '-' == *name ) /* ignore leading dash */
name++;
if (! *name) {
return 0;
}
if ( '0' <= *name && *name <= '9' )
return fById( fdt, a2i( name, -1 ), 0 );
p = name;
while ( 'a' <= *p ? *p <= 'z' : '9' >= *p ? *p >= '0' : '_' == *p )
p++;
l = p - name;
if ( ! l || l > FD_NAMELEN - 1 )
return 0;
for ( cnt = 0, g = 0; f < e; f++ ) {
if ( *name == *f->name
&& !(0xf0 & f->type) /* is field */
&& !memcmp( name, f->name, l ) ) {
if (!f->name[l]) {
return f;
}
g = f;
++cnt;
}
}
return 1 == cnt ? g : 0;
}
/**
lookup enum:
if name is numeric, the value is returned, if legal
considered are value entries with given id or id 0
- if there is an exact match with same id, this is used
- if there is an exact match with id 0, this is used
- if name is a unique prefix on given id, this is used
- if name is no prefix on given id, but a unique prefix on 0, this is used
*/
int fEnum ( Fdt *fdt, int id, const char *name )
{
Fd *f = fdt->fd, *e = f + fdt->len,
*x0 = 0, *pi = 0, *p0 = 0;
int ui = 1, u0 = 1; /* unique */
int l = strlen( name );
if ( ! l || l > FD_NAMELEN - 1 )
return NOENUM;
if ( ('0' <= *name && *name <= '9')
|| ('-' == *name && '0' <= name[1] && name[1] <= '9')
) {
int v = a2i( name, l );
for ( ; f < e; f++ ) {
if ( FTV == f->type && v == f->len && (f->id == id || !f->id) )
return v;
}
return NOENUM;
}
for ( ; f < e; f++ ) {
if ( FTV != f->type
|| *name != *f->name
|| memcmp( name, f->name, l )
|| (f->id && f->id != id)
)
continue;
if ( !f->name[l] ) { /* exact match */
if ( f->id == id )
return f->len;
x0 = f; /* f->id is 0 */
continue;
}
/* prefix match */
if ( f->id == id ) {
if ( pi )
ui = 0;
else
pi = f;
} else
if ( p0 )
u0 = 0;
else
p0 = f;
}
return x0 ? x0->len
: pi ? (ui ? pi->len : NOENUM)
: p0 && u0 ? p0->len : NOENUM;
}
Fdt* fFree ( Fdt *fdt ) {
Fd *F, *E;
if (fdt) {
if (fdt->fd) {
for (E = (F = fdt->fd) + fdt->len; --E >= F; ) {
fFreeFd (E);
}
mFree (fdt->fd);
}
if (fdt->rec) {
mFree (fdt->rec);
}
mFree (fdt);
}
return 0;
}
Fdt* fFromFile (char *path) {
FILE *fp;
char *line;
Fdt *res;
Fd *fd;
Rec *rec;
int len, err;
/* ldb::setext */
len = strlen (path) - 4;
memcpy (path + len, FDF_EXT, 4);
if ( 'A'<=path[len-1] && path[len-1]<= 'Z' ) {
char *p = path + len;
for ( ;*p; p++ ) /* use uppercase extensions */
if ( 'a' <= *p && *p <= 'z' )
*p -= 'a'-'A';
}
fp = fopen (path, "r");
if (! fp) {
sMsg (LOG_INFO | ERR_BADF, "no such fdt: %s", path);
return 0;
}
res = mAlloc (sizeof(Fdt));
if (! res) {
fclose (fp);
sMsg (ERR_NOMEM, "fFromFile");
return 0;
}
sMsg (LOG_VERBOSE, "> reading fdt: %s", path);
fd = 0;
rec = 0;
err = len = 0;
while ((line = fFileGets (fp))) {
if ('*' == *line) {
continue;
}
if (':' == line[1]) {
if (-ERR_NOMEM == (err = fLine2Tool (line, &rec))) {
break;
}
continue;
}
if (-ERR_NOMEM == (err = fLine2Fd (line, &fd, &len))) {
break;
}
}
fclose (fp);
res->fd = fd;
res->rec = rec;
res->len = len;
if (-ERR_NOMEM == err) {
return fFree (res);
}
sMsg (LOG_VERBOSE, "< %d entries in fdt", len);
return res;
}
#define ADDFDS(tag,val) \
RADDS (rec, tag, val, !0); \
if (! rec) { return 0; }
Rec* fFd2Rec (const Fd *fd, Rec *rec, int embchld) {
char buf[16];
Fd **E, **F;
Rec *child;
if (! fd) {
return rec;
}
i2a (buf, fd->id);
ADDFDS (OPENISIS_FDID, buf);
if ((*buf = fd->subf)) {
buf[1] = 0;
ADDFDS (OPENISIS_FDSUB, buf);
}
i2a (buf, fd->type);
ADDFDS (OPENISIS_FDTYPE, buf);
i2a (buf, fd->rep);
ADDFDS (OPENISIS_FDREP, buf);
i2a (buf, fd->len);
ADDFDS (OPENISIS_FDLEN, buf);
ADDFDS (OPENISIS_FDNAME, fd->name);
ADDFDS (OPENISIS_FDDESC, fd->desc);
if (fd->pat) {
ADDFDS (OPENISIS_FDPAT, fd->pat);
}
if (fd->dflt) {
ADDFDS (OPENISIS_FDDFLT, fd->dflt);
}
if (fd->info) {
rec = luti_wrap (rec, fd->info, OPENISIS_FDINFO);
if (! rec) {
return 0;
}
}
if (embchld && fd->slen) {
for (E = (F = fd->subs) + fd->slen; rec && F < E; ++F) {
child = fFd2Rec (*F, 0, 0);
if (! child) {
return rec;
}
rec = luti_wrap (rec, child, OPENISIS_FDCHLD);
}
if (rec) {
rec = rAddI (rec, OPENISIS_FDNUMC, fd->slen, !0);
}
}
return rec;
}
Rec* fFdt2Rec (const Fdt *fdt, Rec *rec, int embchld) {
Fd *E, *F;
Rec *R;
int len;
if (! fdt) {
return rec;
}
if (fdt->rec) {
rec = luti_wrap (rec, fdt->rec, OPENISIS_FDT_REC);
if (! rec) { return 0; }
}
for (E = (F = fdt->fd) + fdt->len, len = 0; F < E; ++F) {
if (! F->subf || ! embchld) {
R = fFd2Rec (F, 0, embchld);
if (! R) {
return rec;
}
rec = luti_wrap (rec, R, OPENISIS_FDT_FD);
mFree (R);
if (! rec) {
return 0;
}
++len;
}
}
rec = rAddI (rec, OPENISIS_FDT_LEN, len, !0);
return rec;
}
Fd *fRec2Fd (Rec *rec, Fd *buf) {
char name[FD_NAMELEN];
Field *F, *E;
Fd *fd;
int got = 0;
if (! rec) {
return 0;
}
if (! (fd = buf)) {
fd = mAlloc (sizeof(Fd));
if (! fd) {
return 0;
}
}
*name = 0;
for (E = (F = rec->field) + rec->len; F < E; ++F) {
switch (F->tag) {
case OPENISIS_FDID:
got |= 0x01;
fd->id = a2id (F->val, F->len, 0);
break;
case OPENISIS_FDSUB:
if (! (1 == F->len || (2 == F->len && ! F->val[1]))) {
sMsg (ERR_INVAL,
"fRec2Fd: ignoring illegal subfield id (%s)", name);
}
else {
fd->subf = F->val[0];
}
break;
case OPENISIS_FDTYPE:
got |= 0x02;
fd->type = (char) a2id (F->val, F->len, 0);
break;
case OPENISIS_FDREP:
if (! (1 == F->len || (2 == F->len && ! F->val[1]))) {
sMsg (ERR_INVAL,
"fRec2Fd: ignoring illegal repeatable flag (%s)", name);
}
else {
fd->rep = F->val[0] && '0' != F->val[0];
}
break;
case OPENISIS_FDLEN:
fd->len = (short) a2id (F->val, F->len, 0);
break;
case OPENISIS_FDNAME:
got |= 0x04;
if (FD_NAMELEN <= F->len) {
memcpy (name, F->val, FD_NAMELEN - 1);
name[FD_NAMELEN - 1] = 0;
sMsg (ERR_INVAL,
"fRec2Fd: name too long (%d) - truncated to %s",
F->len, name);
}
else {
memcpy (name, F->val, F->len);
name[F->len] = 0;
}
if (! *fd->desc) {
strcpy (fd->desc, name);
}
fDesc2Name (name, fd->name);
if (!*(fd->name)) {
sMsg (ERR_INVAL,
"fRec2Fd: illegal name (%s)", name);
got &= ~0x04;
}
break;
case OPENISIS_FDDESC:
if (FD_NAMELEN <= F->len) {
memcpy (fd->desc, F->val, FD_NAMELEN - 1);
fd->desc[FD_NAMELEN - 1] = 0;
sMsg (ERR_INVAL,
"fRec2Fd: descr too long (%d) - truncated to %s (%s)",
F->len, fd->desc, name);
}
else {
memcpy (fd->desc, F->val, F->len);
fd->desc[F->len] = 0;
}
break;
case OPENISIS_FDPAT:
if (fd->pat) {
sMsg (ERR_INVAL,
"fRec2Fd: ignoring multiple occurences of pattern (%s)",
name);
}
else {
fd->pat = (char*) mAlloc (1 + F->len);
if (! fd->pat) {
goto err;
}
memcpy (fd->pat, F->val, F->len);
fd->pat[F->len] = 0;
}
break;
case OPENISIS_FDDFLT:
if (fd->dflt) {
sMsg (ERR_INVAL,
"fRec2Fd: ignoring multiple occurences of dflt (%s)",
name);
}
else {
fd->dflt = (char*) mAlloc (1 + F->len);
if (! fd->dflt) {
goto err;
}
memcpy (fd->dflt, F->val, F->len);
fd->dflt[F->len] = 0;
}
break;
case OPENISIS_FDINFO:
if (fd->info) {
sMsg (ERR_INVAL,
"fRec2Fd: ignoring multiple occurences of info (%s)",
name);
}
else {
int pos = F - rec->field;
fd->info = luti_unwrap (rec, &pos, OPENISIS_FDINFO, -1);
if (! fd->info) {
goto err;
}
F = rec->field + pos - 1;
}
break;
default:
sMsg (ERR_INVAL,
"fRec2Fd: ignoring unexpected tag %d (%s)",
F->tag, name);
}
}
if (0x07 != got) {
sMsg (ERR_TRASH,
"fRec2Fd: incomplete field description [%x] (%s)", got, name);
err:
if (fd->pat) { mFree (fd->pat); }
if (fd->dflt) { mFree (fd->dflt); }
if (fd->info) { mFree (fd->info); }
if (fd != buf) { mFree (fd); }
return 0;
}
return fd;
}
Fdt *fRec2Fdt (Rec *rec) {
Rec *R, *cfg;
Fdt *fdt;
Fd fdbuf;
Fd *F, *arr;
int err, num, len, pos;
if (!rec) {
return 0;
}
num = rInt (rec, OPENISIS_FDT_LEN, 0, 0);
if (0 >= num) {
return 0;
}
arr = (Fd*) mAlloc (num * sizeof (Fd));
if (!arr) {
return 0;
}
fdt = (Fdt*) mAlloc (sizeof(Fdt));
if (! fdt) {
mFree (arr);
return 0;
}
for (F = arr, len = pos = 0; num; --num) {
R = luti_unwrap (rec, &pos, OPENISIS_FDT_FD, -1);
if (!R) {
return fCleanupArr (fdt, arr, len);
}
memset (&fdbuf, 0, sizeof(Fd));
if (fRec2Fd (R, &fdbuf)) {
memcpy (F, &fdbuf, sizeof(Fd));
++len;
++F;
}
mFree (R);
}
if (len != num) {
num = len * sizeof(Fd);
F = (Fd*) mAlloc (num);
if (! F) {
return fCleanupArr (fdt, arr, len);
}
memcpy (F, arr, num);
mFree (arr);
arr = F;
}
cfg = luti_unwrap (rec, 0, OPENISIS_FDT_REC, -1);
fdt->len = len;
fdt->fd = arr;
fdt->rec = cfg;
err = fResolveChilds (arr, len);
if (-ERR_NOMEM == err) {
return fFree (fdt);
}
return fdt;
}
RSS Feed