database.h

Go to the documentation of this file.

/****************************************************************************\
*  database.h - definitions and prototypes for the hydromet database, 1994   *
\****************************************************************************/
 
#ifndef _databaseh
#define _databaseh
 
#include  <sys/types.h>
 
/****************************************************************************\
* The EOL stands for End Of Line. It defines the end of line for a text file *
* (such as ALARM.LOG, ERROR.LOG, and DIAL.LOG). In 2.15 QNX EOF's are        *
* indicated by the Record Separator (0x1E). In POSIX QNX,EOF's are indicated *
* with the Line Feed (0x0A).                                                 *
\****************************************************************************/
#define  EOL         0x0A
#define  QNX2_EOL    0x1E
 
/****************************************************************************\
* This structure is the message that gets passed from one program to another *
* when data comes into the system. You can have several programs that are    *
* all recieving data at the same time. A data recieving program (recdata,    *
* autointr, datacol, shef_post, etc...) uses this structure to pass the data *
* to the databuffer program. The databuffer is a queue that stores incoming  *
* data until the data filing program, filer, is able to put the data in the  *
* database. Databuffer uses this message structure to pass data to filer.    *
* Filer also uses this structure to pass data to any program that want to be *
* updated everytime data comes in.                                           *
*                                                                            *
*           data           data           data            data               *
*            |              |              |               |                 *
*          recdata       datacol       shef_post       autointr              *
*            |              |              |               |                 *
*            -----------------------------------------------                 *
*                                 |                                          *
*                            databuffer                                      *
*                                 |                                          *
*                               filer                                        *
*                                 |                                          *
*                  ---------------------------------                         *
*                  |              |                |                         * 
*               update         dbmngr         alertalarm                     *
*                                                                            *
\****************************************************************************/
#define  HB5_ID_LEN      17
#define  PC_LEN          11
#define  NAME_LEN        51
 
struct msgbuf {
    unsigned char       action;
    unsigned long int   sta_id;
    unsigned char       hb5_id[HB5_ID_LEN];
    unsigned char       pc[PC_LEN];
    float               report;
    time_t              clock;
    unsigned char       dqr;
    unsigned char       qds;
    unsigned char       qpi;
    signed short int    node;
    signed short int    tty_num;
    unsigned char       gage_type;
};
 
/* Message passing actions   */
#define  MSG_OUT       0x01
#define  DATA_IN       0x02
#define  READ_SINDX    0x03
#define  UPDATE        0x04
#define  SHOWREPORTS   0x05
#define  VERIFY        0x06
#define  ALARMS        0x07
#define  STATS_OUT     0x08
#define  STATS_CLEAR   0x09
 
/* Gage type */
#define  UNKNOWN       0x00
#define  ASCII         0x01     /* ALERT ASCII format        */
#define  BINARY        0x02     /* ALERT binary format       */
#define  ENHANCED      0x03     /* ALERT enhanced format     */
#define  DARDC         0x04     /* NWS DARDC formatted gage  */
#define  LARC          0x05     /* Handar 550A in smart mode */
#define  HANDAR_560A   0x06     /* Handar 560A in smart mode */
#define  SYNERGETICS   0x07
#define  TELMK         0x08
#define  BDT           0x09
#define  SSBDT         0x0A
#define  COMPULOGGER   0x0B
#define  CLIMATRONICS  0x0C
#define  CAMBELL_21    0x0D
#define  CAMBELL_10    0x0E
#define  ASOS          0x0F
#define  FTS11         0x10
#define  STEVENS       0x11
#define  SUTRON        0x12
#define  TALKAMARK     0x13
 
struct update {
    unsigned char  name[9];
    unsigned int   tid;
};
 
/****************************************************************************\
*  The sensor id number is the primary key. The sensor id number is          *
*  guaranteed to be a unique value.                                          *
*  The sensor id number is an unsigned long int. A valid sensor id number may*
*  take on a value from 0 through 4,294,967,294. The value 4,294,967,295 is  *
*  reserved for marking a record as empty, i.e. empty records in the         *
*  SINDX.DAT file contain the value 4,294,967,295 (NOT_USED = 0xFFFFFFFF).   *
\****************************************************************************/
#define NOT_USED        0xFFFFFFFF
#define OLD_NOT_USED    0xFFFF  
    
 
/*  ALARM_SAVE.DAT file info  */
#define ALARMDIR        "/usr/DAT/alarm"
#define ALARM_SAVE      "/usr/DAT/ALARM.LOG"
#define DEFAULTACTION   "/usr/DAT/alarm/defaultaction"
struct  alarm_save  {
    unsigned char  line1[80];
    unsigned char  line2[80];
};
 
