fc-selenite: src/g23m-aci/aci/db.c comparison

comparison src/g23m-aci/aci/db.c @ 1:d393cd9bb723

src/g23m-*: initial import from Magnetite

author	Mychaela Falconia <falcon@freecalypso.org>
date	Sun, 15 Jul 2018 04:40:46 +0000
parents
children

comparison

equal deleted inserted replaced

-:b6a5e36de839
+:d393cd9bb723
+/*
++-----------------------------------------------------------------------------
+|  Project :  PHB
+|  Modul   :  DBM
++-----------------------------------------------------------------------------
+|  Copyright 2005 Texas Instruments Berlin, AG
+|                 All rights reserved.
+|
+|                 This file is confidential and a trade secret of Texas
+|                 Instruments Berlin, AG
+|                 The receipt of or possession of this file does not convey
+|                 any rights to reproduce or disclose its contents or to
+|                 manufacture, use, or sell anything it may describe, in
+|                 whole, or in part, without the specific written consent of
+|                 Texas Instruments Berlin, AG.
++-----------------------------------------------------------------------------
+|  Purpose :  Implementation of DBM functions
++-----------------------------------------------------------------------------
+*/
+#ifdef TI_PS_FFS_PHB
+#include "db_int.h"
+#include <string.h>
+#ifdef _SIMULATION_
+int sprintf (char *, const char *, ...); /* Use appropriate include ... */
+#endif
+/* For DB Testing */
+/* Check if we are closing FFS files properly */
+/* Implements measure 54 */
+/* A simple check to make sure that all allocated
+memory is freed to avoid memory leak */
+// #define DB_MEMORY_CHECK
+/**************************
+D E F I N I T I O N S &
+D E C L A R A T I O N S
+**************************/
+#define INVALID_FD      (-1)
+#define IS_FD_VALID(fd) ((fd) >= 0)
+GLOBAL UBYTE              UsedDBs;								          /* Number of existing databases  */
+GLOBAL int                LastFFS_ReturnCode;			          /* Last FFS return code          */
+GLOBAL T_DBM_MASTERRECORD DbmMaster [MAX_DBs];              /* Database Master               */
+GLOBAL T_DBM_STATE        DBM_State = DBM_NOT_INITIALISED;  /* DBM State                     */
+GLOBAL T_DB_CHANGED       DB_History_log;                   /* History log                   */
+/* Implements Measure#32: Row 1167, 1171, 1189 & 1200 */
+LOCAL const char * const format_sUDd_str="%s/UD_%04X";
+/* Implements Measure#32: Row 1170, 1177 & 1193 */
+LOCAL const char * const format_sUDd_sortd_str="%s/UD_%04X_sort_%d";
+/* Implements Measure#32: Row 1178, 1182, 1186, 1190, 1195, 1198 & 1202 */
+LOCAL const char * const format_sDDd_str="%s/DD_%d";
+#ifdef FFS_CLOSE_BEFORE_OPEN
+T_FFS_FD Dummy_FFSFileHandle = INVALID_FD;
+#define INVALID_FLD_CTR  0xFF
+#define NOT_OPENED       0x00
+#define OPENED_FOR_READ  0x01
+#define OPENED_FOR_WRITE 0x02
+#endif
+#ifdef DB_TEST
+S8 db_test_ffs_open_ctr = 0;
+T_FFS_SIZE db_test_ffs_ret_code = EFFS_OK;
+#define DB_FFS_OPEN( ret, file, flag ) \
+{ \
+ret = ffs_open( file, flag ); \
+\
+if( ret >= EFFS_OK ) \
+{ \
+++db_test_ffs_open_ctr; \
+TRACE_EVENT_P1( "DB_FFS_OPEN:db_test_ffs_open_ctr:%d", db_test_ffs_open_ctr ); \
+} else { \
+TRACE_EVENT_P1( "DB_FFS_OPEN:FFS ERROR:%d", ret ); \
+} \
+}
+#define DB_FFS_CLOSE( fd ) \
+{ \
+T_FFS_SIZE db_test_ffs_ret_code = ffs_close( fd ); \
+\
+if( db_test_ffs_ret_code >= EFFS_OK ) \
+{ \
+--db_test_ffs_open_ctr; \
+TRACE_EVENT_P1( "DB_FFS_CLOSE:db_test_ffs_open_ctr:%d", db_test_ffs_open_ctr ); \
+} else { \
+TRACE_EVENT_P1( "DB_FFS_CLOSE:FFS ERROR:%d", db_test_ffs_ret_code ); \
+} \
+\
+fd = INVALID_FD; \
+}
+#define DB_RETURN( ret ) \
+{ \
+TRACE_EVENT_P1( "DB_RETURN:ret:%d", ret ); \
+return ret; \
+}
+#define DB_VALUE_RETURN( ret ) \
+{ \
+TRACE_EVENT_P1( "DB_VALUE_RETURN:ret:%d", ret ); \
+return ret; \
+}
+#else
+#define DB_FFS_OPEN( ret, file, flag ) { ret = ffs_open( file, flag ); }
+#define DB_FFS_CLOSE( fd ) { ffs_close( fd ); fd = INVALID_FD; }
+#define DB_RETURN( ret ) return ret;
+#define DB_VALUE_RETURN( ret ) return ret;
+#endif
+#ifdef DB_MEMORY_CHECK
+LOCAL UBYTE alloc_ctr = 0;
+LOCAL void db_mfree (void *ptr)
+{
+if (ptr NEQ NULL)
+{
+--alloc_ctr;
+TRACE_EVENT_P1( "DB Memory Free:%d", alloc_ctr );
+ACI_MFREE( ptr );
+}
+else
+{
+TRACE_ERROR ("Attempted to free NULL");
+}
+}
+LOCAL void *db_malloc (ULONG num_of_bytes)
+{
+void *ptr;
+++alloc_ctr;
+TRACE_EVENT_P1( "DB Memory Alloc:%d", alloc_ctr );
+ACI_MALLOC( ptr, num_of_bytes );
+return ptr;
+}
+#define DB_MALLOC( ptr, size )  { ptr = db_malloc ( size ); }
+#define DB_MFREE( ptr )         { db_mfree ( ptr ); }
+#else
+#define DB_MALLOC( ptr, num_of_bytes ) ACI_MALLOC( ptr, num_of_bytes )
+#define DB_MFREE( ptr ) ACI_MFREE( ptr )
+#endif
+#ifdef _SIMULATION_
+#define DB_DIR "/dbm"
+#define DB_MASTER_FILE "/dbm/DD_master"
+#else
+#define DB_DIR "/gsm/dbm"
+#define DB_MASTER_FILE "/gsm/dbm/DD_master"
+#endif
+/* Implements Measure#32: Row 1179, 1184, 1191, 1196, 1199 & 1203 */
+LOCAL const char * const db_dir=DB_DIR;
+/* Implements Measure#32: Row 1181, 1188 & 1201 */
+LOCAL  char * const db_master_file=DB_MASTER_FILE;
+#define FILENAME_LEN 40
+#define T_DB_MASTER_RECORD_SIZE 18
+/* DBM master record
+File: DB_DIR/DD_master
+Data:
+1)	DBDirectory (16 bytes, based on MAX_LEN_DIRECTORY=16)
+2)	NumOfFiles (1 byte, based on MAX_NUM_FILES=255)
+3) Clean (1 byte)
+*/
+#define T_DB_FIELD_RECORD_SIZE 43
+/* Based on the following data written into FFS
+File: DB_DIR/DD_<DBDirectory>
+Data:
+1)	FieldID (2 bytes, given in Interface)
+2)	DBType (1 byte)
+3)	RecordSize (2 bytes, based on MAX_RECORD_SIZE=65kb)
+4)	NumOfRecords (1 byte, based on MAX_NUM_RECORDS=255)
+5) SortIndexes (MAX_NUM_OF_SORT_INDEXS bytes, 1 byte for each index)
+6)	RecordBitMap (32 bytes, as of now based on MAX_NUM_RECORDS=255)
+7) Clean (1 byte)
+*/
+#define RecordBitMap_OFFSET 10  /* depending on structure in DB_DIR/DD_<DBDirectory> */
+#define SortIndexList_OFFSET 6  /* depending on structure in DB_DIR/DD_<DBDirectory> */
+#define SEARCH_FAILED -1
+/* For FFS strctures */
+#define FFS_CLEAN       0x01
+#define FFS_DIRTY       0x00
+#define FFS_TRACKED 0x01
+#define FFS_NOT_TRACKED 0x00
+#define NOT !
+#define INVALID_RECORD_NUM 0xFF
+/*
+Internal function to initialize RAM structures with FFS
+*/
+LOCAL T_DB_CODE init_RAM_with_FFS ( void );
+#define	DBM_State_check \
+if ( DBM_State EQ DBM_NOT_INITIALISED ) DB_RETURN( DB_NOT_INITIALISED );
+LOCAL T_DB_CODE db_handle_check ( int db_handle );
+LOCAL UBYTE field_id_search ( int db_handle,
+USHORT field_id );
+LOCAL T_DB_CODE update_history_log ( int    db_handle,
+USHORT field_id,
+USHORT record_num );
+LOCAL void db_set_bit_in_bitmap (UBYTE *bitmap,
+USHORT position,
+BOOL value);
+LOCAL UBYTE db_search_bit_in_bitmap (UBYTE* bitmap,
+USHORT max_record,
+BOOL value);
+LOCAL T_DB_CODE populate_sorted_list_from_FFS (
+#ifdef FFS_CLOSE_BEFORE_OPEN
+UBYTE db_ctr,
+#endif
+char*   sort_file,
+UBYTE   num_of_elements,
+UBYTE** sort_list_ptr );
+LOCAL T_DB_CODE write_sorted_list_to_FFS (
+#ifdef FFS_CLOSE_BEFORE_OPEN
+UBYTE db_ctr,
+#endif
+char*   sort_file,
+UBYTE   num_of_elements,
+UBYTE*  sort_list );
+LOCAL int db_binary_search ( UBYTE*            sort_list,
+UBYTE             num_of_elements,
+SHORT*            order_num,
+T_SEARCH_FUNC     search_function,
+ULONG             flags,
+const UBYTE*      search_tag,
+int               db_handle,
+USHORT            field_id );
+LOCAL T_DB_CODE update_field_data_in_FFS ( T_FFS_FD*   filehandle,
+UBYTE       db_handle,
+UBYTE       fld_ctr,
+UBYTE*      field_data,
+USHORT      offset,
+USHORT      length );
+LOCAL UBYTE cal_NextRecordNum ( const char* DBDirectory,
+USHORT      FieldID,
+USHORT      RecordSize );
+LOCAL T_DB_CODE read_write_user_record_from_FFS ( const char      *user_field_file,
+#ifdef FFS_CLOSE_BEFORE_OPEN
+UBYTE       db_ctr,
+UBYTE       fld_ctr,
+#endif
+T_FFS_FD        *filehandle,
+UBYTE       record_num,
+USHORT      record_size,
+USHORT      offset,
+USHORT      length,
+UBYTE           *record_buffer,
+T_FFS_OPEN_FLAGS open_option);
+LOCAL T_DB_CODE check_ffs_ret_code (T_FFS_SIZE ffs_ret_code,
+T_FFS_FD  *filehandle,
+T_FFS_FD   ffs_fd,
+BOOL       check_invalid);
+LOCAL T_DB_CODE delete_file_dir_from_FFS ( const char* filename );
+LOCAL T_DB_CODE update_dbm_data_in_FFS ( const char* filename,
+UBYTE       db_ctr,
+UBYTE       db_data_max_size,
+UBYTE*      db_data,
+USHORT      offset,
+USHORT      length );
+LOCAL T_DB_CODE remove_field_from_FFS ( UBYTE db_ctr,
+UBYTE fld_ctr );
+#ifdef FFS_CLOSE_BEFORE_OPEN
+LOCAL T_FFS_FD db_open_user_field_file ( UBYTE            db_ctr,
+UBYTE            fld_ctr,
+const char*      user_field_file,
+T_FFS_OPEN_FLAGS open_option );
+LOCAL void db_close_user_field_files ( UBYTE db_ctr );
+LOCAL BOOL db_open_full_for_read ( UBYTE db_ctr );
+LOCAL BOOL db_open_full_for_write ( UBYTE db_ctr );
+LOCAL void db_close_for_write ( UBYTE db_ctr );
+LOCAL void db_close_for_read ( UBYTE db_ctr );
+LOCAL UBYTE db_status_user_field_file ( UBYTE db_ctr,
+UBYTE fld_ctr );
+#endif /* FFS_CLOSE_BEFORE_OPEN */
+LOCAL T_DB_CODE delete_dir_forced ( const char* filename );
+LOCAL void get_sort_lists_from_FFS ( UBYTE db_ctr,
+UBYTE fld_ctr );
+LOCAL void new_in_sort_lists ( UBYTE db_ctr,
+UBYTE fld_ctr,
+UBYTE record_num );
+LOCAL void update_in_sort_lists ( UBYTE db_ctr,
+UBYTE fld_ctr,
+UBYTE record_num );
+LOCAL void delete_in_sort_lists ( UBYTE db_ctr,
+UBYTE fld_ctr,
+UBYTE record_num );
+LOCAL void insertion_sort ( UBYTE*        sort_list,
+UBYTE         num_of_elements,
+T_COMP_FUNC   compare_function,
+ULONG         flags,
+int           db_handle,
+USHORT        field_id );
+LOCAL void insert_element ( UBYTE*        sort_list,
+UBYTE         num_of_elements,
+UBYTE         bottom,
+UBYTE         top,
+UBYTE         record_num,
+T_COMP_FUNC   compare_function,
+ULONG         flags,
+int           db_handle,
+USHORT        field_id );
+LOCAL T_DB_CODE internal_db_sort ( int          db_handle,
+USHORT       field_id,
+UBYTE        sort_index,
+T_COMP_FUNC  compare_function,
+ULONG        flags );
+LOCAL void db_close_for_read_write ( FileHandleRecord  *tmp_open_fields,
+UBYTE             *tmp_old,
+UBYTE              max_per_db);
+/******************************
+I M P L E M E N T A T I O N
+******************************/
+/**********************/
+/* INTERNAL FUNCTIONS */
+/**********************/
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_handle_check      |
++--------------------------------------------------------------------+
+PURPOSE : DB Handle checks
+*/
+LOCAL T_DB_CODE db_handle_check ( int db_handle )
+{
+/* Check for db_handle range */
+if( db_handle >= MAX_DBs )
+return DB_INVALID_DB;
+/* Check for DBState of db_handle is CLOSED or UNUSED_ENTRY
+If yes, return DB_INVALID_DB  */
+if( ( DbmMaster[db_handle].DBState EQ CLOSED       ) OR
+( DbmMaster[db_handle].DBState EQ UNUSED_ENTRY ) )
+return DB_INVALID_DB;
+return DB_OK;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: field_id_search      |
++--------------------------------------------------------------------+
+PURPOSE : checks for the existence of field id in RAM
+*/
+LOCAL UBYTE field_id_search ( int     db_handle,
+USHORT  field_id )
+{
+UBYTE  fld_ctr;
+for( fld_ctr = 0; fld_ctr < DbmMaster[db_handle].NumOfFiles; ++fld_ctr )
+{
+if( DbmMaster[db_handle].ptrFieldRecord[fld_ctr].FieldID EQ field_id )
+{
+return fld_ctr;
+}
+}
+return fld_ctr;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: update_history_log   |
++--------------------------------------------------------------------+
+PURPOSE : Updating history log
+*/
+LOCAL T_DB_CODE update_history_log ( int    db_handle,
+USHORT field_id,
+USHORT record_num )
+{
+UBYTE i;
+/* Check if database is tracked */
+if (!DbmMaster[db_handle].Tracked) /* if db is NOT tracked */
+return DB_OK;
+/* Search history log if the record is present
+If present, return DB_OK */
+for( i = 0; i < DB_History_log.entries; ++i )
+{
+if( DB_History_log.field_id[i] EQ field_id )
+if( DB_History_log.record[i] EQ record_num )
+return DB_OK;
+}
+/* If the number of existing logs in history is reached limit, DB_MAX_AFFECTED,
+return error "DB_HISTORY_FULL". */
+if( DB_History_log.entries EQ DB_MAX_AFFECTED )
+return DB_HISTORY_FULL;
+/* Add new entry */
+DB_History_log.field_id [DB_History_log.entries] = field_id;
+DB_History_log.record [DB_History_log.entries] = record_num;
+++DB_History_log.entries;
+return DB_OK;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_get_bit_in_bitmap |
++--------------------------------------------------------------------+
+PURPOSE : Gets a bit in record bitmap
+*/
+LOCAL BOOL db_get_bit_in_bitmap (const UBYTE *bitmap, USHORT position)
+{
+USHORT offset;
+UBYTE mask;
+position--; /* We count from 1 */
+offset = position >> 3;
+mask = 0x80 >> (position & 0x7);
+return ((bitmap[offset] & mask) NEQ 0);
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: set_bit_in_bitmap    |
++--------------------------------------------------------------------+
+PURPOSE : Sets a bit in record bitmap
+*/
+LOCAL void db_set_bit_in_bitmap (UBYTE *bitmap, USHORT position, BOOL value)
+{
+USHORT offset;
+UBYTE mask;
+//TISH modified for MSIM
+if (position==0) return;
+position--; /* We count from 1 */
+offset = position >> 3;
+mask = 0x80 >> (position & 0x7);
+if (value)
+bitmap[offset] |= mask;
+else
+bitmap[offset] &= ~mask;
+}
+/*
++----------------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                          |
+|                                       ROUINE: db_search_bit_in_bitmap      |
++----------------------------------------------------------------------------+
+PURPOSE : Searches for the bit not set in record bitmap which
+indicates free record
+*/
+LOCAL UBYTE db_search_bit_in_bitmap (UBYTE* bitmap, USHORT max_record, BOOL value)
+{
+UBYTE i;
+for (i = 1; i <= max_record; i++)
+{
+if (db_get_bit_in_bitmap (bitmap, i) EQ value)
+return i;
+}
+return 0; /* Not found */
+}
+/*
++----------------------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                                |
+|                                       ROUINE: populate_sorted_list_from_FFS      |
++----------------------------------------------------------------------------------+
+PURPOSE : Reads the sorted list from FFS
+*/
+LOCAL T_DB_CODE populate_sorted_list_from_FFS (
+#ifdef FFS_CLOSE_BEFORE_OPEN
+UBYTE db_ctr,
+#endif
+char*   sort_file,
+UBYTE   num_of_elements,
+UBYTE** sort_list_ptr )
+{
+T_FFS_FD   ffs_fd_sort_file;
+T_FFS_SIZE ffs_ret_code;
+UBYTE*     sort_list;
+#ifdef FFS_CLOSE_BEFORE_OPEN
+/* READ */
+if( db_open_full_for_read( db_ctr ) )
+{
+db_close_for_read( db_ctr );
+}
+#endif
+DB_FFS_OPEN( ffs_fd_sort_file, sort_file, FFS_O_RDONLY );
+if( (ffs_fd_sort_file EQ EFFS_NAMETOOLONG ) OR
+(ffs_fd_sort_file EQ EFFS_BADNAME     ) OR
+(ffs_fd_sort_file EQ EFFS_NOTFOUND    ) OR
+(ffs_fd_sort_file EQ EFFS_INVALID     ) OR
+(ffs_fd_sort_file EQ EFFS_LOCKED      ) )
+{
+	  TRACE_EVENT_P1( "populate_sorted_list_from_FFS:DB_FFS_OPEN %d", ffs_fd_sort_file );
+return DB_FAIL;
+}
+if( ffs_fd_sort_file < EFFS_OK )
+{
+LastFFS_ReturnCode = ffs_fd_sort_file;
+	  TRACE_EVENT_P1( "populate_sorted_list_from_FFS:DB_FFS_OPEN %d", ffs_fd_sort_file );
+return DB_FAIL_FS;
+}
+/* This seek is not required as file pointer will be at start of file,
+but ffs guide doesn't say so ! This needs to be clarified and
+accordingly all ffs_seek at start of file after opening the file
+can be removed ! */
+ffs_ret_code = ffs_seek( ffs_fd_sort_file, 0, FFS_SEEK_SET );
+if( ( ffs_ret_code EQ EFFS_BADFD )   OR
+( ffs_ret_code EQ EFFS_INVALID ) OR
+( ffs_ret_code EQ EFFS_BADOP )   )
+{
+DB_FFS_CLOSE( ffs_fd_sort_file );
+	  TRACE_EVENT_P1( "populate_sorted_list_from_FFS:ffs_seek %d", ffs_ret_code );
+return DB_FAIL;
+}
+DB_MALLOC( sort_list, num_of_elements + 1 );
+memset( sort_list, INVALID_RECORD_NUM, num_of_elements + 1 );
+ffs_ret_code = ffs_read( ffs_fd_sort_file,
+sort_list,
+num_of_elements );
+if( (ffs_ret_code EQ EFFS_BADFD ) OR
+(ffs_ret_code EQ EFFS_BADOP ) )
+{
+DB_MFREE( sort_list );
+DB_FFS_CLOSE( ffs_fd_sort_file );
+	  TRACE_EVENT_P1( "populate_sorted_list_from_FFS:ffs_read %d", ffs_ret_code );
+return DB_FAIL;
+}
+if( ffs_ret_code < EFFS_OK )
+{
+LastFFS_ReturnCode = ffs_fd_sort_file;
+DB_MFREE( sort_list );
+	  TRACE_EVENT_P1( "populate_sorted_list_from_FFS:ffs_read %d", ffs_ret_code );
+DB_FFS_CLOSE( ffs_fd_sort_file );
+return DB_FAIL_FS;
+}
+DB_FFS_CLOSE( ffs_fd_sort_file );
+/* to avoid memory leak */
+if( *sort_list_ptr NEQ NULL )
+DB_MFREE( *sort_list_ptr );
+*sort_list_ptr = sort_list;
+return DB_OK;
+}
+/*
++-----------------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                           |
+|                                       ROUINE: write_sorted_list_to_FFS      |
++-----------------------------------------------------------------------------+
+PURPOSE : Writes the sorted list into FFS
+*/
+LOCAL T_DB_CODE write_sorted_list_to_FFS (
+#ifdef FFS_CLOSE_BEFORE_OPEN
+UBYTE db_ctr,
+#endif
+char*   sort_file,
+UBYTE   num_of_elements,
+UBYTE*  sort_list )
+{
+T_FFS_FD   ffs_fd_sort_file;
+T_FFS_SIZE ffs_ret_code;
+#ifdef FFS_CLOSE_BEFORE_OPEN
+/* WRITE */
+if( db_open_full_for_write( db_ctr ) )
+{
+db_close_for_write( db_ctr );
+}
+#endif
+/* FFS_O_TRUNC => If file already exists and it is opened for writing, its
+length is truncated to zero. */
+DB_FFS_OPEN( ffs_fd_sort_file, sort_file, FFS_O_CREATE | FFS_O_WRONLY | FFS_O_TRUNC );
+if( (ffs_fd_sort_file EQ EFFS_NAMETOOLONG ) OR
+(ffs_fd_sort_file EQ EFFS_BADNAME     ) )
+{
+	  TRACE_EVENT_P1( "write_sorted_list_to_FFS:DB_FFS_OPEN %d", ffs_fd_sort_file );
+return DB_FAIL;
+}
+if( ffs_fd_sort_file < EFFS_OK )
+{
+	  TRACE_EVENT_P1( "write_sorted_list_to_FFS:DB_FFS_OPEN %d", ffs_fd_sort_file );
+LastFFS_ReturnCode = ffs_fd_sort_file;
+return DB_FAIL_FS;
+}
+ffs_ret_code = ffs_seek( ffs_fd_sort_file, 0, FFS_SEEK_SET );
+if( ( ffs_ret_code EQ EFFS_BADFD )   OR
+( ffs_ret_code EQ EFFS_INVALID ) OR
+( ffs_ret_code EQ EFFS_BADOP )   )
+{
+	  TRACE_EVENT_P1( "write_sorted_list_to_FFS:ffs_seek %d", ffs_ret_code );
+DB_FFS_CLOSE( ffs_fd_sort_file );
+return DB_FAIL;
+}
+ffs_ret_code = ffs_write( ffs_fd_sort_file,
+sort_list,
+num_of_elements );
+if( ( ffs_ret_code EQ EFFS_BADFD ) OR
+( ffs_ret_code EQ EFFS_BADOP ) )
+{
+DB_FFS_CLOSE( ffs_fd_sort_file );
+ffs_ret_code = ffs_remove( sort_file );
+	  TRACE_EVENT_P1( "write_sorted_list_to_FFS:ffs_write %d", ffs_ret_code );
+return DB_FAIL;
+}
+if( ffs_ret_code < EFFS_OK )
+{
+LastFFS_ReturnCode = ffs_ret_code;
+DB_FFS_CLOSE( ffs_fd_sort_file );
+ffs_ret_code = ffs_remove( sort_file );
+	  TRACE_EVENT_P1( "write_sorted_list_to_FFS:ffs_write %d", ffs_ret_code );
+return DB_FAIL_FS;
+}
+DB_FFS_CLOSE( ffs_fd_sort_file ); /* yeah, we close it here ! */
+return DB_OK;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_binary_search     |
++--------------------------------------------------------------------+
+PURPOSE : Searches for the record; uses binary search and compare
+function is passed as a parameter.
+*/
+LOCAL int db_binary_search ( UBYTE*            sort_list,
+UBYTE             num_of_elements,
+SHORT*            order_num,
+T_SEARCH_FUNC     search_function,
+ULONG             flags,
+const UBYTE*      search_tag,
+int               db_handle,
+USHORT            field_id )
+{
+UINT32 left, right;
+UINT32 mid;
+int cmp_res;
+BOOL matched;
+TRACE_FUNCTION ("db_binary_search()");
+left = *order_num;
+right = num_of_elements;
+if (left >= right)
+return SEARCH_FAILED;
+/* As often the 1st element is the matching one we try a shortcut. */
+cmp_res = search_function (flags,
+search_tag,
+db_handle,
+field_id,
+sort_list[left]);
+if (cmp_res EQ 0)
+{
+*order_num = left + 1;
+return *order_num;
+}
+else if (cmp_res > 0)
+return SEARCH_FAILED; /* We learned already no exact match possible */
+/* Get the first (leftmost) matching element in the sorted list. */
+matched = FALSE;
+do
+{
+mid = (left + right) >> 1;
+cmp_res = search_function (flags,
+search_tag,
+db_handle,
+field_id,
+sort_list[mid]);
+if (cmp_res EQ 0)
+matched = TRUE;
+if (cmp_res < 0)
+left = mid + 1;
+else
+right = mid;
+}
+while (left < right);
+if (matched)
+{
+*order_num = left + 1;
+return *order_num;
+}
+return SEARCH_FAILED;
+}
+/*
++-----------------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                           |
+|                                       ROUINE: update_field_data_in_FFS      |
++-----------------------------------------------------------------------------+
+PURPOSE : Updates elementary file data in FFS
+PARAMS:   filehandle: Pointer to file handle, maybe INVALID_FD
+db_handle: Handle of the particular DB
+fld_ctr: Number of field (0..n)
+field_data: (const) Pointer to data to be written
+offset: offset within the data
+length: length of data to be written
+*/
+LOCAL T_DB_CODE update_field_data_in_FFS ( T_FFS_FD*   filehandle,
+UBYTE       db_handle,
+UBYTE       fld_ctr,
+UBYTE*      field_data,
+USHORT      offset,
+USHORT      length )
+{
+T_FFS_FD   ffs_fd = *filehandle;
+T_FFS_SIZE ffs_ret_code;
+CHAR field_file[FILENAME_LEN];
+/* Updating field data in FFS in file "field_file" */
+/* Implements Measure#32: */
+sprintf(field_file, format_sDDd_str, db_dir, db_handle);
+if (!IS_FD_VALID(ffs_fd))
+{
+DB_FFS_OPEN( ffs_fd, field_file, FFS_O_WRONLY );
+if( ( ffs_fd EQ EFFS_NOTFOUND )    OR
+( ffs_fd EQ EFFS_NAMETOOLONG ) OR
+( ffs_fd EQ EFFS_BADNAME )     OR
+( ffs_fd EQ EFFS_INVALID )     )
+{
+	    TRACE_EVENT_P1( "update_field_data_in_FFS:DB_FFS_OPEN %d", ffs_fd );
+return DB_FAIL;
+}
+if( ffs_fd < EFFS_OK )
+{
+LastFFS_ReturnCode = ffs_fd;
+	    TRACE_EVENT_P1( "update_field_data_in_FFS:DB_FFS_OPEN %d", ffs_fd );
+return DB_FAIL_FS;
+}
+*filehandle = ffs_fd;
+} /* filehandle invalid? */
+/* Seek the file to fld_ctr position to update the entry */
+ffs_ret_code = ffs_seek( ffs_fd,
+( fld_ctr * T_DB_FIELD_RECORD_SIZE ) + offset,
+FFS_SEEK_SET );
+if( ( ffs_ret_code EQ EFFS_BADFD )   OR
+( ffs_ret_code EQ EFFS_INVALID ) OR
+( ffs_ret_code EQ EFFS_BADOP )   )
+{
+TRACE_EVENT_P1( "update_field_data_in_FFS:ffs_seek %d", ffs_ret_code );
+DB_FFS_CLOSE( ffs_fd );
+*filehandle = INVALID_FD;
+return DB_FAIL;
+}
+if( ffs_ret_code < EFFS_OK )
+{
+TRACE_EVENT_P1( "update_field_data_in_FFS:ffs_seek %d", ffs_ret_code );
+LastFFS_ReturnCode = ffs_ret_code;
+DB_FFS_CLOSE( ffs_fd );
+*filehandle = INVALID_FD;
+return DB_FAIL_FS;
+}
+/* clean is reset in memset, so no processing for it
+(in case of non-tracked database, anyway we ignore it ! */
+ffs_ret_code = ffs_write( ffs_fd,
+field_data,
+length );
+if( (ffs_ret_code EQ EFFS_BADFD ) OR
+(ffs_ret_code EQ EFFS_BADOP ) )
+{
+TRACE_EVENT_P1( "update_field_data_in_FFS:ffs_write %d", ffs_ret_code );
+DB_FFS_CLOSE( ffs_fd );
+*filehandle = INVALID_FD;
+return DB_FAIL;
+}
+if( ffs_ret_code < EFFS_OK )
+{
+TRACE_EVENT_P1( "update_field_data_in_FFS:ffs_write %d", ffs_ret_code );
+DB_FFS_CLOSE ( ffs_fd );
+*filehandle = INVALID_FD;
+LastFFS_ReturnCode = ffs_ret_code;
+return DB_FAIL_FS;
+}
+/* DB_FFS_CLOSE( ffs_fd ); we will do it in db_flush */
+/* updation is over */
+#ifdef FFS_OPEN_PROBLEM_PATCH
+DB_FFS_CLOSE( ffs_fd );
+*filehandle = INVALID_FD;
+#endif
+#ifndef FFS_CLOSE_BEFORE_OPEN
+/* this is db file, but we do not close it */
+#endif
+return DB_OK;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: cal_NextRecordNum    |
++--------------------------------------------------------------------+
+PURPOSE : Reads the status of the file and returns
+the next available record (position)
+*/
+LOCAL UBYTE cal_NextRecordNum ( const char* db_directory,
+USHORT      field_id,
+USHORT      record_size )
+{
+char user_field_file[FILENAME_LEN];
+T_FFS_SIZE ffs_ret_code;
+T_FFS_STAT ffs_file_stat;
+/* Implements Measure#32: Row 1167 */
+sprintf( user_field_file,
+format_sUDd_str,
+db_directory,
+field_id );
+ffs_ret_code = ffs_stat( user_field_file, &ffs_file_stat );
+if( ffs_ret_code EQ EFFS_OK )
+{
+return ( (ffs_file_stat.size / record_size) + 1);
+}
+if( ffs_ret_code EQ EFFS_NOTFOUND )
+{
+TRACE_EVENT( "cal_NextRecordNum:ffs_stat:FILE NOT FOUND" );
+return 1;
+}
+/* this is a problem with user_field_file, raise an error and
+return 0 */
+TRACE_ERROR( "cal_NextRecordNum: PROBLEM with user_field_file" );
+TRACE_EVENT_P1( "cal_NextRecordNum:ffs_stat %d", ffs_ret_code );
+return 1;
+}
+/* Implements Measure # 211 */
+/*
++-----------------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                           |
+|                                       ROUINE: delete_file_dir_from_FFS      |
++-----------------------------------------------------------------------------+
+PURPOSE : Deletes a file from FFS
+*/
+LOCAL T_DB_CODE delete_file_dir_from_FFS ( const char* filename )
+{
+T_FFS_SIZE ffs_ret_code;
+TRACE_EVENT_P1( "delete_file_dir_from_FFS %s", filename );
+ffs_ret_code = ffs_remove( filename );
+if( ffs_ret_code EQ EFFS_DIRNOTEMPTY )
+{
+TRACE_EVENT( "Inconsistency; going for delete_dir_forced" );
+return delete_dir_forced( filename );
+}
+if( ffs_ret_code EQ EFFS_NOTFOUND )
+{
+TRACE_EVENT( "delete_file_dir_from_FFS:ffs_remove:FILE NOT FOUND" );
+return DB_OK;
+}
+if( ( ffs_ret_code EQ EFFS_ACCESS   ) OR
+( ffs_ret_code EQ EFFS_LOCKED   ) )
+{
+TRACE_EVENT_P1( "delete_file_dir_from_FFS:ffs_remove %d", ffs_ret_code );
+return DB_FAIL;
+}
+if( ffs_ret_code < EFFS_OK )
+{
+TRACE_EVENT_P1( "delete_file_dir_from_FFS:ffs_remove %d", ffs_ret_code );
+LastFFS_ReturnCode = ffs_ret_code;
+return DB_FAIL_FS;
+}
+return DB_OK;
+}
+/*
++---------------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                         |
+|                                       ROUINE: update_dbm_data_in_FFS      |
++---------------------------------------------------------------------------+
+PURPOSE : Updates the database manager information of a
+particular database
+*/
+LOCAL T_DB_CODE update_dbm_data_in_FFS ( const char* filename,
+UBYTE       db_ctr,
+UBYTE       db_data_max_size,
+UBYTE*      db_data,
+USHORT      offset,
+USHORT      length )
+{
+T_FFS_FD   ffs_fd = INVALID_FD;
+T_FFS_SIZE ffs_ret_code;
+/* See if file already opened,
+if not open it and update the file handle */
+#ifdef FFS_CLOSE_BEFORE_OPEN
+/* WRITE */
+if( db_open_full_for_write( db_ctr ) )
+{
+db_close_for_write( db_ctr );
+}
+#endif
+DB_FFS_OPEN( ffs_fd, filename, FFS_O_WRONLY );
+if( ( ffs_fd EQ EFFS_NAMETOOLONG ) OR
+( ffs_fd EQ EFFS_BADNAME )     OR
+( ffs_fd EQ EFFS_NOTFOUND )    OR
+( ffs_fd EQ EFFS_INVALID )     OR
+( ffs_fd EQ EFFS_LOCKED )      )
+{
+TRACE_EVENT_P1( "update_dbm_data_in_FFS:DB_FFS_OPEN %d", ffs_fd );
+return DB_FAIL;
+}
+if( ffs_fd < EFFS_OK )
+{
+TRACE_EVENT_P1( "update_dbm_data_in_FFS:DB_FFS_OPEN %d", ffs_fd );
+LastFFS_ReturnCode = ffs_fd;
+return DB_FAIL_FS;
+}
+ffs_ret_code = ffs_seek( ffs_fd, db_ctr * db_data_max_size, FFS_SEEK_SET );
+if( ( ffs_ret_code EQ EFFS_BADFD )   OR
+( ffs_ret_code EQ EFFS_INVALID ) OR
+( ffs_ret_code EQ EFFS_BADOP )   )
+{
+TRACE_EVENT_P1( "update_dbm_data_in_FFS:ffs_seek %d", ffs_ret_code );
+DB_FFS_CLOSE( ffs_fd );
+return DB_FAIL;
+}
+if( ffs_ret_code < EFFS_OK )
+{
+TRACE_EVENT_P1( "update_dbm_data_in_FFS:ffs_seek %d", ffs_ret_code );
+LastFFS_ReturnCode = ffs_ret_code;
+DB_FFS_CLOSE( ffs_fd );
+return DB_FAIL_FS;
+}
+ffs_ret_code = ffs_write( ffs_fd, db_data, db_data_max_size );
+if( ( ffs_ret_code EQ EFFS_BADFD ) OR
+( ffs_ret_code EQ EFFS_BADOP ) )
+{
+TRACE_EVENT_P1( "update_dbm_data_in_FFS:ffs_write %d", ffs_ret_code );
+DB_FFS_CLOSE( ffs_fd );
+return DB_FAIL;
+}
+if( ffs_ret_code < EFFS_OK )
+{
+TRACE_EVENT_P1( "update_dbm_data_in_FFS:ffs_write %d", ffs_ret_code );
+DB_FFS_CLOSE( ffs_fd );
+LastFFS_ReturnCode = ffs_ret_code;
+return DB_FAIL_FS;
+}
+DB_FFS_CLOSE( ffs_fd );  /* yeah, DB file, so ok to close it here ! */
+/* updation of dbm data done */
+return DB_OK;
+}
+/*
++--------------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                        |
+|                                       ROUINE: remove_field_from_FFS      |
++--------------------------------------------------------------------------+
+PURPOSE : Removes the elementary file and associated Index
+file from FFS
+*/
+LOCAL T_DB_CODE remove_field_from_FFS ( UBYTE db_ctr,
+UBYTE fld_ctr )
+{
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+char               user_field_file[FILENAME_LEN],
+sort_file[FILENAME_LEN];
+T_DB_CODE          db_ret_code;
+UBYTE              sort_index_ctr;
+/* Assumed that DBState is not IN_USE */
+tmp_ptrFieldRecord = DbmMaster[db_ctr].ptrFieldRecord + fld_ctr;
+if( tmp_ptrFieldRecord -> FieldID EQ INVALID_FIELD_ID ) /* if not valid field id */
+return DB_OK;
+/* Close of user record files not required as DBState is not IN_USE */
+/* Delete file "<DBDirectory>/UD_<field_id>" */
+/* Implements Measure#32: Row 1171 */
+sprintf( user_field_file,
+format_sUDd_str,
+(char *)DbmMaster[db_ctr].DBDirectory,
+tmp_ptrFieldRecord -> FieldID );
+db_ret_code = delete_file_dir_from_FFS ( user_field_file );
+if( db_ret_code NEQ DB_OK )
+return db_ret_code;
+/* For sorted lists */
+for( sort_index_ctr = 0; sort_index_ctr < MAX_NUM_OF_SORT_INDEXS; ++sort_index_ctr )
+{
+/* Delete the SortedLists from memory */
+if (tmp_ptrFieldRecord->SortedLists[sort_index_ctr] NEQ NULL)
+{
+DB_MFREE (tmp_ptrFieldRecord->SortedLists[sort_index_ctr]);
+tmp_ptrFieldRecord->SortedLists[sort_index_ctr] = NULL;
+}
+/* Delete the SortedLists from the FFS */
+if( tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] NEQ INVALID_SORT_INDEX )
+{
+/* Sort file, "<DBDirectory>/UD_<field_id>_sort_<sort_index>" */
+/* Implements Measure#32: Row 1170 */
+sprintf( sort_file,
+format_sUDd_sortd_str,
+(char *)DbmMaster[db_ctr].DBDirectory,
+tmp_ptrFieldRecord -> FieldID,
+tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] );
+db_ret_code = delete_file_dir_from_FFS ( sort_file );
+if( db_ret_code NEQ DB_OK )
+return db_ret_code;
+}
+}
+return DB_OK;
+}
+#ifdef FFS_CLOSE_BEFORE_OPEN
+LOCAL T_FFS_FD db_open_user_field_file ( UBYTE            db_ctr,
+UBYTE            fld_ctr,
+const char*      user_field_file,
+T_FFS_OPEN_FLAGS open_option )
+{
+UBYTE i;
+FileHandleRecord* tmp_open_fields;
+UBYTE*            tmp_old;
+UBYTE             tmp_max;
+/* sanity checks not done (db_ctr >= MAX_DBs OR fld_ctr EQ INVALID_FLD_CTR) */
+/* note that we store field counters and not field ids */
+/* Search in write/read list */
+for( i = 0; i < MAX_OPEN_WRITE_PER_DB; ++i )
+{
+if( DbmMaster[db_ctr].WRITE_OPEN_FIELDS[i].fld_ctr EQ fld_ctr )
+return DbmMaster[db_ctr].WRITE_OPEN_FIELDS[i].filehandle;
+} /* for */
+/* Search in read only list */
+for( i = 0; i < MAX_OPEN_READ_PER_DB; ++i )
+{
+if( DbmMaster[db_ctr].READ_OPEN_FIELDS[i].fld_ctr EQ fld_ctr )
+{
+if( NOT ( open_option & FFS_O_WRONLY ) ) /* if not opened for writing */
+{
+return DbmMaster[db_ctr].READ_OPEN_FIELDS[i].filehandle;
+}
+/* we need to reopen it in write mode */
+DB_FFS_CLOSE( DbmMaster[db_ctr].READ_OPEN_FIELDS[i].filehandle );
+DbmMaster[db_ctr].READ_OPEN_FIELDS[i].filehandle = INVALID_FD;
+DbmMaster[db_ctr].READ_OPEN_FIELDS[i].fld_ctr = INVALID_FLD_CTR;
+break;
+}
+} /* for */
+/* field is not present in both lists */
+if( open_option & FFS_O_WRONLY )
+{
+/* for writing and reading both */
+tmp_open_fields = DbmMaster[db_ctr].WRITE_OPEN_FIELDS;
+tmp_old = &(DbmMaster[db_ctr].old_write);
+tmp_max = MAX_OPEN_WRITE_PER_DB;
+} else {
+/* for reading only */
+tmp_open_fields = DbmMaster[db_ctr].READ_OPEN_FIELDS;
+tmp_old = &(DbmMaster[db_ctr].old_read);
+tmp_max = MAX_OPEN_READ_PER_DB;
+}
+/* search the list */
+for( i = 0; i < tmp_max; ++i )
+{
+if( tmp_open_fields[i].fld_ctr EQ INVALID_FLD_CTR )
+{
+DB_FFS_OPEN( tmp_open_fields[i].filehandle,
+user_field_file,
+open_option );
+tmp_open_fields[i].fld_ctr = fld_ctr;
+return tmp_open_fields[i].filehandle;
+}
+} /* for */
+/* we need to close the some file for opening this */
+if( *tmp_old >= tmp_max )
+*tmp_old = 0;
+DB_FFS_CLOSE( tmp_open_fields[*tmp_old].filehandle );
+DB_FFS_OPEN( tmp_open_fields[*tmp_old].filehandle,
+user_field_file,
+open_option );
+if( tmp_open_fields[*tmp_old].filehandle >= EFFS_OK )
+{
+tmp_open_fields[*tmp_old].fld_ctr = fld_ctr;
+++(*tmp_old);
+return tmp_open_fields[*tmp_old - 1].filehandle;
+}
+tmp_open_fields[*tmp_old].fld_ctr = INVALID_FLD_CTR;
+return tmp_open_fields[*tmp_old].filehandle;
+}
+LOCAL void db_close_user_field_files ( UBYTE db_ctr )
+{
+UBYTE i;
+FileHandleRecord* tmp_open_fields;
+/* sanity check not done */
+/* for write list */
+tmp_open_fields = DbmMaster[db_ctr].WRITE_OPEN_FIELDS;
+for( i = 0; i < MAX_OPEN_WRITE_PER_DB; ++i )
+{
+if( tmp_open_fields[i].fld_ctr NEQ INVALID_FLD_CTR )
+{
+DB_FFS_CLOSE( tmp_open_fields[i].filehandle );
+tmp_open_fields[i].filehandle = INVALID_FD;
+tmp_open_fields[i].fld_ctr = INVALID_FLD_CTR;
+}
+}
+/* for read list */
+tmp_open_fields = DbmMaster[db_ctr].READ_OPEN_FIELDS;
+for( i = 0; i < MAX_OPEN_READ_PER_DB; ++i )
+{
+if( tmp_open_fields[i].fld_ctr NEQ INVALID_FLD_CTR )
+{
+DB_FFS_CLOSE( tmp_open_fields[i].filehandle );
+tmp_open_fields[i].filehandle = INVALID_FD;
+tmp_open_fields[i].fld_ctr = INVALID_FLD_CTR;
+}
+}
+}
+LOCAL BOOL db_open_full_for_read ( UBYTE db_ctr )
+{
+UBYTE i;
+FileHandleRecord* tmp_open_fields;
+/* sanity check not done */
+/* for read list */
+tmp_open_fields = DbmMaster[db_ctr].READ_OPEN_FIELDS;
+for( i = 0; i < MAX_OPEN_READ_PER_DB; ++i )
+{
+if( tmp_open_fields[i].fld_ctr EQ INVALID_FLD_CTR )
+return FALSE;
+}
+return TRUE;
+}
+LOCAL BOOL db_open_full_for_write ( UBYTE db_ctr )
+{
+UBYTE i;
+FileHandleRecord* tmp_open_fields;
+/* sanity check not done */
+/* for write list */
+tmp_open_fields = DbmMaster[db_ctr].WRITE_OPEN_FIELDS;
+for( i = 0; i < MAX_OPEN_WRITE_PER_DB; ++i )
+{
+if( tmp_open_fields[i].fld_ctr EQ INVALID_FLD_CTR )
+return FALSE;
+}
+return TRUE;
+}
+LOCAL void db_close_for_read ( UBYTE db_ctr )
+{
+/* Implements Measure # 83 */
+db_close_for_read_write (DbmMaster[db_ctr].READ_OPEN_FIELDS,
+&(DbmMaster[db_ctr].old_read), MAX_OPEN_READ_PER_DB);
+return;
+}
+LOCAL void db_close_for_write ( UBYTE db_ctr )
+{
+/* Implements Measure # 83 */
+db_close_for_read_write (DbmMaster[db_ctr].WRITE_OPEN_FIELDS,
+&(DbmMaster[db_ctr].old_write), MAX_OPEN_WRITE_PER_DB);
+return;
+}
+LOCAL UBYTE db_status_user_field_file ( UBYTE db_ctr,
+UBYTE fld_ctr )
+{
+UBYTE i;
+FileHandleRecord* tmp_open_fields;
+/* sanity check not done */
+/* for write list */
+tmp_open_fields = DbmMaster[db_ctr].WRITE_OPEN_FIELDS;
+for( i = 0; i < MAX_OPEN_WRITE_PER_DB; ++i )
+{
+if( tmp_open_fields[i].fld_ctr EQ fld_ctr )
+return OPENED_FOR_WRITE;
+}
+/* for read list */
+tmp_open_fields = DbmMaster[db_ctr].READ_OPEN_FIELDS;
+for( i = 0; i < MAX_OPEN_READ_PER_DB; ++i )
+{
+if( tmp_open_fields[i].fld_ctr EQ fld_ctr )
+return OPENED_FOR_READ;
+}
+return NOT_OPENED;
+}
+#endif /* FFS_CLOSE_BEFORE_OPEN */
+/*
++-----------------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                           |
+|                                       ROUINE: delete_dir_forced             |
++-----------------------------------------------------------------------------+
+PURPOSE : Removes contents of dir and then delete the dir
+(it uses recursion)
+*/
+LOCAL T_DB_CODE delete_dir_forced ( const char* dir )
+{
+T_FFS_SIZE ffs_ret_code;
+T_FFS_DIR  ffs_dir; /*lint !e813 big var on stack, not true for target */
+T_FFS_STAT tmp_ffs_stat;
+char  pathname[FILENAME_LEN];
+UBYTE dir_len;
+/* Open dir, if does not exist, just return DB_OK */
+ffs_ret_code = ffs_opendir (dir, &ffs_dir);
+if( ffs_ret_code EQ EFFS_NOTFOUND )
+DB_RETURN( DB_OK );
+if( ffs_ret_code < EFFS_OK )
+{
+TRACE_EVENT_P2( "delete_dir_forced:ffs_remove %d, %s", ffs_ret_code, dir );
+LastFFS_ReturnCode = ffs_ret_code;
+DB_RETURN( DB_FAIL_FS )
+}
+/* read dir recursively */
+sprintf( pathname,
+"%s/",
+dir );
+dir_len = strlen( pathname );
+while( 1 )
+{
+/* filename inside the directory would be copied at pathname + dirlen */
+ffs_ret_code = ffs_readdir( &ffs_dir,
+pathname + dir_len,
+FILENAME_LEN - dir_len - 1 );
+if( ffs_ret_code EQ 0 ) /* dir is empty now */
+{
+break;
+}
+if( ffs_ret_code < EFFS_OK )
+{
+TRACE_EVENT_P2( "delete_dir_forced:ffs_readdir:%d, %s", ffs_ret_code, dir );
+LastFFS_ReturnCode = ffs_ret_code;
+DB_RETURN( DB_FAIL_FS )
+}
+ffs_ret_code = ffs_stat( pathname, &tmp_ffs_stat );
+if( ffs_ret_code < EFFS_OK )
+{
+TRACE_EVENT_P2( "delete_dir_forced:ffs_stat:%d, %s", ffs_ret_code, pathname);
+LastFFS_ReturnCode = ffs_ret_code;
+DB_RETURN( DB_FAIL_FS )
+}
+if( tmp_ffs_stat.type EQ OT_DIR )
+{
+/* Directory !! */
+T_DB_CODE db_code;
+TRACE_EVENT_P1( "Warning: directory %s", pathname );
+/* Recursion */
+db_code = delete_dir_forced( pathname );
+if( db_code NEQ DB_OK )
+DB_RETURN( db_code );
+} else {
+/* normal file (OT_FILE) or symbolic link (OT_LINK) */
+ffs_ret_code = ffs_remove( pathname );
+if( ffs_ret_code < EFFS_OK )
+{
+TRACE_EVENT_P2( "delete_dir_forced:ffs_remove:%d, %s", ffs_ret_code, pathname );
+LastFFS_ReturnCode = ffs_ret_code;
+DB_RETURN( DB_FAIL_FS )
+}
+} /* if( tmp_ffs_stat.type EQ OT_DIR ) */
+} /* while( 1 ) */
+/* now delete the directory */
+ffs_ret_code = ffs_remove( dir );
+if( ffs_ret_code < EFFS_OK )
+{
+TRACE_EVENT_P2( "delete_dir_forced:ffs_remove:%d, %s", ffs_ret_code, dir );
+LastFFS_ReturnCode = ffs_ret_code;
+DB_RETURN( DB_FAIL_FS )
+}
+DB_RETURN( DB_OK )
+}
+LOCAL void get_sort_lists_from_FFS ( UBYTE db_ctr,
+UBYTE fld_ctr )
+{
+UBYTE sort_index_ctr;
+T_DB_CODE db_ret_code;
+char sort_file[FILENAME_LEN];
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord = DbmMaster[db_ctr].ptrFieldRecord + fld_ctr;
+/* for all existing sort indexes */
+for( sort_index_ctr = 0; sort_index_ctr < MAX_NUM_OF_SORT_INDEXS; ++sort_index_ctr )
+{
+/* valid index ? */
+if( tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] NEQ INVALID_SORT_INDEX )
+{
+/* Check if we already have sorted list in RAM structure SortedLists */
+if( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] EQ NULL )
+{
+/* If no, populate the sorted list from file,
+"<DBDirectory>/UD_<field_id>_sort_<sort_index>".
+Sorted lists are freed in db_flush */
+/* Implements Measure#32: Row 1177 */
+sprintf( sort_file,
+format_sUDd_sortd_str,
+(char *)DbmMaster[db_ctr].DBDirectory,
+tmp_ptrFieldRecord -> FieldID,
+tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] );
+db_ret_code =
+populate_sorted_list_from_FFS (
+#ifdef FFS_CLOSE_BEFORE_OPEN
+db_ctr,
+#endif
+sort_file,
+tmp_ptrFieldRecord -> NumOfRecords,
+&(tmp_ptrFieldRecord -> SortedLists[sort_index_ctr]) );
+if( db_ret_code NEQ DB_OK )
+{
+/* Failure, still we can continue as later during actual sorting,
+FFS would be retried */
+TRACE_EVENT( "Warning: populate_sorted_list_from_FFS failed" );
+TRACE_EVENT_P3( "db_ctr %d field_id %04X sort_index %d",
+db_ctr,
+tmp_ptrFieldRecord -> FieldID,
+tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] );
+continue;
+}
+} /* if we have sort list */
+} /* if valid index */
+} /* for all sort indexes */
+return;
+}
+LOCAL void new_in_sort_lists ( UBYTE db_ctr,
+UBYTE fld_ctr,
+UBYTE record_num )
+{
+UBYTE sort_index_ctr;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord = DbmMaster[db_ctr].ptrFieldRecord + fld_ctr;
+/* make a note that this record needs to be sorted */
+/* for all existing sort indexes */
+for( sort_index_ctr = 0; sort_index_ctr < MAX_NUM_OF_SORT_INDEXS; ++sort_index_ctr )
+{
+if( tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] NEQ INVALID_SORT_INDEX )
+{
+/* add it at the end like all sorted records + INVALID RECORD + .... */
+tmp_ptrFieldRecord -> SortedLists[sort_index_ctr][tmp_ptrFieldRecord -> UsedRecords]
+= record_num;
+}
+}
+return;
+}
+LOCAL void update_in_sort_lists ( UBYTE db_ctr,
+UBYTE fld_ctr,
+UBYTE record_num )
+{
+UBYTE sort_index_ctr,
+rec_ctr;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord = DbmMaster[db_ctr].ptrFieldRecord + fld_ctr;
+/* make a note that this record needs to be sorted */
+/* for all existing sort indexes */
+for( sort_index_ctr = 0; sort_index_ctr < MAX_NUM_OF_SORT_INDEXS; ++sort_index_ctr )
+{
+if( tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] NEQ INVALID_SORT_INDEX )
+{
+/* search entry in sorted records */
+rec_ctr = 0;
+while( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr][rec_ctr] NEQ INVALID_RECORD_NUM )
+{
+if( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr][rec_ctr] EQ record_num )
+{
+/* found in sorted records,
+now delete this entry */
+memmove( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] + rec_ctr,                    /* dest */
+(const char*)(tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] + rec_ctr + 1), /* source */
+tmp_ptrFieldRecord -> UsedRecords - rec_ctr );                                  /* size */
+tmp_ptrFieldRecord -> SortedLists[sort_index_ctr][tmp_ptrFieldRecord -> UsedRecords]
+= record_num;
+break;
+}
+++rec_ctr;
+}
+} /* NEQ INVALID_SORT_INDEX */
+} /* for sort_index_ctr */
+return;
+}
+LOCAL void delete_in_sort_lists ( UBYTE db_ctr,
+UBYTE fld_ctr,
+UBYTE record_num )
+{
+UBYTE sort_index_ctr,
+rec_ctr;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord = DbmMaster[db_ctr].ptrFieldRecord + fld_ctr;
+/* make a note that this record needs to be sorted */
+/* for all existing sort indexes */
+for( sort_index_ctr = 0; sort_index_ctr < MAX_NUM_OF_SORT_INDEXS; ++sort_index_ctr )
+{
+if( tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] NEQ INVALID_SORT_INDEX )
+{
+/* search entry in sorted records */
+rec_ctr = 0;
+while( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr][rec_ctr] NEQ INVALID_RECORD_NUM )
+{
+if( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr][rec_ctr] EQ record_num )
+break;
+++rec_ctr;
+}
+if( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr][rec_ctr] NEQ INVALID_RECORD_NUM )
+{
+/* found in sorted records,
+now delete this entry */
+memmove( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] + rec_ctr,
+(const char*)(tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] + rec_ctr + 1),
+tmp_ptrFieldRecord -> UsedRecords - rec_ctr );
+tmp_ptrFieldRecord -> SortedLists[sort_index_ctr][tmp_ptrFieldRecord -> UsedRecords]
+= INVALID_RECORD_NUM;
+} else {
+/* search in UN-sorted records */
+++rec_ctr;
+while( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr][rec_ctr] NEQ INVALID_RECORD_NUM )
+{
+if( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr][rec_ctr] EQ record_num )
+{
+/* delete this entry */
+memmove( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] + rec_ctr,
+(const char*)(tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] + rec_ctr + 1),
+tmp_ptrFieldRecord -> UsedRecords - rec_ctr );
+tmp_ptrFieldRecord -> SortedLists[sort_index_ctr][tmp_ptrFieldRecord -> UsedRecords]
+= INVALID_RECORD_NUM;
+break;
+}
+++rec_ctr;
+}
+}
+} /* NEQ INVALID_SORT_INDEX */
+} /* for sort_index_ctr */
+return;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: insertion_sort       |
++--------------------------------------------------------------------+
+PURPOSE : Sorts the user data records in FFS based on insertion sort method
+*/
+LOCAL void insertion_sort ( UBYTE*        sort_list,
+UBYTE         num_of_elements,
+T_COMP_FUNC   compare_function,
+ULONG         flags,
+int           db_handle,
+USHORT        field_id )
+{
+UBYTE rec_ctr;
+/* sanity check */
+if( num_of_elements EQ 0 )
+return;
+if( sort_list[0] EQ INVALID_RECORD_NUM )
+{
+/* This is beginning of new sort list,
+Let's add first element */
+sort_list[0] = sort_list[1];
+sort_list[1] = INVALID_RECORD_NUM;
+}
+/* So now here we have list something like this
+{ Sorted records } + INVALID_RECORD_NUM + { UNsorted records }
+*/
+/* let's get to Unsorted records */
+rec_ctr = 1;
+while( sort_list[rec_ctr] NEQ INVALID_RECORD_NUM )
+{
+++rec_ctr;
+}
+++rec_ctr;
+/* rec_ctr is now pointing at UNsorted records */
+/* now add UNsorted records one by one */
+/* Not required "( sort_list[rec_ctr] NEQ INVALID_RECORD_NUM )", right ? */
+while( rec_ctr <= num_of_elements )
+{
+insert_element( sort_list,
+rec_ctr,                /* num_of_elements */
+0,                      /* bottom */
+rec_ctr - 2,            /* top */
+sort_list[rec_ctr],     /* record_num to be inserted */
+compare_function,
+flags,
+db_handle,
+field_id );
+++rec_ctr;
+}
+/* done ! */
+return;
+}
+LOCAL void insert_element ( UBYTE*        sort_list,
+UBYTE         num_of_elements,
+UBYTE         bottom,
+UBYTE         top,
+UBYTE         record_num,
+T_COMP_FUNC   compare_function,
+ULONG         flags,
+int           db_handle,
+USHORT        field_id )
+{
+UBYTE middle = ( top + bottom ) / 2;
+/* use binary algorithm to find the right place for insertion */
+while( middle NEQ bottom )
+{
+if( compare_function( db_handle,
+field_id,
+sort_list[middle],
+record_num,
+flags )
+< 0 )
+{
+bottom = middle;
+} else {
+top = middle;
+}
+middle = ( top + bottom ) / 2;
+} /* while( middle NEQ bottom ) */
+if( compare_function( db_handle,
+field_id,
+sort_list[bottom],
+record_num,
+flags )
+< 0 )
+{
+if( compare_function( db_handle,
+field_id,
+sort_list[top],
+record_num,
+flags )
+< 0 )
+{
+/* insert at top + 1 */
+memmove( sort_list + top + 2,            /* dest */
+sort_list + top + 1,            /* source */
+num_of_elements - (top + 1) );  /* size */
+sort_list[top + 1] = record_num;
+} else {
+/* insert at bottom + 1 */
+memmove( sort_list + bottom + 2,            /* dest */
+sort_list + bottom + 1,            /* source */
+num_of_elements - (bottom + 1) );  /* size */
+sort_list[bottom + 1] = record_num;
+} /* if top_th < insert_th */
+} else {
+/* insert at bottom */
+memmove( sort_list + bottom + 1,       /* dest */
+sort_list + bottom,           /* source */
+num_of_elements - bottom );   /* size */
+sort_list[bottom] = record_num;
+} /* if bottom_th < insert_th */
+return;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: internal_db_sort     |
++--------------------------------------------------------------------+
+PURPOSE : (Internal) Creates or updates a sort index for
+a given (database, field)
+*/
+LOCAL T_DB_CODE internal_db_sort ( int          db_handle,
+USHORT       field_id,
+UBYTE        sort_index,
+T_COMP_FUNC  compare_function,
+ULONG        flags )
+{
+UBYTE  fld_ctr,
+sort_index_ctr,
+remb_sort_index_ctr,
+record_num;
+UBYTE* sort_list;
+UBYTE* copy_sort_list;
+T_DB_CODE  db_ret_code;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+UBYTE* field_data;
+TRACE_FUNCTION("internal_db_sort()");
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field not found, return error DB_INVALID_FIELD */
+fld_ctr = field_id_search( db_handle, field_id );
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_INVALID_FIELD );
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord + fld_ctr;
+/* Check if this is existing sort index */
+remb_sort_index_ctr = MAX_NUM_OF_SORT_INDEXS;
+for( sort_index_ctr = 0; sort_index_ctr < MAX_NUM_OF_SORT_INDEXS; ++sort_index_ctr )
+{
+if( tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] EQ sort_index )
+break;
+if( tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] EQ INVALID_SORT_INDEX )
+remb_sort_index_ctr = sort_index_ctr;
+}
+if( sort_index_ctr EQ MAX_NUM_OF_SORT_INDEXS )
+{
+/* ok, this is new index, so
+Check if limit for sort list corresponding to field_id (for a given database)
+has reached limit, MAX_NUM_OF_SORT_INDEXS. If so, return DB_FULL. */
+if( remb_sort_index_ctr EQ MAX_NUM_OF_SORT_INDEXS )
+DB_RETURN( DB_FULL );
+sort_index_ctr = remb_sort_index_ctr;
+/* update file , "~/dbm/DD_<db_handle>" for SortIndexes. */
+/* create the field data that is to be written */
+DB_MALLOC( field_data, MAX_NUM_OF_SORT_INDEXS );
+memcpy( field_data, tmp_ptrFieldRecord -> SortIndexList, MAX_NUM_OF_SORT_INDEXS );
+field_data[sort_index_ctr] = sort_index;
+db_ret_code =
+update_field_data_in_FFS ( &DbmMaster[db_handle].FFSFileHandle,
+db_handle,
+fld_ctr,
+field_data,
+SortIndexList_OFFSET,
+MAX_NUM_OF_SORT_INDEXS );
+if( db_ret_code NEQ DB_OK )
+{
+DB_MFREE( field_data );
+DB_RETURN( db_ret_code )
+}
+DB_MFREE( field_data );
+/* updation of DD_<db_handle> is over */
+}
+/* create sort list (if not there) */
+if( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] NEQ NULL )
+{
+sort_list = tmp_ptrFieldRecord -> SortedLists[sort_index_ctr];
+}
+else
+{
+DB_MALLOC( sort_list, tmp_ptrFieldRecord -> NumOfRecords + 1 );
+memset( sort_list, INVALID_RECORD_NUM, tmp_ptrFieldRecord -> NumOfRecords + 1 );
+/* the first element would be INVALID_RECORD_NUM (0xFF) */
+copy_sort_list = sort_list + 1;
+/* The list of available records is prepared from RecordBitMap */
+for (record_num = 1; record_num <= tmp_ptrFieldRecord->NumOfRecords; record_num++)
+{
+if (db_get_bit_in_bitmap (tmp_ptrFieldRecord->RecordBitMap, record_num))
+{
+*copy_sort_list++ = record_num;
+}
+}
+} /* sort_list is NULL */
+/* Sort the records with given "comparison_function" (it takes record numbers,
+field_id and db_handle). Note that the sorted list would be kept in RAM
+(structure SortedLists, part of field record) till db_flush is called and
+cleared in db_flush. */
+insertion_sort( sort_list,
+tmp_ptrFieldRecord -> UsedRecords,   /* only used records */
+compare_function,
+flags,
+db_handle,
+field_id );
+/* writing sorted list to FFS would be done in db_flush */
+/* Update corresponding field SortIndexList in RAM structures. */
+tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] = sort_index;
+tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] = sort_list;
+DB_RETURN( DB_OK )
+}
+/***********************/
+/* INTERFACE FUNCTIONS */
+/***********************/
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_init              |
++--------------------------------------------------------------------+
+PURPOSE : Initialises database manager
+*/
+void db_init ( void )
+{
+UBYTE db_ctr;
+#ifdef FFS_CLOSE_BEFORE_OPEN
+UBYTE fld_ctr;
+#endif
+TRACE_FUNCTION("db_init()");
+/* 1) Check DBM_State and if already initialized, return DB_OK */
+if ( DBM_State EQ DBM_INITIALISED )
+return;
+/* 2)	Initialize DbmMaster structure */
+for ( db_ctr = 0; db_ctr < MAX_DBs; ++db_ctr )
+{
+DbmMaster[db_ctr].DBState = UNUSED_ENTRY;
+#ifdef FFS_CLOSE_BEFORE_OPEN
+for( fld_ctr = 0; fld_ctr < MAX_OPEN_READ_PER_DB; ++fld_ctr )
+{
+DbmMaster[db_ctr].READ_OPEN_FIELDS[fld_ctr].fld_ctr = INVALID_FLD_CTR;
+}
+for( fld_ctr = 0; fld_ctr < MAX_OPEN_WRITE_PER_DB; ++fld_ctr )
+{
+DbmMaster[db_ctr].WRITE_OPEN_FIELDS[fld_ctr].fld_ctr = INVALID_FLD_CTR;
+}
+DbmMaster[db_ctr].old_read = 0;
+DbmMaster[db_ctr].old_write = 0;
+#endif
+}
+UsedDBs = 0;
+#ifdef _SIMULATION_
+{
+T_FFS_SIZE ffs_ret_code = ffs_init();
+TRACE_EVENT_P1("Initialization of FFS Simulation %d", ffs_ret_code );
+/* Delete existing database */
+init_RAM_with_FFS();
+for( db_ctr = 0; db_ctr < MAX_DBs; ++db_ctr )
+{
+if( DbmMaster[db_ctr].DBState NEQ UNUSED_ENTRY )
+db_remove( DbmMaster[db_ctr].DBDirectory );
+}
+db_exit();
+}
+#endif
+return;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: init_RAM_with_FFS    |
++--------------------------------------------------------------------+
+PURPOSE : Initialise DBM RAM structures with FFS data
+*/
+LOCAL T_DB_CODE init_RAM_with_FFS ( void )
+{
+/* Initializing "DBM related data" in RAM from FFS */
+T_FFS_FD            ffs_dbm_fd;
+T_FFS_SIZE          ffs_ret_code;
+T_FFS_STAT          ffs_status;
+UBYTE*              db_buffer;
+UBYTE*              remb_db_buffer;
+UBYTE*              field_buffer;
+UBYTE*              remb_field_buffer;
+UBYTE               db_ctr,
+fld_ctr,
+i;
+char                filename[FILENAME_LEN];
+/* Implements Measure#32: Row 1181 */
+char*               dbm_file = db_master_file;
+T_DBM_MASTERRECORD  *dbm;
+TRACE_FUNCTION("init_RAM_with_FFS()");
+/* Check the presence of FFS directory DB_DIR */
+/* Implements Measure#32: Row 1184 */
+ffs_ret_code = ffs_stat( db_dir, &ffs_status );
+TRACE_EVENT_P1( "init_RAM_with_FFS:ffs_stat %d", ffs_ret_code );
+/* error values of ffs_ret_code are handled later */
+if( ffs_ret_code >= EFFS_OK )
+{
+/* Directory is present */
+/* Synchronize DB related data between FFS and RAM
+i.e. structures DbmMasterRecord and corresponding DbmFieldRecord. */
+/* For DbmMaster */
+DB_FFS_OPEN( ffs_dbm_fd, dbm_file, FFS_O_RDONLY );
+if( (ffs_dbm_fd EQ EFFS_NAMETOOLONG ) OR
+(ffs_dbm_fd EQ EFFS_BADNAME     ) OR
+(ffs_dbm_fd EQ EFFS_NOTFOUND    ) OR
+(ffs_dbm_fd EQ EFFS_INVALID     ) OR
+(ffs_dbm_fd EQ EFFS_LOCKED      ) )
+{
+TRACE_EVENT_P1( "init_RAM_with_FFS:DB_FFS_OPEN %d", ffs_dbm_fd );
+return DB_FAIL;
+}
+if( ffs_dbm_fd < EFFS_OK )
+{
+TRACE_EVENT_P1( "init_RAM_with_FFS:DB_FFS_OPEN %d", ffs_dbm_fd );
+LastFFS_ReturnCode = ffs_dbm_fd;
+return DB_FAIL_FS;
+}
+/* buffer for master records */
+DB_MALLOC( db_buffer, T_DB_MASTER_RECORD_SIZE );
+remb_db_buffer = db_buffer;
+for( db_ctr = 0; db_ctr < MAX_DBs; ++db_ctr )
+{
+dbm = &DbmMaster[db_ctr];
+db_buffer = remb_db_buffer;
+ffs_ret_code = ffs_read( ffs_dbm_fd, db_buffer, T_DB_MASTER_RECORD_SIZE );
+if( ( ffs_ret_code EQ EFFS_BADFD ) OR
+( ffs_ret_code EQ EFFS_BADOP ) )
+{
+TRACE_EVENT_P1( "init_RAM_with_FFS:ffs_read %d", ffs_ret_code );
+DB_FFS_CLOSE( ffs_dbm_fd );
+DB_MFREE( db_buffer );
+return DB_FAIL;
+}
+if( ffs_ret_code EQ 0 ) /* number of bytes read EQ 0 */
+break;
+if( *db_buffer EQ 0xFF ) /* if invalid database */
+continue;
+memcpy( dbm->DBDirectory, db_buffer, MAX_LEN_DIRECTORY );
+db_buffer += MAX_LEN_DIRECTORY;
+dbm->NumOfFiles = *db_buffer++; /* Maximum number of supported fields */
+dbm->Clean   = TRUE;
+dbm->Tracked = (*db_buffer++ EQ FFS_TRACKED);
+dbm->UsedFiles = 0;
+dbm->DBState = CLOSED;
+++UsedDBs;
+/* we need not "seek" here file pointer would have moved to next */
+}
+DB_FFS_CLOSE( ffs_dbm_fd );
+DB_MFREE( remb_db_buffer ); /* freeing db_buffer */
+/* For FieldRecords */
+/* buffer for field records */
+DB_MALLOC( field_buffer, T_DB_FIELD_RECORD_SIZE );
+remb_field_buffer = field_buffer;
+for( db_ctr = 0; db_ctr < MAX_DBs; ++db_ctr )
+{
+dbm = &DbmMaster[db_ctr];
+if( dbm->DBState EQ UNUSED_ENTRY )
+continue;
+/* Field file = DD_<pos. in DD_master> */
+/* Implements Measure#32: Row 1182, 1184 */
+sprintf( filename, format_sDDd_str, db_dir, db_ctr);
+DB_FFS_OPEN( ffs_dbm_fd, filename, FFS_O_RDONLY );
+if(  ( ffs_dbm_fd EQ EFFS_NOTFOUND ) OR   /* Field file not found */
+( ffs_dbm_fd EQ EFFS_NUMFD )    OR   /* FFS specific errors */
+( ffs_dbm_fd EQ EFFS_LOCKED)    )
+{
+TRACE_EVENT_P1( "init_RAM_with_FFS:DB_FFS_OPEN %d", ffs_dbm_fd );
+DB_MFREE( field_buffer );
+return DB_FAIL;
+}
+/* Allocate memory for field records */
+DB_MALLOC( dbm->ptrFieldRecord,
+dbm->NumOfFiles * sizeof(T_DBM_FIELDRECORD) );
+for (fld_ctr = 0; fld_ctr < dbm->NumOfFiles; fld_ctr++)
+{
+field_buffer = remb_field_buffer;
+ffs_ret_code = ffs_read( ffs_dbm_fd, field_buffer, T_DB_FIELD_RECORD_SIZE );
+if( (ffs_ret_code EQ EFFS_BADFD ) OR
+(ffs_ret_code EQ EFFS_BADOP ) )
+{
+TRACE_EVENT_P2( "init_RAM_with_FFS:ffs_read %d, fld_ctr %d", ffs_ret_code, fld_ctr );
+DB_FFS_CLOSE ( ffs_dbm_fd );
+DB_MFREE( field_buffer );
+DB_MFREE( dbm->ptrFieldRecord );
+dbm->ptrFieldRecord = NULL;
+return DB_FAIL;
+}
+if( ffs_ret_code < T_DB_FIELD_RECORD_SIZE )
+{
+/* we need not go further, just make rest of field ids as invalid (not existing) */
+for( ; fld_ctr < dbm->NumOfFiles; ++fld_ctr )
+{
+dbm->ptrFieldRecord[fld_ctr].FieldID = INVALID_FIELD_ID;
+}
+break;
+}
+/* Syncing of field records (FFS => RAM) */
+dbm->ptrFieldRecord[fld_ctr].FieldID = *field_buffer++;
+dbm->ptrFieldRecord[fld_ctr].FieldID <<= 8;
+dbm->ptrFieldRecord[fld_ctr].FieldID |= *field_buffer++;
+dbm->ptrFieldRecord[fld_ctr].DBType = (T_DB_TYPE)*field_buffer++;
+dbm->ptrFieldRecord[fld_ctr].RecordSize = *field_buffer++;
+dbm->ptrFieldRecord[fld_ctr].RecordSize <<= 8;
+dbm->ptrFieldRecord[fld_ctr].RecordSize |= *field_buffer++;
+dbm->ptrFieldRecord[fld_ctr].NumOfRecords = *field_buffer++;
+for (i = 0; i < MAX_NUM_OF_SORT_INDEXS; i++)
+{
+dbm->ptrFieldRecord[fld_ctr].SortIndexList[i] = *field_buffer++;
+dbm->ptrFieldRecord[fld_ctr].SortedLists[i] = NULL;
+}
+memcpy (dbm->ptrFieldRecord[fld_ctr].RecordBitMap, field_buffer, RECORD_BITMAP_SIZE);
+field_buffer += RECORD_BITMAP_SIZE;
+dbm->ptrFieldRecord[fld_ctr].Clean = *field_buffer++;
+if ( dbm->ptrFieldRecord[fld_ctr].FieldID NEQ INVALID_FIELD_ID )
+{
+/*
+* Trace out whether we consider the respective field as not clean.
+*/
+if (!dbm->ptrFieldRecord[fld_ctr].Clean)
+{
+TRACE_EVENT_P1 ("Field %04X not clean in master file",
+dbm->ptrFieldRecord[fld_ctr].FieldID);
+}
+/*
+* Consistency check.
+* Check whether the respective user field exists.
+* If it does not exist set it to invalid.
+* We are not taking care about possibly left over sort indexes.
+* This inconsistency can happen when we got a hard power cycle
+* during some database updating operation.
+*/
+sprintf (filename, "%s/UD_%04X", (char *)dbm->DBDirectory,
+dbm->ptrFieldRecord[fld_ctr].FieldID);
+ffs_ret_code = ffs_stat (filename, &ffs_status);
+if (ffs_ret_code NEQ EFFS_OK)
+{
+TRACE_EVENT_P1 ("User data %s not existing in FFS", filename);
+dbm->ptrFieldRecord[fld_ctr].FieldID = INVALID_FIELD_ID;
+dbm->Clean = FALSE; /* Mark DB as not clean */
+}
+/*
+* Consistency check.
+* Check that the respective user data does not exist twice.
+* Normally it is expected that this inconsistency should not happen,
+* if it happens we ignore all subsequent entries.
+*/
+if ( dbm->ptrFieldRecord[fld_ctr].FieldID NEQ INVALID_FIELD_ID )
+{
+for (i = 0; i < fld_ctr; i++)
+{
+if (dbm->ptrFieldRecord[fld_ctr].FieldID EQ
+dbm->ptrFieldRecord[i].FieldID)
+{
+TRACE_EVENT_P1 ("User data %04x existed twice",
+dbm->ptrFieldRecord[fld_ctr].FieldID);
+dbm->ptrFieldRecord[fld_ctr].FieldID = INVALID_FIELD_ID;
+dbm->ptrFieldRecord[i].Clean = FALSE; /* Don't trust this field */
+dbm->Clean = FALSE; /* Mark DB as not clean */
+break;
+}
+}
+}
+/*
+* Consistency check.
+* Check whether the sorted index really exists in the FFS.
+* If it does not exist set it to invalid.
+*/
+if ( dbm->ptrFieldRecord[fld_ctr].FieldID NEQ INVALID_FIELD_ID )
+{
+for( i = 0; i < MAX_NUM_OF_SORT_INDEXS; i++ )
+{
+if (dbm->ptrFieldRecord[fld_ctr].SortIndexList[i] NEQ INVALID_SORT_INDEX)
+{
+sprintf(filename, "%s/UD_%04X_sort_%d",
+(char *)dbm->DBDirectory,
+dbm->ptrFieldRecord[fld_ctr].FieldID,
+dbm->ptrFieldRecord[fld_ctr].SortIndexList[i]);
+ffs_ret_code = ffs_stat (filename, &ffs_status);
+if (ffs_ret_code NEQ EFFS_OK)
+{
+TRACE_EVENT_P1 ("Sort index %s not existing in FFS", filename);
+dbm->ptrFieldRecord[fld_ctr].SortIndexList[i] = INVALID_SORT_INDEX;
+dbm->ptrFieldRecord[fld_ctr].Clean = FALSE; /* Don't trust this field */
+}
+}
+}
+}
+#ifndef FFS_CLOSE_BEFORE_OPEN
+tmp_ptrFieldRecord -> FFSFileHandle = INVALID_FD;
+#endif
+/* we need to get size of user file <DBDirectory>/UD_<field_id>
+NextRecordNum = (size of user file) / record size */
+dbm->ptrFieldRecord[fld_ctr].NextRecordNum =
+cal_NextRecordNum ( (const char*)DbmMaster[db_ctr].DBDirectory,
+dbm->ptrFieldRecord[fld_ctr].FieldID,
+dbm->ptrFieldRecord[fld_ctr].RecordSize );
+/* Update database records for UsedFiles, Clean, and UsedRecords */
+dbm->UsedFiles++;
+/* Mark DB as not clean if only one field is not clean */
+if (!dbm->ptrFieldRecord[fld_ctr].Clean)
+dbm->Clean = FALSE;
+/* For calculating UsedRecords */
+dbm->ptrFieldRecord[fld_ctr].UsedRecords = 0;
+for (i = 1; i <= dbm->ptrFieldRecord[fld_ctr].NumOfRecords; i++)
+{
+if (db_get_bit_in_bitmap (dbm->ptrFieldRecord[fld_ctr].RecordBitMap, i))
+dbm->ptrFieldRecord[fld_ctr].UsedRecords++;
+}
+} /* FieldID NEQ INVALID_FIELD_ID */
+} /* for( fld_ctr ) ... all fields */
+/* close the DD_<db_handle> file */
+DB_FFS_CLOSE( ffs_dbm_fd );
+} /* ffs_ret_code >= EFFS_OK */
+DB_MFREE( remb_field_buffer );  /* freeing field buffer */
+DBM_State = DBM_INITIALISED;
+return DB_OK;
+} /* if( ffs_ret_code >= EFFS_OK ) */
+/* Directory not present */
+if( ffs_ret_code EQ EFFS_NOTFOUND )
+{
+/* Create DBM directory */
+/* Implements Measure#32: Row 1184 */
+ffs_ret_code = ffs_mkdir( db_dir );
+if( (ffs_ret_code EQ EFFS_NAMETOOLONG ) OR
+(ffs_ret_code EQ EFFS_BADNAME     ) )
+{
+TRACE_EVENT_P1( "init_RAM_with_FFS:ffs_mkdir %d", ffs_ret_code );
+return DB_FAIL;
+}
+if( ffs_ret_code < EFFS_OK )
+{
+TRACE_EVENT_P1( "init_RAM_with_FFS:ffs_mkdir %d", ffs_ret_code );
+LastFFS_ReturnCode = ffs_ret_code;
+return DB_FAIL_FS;
+}
+/* Create empty file DD_master
+FFS_O_EXCL => Generate error if FFS_O_CREATE is also specified and
+the file already exists. */
+DB_FFS_OPEN( ffs_dbm_fd, dbm_file, FFS_O_CREATE | FFS_O_RDWR | FFS_O_EXCL );
+if( (ffs_dbm_fd EQ EFFS_NAMETOOLONG ) OR
+(ffs_dbm_fd EQ EFFS_BADNAME     ) )
+{
+TRACE_EVENT_P1( "init_RAM_with_FFS:DB_FFS_OPEN %d", ffs_dbm_fd );
+/* Implements Measure#32: Row 1184 */
+ffs_ret_code = ffs_remove( db_dir ); /* undo creating of DBM directory */
+return DB_FAIL;
+}
+if( ffs_dbm_fd < EFFS_OK )
+{
+TRACE_EVENT_P1( "init_RAM_with_FFS:DB_FFS_OPEN %d", ffs_dbm_fd );
+LastFFS_ReturnCode = ffs_dbm_fd;
+/* Implements Measure#32: Row 1184 */
+ffs_ret_code = ffs_remove( db_dir ); /* undo creating of DBM directory */
+return DB_FAIL_FS;
+}
+DB_FFS_CLOSE( ffs_dbm_fd );
+DBM_State = DBM_INITIALISED;
+return DB_OK;
+}
+/* Unexpected error: Not a directory */
+return DB_FAIL;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_create            |
++--------------------------------------------------------------------+
+PURPOSE : Create a new database in the given directory of the FFS.
+The directory must not to exist yet, it will be created.
+*/
+int db_create ( const char* directory,
+UBYTE       num_of_fields,
+BOOL        tracked )
+{
+int         db_handle;
+T_DB_CODE   db_ret_code;
+UBYTE       fld_ctr;
+S8          db_ctr;
+T_FFS_SIZE  ffs_ret_code;
+T_FFS_FD    ffs_fd;
+char        field_file[FILENAME_LEN];
+char*       field_file_ptr = field_file;
+UBYTE*      dbm_data;
+UBYTE*      remb_dbm_data;
+TRACE_FUNCTION("db_create()");
+/* If DBM is not in initialized state, call init_RAM_with_FFS (). */
+if( DBM_State NEQ DBM_INITIALISED )
+{
+T_DB_CODE db_ret_code;
+db_ret_code = init_RAM_with_FFS();
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+}
+/* See if you have reached the maximum number of DBs, ?
+(UsedDBs+1) > MAX_DBs */
+if( UsedDBs EQ MAX_DBs )
+DB_RETURN( DB_FULL );
+/* Check DbmMaster if already database for "directory" exists.
+If yes, return error "DB_EXISTS" */
+db_handle = -1;
+for( db_ctr = (MAX_DBs - 1); db_ctr >= 0; --db_ctr )
+{
+if ( DbmMaster[db_ctr].DBState NEQ UNUSED_ENTRY )
+{
+if( memcmp( DbmMaster[db_ctr].DBDirectory,
+directory,
+strlen( directory )          ) EQ 0 )
+DB_RETURN( DB_EXISTS )
+}
+else
+{
+db_handle = db_ctr;
+}
+}
+/* sanity check */
+if( num_of_fields <= 0 ) /*lint !e775 check for <= on non-negative*/
+DB_RETURN( DB_FAIL );
+if (db_handle EQ -1)
+{
+/* No free slot found */
+DB_RETURN ( DB_FAIL ) /* DB_FULL maybe better choice */
+}
+/* Create a directory, "<DBDirectory>" (DBDirectory = directory) */
+ffs_ret_code = ffs_mkdir( directory );
+if( ffs_ret_code < EFFS_OK )
+{
+TRACE_EVENT_P1( "db_create:ffs_mkdir %d", ffs_ret_code );
+LastFFS_ReturnCode = ffs_ret_code;
+DB_RETURN( DB_FAIL_FS )
+}
+/* Create a empty file, "~/dbm/DD_<position in DD_master = db_handle>";
+if this FFS operation fails, we need to delete the directory
+before returning error.
+*/
+/* Implements Measure#32: Row 1182, 1191 */
+sprintf( field_file, format_sDDd_str, db_dir, db_handle);
+TRACE_EVENT_P1( "field_file %s", field_file );
+/* FFS_O_EXCL => Generate error if FFS_O_CREATE is also specified and
+the file already exists. */
+DB_FFS_OPEN( ffs_fd, field_file_ptr, FFS_O_CREATE | FFS_O_RDWR | FFS_O_EXCL );
+if( ( ffs_fd EQ EFFS_EXISTS )      OR
+( ffs_fd EQ EFFS_NAMETOOLONG ) OR
+( ffs_fd EQ EFFS_BADNAME )     OR
+( ffs_fd EQ EFFS_INVALID )     )
+{
+TRACE_EVENT_P1( "db_create:DB_FFS_OPEN %d", ffs_fd );
+ffs_fd = ffs_remove( directory );
+DB_RETURN( DB_FAIL )
+}
+if( ffs_fd < EFFS_OK )
+{
+TRACE_EVENT_P1( "db_create:DB_FFS_OPEN %d", ffs_fd );
+LastFFS_ReturnCode = ffs_fd;
+ffs_ret_code = ffs_remove( directory );
+DB_RETURN( DB_FAIL_FS )
+}
+/* DB_FFS_CLOSE( ffs_fd ); we will close it in db_flush */
+#ifdef FFS_OPEN_PROBLEM_PATCH
+DB_FFS_CLOSE( ffs_fd );
+ffs_fd = INVALID_FD;
+#endif
+#ifdef FFS_CLOSE_BEFORE_OPEN
+/* no we do not close it */
+#endif
+/* Update FFS data i.e. file, "~/dbm/DD_master". */
+/* prepare the dbm data and write */
+DB_MALLOC( dbm_data, T_DB_MASTER_RECORD_SIZE );
+memset( dbm_data, 0, T_DB_MASTER_RECORD_SIZE );
+remb_dbm_data = dbm_data;
+memcpy( dbm_data, directory, MAX_LEN_DIRECTORY );
+dbm_data += MAX_LEN_DIRECTORY;
+*dbm_data++ = num_of_fields;
+*dbm_data++ = ( tracked ) ? FFS_TRACKED : FFS_NOT_TRACKED;
+dbm_data = remb_dbm_data;
+/* Implements Measure#32: Row 1188 */
+db_ret_code =
+update_dbm_data_in_FFS ( db_master_file,
+(UBYTE) db_handle,   /* to supress warning */
+T_DB_MASTER_RECORD_SIZE,
+dbm_data,
+0,
+T_DB_MASTER_RECORD_SIZE );
+if( db_ret_code NEQ DB_OK )
+{
+DB_MFREE( dbm_data );
+ffs_ret_code = ffs_remove( directory );
+DB_FFS_CLOSE( ffs_fd );
+ffs_ret_code = ffs_remove( field_file );
+DB_RETURN( db_ret_code )
+}
+DB_MFREE( dbm_data );
+/* updation of DD_master done
+now update RAM structures  */
+memcpy( DbmMaster[db_handle].DBDirectory,
+directory,
+strlen(directory) );
+DbmMaster[db_handle].NumOfFiles    = num_of_fields;
+DbmMaster[db_handle].UsedFiles     = 0;
+DbmMaster[db_handle].Clean = TRUE;
+DbmMaster[db_handle].Tracked = tracked;
+DbmMaster[db_handle].DBState       = OPEN;
+DbmMaster[db_handle].FFSFileHandle = ffs_fd;
+#ifdef FFS_CLOSE_BEFORE_OPEN
+/* No files corresponding to fields have been opened
+This initialization is already done in db_init */
+#endif
+/* Allocate memory for storing field information
+and initialize the memory with "FF" */
+DB_MALLOC( DbmMaster[db_handle].ptrFieldRecord,
+num_of_fields * sizeof(T_DBM_FIELDRECORD) );
+for( fld_ctr = 0; fld_ctr < num_of_fields; ++fld_ctr )
+{
+DbmMaster[db_handle].ptrFieldRecord[fld_ctr].FieldID = INVALID_FIELD_ID;
+}
+UsedDBs++;
+DB_RETURN( db_handle )
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_open              |
++--------------------------------------------------------------------+
+PURPOSE : Open an existing database
+*/
+int db_open ( const char *directory )
+{
+T_DB_CODE  db_ret_code;
+UBYTE      db_ctr;
+TRACE_FUNCTION("db_open()");
+/* If DBM is not in initialized state, call init_RAM_with_FFS (). */
+if( DBM_State NEQ DBM_INITIALISED )
+{
+db_ret_code = init_RAM_with_FFS();
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+}
+/* Search for "directory" in DbmMaster */
+for( db_ctr = 0; db_ctr < MAX_DBs; ++db_ctr )
+{
+if( DbmMaster[db_ctr].DBState NEQ UNUSED_ENTRY )
+{
+if( memcmp( DbmMaster[db_ctr].DBDirectory,
+directory,
+strlen(directory)                     ) EQ 0 )
+break;
+}
+}
+/* If "directory" not found, return DB_FAIL. */
+if( db_ctr EQ MAX_DBs )
+DB_RETURN( DB_INVALID_DB );
+/* Update DBState as "OPEN". */
+DbmMaster[db_ctr].DBState = OPEN;
+/* Return corresponding DBHandle. */
+DB_RETURN( db_ctr )
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_create_field      |
++--------------------------------------------------------------------+
+PURPOSE : Create a new elementary file of a given type with a given
+numeric identifier and a given record size.
+*/
+T_DB_CODE db_create_field ( int         db_handle,
+T_DB_TYPE   db_type,
+USHORT      field_id,
+USHORT      record_size,
+USHORT      num_of_records )
+{
+T_DB_CODE          db_ret_code;
+char               user_field_file[FILENAME_LEN];
+UBYTE              fld_ctr,
+sort_index_ctr;
+T_FFS_FD           ffs_fd_user_field_file;
+UBYTE*             field_data;
+UBYTE*             remb_field_data;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+TRACE_FUNCTION("db_create_field()");
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field id found, return error DB_FIELD_EXISTS */
+if( field_id_search( db_handle, field_id ) NEQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_FIELD_EXISTS );
+/* If limit for number of fields for this DB has been reached, return error DB_FULL. */
+if( DbmMaster[db_handle].UsedFiles  EQ
+DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_FULL );
+/* Search for free field entry in field records corresponding to the database. */
+for( fld_ctr = 0; fld_ctr < DbmMaster[db_handle].NumOfFiles; ++fld_ctr )
+{
+if( DbmMaster[db_handle].ptrFieldRecord[fld_ctr].FieldID EQ INVALID_FIELD_ID )
+break;
+}
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+{ /* this is "inconsistency"; should never happen */
+DB_RETURN( DB_FAIL )
+}
+/* sanity check */
+/*lint -e{775} check for <= on non-negative */
+if ((num_of_records <= 0) OR
+(record_size <= 0))
+{
+DB_RETURN( DB_FAIL )
+}
+/* Create file "<DBDirectory>/UD_<field_id>" */
+/* Implements Measure#32: Row 1189 */
+sprintf( user_field_file, format_sUDd_str, (char *)DbmMaster[db_handle].DBDirectory, field_id );
+/* FFS_O_EXCL => Generate error if FFS_O_CREATE is also specified and
+the file already exists. */
+#ifndef FFS_CLOSE_BEFORE_OPEN
+DB_FFS_OPEN( ffs_fd_user_field_file, user_field_file, FFS_O_CREATE | FFS_O_RDWR | FFS_O_EXCL );
+#else
+ffs_fd_user_field_file =
+db_open_user_field_file( db_handle,
+fld_ctr,
+user_field_file,
+FFS_O_CREATE | FFS_O_RDWR | FFS_O_EXCL );
+#endif
+if( ( ffs_fd_user_field_file EQ EFFS_EXISTS )      OR
+( ffs_fd_user_field_file EQ EFFS_NAMETOOLONG ) OR
+( ffs_fd_user_field_file EQ EFFS_BADNAME )     OR
+( ffs_fd_user_field_file EQ EFFS_INVALID )     )
+{
+TRACE_EVENT_P1( "db_create_field:DB_FFS_OPEN %d", ffs_fd_user_field_file );
+DB_RETURN( DB_FAIL )
+}
+if( ffs_fd_user_field_file < EFFS_OK )
+{
+TRACE_EVENT_P1( "db_create_field:DB_FFS_OPEN %d", ffs_fd_user_field_file );
+LastFFS_ReturnCode = ffs_fd_user_field_file;
+DB_RETURN( DB_FAIL_FS )
+}
+/* We will close this file in db_flush */
+#ifdef FFS_OPEN_PROBLEM_PATCH
+DB_FFS_CLOSE( ffs_fd_user_field_file );
+ffs_fd_user_field_file = INVALID_FD;
+#endif
+/* file "<DBDirectory>/UD_<field_id>" has been created
+Now, Add new field entry in "~/dbm/DD_<db_handle>" */
+/* create the field data that needs to be written */
+DB_MALLOC( field_data, T_DB_FIELD_RECORD_SIZE );
+memset( field_data, 0, T_DB_FIELD_RECORD_SIZE );
+remb_field_data = field_data;
+*field_data = (UBYTE) ( (field_id & 0xFF00) >> 8 );
+++field_data;
+*field_data = (UBYTE) (field_id & 0x00FF);
+++field_data;
+*field_data = db_type;
+++field_data;
+*field_data = (UBYTE) ( (record_size & 0xFF00) >> 8 );
+++field_data;
+*field_data = (UBYTE) (record_size & 0x00FF);
+++field_data;
+*field_data = (UBYTE)num_of_records;
+field_data++;
+memset( field_data, 0xFF, MAX_NUM_OF_SORT_INDEXS );
+field_data += MAX_NUM_OF_SORT_INDEXS;
+memset( field_data, 0, RECORD_BITMAP_SIZE );
+field_data += RECORD_BITMAP_SIZE;
+*field_data = FFS_CLEAN;
+field_data = remb_field_data;
+db_ret_code =
+update_field_data_in_FFS ( &DbmMaster[db_handle].FFSFileHandle,
+db_handle,
+fld_ctr,
+field_data,
+0,
+T_DB_FIELD_RECORD_SIZE );
+if( db_ret_code NEQ DB_OK )
+{
+DB_MFREE( field_data );
+ffs_remove( user_field_file );
+DB_RETURN( db_ret_code )
+}
+DB_MFREE( field_data );
+/* updation of DD_<db_handle> is over */
+/* Add new field entry in field records in RAM. */
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord + fld_ctr;
+tmp_ptrFieldRecord -> FieldID       = field_id;
+tmp_ptrFieldRecord -> DBType        = db_type;
+tmp_ptrFieldRecord -> RecordSize    = record_size;
+tmp_ptrFieldRecord -> NumOfRecords  = (UBYTE)num_of_records;
+tmp_ptrFieldRecord -> UsedRecords   = 0;
+tmp_ptrFieldRecord -> Clean         = TRUE;
+#ifndef FFS_CLOSE_BEFORE_OPEN
+tmp_ptrFieldRecord -> FFSFileHandle = ffs_fd_user_field_file;
+#endif
+tmp_ptrFieldRecord -> NextRecordNum = 1;
+memset( tmp_ptrFieldRecord -> RecordBitMap, 0, RECORD_BITMAP_SIZE );
+for( sort_index_ctr = 0; sort_index_ctr < MAX_NUM_OF_SORT_INDEXS; ++sort_index_ctr )
+{
+tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr]  = INVALID_SORT_INDEX;
+tmp_ptrFieldRecord -> SortedLists[sort_index_ctr]    = NULL;
+}
+/* Increment UsedFiles for the particular database in RAM */
+DbmMaster[db_handle].UsedFiles += 1;
+/* everyting ok */
+DB_RETURN( DB_OK )
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_write_record      |
++--------------------------------------------------------------------+
+PURPOSE : Write length bytes at offset into the given record in
+(database, field)
+*/
+int db_write_record ( int          db_handle,
+USHORT       field_id,
+USHORT       record_num,
+USHORT       offset,
+USHORT       length,
+const UBYTE* buffer )
+{
+T_DB_CODE  db_ret_code;
+UBYTE fld_ctr,
+rec_ctr;
+char  user_field_file[FILENAME_LEN];
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+UBYTE*  record_buffer;
+UBYTE*  field_data;
+BOOL this_is_new_record = TRUE;
+TRACE_FUNCTION("db_write_record()");
+TRACE_EVENT_P1("field_id %04X", field_id);
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field not found, return error DB_INVALID_FIELD */
+fld_ctr = field_id_search( db_handle, field_id );
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_INVALID_FIELD );
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord + fld_ctr;
+/* Check if record exceeds the record size (i.e. offset + length > record size);
+if it exceeds, return error DB_INVALID_SIZE */
+if( (offset + length) >
+tmp_ptrFieldRecord -> RecordSize )
+DB_RETURN( DB_INVALID_SIZE );
+/* Check if FFS file is already opened using FFSFileHandle, part of field record.
+If it is not yet opened, open the FFS file and update FFSFileHandle.
+This is taken care in read_user_record_from_FFS */
+/* User data file name is "<DBDirectory>/UD_<field_id>"
+This would be used below */
+/* Implements Measure#32: Row 1200 */
+sprintf( user_field_file,
+format_sUDd_str,
+(char *)DbmMaster[db_handle].DBDirectory,
+tmp_ptrFieldRecord -> FieldID );
+if( record_num EQ 0 )
+{
+/* If given record is equal to zero,
+o	Find a free record using RecordBitMap.
+o	If free record not found, return DB_FULL */
+record_num = db_search_bit_in_bitmap (tmp_ptrFieldRecord->RecordBitMap,
+tmp_ptrFieldRecord->NumOfRecords,
+FALSE);
+if (record_num EQ 0)
+DB_RETURN( DB_FULL );
+}
+else
+{
+/* If given record is not equal to zero,
+o	Check if record exists using RecordBitMap;
+if not found, proceed to writing..
+o	Read the record from "<DBDirectory>/UD_<field_id>" and
+compare it with given record (partially if offset > 0). Memcmp would be used.
+o	If record match, return DB_OK. */
+if (db_get_bit_in_bitmap (tmp_ptrFieldRecord->RecordBitMap, record_num))
+{
+/* record exists */
+this_is_new_record = FALSE;
+DB_MALLOC( record_buffer, length);
+/* Implements Measure # 211 */
+db_ret_code =
+read_write_user_record_from_FFS ( user_field_file,
+#ifndef FFS_CLOSE_BEFORE_OPEN
+&(tmp_ptrFieldRecord -> FFSFileHandle),
+#else
+db_handle,
+fld_ctr,
+&Dummy_FFSFileHandle,
+#endif
+(UBYTE)record_num,
+tmp_ptrFieldRecord -> RecordSize,
+offset,
+length,
+record_buffer,
+FFS_O_RDONLY );
+if( db_ret_code NEQ DB_OK )
+{
+DB_MFREE( record_buffer );
+DB_RETURN( db_ret_code )
+}
+/* See if there is same data, if so, we need not overwrite */
+if( memcmp( record_buffer, buffer, length) EQ 0 )
+{ /* matching data */
+DB_MFREE( record_buffer );
+DB_RETURN( DB_OK )
+}
+DB_MFREE( record_buffer );
+} /* record exists */
+} /* record_num EQ 0 ? */
+/* As per the request, write record in FFS in "<DBDirectory>/UD_<field_id>" */
+/* in case of new record, we need to create fill unfilled-data with FF */
+if( this_is_new_record )
+{ /* new record */
+DB_MALLOC( record_buffer, tmp_ptrFieldRecord -> RecordSize );
+memset( record_buffer, 0xFF, tmp_ptrFieldRecord -> RecordSize ) ;
+/* To take care of non-sequential write
+For example, initially when file is empty, and say user writes
+3rd record, 1st and 2nd record should be addded as dummy and then
+3rd record */
+rec_ctr = tmp_ptrFieldRecord -> NextRecordNum;
+while( rec_ctr < record_num   )
+{
+/* Implements Measure # 211 */
+db_ret_code =
+read_write_user_record_from_FFS ( user_field_file,
+#ifndef FFS_CLOSE_BEFORE_OPEN
+&(tmp_ptrFieldRecord -> FFSFileHandle),
+#else
+db_handle,
+fld_ctr,
+&Dummy_FFSFileHandle,
+#endif
+rec_ctr,
+tmp_ptrFieldRecord -> RecordSize,
+0,
+tmp_ptrFieldRecord -> RecordSize,
+record_buffer,
+FFS_O_RDWR );
+if( db_ret_code NEQ DB_OK )
+{
+DB_MFREE( record_buffer );
+DB_RETURN( db_ret_code )
+}
+++rec_ctr;
+}
+/* Add the new record */
+memcpy( record_buffer + offset, buffer, length );
+/* Implements Measure # 211 */
+db_ret_code =
+read_write_user_record_from_FFS ( user_field_file,
+#ifndef FFS_CLOSE_BEFORE_OPEN
+&(tmp_ptrFieldRecord -> FFSFileHandle),
+#else
+db_handle,
+fld_ctr,
+&Dummy_FFSFileHandle,
+#endif
+(UBYTE)record_num,
+tmp_ptrFieldRecord -> RecordSize,
+0,
+tmp_ptrFieldRecord -> RecordSize,
+record_buffer,
+FFS_O_RDWR );
+if( db_ret_code NEQ DB_OK )
+{
+DB_MFREE( record_buffer );
+DB_RETURN( db_ret_code )
+}
+DB_MFREE( record_buffer );
+/* writing of record is over, update DBState (as IN_USE). */
+DbmMaster[db_handle].DBState = IN_USE;
+} else {
+/* overwritten record */
+/* Implements Measure # 211 */
+db_ret_code =
+read_write_user_record_from_FFS ( user_field_file,
+#ifndef FFS_CLOSE_BEFORE_OPEN
+&(tmp_ptrFieldRecord -> FFSFileHandle),
+#else
+db_handle,
+fld_ctr,
+&Dummy_FFSFileHandle,
+#endif
+(UBYTE)record_num,
+tmp_ptrFieldRecord -> RecordSize,
+offset,
+length,
+(UBYTE*)buffer,
+FFS_O_RDWR );
+if( db_ret_code NEQ DB_OK )
+{
+DB_RETURN( db_ret_code )
+}
+/* writing of record is over, update DBState (as IN_USE). */
+DbmMaster[db_handle].DBState = IN_USE;
+/* get the sort lists in RAM from FFS */
+get_sort_lists_from_FFS( (UBYTE)db_handle, fld_ctr );
+/* this is updation of record, so need to be re-sorted */
+update_in_sort_lists( (UBYTE)db_handle, fld_ctr, (UBYTE)record_num );
+/* if database is not tracked, no need to go further for history log writing */
+if (!DbmMaster[db_handle].Tracked)
+DB_VALUE_RETURN( record_num );
+/* if already Clean has been reset, only history updation */
+if (!DbmMaster[db_handle].Clean)
+{
+db_ret_code = update_history_log( db_handle, field_id, record_num );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+DB_VALUE_RETURN( record_num )
+}
+} /* this_is_new_record */
+/* Updating RecordBitMap and Clean in FFS, ~/dbm/DD_<db_handle> */
+/* create the field data that is to be written */
+DB_MALLOC( field_data, ( T_DB_FIELD_RECORD_SIZE - RecordBitMap_OFFSET ) );
+memset( field_data, 0, ( T_DB_FIELD_RECORD_SIZE - RecordBitMap_OFFSET ) );
+memcpy( field_data, tmp_ptrFieldRecord -> RecordBitMap, RECORD_BITMAP_SIZE );
+if( this_is_new_record )
+{ /* RecordBitMap to be updated only for new records */
+db_set_bit_in_bitmap (field_data, record_num, TRUE);
+}
+/* clean is reset in memset, so no processing for it
+(in case of non-tracked database, anyway we ignore it ! */
+db_ret_code =
+update_field_data_in_FFS ( &DbmMaster[db_handle].FFSFileHandle,
+db_handle,
+fld_ctr,
+field_data,
+RecordBitMap_OFFSET,
+( T_DB_FIELD_RECORD_SIZE - RecordBitMap_OFFSET ) );
+if( db_ret_code NEQ DB_OK )
+{
+DB_MFREE( field_data );
+DB_RETURN( db_ret_code )
+}
+DB_MFREE( field_data );
+/* updation of DD_<db_handle> is over */
+/* Updating RAM (both DbmMaster and Field records) strctures */
+tmp_ptrFieldRecord->Clean = FALSE;
+if( this_is_new_record )
+{ /* RecordBitMap to be updated only for new records */
+db_set_bit_in_bitmap (tmp_ptrFieldRecord->RecordBitMap,
+record_num,
+TRUE);
+++tmp_ptrFieldRecord -> UsedRecords;
+tmp_ptrFieldRecord -> NextRecordNum =
+( (record_num + 1) > tmp_ptrFieldRecord -> NextRecordNum ) ?
+(record_num + 1) : tmp_ptrFieldRecord -> NextRecordNum ;
+/* get the sort lists in RAM from FFS */
+get_sort_lists_from_FFS( (UBYTE)db_handle, fld_ctr );
+/* note the record number for sorting later
+yeah, we call it *after* updating UsedRecords */
+new_in_sort_lists( (UBYTE)db_handle, fld_ctr, (UBYTE)record_num );
+}
+DbmMaster[db_handle].Clean = FALSE;
+/* history log updation */
+db_ret_code = update_history_log( db_handle, field_id, record_num );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+DB_VALUE_RETURN( record_num )
+}
+int db_update_ext_bitmap(int          db_handle,
+USHORT       field_id,
+USHORT       record_num,
+BOOL           flag)
+{
+T_DB_CODE  db_ret_code;
+UBYTE fld_ctr;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+UBYTE*  record_buffer;
+UBYTE*  field_data;
+BOOL this_is_new_record = TRUE;
+TRACE_FUNCTION("db_update_ext_bimap()");
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field not found, return error DB_INVALID_FIELD */
+fld_ctr = field_id_search( db_handle, field_id );
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_INVALID_FIELD );
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord + fld_ctr;
+/* Updating RecordBitMap and Clean in FFS, DD_<db_handle> */
+/* create the field data that is to be written */
+DB_MALLOC( field_data, ( T_DB_FIELD_RECORD_SIZE - RecordBitMap_OFFSET ) );
+memset( field_data, 0, ( T_DB_FIELD_RECORD_SIZE - RecordBitMap_OFFSET ) );
+memcpy( field_data, tmp_ptrFieldRecord -> RecordBitMap, RECORD_BITMAP_SIZE );
+/* RecordBitMap to be updated only for new records */
+db_set_bit_in_bitmap (field_data, record_num, flag);
+/* clean is reset in memset, so no processing for it
+(in case of non-tracked database, anyway we ignore it ! */
+db_ret_code =
+update_field_data_in_FFS ( &DbmMaster[db_handle].FFSFileHandle,
+db_handle,
+fld_ctr,
+field_data,
+RecordBitMap_OFFSET,
+( T_DB_FIELD_RECORD_SIZE - RecordBitMap_OFFSET ) );
+if( db_ret_code NEQ DB_OK )
+{
+DB_MFREE( field_data );
+DB_RETURN( db_ret_code )
+}
+DB_MFREE( field_data );
+/* RecordBitMap to be updated only for new records */
+db_set_bit_in_bitmap (tmp_ptrFieldRecord->RecordBitMap,
+record_num,
+flag);
+++tmp_ptrFieldRecord -> UsedRecords;
+tmp_ptrFieldRecord -> NextRecordNum =
+( (record_num + 1) > tmp_ptrFieldRecord -> NextRecordNum ) ?
+(record_num + 1) : tmp_ptrFieldRecord -> NextRecordNum ;
+DB_VALUE_RETURN( record_num )
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+PURPOSE : Creates or updates a sort index for a given (database, field)
+*/
+T_DB_CODE db_create_index ( int          db_handle,
+USHORT       field_id,
+UBYTE        sort_index,
+T_COMP_FUNC  compare_function,
+ULONG        flags )
+{
+return internal_db_sort( db_handle,
+field_id,
+sort_index,
+compare_function,
+flags );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_update_index      |
++--------------------------------------------------------------------+
+PURPOSE : Sort the list for newly added/deleted records (uses incremental
+sort i.e. add the element at the right place)
+*/
+T_DB_CODE db_update_index ( int          db_handle,
+USHORT       field_id,
+UBYTE        sort_index,
+T_COMP_FUNC  compare_function,
+ULONG        flags )
+{
+return internal_db_sort( db_handle,
+field_id,
+sort_index,
+compare_function,
+flags );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_get_phy_from_idx  |
++--------------------------------------------------------------------+
+PURPOSE : Translates a logical entry within a given sort index to the
+physical record number
+*/
+T_DB_CODE db_get_phy_from_idx ( int    db_handle,
+USHORT field_id,
+UBYTE  sort_index,
+USHORT order_num )
+{
+T_DB_CODE          db_ret_code;
+UBYTE              fld_ctr,
+sort_index_ctr;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+char              sort_file[FILENAME_LEN];
+TRACE_FUNCTION("db_get_phy_from_idx()");
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field not found, return error DB_INVALID_FIELD */
+fld_ctr = field_id_search( db_handle, field_id );
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_INVALID_FIELD );
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord + fld_ctr;
+/* sanity check on order_num */
+if( ( order_num > tmp_ptrFieldRecord -> NumOfRecords ) OR
+( order_num EQ 0 ) )
+DB_RETURN( DB_FAIL );  /* may be we can return 0xFF => no record for it ! */
+/* Search given sort_index in SortIndexList for above field_id;
+if not found, return DB_INVALID_INDEX. */
+for( sort_index_ctr = 0; sort_index_ctr < MAX_NUM_OF_SORT_INDEXS; ++sort_index_ctr )
+{
+if( tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] EQ sort_index )
+break;
+}
+if( sort_index_ctr EQ MAX_NUM_OF_SORT_INDEXS )
+DB_RETURN( DB_INVALID_INDEX );
+/* Check if we already have sorted list in RAM structure SortedLists */
+if( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] EQ NULL )
+{
+/* If no, populate the sorted list from file,
+"<DBDirectory>/UD_<field_id>_sort_<sort_index>".
+Sorted lists are freed in db_flush */
+/* Implements Measure#32: Row 1177 */
+sprintf( sort_file,
+format_sUDd_sortd_str,
+(char *)DbmMaster[db_handle].DBDirectory,
+tmp_ptrFieldRecord -> FieldID,
+sort_index );
+db_ret_code =
+populate_sorted_list_from_FFS (
+#ifdef FFS_CLOSE_BEFORE_OPEN
+db_handle,
+#endif
+sort_file,
+tmp_ptrFieldRecord -> NumOfRecords,
+&(tmp_ptrFieldRecord -> SortedLists[sort_index_ctr]) );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+} /* if we have sort list */
+/* Get (physical) record number for given order_num from sorted list. */
+DB_VALUE_RETURN((T_DB_CODE)tmp_ptrFieldRecord -> SortedLists[sort_index_ctr][order_num - 1] )
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_flush             |
++--------------------------------------------------------------------+
+PURPOSE : Flush all internal data structures of the database described by
+db_handle
+*/
+T_DB_CODE db_flush ( int db_handle)
+{
+T_DB_CODE  db_ret_code;
+UBYTE      clean_byte, /* Coded as in the FFS */
+fld_ctr,
+i;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+char sort_file[FILENAME_LEN];
+T_FFS_STAT ffs_file_stat;
+T_FFS_SIZE ffs_ret_code;
+TRACE_FUNCTION("db_flush()");
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/* Clear "clean" in "~/dbm/DD_<db_handle>" for fields.
+after ffs updation, update RAM data */
+clean_byte = FFS_CLEAN;
+/* Update the affected field records */
+#ifdef FFS_CLOSE_BEFORE_OPEN
+db_close_user_field_files( db_handle );
+#endif
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord;
+for( fld_ctr = 0; fld_ctr < DbmMaster[db_handle].NumOfFiles; ++fld_ctr )
+{
+if( tmp_ptrFieldRecord -> FieldID EQ INVALID_FIELD_ID ) /* if not valid field id */
+{
+++tmp_ptrFieldRecord;   /* next field */
+continue;
+}
+/* Clear file handles */
+#ifndef FFS_CLOSE_BEFORE_OPEN
+if (IS_FD_VALID(tmp_ptrFieldRecord->FFSFileHandle))
+{
+DB_FFS_CLOSE( tmp_ptrFieldRecord -> FFSFileHandle );
+tmp_ptrFieldRecord -> FFSFileHandle = INVALID_FD;
+}
+#else
+/* Done it closing before for loop */
+#endif
+/* Write sort lists to FFS and clear (free memory) sort lists */
+for( i = 0; i < MAX_NUM_OF_SORT_INDEXS; ++i )
+{
+if( tmp_ptrFieldRecord -> SortedLists[i] NEQ NULL )
+{
+/* currently I am not removing unused entries in sort list */
+/* Write sorted lists to "<DBDirectory>/UD_<field_id>_sort_<sort_index>". */
+/* Implements Measure#32: Row 1193 */
+sprintf( sort_file,
+format_sUDd_sortd_str,
+(char *)DbmMaster[db_handle].DBDirectory,
+tmp_ptrFieldRecord -> FieldID,
+tmp_ptrFieldRecord -> SortIndexList[i] );
+/* writing sorted lists to FFS s required in two cases
+1) the field is not clean and/or
+2) sort file does not exist, but we have sort list (happen during
+bootup time with zero records)
+*/
+ffs_ret_code = ffs_stat( sort_file, &ffs_file_stat );
+if( ( ffs_ret_code NEQ EFFS_OK )      AND
+( ffs_ret_code NEQ EFFS_NOTFOUND ) )
+{
+LastFFS_ReturnCode = ffs_ret_code;
+DB_MFREE( tmp_ptrFieldRecord -> SortedLists[i] );
+tmp_ptrFieldRecord -> SortedLists[i] = NULL;
+DB_RETURN( DB_FAIL_FS )
+}
+if( ( NOT tmp_ptrFieldRecord -> Clean )  OR /* not clean (consistent) */
+( ffs_ret_code EQ EFFS_NOTFOUND )    )  /* file does not exist */
+{
+db_ret_code =
+write_sorted_list_to_FFS (
+#ifdef FFS_CLOSE_BEFORE_OPEN
+db_handle,
+#endif
+sort_file,
+tmp_ptrFieldRecord -> NumOfRecords,
+tmp_ptrFieldRecord -> SortedLists[i] );
+if( db_ret_code NEQ DB_OK )
+{
+DB_MFREE( tmp_ptrFieldRecord -> SortedLists[i] );
+tmp_ptrFieldRecord -> SortedLists[i] = NULL;
+DB_RETURN( db_ret_code )
+}
+}
+/* writing in sort file is over */
+DB_MFREE( tmp_ptrFieldRecord -> SortedLists[i] );
+tmp_ptrFieldRecord -> SortedLists[i] = NULL;
+}
+}
+if( tmp_ptrFieldRecord -> Clean ) /* is it clean (consistent) ? */
+{
+++tmp_ptrFieldRecord;   /* next field */
+continue;
+}
+/* Clear "clean" in "~/dbm/DD_<db_handle>" if not clean  */
+db_ret_code =
+update_field_data_in_FFS ( &DbmMaster[db_handle].FFSFileHandle,
+db_handle,
+fld_ctr,
+&clean_byte,
+( T_DB_FIELD_RECORD_SIZE - 1 ),
+1 );       /* "Clean" contained in last one byte */
+if( db_ret_code NEQ DB_OK )
+{
+/* this leaves out FFS and RAM in consistent state,
+this is ok since FFS is in correct state for some of fields ! */
+DB_RETURN( db_ret_code )
+}
+tmp_ptrFieldRecord->Clean = TRUE;
+++tmp_ptrFieldRecord;   /* next field */
+} /* for all field records */
+if (IS_FD_VALID(DbmMaster[db_handle].FFSFileHandle))
+{
+DB_FFS_CLOSE( DbmMaster[db_handle].FFSFileHandle );
+DbmMaster[db_handle].FFSFileHandle = INVALID_FD;
+}
+/* updation of FFS is over */
+/* Update corresponding "clean" field for database in RAM data structures,
+also DBState = OPEN */
+DbmMaster[db_handle].Clean = TRUE;
+DbmMaster[db_handle].DBState = OPEN;
+/* done */
+DB_RETURN( DB_OK )
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_search            |
++--------------------------------------------------------------------+
+PURPOSE : Searches for an entry within a given database and a given file
+*/
+int db_search ( int               db_handle,
+USHORT            field_id,
+UBYTE             sort_index,
+SHORT*            order_num,
+T_SEARCH_FUNC     search_function,
+ULONG             flags,
+const UBYTE*      search_tag )
+{
+T_DB_CODE  db_ret_code;
+UBYTE fld_ctr,
+sort_index_ctr;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+char sort_file[FILENAME_LEN];
+int record_num = 0,
+index_num ;
+TRACE_FUNCTION("db_search()");
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field not found, return error DB_INVALID_FIELD */
+fld_ctr = field_id_search( db_handle, field_id );
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_INVALID_FIELD );
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord + fld_ctr;
+if( sort_index EQ 0 )
+{
+/* If sort_index is zero,
+o	Do linear search using RecordBitMap, search/comparison function is given by caller.
+o	If search is successful, return the record number.
+o	Otherwise return DB_RECORD_NOT_FOUND. */
+/* Sanity check */
+if( (*order_num) > tmp_ptrFieldRecord -> NumOfRecords )
+DB_RETURN( DB_FAIL );
+/* search from next record,
+search_node->top would be zero for fresh search */
+for (record_num = *order_num + 1;
+record_num <= tmp_ptrFieldRecord->NumOfRecords;
+record_num++)
+{
+if (db_get_bit_in_bitmap (tmp_ptrFieldRecord->RecordBitMap, record_num))
+{
+/* ok, this is a valid record */
+if( search_function( flags,
+search_tag,
+db_handle,
+field_id,
+(UBYTE)record_num )
+EQ 0 )  /* yeah, "EQ 0" is success */
+{
+/* found it ! */
+*order_num = record_num; /* for next search */
+DB_VALUE_RETURN( record_num )
+}
+}
+} /* for bytes in bitmap */
+/* record not found */
+DB_RETURN( DB_RECORD_NOT_FOUND )
+}
+/* If sort_index is not zero, search using sorted list */
+else
+{
+/* Search given sort_index in SortIndexList for above field_id;
+if not found, return DB_INVALID_INDEX. */
+for( sort_index_ctr = 0; sort_index_ctr < MAX_NUM_OF_SORT_INDEXS; ++sort_index_ctr )
+{
+if( tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] EQ sort_index )
+break;
+}
+if( sort_index_ctr EQ MAX_NUM_OF_SORT_INDEXS )
+DB_RETURN( DB_INVALID_INDEX );
+if( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] EQ NULL )
+{
+/* If no, populate the sorted list from file,
+"<DBDirectory>/UD_<field_id>_sort_<sort_index>".
+Sorted lists are freed in db_flush */
+/* Implements Measure#32: Row 1193 */
+sprintf( sort_file,
+format_sUDd_sortd_str,
+(char *)DbmMaster[db_handle].DBDirectory,
+tmp_ptrFieldRecord -> FieldID,
+sort_index );
+db_ret_code =
+populate_sorted_list_from_FFS (
+#ifdef FFS_CLOSE_BEFORE_OPEN
+db_handle,
+#endif
+sort_file,
+tmp_ptrFieldRecord -> NumOfRecords,
+&(tmp_ptrFieldRecord -> SortedLists[sort_index_ctr]) );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+}
+/* (Binary) search the sorted list, search/compare function is given by caller.
+o	If search is successful, return the record number.
+o	Otherwise return DB_RECORD_NOT_FOUND */
+index_num =
+db_binary_search( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr],
+tmp_ptrFieldRecord -> UsedRecords,
+order_num,
+search_function,
+flags,
+search_tag,
+db_handle,
+field_id );
+if( index_num EQ SEARCH_FAILED )
+DB_RETURN( DB_RECORD_NOT_FOUND );
+DB_VALUE_RETURN( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr][index_num - 1] )
+}
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_delete_record     |
++--------------------------------------------------------------------+
+PURPOSE : Delete a record in the given field of the given database
+*/
+T_DB_CODE db_delete_record ( int    db_handle,
+USHORT field_id,
+USHORT record_num )
+{
+T_DB_CODE  db_ret_code;
+UBYTE fld_ctr;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+UBYTE*  field_data;
+TRACE_FUNCTION("db_delete_record()");
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field not found, return error DB_INVALID_FIELD */
+fld_ctr = field_id_search( db_handle, field_id );
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_INVALID_FIELD );
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord + fld_ctr;
+/* Using RecordBitMap, check whether record_num exists;
+if it does not exist, return DB_OK. */
+if (!db_get_bit_in_bitmap (tmp_ptrFieldRecord->RecordBitMap, record_num))
+{
+/* if record does *not* exist */
+DB_RETURN( DB_OK )
+}
+/* Update "Clean" and "RecordBitMap" fields in "~/dbm/DD_<db_handle>" */
+/* create the field data that is to be written */
+DB_MALLOC( field_data, ( T_DB_FIELD_RECORD_SIZE - RecordBitMap_OFFSET ) );
+memset( field_data, 0, ( T_DB_FIELD_RECORD_SIZE - RecordBitMap_OFFSET ) );
+memcpy( field_data, tmp_ptrFieldRecord -> RecordBitMap, RECORD_BITMAP_SIZE );
+/* updating RecordBitMap */
+db_set_bit_in_bitmap (field_data, record_num, FALSE);
+/* clean is reset in memset, so no processing for it
+(in case of non-tracked database, anyway we ignore it ! */
+db_ret_code =
+update_field_data_in_FFS ( &DbmMaster[db_handle].FFSFileHandle,
+db_handle,
+fld_ctr,
+field_data,
+RecordBitMap_OFFSET,
+( T_DB_FIELD_RECORD_SIZE - RecordBitMap_OFFSET ) );
+if( db_ret_code NEQ DB_OK )
+{
+DB_MFREE( field_data );
+DB_RETURN( db_ret_code )
+}
+DB_MFREE( field_data );
+/* updation of DD_<db_handle> is over */
+/* Update corresponding "Clean" and "RecordBitMap" fields in RAM data structures,
+also update DBState (as IN_USE) and decrement UsedRecords. */
+tmp_ptrFieldRecord->Clean = FALSE;
+/* updating RecordBitMap */
+db_set_bit_in_bitmap (tmp_ptrFieldRecord->RecordBitMap, record_num, FALSE);
+/* get the sort lists in RAM from FFS */
+get_sort_lists_from_FFS( (UBYTE)db_handle, fld_ctr );
+/* delete in available sort lists
+yeah, we call it *before* updating UsedRecords */
+delete_in_sort_lists( (UBYTE)db_handle, fld_ctr, (UBYTE)record_num );
+--tmp_ptrFieldRecord -> UsedRecords;
+DbmMaster[db_handle].Clean = FALSE;
+DbmMaster[db_handle].DBState = IN_USE;
+/* history log updation */
+return update_history_log( db_handle, field_id, record_num );
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_read_record       |
++--------------------------------------------------------------------+
+PURPOSE : Read length bytes at offset from the record in given (database, field)
+*/
+int db_read_record ( int     db_handle,
+USHORT  field_id,
+USHORT  record_num,
+USHORT  offset,
+USHORT  length,
+UBYTE*  record_buffer )
+{
+T_DB_CODE  db_ret_code;
+UBYTE fld_ctr;
+char  user_field_file[FILENAME_LEN];
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+TRACE_FUNCTION("db_read_record()");
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field not found, return error DB_INVALID_FIELD */
+fld_ctr = field_id_search( db_handle, field_id );
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_INVALID_FIELD );
+/* Using RecordBitMap, check whether record_num exists;
+if it does not exist, return DB_EMPTY_RECORD. */
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord + fld_ctr;
+if (!db_get_bit_in_bitmap (tmp_ptrFieldRecord -> RecordBitMap, record_num))
+{
+/* if record does *not* exist */
+DB_RETURN( DB_EMPTY_RECORD )
+}
+/* Check if record exceeds the record size (i.e. offset + length > record size);
+if it exceeds, return error DB_INVALID_SIZE */
+if( (offset + length) >
+tmp_ptrFieldRecord -> RecordSize )
+DB_RETURN( DB_INVALID_SIZE );
+/* Check if FFS file is already opened using FFSFileHandle, part of field record.
+If it is not yet opened, open the FFS file and update FFSFileHandle.
+This is taken care in read_user_record_from_FFS below. */
+/* Read record_num from "<DBDirectory>/UD_<field_id>"
+Put "length" number of bytes from "offset" in buffer. (assuming that
+buffer contain enough memory i.e. caller should take care of allocating
+enough memory space for buffer) */
+/* User data file name is "<DBDirectory>/UD_<field_id>" */
+/* Implements Measure#32: Row 1200 */
+sprintf( user_field_file,
+format_sUDd_str,
+(char *)DbmMaster[db_handle].DBDirectory,
+tmp_ptrFieldRecord -> FieldID );
+/* Implements Measure # 211 */
+db_ret_code =
+read_write_user_record_from_FFS ( user_field_file,
+#ifndef FFS_CLOSE_BEFORE_OPEN
+&(tmp_ptrFieldRecord -> FFSFileHandle),
+#else
+db_handle,
+fld_ctr,
+&Dummy_FFSFileHandle,
+#endif
+(UBYTE)record_num,
+tmp_ptrFieldRecord -> RecordSize,
+offset,
+length,
+record_buffer,
+FFS_O_RDONLY );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+DB_VALUE_RETURN( record_num )
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_remove            |
++--------------------------------------------------------------------+
+PURPOSE : Remove a database. The database must not be in use.
+*/
+T_DB_CODE db_remove ( const char* directory )
+{
+int db_handle;
+UBYTE db_ctr,
+fld_ctr;
+T_DB_CODE          db_ret_code;
+UBYTE* dbm_data;
+UBYTE field_file[FILENAME_LEN];
+TRACE_FUNCTION("db_remove()");
+/* DBM_State check */
+DBM_State_check;
+/* Search for "directory" in DbmMaster
+If not found, return DB_INVALID_DB */
+for( db_ctr = 0; db_ctr < MAX_DBs; ++db_ctr )
+{
+if ( DbmMaster[db_ctr].DBState NEQ UNUSED_ENTRY )
+{
+if( memcmp( DbmMaster[db_ctr].DBDirectory,
+directory,
+strlen(directory) ) EQ 0 )
+break;
+}
+}
+if( db_ctr EQ MAX_DBs )
+DB_RETURN( DB_INVALID_DB );
+db_handle = db_ctr;
+/* If DBState for found database in DbmMaster is OPEN or IN_USE, return error DB_IN_USE */
+if( ( DbmMaster[db_ctr].DBState EQ OPEN ) OR
+( DbmMaster[db_ctr].DBState EQ IN_USE ) )
+DB_RETURN( DB_IN_USE );
+/* Delete all files under directory "<DBDirectory>" (DBDirectory = directory) */
+for( fld_ctr = 0; fld_ctr < DbmMaster[db_handle].NumOfFiles; ++fld_ctr )
+{
+db_ret_code = remove_field_from_FFS( (UBYTE)db_handle, fld_ctr );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+}
+/* Delete the DBDirectory */
+db_ret_code = delete_file_dir_from_FFS ( (const char*)DbmMaster[db_handle].DBDirectory );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/* Delete Field file = DD_<pos. in DD_master> */
+/* Implements Measure#32: Row 1195, 1203 */
+sprintf( (char*)field_file, format_sDDd_str, db_dir, db_ctr);
+db_ret_code = delete_file_dir_from_FFS ( (const char*)field_file );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/* Update FFS data i.e. file, "~/dbm/DD_master" */
+/* prepare the dbm data and write */
+DB_MALLOC( dbm_data, T_DB_MASTER_RECORD_SIZE );
+memset( dbm_data, 0xFF, T_DB_MASTER_RECORD_SIZE );
+/* Implements Measure#32: Row 1201 */
+db_ret_code =
+update_dbm_data_in_FFS ( db_master_file,
+(UBYTE) db_handle,   /* to supress warning */
+T_DB_MASTER_RECORD_SIZE,
+dbm_data,
+0,
+T_DB_MASTER_RECORD_SIZE );
+if( db_ret_code NEQ DB_OK )
+{
+DB_MFREE( dbm_data );
+DB_RETURN( db_ret_code )
+}
+DB_MFREE( dbm_data );
+/* updation of DD_master done */
+/* Free the memory for field records.
+Update this entry in DbmMaster as unused. (DBState = UNUSED_ENTRY).
+Also, decrement UsedDBs. */
+DB_MFREE( DbmMaster[db_handle].ptrFieldRecord );
+DbmMaster[db_handle].DBState = UNUSED_ENTRY;
+--UsedDBs;
+/* everything ok ! */
+DB_RETURN( DB_OK )
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_close             |
++--------------------------------------------------------------------+
+PURPOSE : Close a database; if in use, it flushes it before closing it.
+*/
+T_DB_CODE db_close ( int db_handle )
+{
+TRACE_FUNCTION("db_close()");
+/* DBM_State check */
+DBM_State_check;
+/* Check for db_handle range */
+if( db_handle >= MAX_DBs )
+DB_RETURN( DB_INVALID_DB );
+/* If DBState for db_handleth position in DbmMaster is
+o	UNUSED_ENTRY, return error DB_INVALID_DB
+o	CLOSED, return DB_OK.
+o	OPEN, update DBState as CLOSED and return DB_OK.
+o	IN_USE, call db_flush, update DBState as CLOSED and return DB_OK */
+switch( DbmMaster[db_handle].DBState )
+{
+case UNUSED_ENTRY: DB_RETURN( DB_INVALID_DB )
+case CLOSED: DB_RETURN( DB_OK )
+case OPEN:
+case IN_USE:  {
+db_flush( db_handle );
+DbmMaster[db_handle].DBState = CLOSED;
+DB_RETURN( DB_OK )
+}
+default: break;
+}
+DB_RETURN( DB_FAIL )
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_exit              |
++--------------------------------------------------------------------+
+PURPOSE : Shutdown the data base
+*/
+void db_exit ( void )
+{
+/* It is assumed as "forced" exit and so no error would be
+raised even if database is in use. Also, here we will not
+delete the database, but just sync the database and free
+the RAM structures.
+1)	Call db_flush for all databases present in DbmMaster.
+2)	Free the memory for field records for all databases.
+3)	Update all entries in DbmMaster as unused (this step is not required)
+4)	Set DBM_State as DBM_NOT_INITIALISED. */
+UBYTE db_ctr;
+for ( db_ctr = 0; db_ctr < MAX_DBs; ++db_ctr )
+{
+if( DbmMaster[db_ctr].DBState EQ UNUSED_ENTRY )
+continue;
+db_close( db_ctr );
+DB_MFREE( DbmMaster[db_ctr].ptrFieldRecord );
+DbmMaster[db_ctr].DBState = UNUSED_ENTRY;
+}
+DBM_State = DBM_NOT_INITIALISED;
+UsedDBs = 0;
+return;
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_remove_field      |
++--------------------------------------------------------------------+
+PURPOSE : Delete field in given database
+*/
+T_DB_CODE db_remove_field ( int    db_handle,
+USHORT field_id )
+{
+UBYTE fld_ctr;
+T_DB_CODE db_ret_code;
+UBYTE* field_data;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+TRACE_FUNCTION("db_remove_field()");
+TRACE_EVENT_P1 ("Removing field %04X", field_id);
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field id not found, return error DB_INVALID_FIELD */
+fld_ctr = field_id_search( db_handle, field_id );
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_INVALID_FIELD );
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord + fld_ctr;
+/* >>>HM 4-Sep-2006
+It would be nice if we would close here only the file
+which is opened and not everything, but such a solution is impossible
+within the work environment at the customer.*/
+#ifdef FFS_CLOSE_BEFORE_OPEN
+db_close_user_field_files( db_handle );
+#endif
+/*   <<< HM 4-Sep-2006 */
+#ifndef FFS_CLOSE_BEFORE_OPEN
+/* Check if FFS file is open using FFSFileHandle, part of field record;
+if so, return error DB_IN_USE. */
+if (IS_FD_VALID(tmp_ptrFieldRecord->FFSFileHandle)
+{
+TRACE_ERROR ("File handle in use");
+DB_RETURN( DB_IN_USE );
+}
+#else
+if( db_status_user_field_file( db_handle, fld_ctr ) EQ OPENED_FOR_WRITE )
+{
+TRACE_ERROR ("File handle in use for writing");
+DB_RETURN( DB_IN_USE )
+}
+#endif
+/* Remove file "<DBDirectory>/UD_<field_id>" */
+db_ret_code = remove_field_from_FFS( (UBYTE)db_handle, fld_ctr );
+if( db_ret_code NEQ DB_OK )
+{
+TRACE_ERROR ("Could not remove user field file");
+DB_RETURN( db_ret_code )
+}
+/* Update "~/dbm/DD_<db_handle>" for removed field id. */
+/* create the field data that is to be written */
+DB_MALLOC( field_data, ( T_DB_FIELD_RECORD_SIZE - RecordBitMap_OFFSET ) );
+memset( field_data, 0xFF, ( T_DB_FIELD_RECORD_SIZE - RecordBitMap_OFFSET ) );
+db_ret_code =
+update_field_data_in_FFS ( &DbmMaster[db_handle].FFSFileHandle,
+db_handle,
+fld_ctr,
+field_data,
+RecordBitMap_OFFSET,
+( T_DB_FIELD_RECORD_SIZE - RecordBitMap_OFFSET ) );
+if( db_ret_code NEQ DB_OK )
+{
+TRACE_ERROR ("Could not update master file");
+DB_MFREE( field_data );
+DB_RETURN( db_ret_code )
+}
+DB_MFREE( field_data );
+/* updation of DD_<db_handle> is over */
+/* update in RAM */
+tmp_ptrFieldRecord -> FieldID = INVALID_FIELD_ID;
+/* One field less */
+DbmMaster[db_handle].UsedFiles--; // HM 5-Sep-2006 Midnight patch ADN FDN switch
+DB_RETURN( DB_OK )
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_read_change_log   |
++--------------------------------------------------------------------+
+PURPOSE : Get an information about the changed records since the last
+call of this function
+*/
+T_DB_CODE db_read_change_log ( int           db_handle,
+T_DB_CHANGED* changed)
+{
+T_DB_CODE db_ret_code;
+TRACE_FUNCTION("db_read_change_log()");
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/* Copy contents of internal history log to HistoryRecord */
+*changed = DB_History_log;  /* This would work ?? */
+/* Clear internal history log. */
+DB_History_log.entries = 0; /* this is enough for clearing history log ! */
+/* done */
+DB_RETURN( DB_OK )
+}
+#ifdef _SIMULATION_ /* HM 19-Oct-2006: Currently not used but to be kept */
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_remove_index      |
++--------------------------------------------------------------------+
+PURPOSE : Removes a sort index
+*/
+T_DB_CODE db_remove_index ( int    db_handle,
+USHORT field_id,
+UBYTE  sort_index )
+{
+T_DB_CODE db_ret_code;
+UBYTE     fld_ctr,sort_index_ctr;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+char sort_file[FILENAME_LEN];
+UBYTE* field_data;
+TRACE_FUNCTION("db_remove_index()");
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field not found, return error DB_INVALID_FIELD */
+fld_ctr = field_id_search( db_handle, field_id );
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_INVALID_FIELD );
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord + fld_ctr;
+/* Search given sort_index in SortIndexList for above field_id;
+if not found, return DB_INVALID_INDEX. */
+for( sort_index_ctr = 0; sort_index_ctr < MAX_NUM_OF_SORT_INDEXS; ++sort_index_ctr )
+{
+if( tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] EQ sort_index )
+break;
+}
+if( sort_index_ctr EQ MAX_NUM_OF_SORT_INDEXS )
+DB_RETURN( DB_INVALID_INDEX );
+/* Remove file, "<DBDirectory>/UD_<field_id>_sort_<sort_index>" */
+/* Implements Measure#32: Row 1193 */
+sprintf( sort_file,
+format_sUDd_sortd_str,
+DbmMaster[db_handle].DBDirectory,
+tmp_ptrFieldRecord -> FieldID,
+tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] );
+db_ret_code = delete_file_dir_from_FFS ( sort_file );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/* Update file , "~/dbm/DD_<db_handle>" for SortIndexes. */
+/* create the field data that is to be written */
+DB_MALLOC( field_data, MAX_NUM_OF_SORT_INDEXS );
+memcpy( field_data, tmp_ptrFieldRecord -> SortIndexList, MAX_NUM_OF_SORT_INDEXS );
+field_data[sort_index_ctr] = INVALID_SORT_INDEX;
+db_ret_code =
+update_field_data_in_FFS ( &DbmMaster[db_handle].FFSFileHandle,
+db_handle,
+fld_ctr,
+field_data,
+SortIndexList_OFFSET,
+MAX_NUM_OF_SORT_INDEXS );
+if( db_ret_code NEQ DB_OK )
+{
+DB_MFREE( field_data );
+DB_RETURN( db_ret_code )
+}
+DB_MFREE( field_data );
+/* updation of DD_<db_handle> is over */
+/* Update corresponding RAM structure i.e. DbmFieldRecord
+Check if we have sort list corresponding to this sort index; if so, free it. */
+tmp_ptrFieldRecord -> SortIndexList[sort_index_ctr] = INVALID_SORT_INDEX;
+if( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] NEQ NULL )
+{
+DB_MFREE( tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] );
+tmp_ptrFieldRecord -> SortedLists[sort_index_ctr] = NULL;
+}
+DB_RETURN( DB_OK )
+}
+#endif /* #ifdef _SIMULATION_ */
+#ifdef _SIMULATION_ /* HM 19-Oct-2006: Currently not used but to be kept */
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_field_changed     |
++--------------------------------------------------------------------+
+PURPOSE : Check whether a database field has been changed since last
+db_flush().
+*/
+T_DB_CODE db_field_changed ( int    db_handle,
+USHORT field_id,
+BOOL*  changed )
+{
+UBYTE fld_ctr;
+T_DB_CODE db_ret_code;
+TRACE_FUNCTION("db_field_changed()");
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field not found, return error DB_INVALID_FIELD */
+fld_ctr = field_id_search( db_handle, field_id );
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_INVALID_FIELD );
+/* Check "Clean" field in field record;
+a) if (Clean = true), changed = false. */
+*changed = NOT DbmMaster[db_handle].ptrFieldRecord[fld_ctr].Clean;
+DB_RETURN( DB_OK )
+}
+#endif /* #ifdef _SIMULATION_ */
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_record_empty      |
++--------------------------------------------------------------------+
+PURPOSE : Check whether a database field is empty. The result is
+given to the caller in the *empty variable
+*/
+T_DB_CODE db_record_empty ( int    db_handle,
+USHORT field_id,
+USHORT record_num,
+BOOL*  empty )
+{
+UBYTE fld_ctr;
+T_DB_CODE db_ret_code;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+TRACE_FUNCTION("db_record_empty()");
+*empty = TRUE;
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field not found, return error DB_INVALID_FIELD */
+fld_ctr = field_id_search( db_handle, field_id );
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_INVALID_FIELD );
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord + fld_ctr;
+/* Using RecordBitMap, check whether record_num is free;
+if so, empty = true and false otherwise */
+if (db_get_bit_in_bitmap (tmp_ptrFieldRecord -> RecordBitMap, record_num))
+{
+/* if record exist */
+*empty = FALSE;
+}
+DB_RETURN( DB_OK )
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_find_free_record  |
++--------------------------------------------------------------------+
+PURPOSE : Find an free record in given (database, field)
+*/
+int db_find_free_record	( int    db_handle,
+USHORT field_id )
+{
+UBYTE fld_ctr;
+T_DB_CODE  db_ret_code;
+int record_num;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+TRACE_FUNCTION("db_find_free_record()");
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field not found, return error DB_INVALID_FIELD */
+fld_ctr = field_id_search( db_handle, field_id );
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_INVALID_FIELD );
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord + fld_ctr;
+/* Using RecordBitMap, search for free record.
+If found , return the found record_num
+Return DB_RECORD_NOT_FOUND */
+record_num = db_search_bit_in_bitmap (tmp_ptrFieldRecord->RecordBitMap,
+tmp_ptrFieldRecord->NumOfRecords,
+FALSE);
+if (record_num EQ 0)
+DB_RETURN( DB_RECORD_NOT_FOUND );
+DB_VALUE_RETURN( record_num )
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_info              |
++--------------------------------------------------------------------+
+PURPOSE : Get information about an open database
+*/
+T_DB_CODE db_info ( int        db_handle,
+T_DB_INFO* db_info )
+{
+T_DB_CODE db_ret_code;
+TRACE_FUNCTION("db_info()");
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+(*db_info).clean   = DbmMaster[db_handle].Clean;
+(*db_info).tracked = DbmMaster[db_handle].Tracked;
+DB_RETURN( DB_OK )
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_info_field        |
++--------------------------------------------------------------------+
+PURPOSE : Get general information about a field in an open database.
+*/
+T_DB_CODE db_info_field ( int              db_handle,
+USHORT           field_id,
+T_DB_INFO_FIELD* info_field )
+{
+UBYTE fld_ctr;
+T_DB_CODE db_ret_code;
+T_DBM_FIELDRECORD* tmp_ptrFieldRecord;
+TRACE_FUNCTION("db_info_field()");
+/* DBM_State check */
+DBM_State_check;
+/* db_handle check */
+db_ret_code = db_handle_check( db_handle );
+if( db_ret_code NEQ DB_OK )
+DB_RETURN( db_ret_code );
+/*	field id search; if field not found, return error DB_INVALID_FIELD */
+fld_ctr = field_id_search( db_handle, field_id );
+if( fld_ctr EQ DbmMaster[db_handle].NumOfFiles )
+DB_RETURN( DB_INVALID_FIELD );
+tmp_ptrFieldRecord = DbmMaster[db_handle].ptrFieldRecord + fld_ctr;
+/* Using data available in RAM in field record, fill up info_field
+(i.e. clean, db_type, num_of_records and used_records). */
+(*info_field).clean        = tmp_ptrFieldRecord -> Clean;
+(*info_field).entry_type   = tmp_ptrFieldRecord -> DBType;
+(*info_field).record_size  = tmp_ptrFieldRecord -> RecordSize;
+(*info_field).num_records  = tmp_ptrFieldRecord -> NumOfRecords;
+(*info_field).used_records = tmp_ptrFieldRecord -> UsedRecords;
+DB_RETURN( DB_OK )
+}
+#ifdef _SIMULATION_ /* HM 19-Oct-2006: Currently not used but to be kept */
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                          MODULE: DBM                  |
+|                                       ROUINE: db_get_last_fs_error |
++--------------------------------------------------------------------+
+PURPOSE : Delivers the last error provided by the (flash) file system
+that resulted in DB_FAIL_FS.
+*/
+int db_get_last_fs_error ( void )
+{
+DB_VALUE_RETURN( LastFFS_ReturnCode )
+}
+#endif /* #ifdef _SIMULATION_ */
+/* Implements Measure # 83 */
+/*
++--------------------------------------------------------------------+
+| PROJECT: PHB                       MODULE: DBM                     |
+|                                    ROUTINE: db_close_for_read_write|
++--------------------------------------------------------------------+
+PURPOSE : Close Read & write FFS Operations
+*/
+LOCAL void db_close_for_read_write ( FileHandleRecord  *tmp_open_fields,
+UBYTE             *tmp_old,
+UBYTE              max_per_db)
+{
+TRACE_FUNCTION ("db_close_for_read_write ()");
+if( *tmp_old >= max_per_db )
+{
+*tmp_old = 0;
+}
+DB_FFS_CLOSE( tmp_open_fields[*tmp_old].filehandle );
+tmp_open_fields[*tmp_old].filehandle = INVALID_FD;
+tmp_open_fields[*tmp_old].fld_ctr = INVALID_FLD_CTR;
+++(*tmp_old);
+}
+/* Implements Measure # 211 */
+/*
++-------------------------------------------------------------------------------+
+| PROJECT: PHB                         MODULE:  DBM                             |
+|                                      ROUTINE: read_write_user_record_from_FFS |
++-------------------------------------------------------------------------------+
+PURPOSE : Reads OR Writes user record into FFS
+*/
+LOCAL T_DB_CODE read_write_user_record_from_FFS ( const char      *user_field_file,
+#ifdef FFS_CLOSE_BEFORE_OPEN
+UBYTE            db_ctr,
+UBYTE            fld_ctr,
+#endif
+T_FFS_FD        *filehandle,
+UBYTE            record_num,
+USHORT           record_size,
+USHORT           offset,
+USHORT           length,
+UBYTE           *record_buffer,
+T_FFS_OPEN_FLAGS open_option)
+{
+T_FFS_FD   ffs_fd = INVALID_FD;
+T_FFS_SIZE ffs_ret_code;
+T_DB_CODE db_code;
+/* See if file already opened,
+if not open it and update the file handle */
+TRACE_FUNCTION ("read_write_user_record_from_FFS ()");
+#ifndef FFS_CLOSE_BEFORE_OPEN
+ffs_fd = *filehandle;
+if( !IS_FD_VALID(ffs_fd) )
+{
+DB_FFS_OPEN( ffs_fd, user_field_file, open_option );
+if (open_option EQ FFS_O_RDONLY )
+{
+TRACE_EVENT_P1( "read_user_record_from_FFS:DB_FFS_OPEN %d", ffs_fd );
+}
+else
+{
+TRACE_EVENT_P1( "write_user_record_to_FFS:DB_FFS_OPEN %d", ffs_fd );
+}
+if( (ffs_fd EQ EFFS_NOTFOUND)    OR
+(ffs_fd EQ EFFS_NAMETOOLONG) OR
+(ffs_fd EQ EFFS_BADNAME)     OR
+(ffs_fd EQ EFFS_INVALID)     OR
+(ffs_fd EQ EFFS_LOCKED)      )
+{
+return DB_FAIL;
+}
+if( ffs_fd < EFFS_OK )
+{
+LastFFS_ReturnCode = ffs_fd;
+return DB_FAIL_FS;
+}
+*filehandle = ffs_fd;
+}
+#else /* FFS_CLOSE_BEFORE_OPEN */
+ffs_fd = db_open_user_field_file( db_ctr, fld_ctr, user_field_file, open_option );
+#endif /* FFS_CLOSE_BEFORE_OPEN */
+ffs_ret_code = ffs_seek( ffs_fd,
+( (record_num - 1) * (record_size) + offset),
+FFS_SEEK_SET );
+if (open_option EQ FFS_O_RDONLY )
+{
+TRACE_EVENT_P1( "read_user_record_from_FFS:ffs_seek %d", ffs_ret_code );
+}
+else
+{
+TRACE_EVENT_P1( "write_user_record_to_FFS:ffs_seek %d", ffs_ret_code );
+}
+db_code = check_ffs_ret_code (ffs_ret_code, filehandle, ffs_fd, TRUE);
+if (db_code NEQ DB_OK)
+{
+return db_code;
+}
+if (open_option EQ FFS_O_RDONLY )
+{
+ffs_ret_code = ffs_read( ffs_fd,
+record_buffer,
+length );
+TRACE_EVENT_P1( "read_user_record_from_FFS:ffs_read %d", ffs_ret_code );
+}
+else
+{
+ffs_ret_code = ffs_write( ffs_fd,
+record_buffer,
+length );
+TRACE_EVENT_P1( "write_user_record_to_FFS:ffs_write %d", ffs_ret_code );
+}
+db_code = check_ffs_ret_code (ffs_ret_code, filehandle, ffs_fd, FALSE);
+if (db_code NEQ DB_OK)
+{
+return db_code;
+}
+/* DB_FFS_CLOSE( ffs_fd ); we will do it in db_flush */
+#ifdef FFS_OPEN_PROBLEM_PATCH
+DB_FFS_CLOSE( ffs_fd );
+*filehandle = INVALID_FD;
+#endif
+return DB_OK;
+}
+/* Implements Measure # 211 */
+/*
++-------------------------------------------------------------------------------+
+| PROJECT: PHB                         MODULE:  DBM                             |
+|                                      ROUTINE: check_ffs_ret_code              |
++-------------------------------------------------------------------------------+
+PURPOSE : Checks ffs_ret_code
+*/
+LOCAL T_DB_CODE check_ffs_ret_code (T_FFS_SIZE ffs_ret_code,
+T_FFS_FD  *filehandle,
+T_FFS_FD   ffs_fd,
+BOOL       check_invalid)
+{
+TRACE_FUNCTION ("check_ffs_ret_code ()");
+if( ( ffs_ret_code EQ EFFS_BADFD )   OR
+( (ffs_ret_code EQ EFFS_INVALID) AND check_invalid ) OR
+( ffs_ret_code EQ EFFS_BADOP )   )
+{
+DB_FFS_CLOSE( ffs_fd );
+*filehandle = INVALID_FD;
+return DB_FAIL;
+}
+if( ffs_ret_code < EFFS_OK )
+{
+LastFFS_ReturnCode = ffs_ret_code;
+DB_FFS_CLOSE( ffs_fd );
+*filehandle = INVALID_FD;
+return DB_FAIL_FS;
+}
+return DB_OK;
+}
+#endif /* #ifdef TI_PS_FFS_PHB */

FreeCalypso > hg > fc-selenite

comparison src/g23m-aci/aci/db.c @ 1:d393cd9bb723