view src/g23m-aci/aci/db.c @ 296:154011ef41b1

components/frame_na7_db_{fl,ir}: missed the -o3 which causes function reordering
author Mychaela Falconia <falcon@freecalypso.org>
date Sat, 21 Oct 2017 03:18:21 +0000
parents 53929b40109c
children
line wrap: on
line source

/* 
+----------------------------------------------------------------------------- 
|  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 */