/* In the struct databank template, there are two coded bytes,
    dbk.on_off and dbk.flag_bits. Each bit in the byte represents the
    status of one of the alarm triggers. For example the first bit
    represents the On/Off status of the Positive Level 1 Alarm Trigger.
    dbk.on_off represents whether alarm criteria has been set.
    dbk.flag_bits represents whether alarm criteria has been exceeded. */
#define  POS_LEVEL_1   0x01     /* Bit 1 (00000001), Positive Level 1        */
#define  POS_LEVEL_2   0x02     /* Bit 2 (00000010), Positive Level 2        */
#define  POS_ROC       0x04     /* Bit 3 (00000100), Positive Rate of Change */
#define  NEG_LEVEL_1   0x10     /* Bit 5 (00010000), Negative Level 1        */
#define  NEG_LEVEL_2   0x20     /* Bit 6 (00100000), Negative Level 2        */
#define  NEG_ROC       0x40     /* Bit 7 (01000000), Negative Rate Of Change */
 
 
#define DB_DIR      "/usr/DAT"
 
/*  DATABANK.DAT file info  */
#define DATABANK        "/usr/DAT/DATABANK.DAT"
 
struct  report  {
    float           data;   /* converted data value                     */
    time_t          clock;  /* time in seconds since 01/01/70 00:00:00  */
    unsigned char   dqr;    /* SHEF Data Qualifier & Revision bit       */
    unsigned char   qds;    /* Quality Departure Score */
    unsigned char   qpi;    /* Quality Process Identifier  */
};
 
#define  RPTS_PER_REC   365
 
struct databank  {
    unsigned long int    sid;           /* Sensor id number                          */
    unsigned long int    stype;     /* sensor type number                        */
    signed long int      next;      /* pointer to next report structure used     */
    unsigned long int    prior;     /* backward pointer to last OVERLOAD rec used*/
    unsigned short int   num_overloads; /* Number of OVERLOAD records assigned to sensor. */
                                    /*********************************************/
    float                divr;      /* data is stored in database as a converted */
    float                base;      /* value. divr,base,mult,and addr fields are */
    float                mult;      /* used to convert sensor reports to data    */
    float                addr;      /* data = (((report/divr)+base)*mult)+addr   */
                                    /*********************************************/
    unsigned short int   cycle_size;    /* sensor cycle size (default=0)             */
    signed char          cycle_count;
    unsigned char        data_rate;
    float                max_accept;    /* maximum acceptable value from this sensor */
    float                min_accept;    /* minimum acceptable value from this sensor */
    float                above_alarm;
    unsigned char        above_status;
    float                below_alarm;
    unsigned char        below_status;
    float                above_roc_level;
    unsigned short int   above_roc_time;
    unsigned char        above_roc_status;
    float                below_roc_level;
    unsigned short int   below_roc_time;
    unsigned char        below_roc_status;
    unsigned short int   alrm_rst_tm;   /* minutes alarms disabled once triggerred   */
    unsigned char        unused_bytes[9];
    struct report  rpt[RPTS_PER_REC];
};
 
