diff options
author | Joel Sherrill <joel.sherrill@OARcorp.com> | 2000-09-01 10:57:21 +0000 |
---|---|---|
committer | Joel Sherrill <joel.sherrill@OARcorp.com> | 2000-09-01 10:57:21 +0000 |
commit | a6b4c0df5f74d1238337f41d1d13f4f168ad01f1 (patch) | |
tree | ae171319a76a707e9f3aa638b7c690e40c9f5d5e /c/src/libnetworking/rtems_webserver/emfdb.c | |
parent | 2000-08-31 Ralf Corsepius <corsepiu@faw.uni-ulm.de> (diff) | |
download | rtems-a6b4c0df5f74d1238337f41d1d13f4f168ad01f1.tar.bz2 |
2000-08-30 Joel Sherrill <joel@OARcorp.com>
* Merged version 2.1 of GoAhead webserver. This update
was submitted by Antti P Miettinen <antti.p.miettinen@nokia.com>.
* NOTES, base64.c, ejIntrn.h, emfdb.c, emfdb.h, md5.h, md5c.c,
um.c, um.h: New files.
* wbase64.c: Removed.
* Makefile.am, asp.c, balloc.c, default.c, ej.h, ejlex.c, ejparse.c,
form.c, h.c, handler.c, mime.c, misc.c, ringq.c, rom.c, security.c,
socket.c, sym.c, uemf.c, uemf.h, url.c, value.c, webcomp.c, webmain.c,
webpage.c, webrom.c, webs.c, webs.h, websuemf.c, wsIntrn.h: Modified.
Diffstat (limited to '')
-rw-r--r-- | c/src/libnetworking/rtems_webserver/emfdb.c | 1050 |
1 files changed, 1050 insertions, 0 deletions
diff --git a/c/src/libnetworking/rtems_webserver/emfdb.c b/c/src/libnetworking/rtems_webserver/emfdb.c new file mode 100644 index 0000000000..a316c1a454 --- /dev/null +++ b/c/src/libnetworking/rtems_webserver/emfdb.c @@ -0,0 +1,1050 @@ +/* + * emfdb.c -- EMF database compatability functions for GoAhead WebServer. + * + * Copyright (c) GoAhead Software Inc., 1995-2000. All Rights Reserved. + * + * See the file "license.txt" for usage and redistribution license requirements + * + * $Id$ + */ + +/******************************** Description *********************************/ +/* + * Textfile-based database support for WebServer 2.1. + */ + +/********************************* Includes ***********************************/ + +#include "emfdb.h" +#include "wsIntrn.h" + +/********************************* Defines ************************************/ + +#define KEYWORD_TABLE T("TABLE") +#define KEYWORD_ROW T("ROW") + +/*********************************** Locals ***********************************/ + +/* + * Variable to support the basicSet and basicGet functions. + */ + +static char_t *basicProdDir = NULL; +static char_t *basicDefaultDir = T("."); /* Default set to current */ + +/* + * hAlloc chain list of table schemas to be closed + */ + +static int dbMaxTables = 0; +static dbTable_t **dbListTables = NULL; + +/****************************** Forward Declarations **************************/ + +static int crack(char_t *buf, char_t **key, char_t **val); +static char_t *trim(char_t *str); +static int GetColumnIndex(int tid, char_t *colName); + +/******************************************************************************/ +/* + * Add a schema to the module-internal schema database + */ + +int dbRegisterDBSchema(dbTable_t *pTableRegister) +{ + dbTable_t *pTable; + int tid; + + a_assert(pTableRegister); + + trace(4, T("DB: Registering database table <%s>\n"), + pTableRegister->name); + +/* + * Bump up the size of the table array + */ + tid = hAllocEntry((void***) &dbListTables, + &dbMaxTables, sizeof(dbTable_t)); + +/* + * Copy the table schema to the last spot in schema array + */ + a_assert(dbListTables); + pTable = dbListTables[tid]; + a_assert(pTable); + +/* + * Copy the name of the table + */ + pTable->name = bstrdup(B_L, pTableRegister->name); + +/* + * Copy the number of columns + */ + pTable->nColumns = pTableRegister->nColumns; + +/* + * Copy the column definitions + */ + if (pTable->nColumns > 0) { + int i; + pTable->columnNames = balloc(B_L, sizeof(char_t *) * pTable->nColumns); + pTable->columnTypes = balloc(B_L, sizeof(int *) * pTable->nColumns); + + for (i = 0; (i < pTableRegister->nColumns); i++) { + pTable->columnNames[i] = + bstrdup(B_L, pTableRegister->columnNames[i]); + pTable->columnTypes[i] = pTableRegister->columnTypes[i]; + } + + } else { + pTable->columnNames = NULL; + pTable->columnTypes = NULL; + } + +/* + * Zero out the table's data (very important!) + */ + pTable->nRows = 0; + pTable->rows = NULL; + + return 0; +} + +/******************************************************************************/ +/* + * This is provided for compatibility with EMF. Tables are "registered" + * with staticly defined schemas. There is only one did in this package: 0. + */ + +int dbOpen(char_t *tablename, char_t *filename, + int (*gettime)(int did), int flags) +{ + basicProdDir = NULL; + basicDefaultDir = T("."); + dbMaxTables = 0; + dbListTables = NULL; + return 0; +} + +/******************************************************************************/ +/* + * Delete all the rows of the tables, and all of the tables + */ + +void dbClose(int did) +{ + int table, column; + dbTable_t *pTable; + +/* + * Before doing anything, delete all the contents of the database + */ + dbZero(did); + +/* + * Now delete the tables + */ + for (table = 0; table < dbMaxTables; table++) { + pTable = dbListTables[table]; + + if (pTable != NULL) { +/* + * Delete the table schema + */ + if (pTable->nColumns) { + for (column = 0; column < pTable->nColumns; column++) { + bfreeSafe(B_L, pTable->columnNames[column]); + } + bfreeSafe(B_L, pTable->columnNames); + bfreeSafe(B_L, pTable->columnTypes); + } +/* + * Delete the table name + */ + bfreeSafe(B_L, pTable->name); +/* + * Free the table + */ + bfreeSafe(B_L, pTable); + hFree((void ***) &dbListTables, table); + } + } + + if (dbListTables) { + bfree(B_L, dbListTables); + } + +/* + * Set the global table list to a safe value + */ + dbListTables = NULL; + dbMaxTables = 0; +} + + +/******************************************************************************/ +/* + * Delete all the data records in all tables + */ + +void dbZero(int did) +{ + int table, row, column, nRows, nColumns; + int *pRow; + dbTable_t *pTable; + +/* + * Delete all data from all tables + */ + for (table = 0; table < dbMaxTables; table++) { + pTable = dbListTables[table]; +/* + * Delete the row data contained within the schema + */ + if (pTable) { + nColumns = pTable->nColumns; + nRows = pTable->nRows; + for (row = 0; row < nRows; row++) { + pRow = pTable->rows[row]; + if (pRow) { +/* + * Only delete the contents of rows not previously deleted! + */ + for (column = 0; column < nColumns; column++) { + if (pTable->columnTypes[column] == T_STRING) { + bfreeSafe(B_L, (char_t *)(pRow[column])); + pRow[column] = (int)NULL; + } + } + + bfreeSafe(B_L, pRow); + hFree((void ***) &pTable->rows, row); + } + } + + pTable->rows = NULL; + pTable->nRows = 0; + } + } +} + +/******************************************************************************/ +/* + * Find the a row in the table with the given string in the given column + */ + +int dbSearchStr(int did, char_t *tablename, + char_t *colName, char_t *value, int flags) +{ + int tid, nRows, nColumns, column; + dbTable_t *pTable; + + a_assert(tablename); + a_assert(colName); + a_assert(value); + + tid = dbGetTableId(0, tablename); + a_assert(tid >= 0); + + if ((tid >= 0) && (tid < dbMaxTables) && (dbListTables[tid] != NULL)) { + pTable = dbListTables[tid]; + } else { + return DB_ERR_TABLE_NOT_FOUND; + } + + nColumns = pTable->nColumns; + nRows = pTable->nRows; + column = GetColumnIndex(tid, colName); + a_assert (column >= 0); + + if (column >= 0) { + char_t *compareVal; + int row, *pRow; +/* + * Scan through rows until we find a match. + * Note that some of these rows may be deleted! + */ + row = 0; + while (row < nRows) { + pRow = pTable->rows[row]; + if (pRow) { + compareVal = (char_t *)(pRow[column]); + if (compareVal && (gstrcmp(compareVal, value) == 0)) { + return row; + } + } + row++; + } + } else { +/* + * Return -2 if search column was not found + */ + trace(3, T("DB: Unable to find column <%s> in table <%s>\n"), + colName, tablename); + return DB_ERR_COL_NOT_FOUND; + } + + return -1; +} + +/******************************************************************************/ +/* + * Add a new row to the given table. Return the new row ID. + */ + +int dbAddRow(int did, char_t *tablename) +{ + int tid, size; + dbTable_t *pTable; + + a_assert(tablename); + + tid = dbGetTableId(0, tablename); + a_assert(tid >= 0); + + if ((tid >= 0) && (tid < dbMaxTables) && (dbListTables[tid] != NULL)) { + pTable = dbListTables[tid]; + } else { + return DB_ERR_TABLE_NOT_FOUND; + } + + a_assert(pTable); + + if (pTable) { + trace(5, T("DB: Adding a row to table <%s>\n"), tablename); + + size = pTable->nColumns * max(sizeof(int), sizeof(char_t *)); + return hAllocEntry((void***) &(pTable->rows), &(pTable->nRows), size); + } + + return -1; +} + +/******************************************************************************/ +/* + * Delete a row in the table. + */ + +int dbDeleteRow(int did, char_t *tablename, int row) +{ + int tid, nColumns, nRows; + dbTable_t *pTable; + + a_assert(tablename); + tid = dbGetTableId(0, tablename); + a_assert(tid >= 0); + + if ((tid >= 0) && (tid < dbMaxTables) && (dbListTables[tid] != NULL)) { + pTable = dbListTables[tid]; + } else { + return DB_ERR_TABLE_NOT_FOUND; + } + + nColumns = pTable->nColumns; + nRows = pTable->nRows; + + if ((row >= 0) && (row < nRows)) { + int *pRow = pTable->rows[row]; + + if (pRow) { + int column = 0; +/* + * Free up any allocated strings + */ + while (column < nColumns) { + if (pRow[column] && + (pTable->columnTypes[column] == T_STRING)) { + bfree(B_L, (char_t *)pRow[column]); + } + + column++; + } +/* + * Zero out the row for safety + */ + memset(pRow, 0, nColumns * max(sizeof(int), sizeof(char_t *))); + + bfreeSafe(B_L, pRow); + pTable->nRows = hFree((void ***)&pTable->rows, row); + trace(5, T("DB: Deleted row <%d> from table <%s>\n"), + row, tablename); + } + return 0; + } else { + trace(3, T("DB: Unable to delete row <%d> from table <%s>\n"), + row, tablename); + } + + return -1; +} + +/*****************************************************************************/ +/* + * Grow the rows in the table to the nominated size. + */ + +int dbSetTableNrow(int did, char_t *tablename, int nNewRows) +{ + int nRet, tid, nRows, nColumns; + dbTable_t *pTable; + + a_assert(tablename); + tid = dbGetTableId(0, tablename); + a_assert(tid >= 0) ; + + if ((tid >= 0) && (tid < dbMaxTables) && (dbListTables[tid] != NULL)) { + pTable = dbListTables[tid]; + } else { + return DB_ERR_TABLE_NOT_FOUND; + } + + nRet = -1; + + a_assert(pTable); + if (pTable) { + nColumns = pTable->nColumns; + nRows = pTable->nRows; + nRet = 0; + + if (nRows >= nNewRows) { +/* + * If number of rows already allocated exceeds requested number, do nothing + */ + trace(4, T("DB: Ignoring row set to <%d> in table <%s>\n"), + nNewRows, tablename); + } else { + trace(4, T("DB: Setting rows to <%d> in table <%s>\n"), + nNewRows, tablename); + while (pTable->nRows < nNewRows) { + if (dbAddRow(did, tablename) < 0) { + return -1; + } + } + } + } + + return nRet; +} + +/******************************************************************************/ +/* + * Return the number of rows in the given table + */ + +int dbGetTableNrow(int did, char_t *tablename) +{ + int tid; + + a_assert(tablename); + tid = dbGetTableId(did, tablename); + + if ((tid >= 0) && (tid < dbMaxTables) && (dbListTables[tid] != NULL)) { + return (dbListTables[tid])->nRows; + } else { + return -1; + } +} + +/******************************************************************************/ +/* + * Do table driven read of the database + */ + +int dbReadInt(int did, char_t *table, char_t *column, int row, int *returnValue) +{ + int colIndex, *pRow, tid; + dbTable_t *pTable; + + a_assert(table); + a_assert(column); + a_assert(returnValue); + + tid = dbGetTableId(0, table); + a_assert(tid >= 0); + +/* + * Return -6 if table is not found + */ + if (tid < 0) { + return DB_ERR_TABLE_NOT_FOUND; + } + +/* + * Return -7 if table id has been deleted + */ + pTable = dbListTables[tid]; + if (pTable == NULL) { + return DB_ERR_TABLE_DELETED; + } + + a_assert(row >= 0); + + if ((row >= 0) && (row < pTable->nRows)) { + colIndex = GetColumnIndex(tid, column); + a_assert(colIndex >= 0); + + if (colIndex >= 0) { + pRow = pTable->rows[row]; + if (pRow) { + *returnValue = pRow[colIndex]; + return 0; + } + return DB_ERR_ROW_DELETED; + } + return DB_ERR_COL_NOT_FOUND; + } + + return DB_ERR_ROW_NOT_FOUND; +} + +/******************************************************************************/ +/* + * dbReadStr calls dbReadInt to do table driven read of database + */ + +int dbReadStr(int did, char_t *table, char_t *column, int row, + char_t **returnValue) +{ + return dbReadInt(did, table, column, row, (int *)returnValue); +} + +/******************************************************************************/ +/* + * The dbWriteInt function writes a value into a table at a given row and + * column. The existence of the row and column is verified before the + * write. 0 is returned on succes, -1 is returned on error. + */ + +int dbWriteInt(int did, char_t *table, char_t *column, int row, int iData) +{ + int tid, colIndex, *pRow; + dbTable_t *pTable; + + a_assert(table); + a_assert(column); + +/* + * Make sure that this table exists + */ + tid = dbGetTableId(0, table); + a_assert(tid >= 0); + + if (tid < 0) { + return DB_ERR_TABLE_NOT_FOUND; + } + + pTable = dbListTables[tid]; + + if (pTable) { +/* + * Make sure that the column exists + */ + colIndex = GetColumnIndex(tid, column); + a_assert(colIndex >= 0); + if (colIndex >= 0) { +/* + * Make sure that the row exists + */ + a_assert((row >= 0) && (row < pTable->nRows)); + if ((row >= 0) && (row < pTable->nRows)) { + pRow = pTable->rows[row]; + if (pRow) { + pRow[colIndex] = iData; + return 0; + } + return DB_ERR_ROW_DELETED; + } + return DB_ERR_ROW_NOT_FOUND; + } + return DB_ERR_COL_NOT_FOUND; + } + + return DB_ERR_TABLE_DELETED; +} + +/******************************************************************************/ +/* + * The dbWriteStr function writes a string value into a table at a given row + * and column. The existence of the row and column is verified before the + * write. The column is also checked to confirm it is a string field. + * 0 is returned on succes, -1 is returned on error. + */ + +int dbWriteStr(int did, char_t *table, char_t *column, int row, char_t *s) +{ + int tid, colIndex; + int *pRow; + char_t *ptr; + dbTable_t *pTable; + + a_assert(table); + a_assert(column); + + tid = dbGetTableId(0, table); + a_assert(tid >= 0); + + if (tid < 0) { + return DB_ERR_TABLE_NOT_FOUND; + } + +/* + * Make sure that this table exists + */ + pTable = dbListTables[tid]; + a_assert(pTable); + if (!pTable) { + return DB_ERR_TABLE_DELETED; + } + +/* + * Make sure that this column exists + */ + colIndex = GetColumnIndex(tid, column); + if (colIndex < 0) { + return DB_ERR_COL_NOT_FOUND; + } + +/* + * Make sure that this column is a string column + */ + if (pTable->columnTypes[colIndex] != T_STRING) { + return DB_ERR_BAD_FORMAT; + } + +/* + * Make sure that the row exists + */ + a_assert((row >= 0) && (row < pTable->nRows)); + if ((row >= 0) && (row < pTable->nRows)) { + pRow = pTable->rows[row]; + } else { + return DB_ERR_ROW_NOT_FOUND; + } + + if (!pRow) { + return DB_ERR_ROW_DELETED; + } + +/* + * If the column already has a value, be sure to delete it to prevent + * memory leaks. + */ + if (pRow[colIndex]) { + bfree(B_L, (char_t *) pRow[colIndex]); + } + +/* + * Make sure we make a copy of the string to write into the column. + * This allocated string will be deleted when the row is deleted. + */ + ptr = bstrdup(B_L, s); + pRow[colIndex] = (int)ptr; + + return 0; +} + +/******************************************************************************/ +/* + * Print a key-value pair to a file + */ + +static int dbWriteKeyValue(int fd, char_t *key, char_t *value) +{ + int rc; + int len; + char_t *pLineOut; + + a_assert(key && *key); + a_assert(value); + + fmtAlloc(&pLineOut, BUF_MAX, T("%s=%s\n"), key, value); + + if (pLineOut) { + len = gstrlen(pLineOut); +#if CE + rc = writeUniToAsc(fd, pLineOut, len); +#else + rc = gwrite(fd, pLineOut, len); +#endif + bfree(B_L, pLineOut); + } else { + rc = -1; + } + + return rc; +} + +/******************************************************************************/ +/* + * Persist a database to a file + */ + +int dbSave(int did, char_t *filename, int flags) +{ + int row, column, nColumns, nRows, fd, rc; + int *colTypes, *pRow, nRet, tid; + char_t *path, *tmpFile, *tmpNum; + char_t **colNames; + dbTable_t *pTable; + + trace(5, T("DB: About to save database to file\n")); + + a_assert(dbMaxTables > 0); + +/* + * First write to a temporary file, then switch around later. + */ + fmtAlloc(&tmpFile, FNAMESIZE, T("%s/data.tmp"), basicGetProductDir()); + if ((fd = gopen(tmpFile, + O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0666)) < 0) { + trace(1, T("WARNING: Failed to open file %s\n"), tmpFile); + bfree(B_L, tmpFile); + return -1; + } + + nRet = 0; + + for (tid = 0; (tid < dbMaxTables) && (nRet != -1); tid++) { + pTable = dbListTables[tid]; + + if (pTable) { +/* + * Print the TABLE=tableName directive to the file + */ + rc = dbWriteKeyValue(fd, KEYWORD_TABLE, pTable->name); + + nColumns = pTable->nColumns; + nRows = pTable->nRows; + + for (row = 0; (row < nRows) && (nRet == 0); row++) { + pRow = pTable->rows[row]; +/* + * if row is NULL, the row has been deleted, so don't + * write it out. + */ + if ((pRow == NULL) || (pRow[0] == '\0') || + (*(char_t *)(pRow[0]) == '\0')) { + continue; + } +/* + * Print the ROW=rowNumber directive to the file + */ + fmtAlloc(&tmpNum, 20, T("%d"), row); + rc = dbWriteKeyValue(fd, KEYWORD_ROW, tmpNum); + bfreeSafe(B_L, tmpNum); + + colNames = pTable->columnNames; + colTypes = pTable->columnTypes; +/* + * Print the key-value pairs (COLUMN=value) for data cells + */ + for (column = 0; (column < nColumns) && (rc >= 0); + column++, colNames++, colTypes++) { + if (*colTypes == T_STRING) { + rc = dbWriteKeyValue(fd, *colNames, + (char_t *)(pRow[column])); + } else { + fmtAlloc(&tmpNum, 20, T("%d"), pRow[column]); + rc = dbWriteKeyValue(fd, *colNames, tmpNum); + bfreeSafe(B_L, tmpNum); + } + } + + if (rc < 0) { + trace(1, T("WARNING: Failed to write to file %s\n"), + tmpFile); + nRet = -1; + } + } + } + } + + gclose(fd); + +/* + * Replace the existing file with the temporary file, if no errors + */ + if (nRet == 0) { + fmtAlloc(&path, FNAMESIZE, T("%s/%s"), basicGetProductDir(), filename); + + gunlink(path); + if (grename(tmpFile, path) != 0) { + trace(1, T("WARNING: Failed to rename %s to %s\n"), tmpFile, path); + nRet = -1; + } + + bfree(B_L, path); + } + + bfree(B_L, tmpFile); + + return nRet; +} + +/******************************************************************************/ +/* + * Crack a keyword=value string into keyword and value. We can change buf. + */ + +static int crack(char_t *buf, char_t **key, char_t **val) +{ + char_t *ptr; + + if ((ptr = gstrrchr(buf, '\n')) != NULL || + (ptr = gstrrchr(buf, '\r')) != NULL) { + *ptr = '\0'; + } + +/* + * Find the = sign. It must exist. + */ + if ((ptr = gstrstr(buf, T("="))) == NULL) { + return -1; + } + + *ptr++ = '\0'; + *key = trim(buf); + *val = trim(ptr); + + return 0; +} + +/******************************************************************************/ +/* + * Parse the file. These files consist of key-value pairs, separated by the + * "=" sign. Parsing of tables starts with the "TABLE=value" pair, and rows + * are parsed starting with the "ROW=value" pair. + */ + +int dbLoad(int did, char_t *filename, int flags) +{ + gstat_t sbuf; + char_t *buf, *keyword, *value, *path, *ptr; + char_t *tablename; + int fd, tid, row; + dbTable_t *pTable; + + a_assert(did >= 0); + + fmtAlloc(&path, FNAMESIZE, T("%s/%s"), basicGetProductDir(), filename); + trace(4, T("DB: About to read data file <%s>\n"), path); + + if (gstat(path, &sbuf) < 0) { + trace(3, T("DB: Failed to stat persistent data file.\n")); + bfree(B_L, path); + return -1; + } + + fd = gopen(path, O_RDONLY | O_BINARY, 0666); + bfree(B_L, path); + + if (fd < 0) { + trace(3, T("DB: No persistent data file present.\n")); + return -1; + } + + if (sbuf.st_size <= 0) { + trace(3, T("DB: Persistent data file is empty.\n")); + gclose(fd); + return -1; + } +/* + * Read entire file into temporary buffer + */ + buf = balloc(B_L, sbuf.st_size + 1); +#if CE + if (readAscToUni(fd, &buf, sbuf.st_size) != (int)sbuf.st_size) { +#else + if (gread(fd, buf, sbuf.st_size) != (int)sbuf.st_size) { +#endif + trace(3, T("DB: Persistent data read failed.\n")); + bfree(B_L, buf); + gclose(fd); + return -1; + } + + gclose(fd); + *(buf + sbuf.st_size) = '\0'; + + row = -1; + tid = -1; + pTable = NULL; + ptr = gstrtok(buf, T("\n")); + tablename = NULL; + + do { + if (crack(ptr, &keyword, &value) < 0) { + trace(5, T("DB: Failed to crack line %s\n"), ptr); + continue; + } + + a_assert(keyword && *keyword); + + if (gstrcmp(keyword, KEYWORD_TABLE) == 0) { +/* + * Table name found, check to see if it's registered + */ + if (tablename) { + bfree(B_L, tablename); + } + + tablename = bstrdup(B_L, value); + tid = dbGetTableId(did, tablename); + + if (tid >= 0) { + pTable = dbListTables[tid]; + } else { + pTable = NULL; + } + + } else if (gstrcmp(keyword, KEYWORD_ROW) == 0) { +/* + * Row/Record indicator found, add a new row to table + */ + if (tid >= 0) { + int nRows = dbGetTableNrow(did, tablename); + + if (dbSetTableNrow(did, tablename, nRows + 1) == 0) { + row = nRows; + } + } + + } else if (row != -1) { +/* + * some other data found, assume it's a COLUMN=value + */ + int nColumn = GetColumnIndex(tid, keyword); + + if ((nColumn >= 0) && (pTable != NULL)) { + int nColumnType = pTable->columnTypes[nColumn]; + if (nColumnType == T_STRING) { + dbWriteStr(did, tablename, keyword, row, value); + } else { + dbWriteInt(did, tablename, keyword, row, gstrtoi(value)); + } + } + } + } while ((ptr = gstrtok(NULL, T("\n"))) != NULL); + + if (tablename) { + bfree(B_L, tablename); + } + + bfree(B_L, buf); + + return 0; +} + +/******************************************************************************/ +/* + * Return a table id given the table name + */ + +int dbGetTableId(int did, char_t *tablename) +{ + int tid; + dbTable_t *pTable; + + a_assert(tablename); + + for (tid = 0; (tid < dbMaxTables); tid++) { + if ((pTable = dbListTables[tid]) != NULL) { + if (gstrcmp(tablename, pTable->name) == 0) { + return tid; + } + } + } + + return -1; +} + +/******************************************************************************/ +/* + * Return a pointer to the table name, given its ID + */ + +char_t *dbGetTableName(int did, int tid) +{ + if ((tid >= 0) && (tid < dbMaxTables) && (dbListTables[tid] != NULL)) { + return (dbListTables[tid])->name; + } + + return NULL; +} + +/******************************************************************************/ +/* + * Trim leading white space. + */ + +static char_t *trim(char_t *str) +{ + while (isspace((int)*str)) { + str++; + } + return str; +} + +/******************************************************************************/ +/* + * Return a column index given the column name + */ + +static int GetColumnIndex(int tid, char_t *colName) +{ + int column; + dbTable_t *pTable; + + a_assert(colName); + + if ((tid >= 0) && (tid < dbMaxTables) && (dbListTables[tid] != NULL)) { + pTable = dbListTables[tid]; + + for (column = 0; (column < pTable->nColumns); column++) { + if (gstrcmp(colName, pTable->columnNames[column]) == 0) + return column; + } + } + + return -1; +} + +/******************************************************************************/ +/* + * Set the prefix-directory + */ + +void basicSetProductDir(char_t *proddir) +{ + int len; + + if (basicProdDir != NULL); { + bfree(B_L, basicProdDir); + } + + basicProdDir = bstrdup(B_L, proddir); +/* + * Make sure that prefix-directory doesn't end with a '/' + */ + len = gstrlen(basicProdDir); + if ((len > 0) && *(basicProdDir + len - 1) == '/') { + *(basicProdDir+len-1) = '\0'; + } +} + +/******************************************************************************/ +/* + * Return the prefix-directory + */ + +char_t *basicGetProductDir() +{ + if (basicProdDir) { + return basicProdDir; + } else { + return basicDefaultDir; + } +} + +/******************************************************************************/ |