struct old_databank  {
    unsigned short int   sid;           /* Sensor id number                          */
    signed short int     next;      /* pointer to next report structure used     */
    unsigned long int    prior;     /* backward pointer to last OVERLOAD rec used*/
    unsigned short int   stype;     /* sensor type number                        */
                                /*********************************************/
    float          divr;        /* data is stored in database as a converted */
    float          base;        /* value. divr,base,mult,and addr fields are */
    float          mult;        /* used to convert sensor reports to data    */
    float          addr;        /* data = (((report/divr)+base)*mult)+addr   */
                                /*********************************************/
    unsigned short int   cycle_size;    /* sensor cycle size (default=0)             */
    unsigned char  cycle_count;
    float          max_accept;  /* maximum acceptable value from this sensor */
    float          min_accept;  /* minimum acceptable value from this sensor */
    unsigned char  on_off;      /* indicates if an alarm is set              */
    unsigned char  flag_bits;   /* indicates if an alarm is exceeded         */
    float          alarm_p1;    /* positive alarm level one, warning level   */
    float          alarm_p2;    /* positive alarm level two, alarm level     */
                                /*********************************************/
    float          delta_levelp;/* delta_levelp & delta_timep used to compute*/
    unsigned short int   delta_timep; /* a positive rate of change alarm value     */
                                /*********************************************/
    float          alarm_n1;    /* negative alarm level one, warning level   */
    float          alarm_n2;    /* negative alarm level two, alarm level     */
    float          delta_leveln;/* delta_leveln & delta_timen used to compute*/ 
    unsigned short int   delta_timen; /* a negative rate of change alarm value     */
                                /*********************************************/
    time_t         time_level1; /* time in secs since 01/01/80 level 1 alarm */
    time_t         time_level2; /* time in secs since 01/01/80 level 2 alarm */
    time_t         time_roc;    /* time in secs since 01/01/80 roc alarm     */
    unsigned short int   alrm_rst_tm;   /* minutes alarms disabled once triggerred   */ 
    struct report  rpt[365];
};
 
/*  DATABASE.DAT file info  */
#define DATABASE        "/usr/DAT/DATABASE.DAT"
struct  database  {
    unsigned long int   recs_allocated; /* # of records allocated for database  */
    unsigned long int   recs_used;      /* # of records used                    */
    unsigned long int   overload_recs;  /* max # of records in OVERLOAD.DAT     */
    unsigned long int   sensor_types;   /* # of sensor types defined            */
    time_t              dbcreated;      /* Creation date of database.           */
    time_t              dbmodified;     /* Date last modified by dbinit.        */
    unsigned char       alarm_check;    /* Check incoming reports for alarms?   */
    unsigned char       mininum;        /* Mininum for datacol dial in          */
};
 
struct  old_database  {
    unsigned short int  recs_allocated;     /* # of records allocated for database  */
    unsigned short int  recs_used;          /* # of records used                    */
    unsigned long int   overload_recs;      /* max # of records in OVERLOAD.DAT     */
    unsigned short int  sensor_types;       /* # of sensor types defined            */
    unsigned char       alarm_check;        /* Check incoming reports for alarms?   */
    unsigned char       mininum;            /* Mininum for datacol dial in          */
};
                             
#define DIAL            "/usr/DAT/DIAL.DAT"
 
/* structure for /usr/DAT/DIAL.LOG file */
#define DIALLOG         "/usr/DAT/DIAL.LOG"
struct dial_message {
    unsigned char message[80];
};
 
 
/* Structure used in the ERROR.LOG file */
#define ERRORLOG        "/usr/DAT/ERROR.LOG"
struct error_message {
    char message[80];
};
 
#define GROUP           "/usr/DAT/GROUP.DAT"
struct group  {
    unsigned char       name[NAME_LEN];
    unsigned long int   sid[8];
    unsigned char       sid_name[8][7];
};
 
struct old_group  {
    unsigned char        name[30];
    unsigned short int   sid[8];
    unsigned char        sid_name[8][7];
};
 
/*  HANDBOOK5.DAT file info  */
#define HANDBOOK5       "/usr/DAT/HANDBOOK5.DAT"
#define THANDBOOK5      "/tmp/HANDBOOK5.DAT"
struct  handbook5  {
    char       id[HB5_ID_LEN];      /* Handbook 5 id                                */
    char       pc[PC_LEN];      /* SHEF parameter code                          */
    unsigned long int   dbk_ptr;    /* relative record number of DATABANK record    */
};
    
struct  old_handbook5  {
    unsigned char        id[11];    /* Handbook 5 id                                */
    unsigned char        pc[9]; /* SHEF parameter code                          */
    unsigned short int   dbk_ptr;   /* relative record number of DATABANK record    */
};
 
/*  INTERROGATE.DAT file info  */
#define INTERROGATE     "/usr/DAT/INTERROGATE.DAT"
struct interrogate  {
    unsigned char  name[26];
    unsigned char  station_id[21];
    unsigned int   gagetype;
    signed int     call_interval;
    signed int     start_time;
    unsigned int   maxtrys;
    unsigned int   timeout;
    unsigned char  phone_num[41];
    unsigned int   baud;
    unsigned char  parity;
    unsigned char  stop_bits;
    unsigned char  data_bits;
    unsigned int   sens_cnt;
    struct channel_gage  {
        unsigned int  ch;
        unsigned int  sid;
    } channel[21];
    unsigned int   scans_per_ch;
    time_t         attempt_time;
    time_t         success_time;
    signed int     time_offset;
};
 
/*  OVERINDX.DAT file info  */
#define OVERINDX        "/usr/DAT/OVERINDX.DAT"
#define DEFAULTOV       10
#define ONOT_USED       0xFFFFFFFF
#define   OVIDX_RECS    0x100        
struct  overindx  {
    unsigned long int  sid;     /* sensor id number of sensor that owns this rec */
    unsigned long int  next;     /* forward pointer to the next OVERLOAD.DAT record
                                to be used */
};
    
struct  old_overindx  {
    unsigned short int  sid;        /* sensor id number of sensor that owns this rec */
    unsigned long int   next;      /* forward pointer to the next OVERLOAD.DAT record
                                to be used */
};
 
/****************************************************************************\
*  The OVERLOAD.DAT file will have a similar format as the DATABANK.DAT      *
*  file.                                                                     *
\****************************************************************************/
#define OVERLOAD        "/usr/DAT/OVERLOAD.DAT"
 
/*  OWNER.DAT file info  */
#define OWNER           "/usr/DAT/OWNER.DAT"
struct  agency  {
    unsigned char  id;
    unsigned char  name[26];
    unsigned char  street1[26];
    unsigned char  street2[26];
    unsigned char  city[26];
    unsigned char  state[3];
    unsigned char  zip[11];
    unsigned char  contact_name[26];
    unsigned char  contact_phone[17];
    unsigned char  comment1[70];
    unsigned char  comment2[70];
    unsigned char  comment3[70];
    unsigned char  comment4[70];
    unsigned char  comment5[70];
};
 
#define RATING  "/usr/DAT/RATING.DAT"
 
/* Extrapolation methods for rating curves: linear or logarithmic. */
#define  LINEAR   '1'
#define  LOG      '2'
 
struct rating  {
    unsigned long int  sid;         /* Sensor ID# for this rating record.   */
    time_t             entry_date;  /* Date when this record last  updated. */
    float              datum;       /* Arbitrary zero point Mean Sea Level. */
    struct shift_factors  {
        float          shift;       /* Adjust rating curve by shift.        */
        float          stage;
    } sf[4];
    char      flow_units[16];
    char      extrapolation_method; /* LINEAR or LOG */
    struct  rating_curve  {
        float          stage;
        float          flow;
    }  rc[129];
    float              warning_stage;
    float              flood_stage;
    float              max_stage;
    float              min_stage;
    struct record_stage  {
            float              stage_of_record;
            signed short int   record_month;
            signed short int   record_day;
            signed long  int   record_year;
    } max_rs, min_rs;
    struct  sig_stages  {
        float          stage;
        unsigned char  message[30];
    } ss[10];
    float              drainage_area;
    unsigned char      unused_bytes[59];
};
 
#define SENSORGRPS      "/usr/DAT/SENSORGRPS.DAT"
struct sensorgrps  {
    unsigned char      name[NAME_LEN];
    unsigned long int  sid[50];
};
 
struct old_sensorgrps  {
    unsigned char       name[31];
    unsigned short int  sid[50];
};  
 
#define SENSOR_FILE     "/usr/DAT/SENSOR_FILE.DAT"
#define NO_OWNER      0x00
 
/* Values for (status_flag fields in SENSOR_FILE.DAT),
    (above_status,below_status,above_roc_status, and
    below_roc_status in DATABANK.DAT)
    and (alarm_level field in ALT_ALARM.DAT). */
#define  INACTIVE    0x00
#define  ACTIVE      0x01
#define  ACTIVE1     0x01
#define  ACTIVE2     0x02
#define  ACTIVE3     0x03
#define  ACTIVE4     0x04
#define  ALARMED     0x05
 
struct absolute_alarm  {
    float               alarm_level;        /* Alarm criteria. */
    time_t              time_last_alarm;    /* Time of last alarm. */
    unsigned char       status_flag;        /* Status: INACTIVE or ACTIVE */
    unsigned long int   alt_ptr;            /* Pointer into ALT_ALARM.DAT.
                                                Set to NOT_USED if default */
};
 
struct roc_alarm  {
    float               delta_level;        /* Alarm criteria.             */
    unsigned short int  delta_time;         /* Alarm criteria.             */
    time_t              time_last_alarm;    /* Time of last alarm.         */
    unsigned char       status_flag;        /* Status: INACTIVE or ACTIVE. */
    unsigned long int   alt_ptr;            /* Pointer into ALT_ALARM.DAT.
                                                Set to NOT_USED if default */
};
 
struct sensor_file  {
    unsigned long int      sid;
    char          name[NAME_LEN];
    char          hb5_id[HB5_ID_LEN];
    char          pc[PC_LEN];
    struct absolute_alarm  above_abs[4];
    struct roc_alarm       above_roc[4];
    struct absolute_alarm  below_abs[4];
    struct roc_alarm       below_roc[4];
    unsigned long int      rating;     /* Index into RATING.DAT file. */
    signed long            lat_ord;
    unsigned char          hemisphere_lat;
    signed long            long_ord;
    unsigned char          hemisphere_long;
    float                  elevation;
    unsigned char          elevation_units[16];
    unsigned char          owner;
    unsigned char          location[NAME_LEN];
    float                  radio_freq;
    unsigned char          criteria_check;
    unsigned short int     criteria_minutes;
    unsigned char          unused_bytes[112];
};
 
#define ALT_ALARM    "/usr/DAT/ALT_ALARM.DAT"
#define ALARM_ABOVE       0x01
#define ALARM_BELOW       0x02
#define ALARM_ABOVE_ROC   0x03
#define ALARM_BELOW_ROC   0x04
 
struct alt_alarm  {
    unsigned long int  sid;                 /* Sensor ID number of sensor
                                                that has an alternate
                                                alarm action. */
    unsigned char      alarm_type;          /* Type of alarm (for this sensor
                                                that has an alternate alarm
                                                action: ALARM_ABOVE,
                                                ALARM_BELOW, ALARM_ABOVE_ROC,
                                                or ALARM_BELOW_ROC. */
    unsigned char      alarm_level;         /* Level of alarm (for this sensor
                                                that has an alternate alarm
                                                action: ACTIVE1, ACTIVE2,
                                                ACTIVE3, or ACTIVE4. */
    unsigned char      alarm_action[NAME_LEN];  /* Alternate alarm program
                                                to execute when alarm
                                                criteria exceeded. */
};
    
struct old_sensor_file  {
    unsigned short int   sid;
    unsigned char        name[26];
    unsigned char        hb5_id[11];
    unsigned char        pc[9];
    signed long          lat_ord;
    signed long          long_ord;
    float                elevation;
    unsigned char        owner;
    unsigned char        location[26];
    float                radio_freq;
};  
 
/*  SENSOR_TYPE.DAT file info  */
#define SENSOR_TYPE     "/usr/DAT/SENSOR_TYPE.DAT"
struct  sensor_type  {
    unsigned long int    number;
    char        name[NAME_LEN];
    char        parm_code[PC_LEN];  /* SHEF parameter code */
    unsigned short int   overloads;
    float                divisor;
    float                base;
    float                multiplier;
    float                adder;
    char        units_name[16];
    char        units_abbr[6];
    float                max_accept;
    float                min_accept;
    unsigned short int   criteria_hours;
    char        criteria_check;
    char        unused_bytes[11];
};
 
struct  old_sensor_type  {
    unsigned short int   number;
    unsigned char        name[26];
    unsigned char        parm_code[9];  /* SHEF parameter code */
    unsigned short int   overloads;
    float                divisor;
    float                base;
    float                multiplier;
    float                adder;
    unsigned char        units_name[16];
    unsigned char        units_abbr[6];
    float                max_accept;
    float                min_accept;
    unsigned short int   criteria_hours;
    unsigned char        criteria_check;
    unsigned char        stop_bits;
    unsigned char        data_bits;
    unsigned char        inter_mode;
    unsigned char        calibrate;   /* 0=NO, 1=YES */
};
 
#define SINDX           "/usr/DAT/SINDX.DAT"
#define TSINDX          "/tmp/SINDX.DAT"
struct sindx  {
    unsigned long int   sid;            /* sensor id number of sensor that owns rec */
    unsigned long int   dbk_ptr;        /* relative record number for DATABANK recd */
};
    
struct old_sindx  {
    unsigned short int   sid;           /* sensor id number of sensor that owns rec */
    unsigned short int   dbk_ptr;       /* relative record number for DATABANK recd */
};
 
 
/* SNAME.DAT file info  */
#define SNAME           "/usr/DAT/SNAME.DAT"
#define TSNAME          "/tmp/SNAME.DAT"
#define CNOT_USED   0x7E
struct sensor_name  {
    unsigned char      name[NAME_LEN];  /* sensor name                              */
    unsigned long int  dbk_ptr;     /* relative record number for DATABANK recd */
};
    
struct old_sensor_name  {
    unsigned char        name[26];  /* sensor name                              */
    unsigned short int   dbk_ptr;       /* relative record number for DATABANK recd */
};
 
#define  SIMPARMS    "/usr/DAT/SIMPARMS.DAT"
#define  QSIM        "/usr/DAT/QSIM.DAT"
#define  QFCST       "/usr/DAT/QFCST"
#define  CONT        "/usr/DAT/CONT.DAT"
#define  DIALGROUPS  "/usr/DAT/DIALGROUPS.DAT"
#define  VERSION     "/usr/DAT/VERSION.DAT"
 
/* Database port information */
#define ALARMPORT 18    /* port number attached to by alarm functions      */
/* the port # attached to by simulation manager can be found in def_file.h */
 
/* Database file index numbers for files that are ALWAYS OPEN        */
#define NDATABANK       0x00000000      /* /usr/DAT/DATABANK.DAT     */
#define NDATABASE       0x00000001      /* /usr/DAT/DATABASE.DAT     */
#define NSENSOR_FILE    0x00000002      /* /usr/DAT/SENSOR_FILE.DAT  */
#define NSENSOR_TYPE    0x00000003      /* /usr/DAT/SENSOR_TYPE.DAT  */
#define NTHANDBOOK5     0x00000004      /* /tmp/HANDBOOK5.DAT        */
#define NTSINDX         0x00000005      /* /tmp/SINDX.DAT            */
#define NTSNAME         0x00000006      /* /tmp/SNAME.DAT            */
 
/* Database file index numbers for files that are NOT ALWAYS OPEN    */
#define NALARMLOG       0x00000007      /* /usr/DAT/ALARM.LOG        */
#define NERRORLOG       0x00000008      /* /usr/DAT/ERROR.LOG        */
#define NGROUP          0x00000009      /* /usr/DAT/GROUP.DAT        */
#define NHANDBOOK5      0x0000000A      /* /usr/DAT/HANDBOOK5.DAT    */
#define NOVERINDX       0x0000000B      /* /usr/DAT/OVERINDX.DAT     */
#define NOVERLOAD       0x0000000C      /* /usr/DAT/OVERLOAD.DAT     */
#define NOWNER          0x0000000D      /* /usr/DAT/OWNER.DAT        */
#define NSENSORGRPS     0x0000000E      /* /usr/DAT/SENSORGRPS.DAT   */
#define NSINDX          0x0000000F      /* /usr/DAT/SINDX.DAT        */
#define NSNAME          0x00000010      /* /usr/DAT/SNAME.DAT        */
#define NDIAL           0x00000011      /* /usr/DAT/DIAL.DAT         */
#define NINTERROGATE    0x00000012      /* /usr/DAT/INTERROGATE.DAT  */
#define NDIALLOG        0x00000013      /* /usr/DAT/DIAL.LOG         */
#define NSIMPARMS       0x00000014      /* /usr/DAT/SIMPARMS.DAT     */
#define NQSIM           0x00000015      /* /usr/DAT/QSIM.DAT         */
#define NQFCST          0x00000016      /* /usr/DAT/QFCST.DAT        */
#define NCONT           0x00000017      /* /usr/DAT/CONT.DAT         */
#define NDIALGROUPS     0x00000018      /* /usr/DAT/DIALGROUPS.DAT   */
#define NRATING         0x00000019      /* /usr/DAT/RATING.DAT       */
#define NALT_ALARM      0x0000001A      /* /usr/DAT/ALT_ALARM.DAT    */
#define NVERSION        0x0000001B      /* /usr/DAT/VERSION.DAT      */
 
/*  Maximum database file index number. */
#define NOT_ALWAYS_OPEN 0x00000007
#define DB_RESERVED     0x0000001C
 
/* dbmngr message type definitions */
#define DBCLOSE         0x00000001
#define DBOPEN          0x00000002
#define DBREAD          0x00000003
#define DBSIZE          0x00000004
#define DBTRUNC         0x00000005
#define DBWRITE         0x00000006
 
/* Maximum size for a message to the database manager, dbmngr. If requested
    data exceeds MAX_MSG_SIZE then dbread/dbwrite breaks large message into
    smaller messages. */
#define MAX_MSG_SIZE   16384L
 
/* dbmngr request structure */
struct dbmsg_req {
    unsigned long int  msg_type;    /* Database message type:DBREAD, DBWRITE, etc...*/
    unsigned long int  file;        /* File index number:NDATABANK,NDATABASE, etc...*/
    off_t              offset;      /* Offset in bytes for start of operation       */
    unsigned long int  rec_size;    /* Number of bytes in a record                  */
    unsigned long int  num_recs;    /* Number of records                            */
};
 
 
/*  database function prototypes.  */
unsigned int dbclose(unsigned long int file_num);
unsigned int dbopen(unsigned long int file_num);
unsigned long int dbread(unsigned long int file_num, signed long int offset,
    unsigned long int rec_size, unsigned long int num_recs, void *buf);
signed long int dbsize(unsigned long int file_num);
signed long int dbtrunc(unsigned long int file_num, signed long int offset);
unsigned long int dbwrite(unsigned long int file_num, signed long int offset,
    unsigned long int rec_size, unsigned long int num_recs, void *buf);
struct period_rain {
    float         total_rainfall;
    unsigned char dq;
};
struct work_array  {
    float           data;   /* converted data value                     */
    time_t          clock;  /* time in seconds since 01/01/80 00:00:00  */
};
struct period_rain sumALERTrain(struct work_array *work, time_t clock_start,
                    time_t clock_end, float max_accumulator);
struct period_rain sum_rain(struct work_array *work, time_t clock_start,
                    time_t clock_end);
 
 
 
struct handbook5 bs_hb5(unsigned char *hb5_pc, size_t max_recs,
                                            struct handbook5 *hb);
void bubble_hb5(size_t num_items);
void bubble_sindx(struct sindx *sid_array, unsigned int num_items);
void bubble_sname(size_t num_items);
void bub_hb5(unsigned long int num_items);
void bub_sindx(unsigned long int num_items);
void bub_sname(unsigned long int num_items);
void check_alarm(struct msgbuf *msg, struct databank *dbk, size_t rec_num,
                            unsigned int reactivate_msg);
void chg_reports(unsigned int index, struct databank *dbk, 
                            float chgval, signed char all_data, time_t told);
pid_t  find_databuf(void);
unsigned long int get_reports(unsigned long int index, struct databank *dbk, 
        time_t tnew, time_t told, char *qualifier,
        unsigned long int report_limit, struct report *rpt);
signed long get_timezone(unsigned char tz_name[4]);
void mk_dial_msg(unsigned char *pname, unsigned char *msg,
        struct dial_message *dialmsg);
void mk_err_msg(char *pname, char *errmsg,
        struct error_message *err);
unsigned long read_ovidx(struct overindx *oi, unsigned long num_oi);
unsigned char read_sindx(void);
struct msgbuf rec_update(void);
void red_alert(struct error_message *err);
unsigned int send_databuf(unsigned int id, unsigned char *hb5_id,
            unsigned char *pc, float data, time_t clock,
            unsigned char dq, unsigned char gage_type, signed int tid,
            unsigned int node_num, signed int tty_num);
 
 
 
struct update  update_on(void);
unsigned char  update_off(struct update);
unsigned long write_ovidx(struct overindx *oi, unsigned long num_oi);
 
#endif  /* _databaseh */