ingest_util.c

Go to the documentation of this file.

/*******************************************************************************
*
*  COPYRIGHT (C) 2006 Battelle Memorial Institute.  All Rights Reserved.
*
********************************************************************************
*
*  Author:
*     name:  Brian Ermold
*     phone: (509) 375-2277
*     email: brian.ermold@pnl.gov
*
********************************************************************************
*
*  RCS INFORMATION:
*    $RCSfile: ingest_util.c,v $
*    $Revision: 1.20 $
*    $Locker:  $
*    $Date: 2006/09/05 19:05:55 $
*    $State: Exp $
*
*******************************************************************************/

#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>
#include <sys/resource.h>

#include "ingest_lib/ingest_util.h"
#include "ingest_lib/ingest_stats.h"
#include "ingest_lib/sds_util.h"
#include "ingest_lib/sds_log.h"
#include "ingest_lib/sds_msg.h"
#include "ingest_lib/sds_status.h"
#include "ingest_lib/sds_tdb.h"

#include "message.h"
#include "timer.h"

/*******************************************************************************
*  Private Variables:
*/

static char *gRCSId;
static char *gRCSState;

static char gTDBInstBase[MAXPLATNAME];
static char gTDBInstName[MAXPLATNAME];
static int  gTDBInstNum;

static ProcLoc  *gIngestLocation;
static char      gIngestInDir[MAXPATHNAME];
static DSClass **gIngestOutputs;

static int   gIngestTimeLimit;
static char *gFileExtensionString;

static char *gIngestCustodian;
static char *gMentorCustodian;

/* End Private Variables */

const char *get_ingest_rcsid(void) { return((const char *)gRCSId); }
const char *get_ingest_rcsstate(void) { return((const char *)gRCSState); }

const char *get_tdb_inst_name(void) { return((const char *)gTDBInstName); }
const char *get_tdb_inst_base(void) { return((const char *)gTDBInstBase); }
int         get_tdb_inst_num(void)  { return(gTDBInstNum); }

ProcLoc     *get_ingest_location(void) { return(gIngestLocation); }
const char  *get_ingest_in_dir(void)   { return(gIngestInDir); }
DSClass    **get_ingest_outputs(void)  { return(gIngestOutputs); }

int   get_time_limit(void)       { return(gIngestTimeLimit); }
char *get_extension_string(void) { return(gFileExtensionString); }

char *get_ingest_custodian(void) { return(gIngestCustodian); }
char *get_mentor_custodian(void) { return(gMentorCustodian); }

/*******************************************************************************
*  Private Functions:
*/

static int get_raw_data_in_dir()
{
    char       *collection_home;
    DSClass   **ds_classes;
    const char *site;
    const char *facility;

    collection_home = get_collection_home();
    if (!collection_home) {
        return(0);
    }

    ds_classes = get_process_inputs();
    if (!ds_classes) {
        return(0);
    }

    site     = get_process_site();
    facility = get_process_facility();

    sprintf(gIngestInDir, "%s/%s/%s%s%s.%s",
        collection_home, site,
        site,
        ds_classes[0]->name,
        facility,
        ds_classes[0]->level);

    print_debug(__FILE__, __LINE__,
        "Raw Data Input Directory: %s\n", gIngestInDir);

    dsdb_free_ds_classes(ds_classes);

    return(1);
}

/* End Private Functions */

int validate_ingest_output_dsc(char *dsc_name, char *dsc_level)
{
    int row;

    for (row = 0; gIngestOutputs[row]; row++) {
        if ((strcmp(gIngestOutputs[row]->name,  dsc_name)  == 0) &&
            (strcmp(gIngestOutputs[row]->level, dsc_level) == 0) ) {
            return(1);
        }
    }

    current_status(STATUS_BADOUTDSC);
    append_log_msg(__FILE__, __LINE__,
        "Invalid output datastream class: ['%s' '%s']\n", dsc_name, dsc_level);

    return(0);
}

/*******************************************************************************
*
* Description:
*   The incoming function is used to hook into ZEBRA's message handler.
*
* Inputs:
*   msg: The msg to go to the ZEBRA message handler..
*
* Outputs:
*   None.
*
* Returns:
*   0
*
*******************************************************************************/
static int incoming(struct message *msg)
{
    switch (msg->m_proto) {
        case MT_TIMER:
            tl_DispatchEvent((struct tm_time *) msg->m_data);
            break;
    }
    return(0);
}

/*******************************************************************************
*
* Description:
*   The init_DS function will hook an ingest module into the ZEBRA datastore
*   and message handler.
*
* Inputs:
*   platbase: The name of the software hooking into ZEB.
*
* Outputs:
*   None.
*
* Returns:
*   1 = success, 0 = failure
*
*******************************************************************************/
int init_DS(char *site, char *facility, char *proc_name)
{
    char id_name[SHORTSTRLEN];

    sprintf(id_name, "%s.%s.%s.ingest.%d", site, facility, proc_name, (int)getpid());

    usy_init();

    if (!msg_connect(incoming, id_name)) {
        print_debug(__FILE__, __LINE__, "msg_connect failed.\n");
        return(0);
    }

    if (!ds_Initialize()) {
        print_debug(__FILE__, __LINE__, "ds_Initialize failed.\n");
        return(0);
    }

    return(1);
}


/*******************************************************************************
*
* Description:
*   The init_ingest function will initialize an ingest.
*   It is responsible for:  <blockquote><p>
*
*       opening the databases                          <br>
*       opening the log file                           <br>
*       hooking into the zebra data store              <br>
*       setting up the mail messages                   <br>
*       updating the history's last time started field <br>
*       reseting the file and data stats structures.   </p></blockquote>
*
*   Note that when an ingest produces multiple datastreams you should only
*   call init_ingest once with the base platform name.  For example, the
*   smos_ingest produces 3 datastreams: 1smos 30smos and 1440smos. In this
*   case init_ingest should be called with the base platform name of "smos".
*
* Inputs:
*   site:      The site name (i.e. sgp)
*
*   facility:  The facility name (i.e. C1)
*
*   proc_name: The process name (i.e. vceil25k)
*
* Outputs:
*   None.
*
* Returns:
*   None.
*
*******************************************************************************/
void init_ingest(
    char *rcsid,
    char *rcsstate,
    char *site,
    char *facility,
    char *proc_name)
{
    int   db_attempts;
    char  mail_from[64];
    char  mail_subject[64];
    char  si;

    print_debug(__FILE__, __LINE__,
        "Initializing ingest for: ['%s' '%s' '%s']\n"
        "RCS Id:    %s\n"
        "RCS State: %s\n",
        site, facility, proc_name, rcsid, rcsstate);

    gRCSId    = rcsid;
    gRCSState = rcsstate;

    /*  Initialize the database connection.
     */

    db_attempts = db_connect("ingest");
    if (!db_attempts) {
        fprintf(stderr,
            "Ingest ['%s' '%s' '%s'] could not connect to DSDB using db_alias 'ingest'.\n",
             __FILE__, __LINE__, site, facility, proc_name);
        exit(1);
    }

    /*  Initialize the database "methods".
     */

    init_process_methods(site, facility, "Ingest", proc_name);
    init_tdb_methods(site);

    /*  Initialize the mail messages
     */

    sprintf(mail_from, "%s.%s.%s", site, facility, proc_name);
    for (si = 0; mail_from[si] != '\0'; si++) {
        mail_from[si] = toupper(mail_from[si]);
    }
    mail_from[si] = '\0';

    sprintf(mail_subject, "Ingest");

    gIngestCustodian = get_tdb_ingest_custodian();
    if (!gIngestCustodian) {
        if (is_db_error()) {
            db_finish();
            exit(1);
        }
        else {
            print_debug(__FILE__, __LINE__,
                "Ingest Mail Disabled: No ingest_custodian found in TDB Tables.\n");
        }
    }

    if (gIngestCustodian) {
        if (!init_mail_message(INGEST_MSG, mail_from, mail_subject)) {
            db_finish();
            exit(1);
        }
    }

    /*  From this point on we can call exit_ingest if a fatal error occurs.
     *  This will at least send the ingest mail and update the status in the
     *  DB even if the log file has not been opened yet.
     */

    gMentorCustodian = get_tdb_mentor_custodian(proc_name);
    if (!gMentorCustodian) {
        if (is_db_error()) {
            db_disconnect();
            exit_ingest(FAILURE);
        }
        else {
            print_debug(__FILE__, __LINE__,
                "Mentor Mail Disabled: No %s_mentor_custodian was found in the TDB Tables.\n",
                proc_name);
        }
    }

    if (gMentorCustodian) {
        if (!init_mail_message(MENTOR_MSG, mail_from, mail_subject)) {
            db_disconnect();
            exit_ingest(FAILURE);
        }
    }

    /*  Open the log file.
     */

    if (!open_instrlog(proc_name, INGESTLOG_EXTENSION)) {
        current_status(STATUS_NOLOGOPEN);
        db_disconnect();
        exit_ingest(FAILURE);
    }

    /*  Initialize the signal handlers
     */

    if (!init_signal_handlers()) {
        db_disconnect();
        exit_ingest(FAILURE);
    }

    /*  Log the number of attempts it took to connect to the database
     *  if it was more than once.
     */

    if (db_attempts > 1) {
        append_instrlog(
            "DB_ATTEPTS: It took %d attempts to connect to the database.",
            db_attempts);
    }

    /*  Update the last started time
     */

    if (!update_process_started()) {
        db_disconnect();
        exit_ingest(FAILURE);
    }

    /*  Get the tdb instrument number from the TDB tables and store the
     *  tdb_inst_base tdb_inst_num and tdb_inst_name in global space.
     */

    strcpy(gTDBInstBase, proc_name);

    gTDBInstNum = get_tdb_instrument_number(gTDBInstBase, facility);

    if (!gTDBInstNum) {
        if (!is_db_error()) {
            append_log_msg(__FILE__, __LINE__,
                "Could not find instrument number in TDB Tables\n",
                 gTDBInstBase, facility);
            current_status(STATUS_NOINSTNUM);
        }
        exit_ingest(FAILURE);
    }

    sprintf(gTDBInstName, "%s%d", gTDBInstBase, gTDBInstNum);

    /*  Pre-load required information from the database
     */

    gIngestLocation = get_process_location();
    if (!gIngestLocation) {
        db_disconnect();
        exit_ingest(FAILURE);
    }

    if (!get_raw_data_in_dir()) {
        db_disconnect();
        exit_ingest(FAILURE);
    }

    gIngestOutputs = get_process_outputs();
    if (!gIngestOutputs) {
        db_disconnect();
        exit_ingest(FAILURE);
    }

    gIngestTimeLimit = get_tdb_ingest_time_limit(gTDBInstBase, gTDBInstNum);
    if (!gIngestTimeLimit) {
        if (!is_db_error()) {
            append_log_msg(__FILE__, __LINE__,
                "Could not find Ingest time limit in TDB Tables\n");
            current_status(STATUS_NOTIMELIMIT);
        }
        db_disconnect();
        exit_ingest(FAILURE);
    }

    gFileExtensionString = get_tdb_ingest_file_extension(gTDBInstBase, gTDBInstNum);
    if (!gFileExtensionString) {
        if (!is_db_error()) {
            append_log_msg(__FILE__, __LINE__,
                "Could not find ingest file extension in TDB Tables\n");
            current_status(STATUS_NOFILEEXT);
        }
        db_disconnect();
        exit_ingest(FAILURE);
    }

    /*  Disconnect from the database until we need it again
     */

    db_disconnect();

    /*  Hook into ZEB
     */

    if (!init_DS(site, facility, proc_name)) {
        current_status(STATUS_INITDS);
        append_log_msg(__FILE__, __LINE__,
            "Unable to initialize the zebra data store\n");
        exit_ingest(FAILURE);
    }

    /*  Initialize the stats structures
     */

    reset_dc_stats();
    reset_file_stats();
}

/*******************************************************************************
*
* Description:
*   The build_extlist function will build the list of file extensions for the
*   ingest specified in the init_ingest function. The last element of the list
*   will be NULL.
*
* Inputs:
*   None.
*
* Outputs:
*   numext: The number of extensions in the list
*
* Returns:
*   A pointer to the list of extensions found.
*
*******************************************************************************/
char **build_extlist(int *numext)
{
    static char *ext_list[MAXEXTENSIONS];
    static char  ext_str[SHORTSTRLEN];

    int   ext_strlen;
    char *chrp;

    *numext = 0;

    strcpy(ext_str, gFileExtensionString);
    ext_strlen = strlen(gFileExtensionString);

    chrp = ext_str;

    while(chrp < ext_str + ext_strlen) {

        while((!isalnum(*chrp)) && (*chrp != '\0')) {
            chrp++;
        }

        if (*chrp == '\0') {
            break;
        }
        else {
            ext_list[*numext] = chrp;
            while(isalnum(*++chrp));
            *chrp = '\0';
            print_debug(__FILE__, __LINE__,
                "Added %s to the file extensions list\n", ext_list[*numext]);
            chrp++;
            (*numext)++;
        }
    }

    if (*numext == 0) {
        ext_str[0] = '\0';
        ext_list[*numext] = ext_str;
        (*numext)++;
    }

    ext_list[*numext] = (char *)NULL;
    return(ext_list);
}

/*******************************************************************************
*
* Description:
*   The build_filelist function will obtain the list of files to ingest for the
*   process specified in init_ingest. The last element of the list will be NULL.
*
* Inputs:
*   None.
*
* Outputs:
*   nfiles:   The number of files returned, -1 on failure.
*
*   dirname:  The name of the directory that was searched.
*
* Returns:
*   A pointer to the list of files found.
*
*******************************************************************************/
char **build_filelist(int *nfiles, char *dirname)
{
    int             increment_size = 128;
    char          **file_list;
    char          **ext_list;
    int             numext;
    DIR            *dirp;
    struct dirent  *direntp;
    char          **extpp;
    char           *file_ext;
    int             list_size;

    print_debug(__FILE__, __LINE__,
        "Building the file list for: %s\n", gTDBInstName);

    /*  Allocate the space for the file_list
     */

    list_size = increment_size;
    file_list = (char **)calloc((size_t)list_size, sizeof(char *));

    if (!file_list) {
        append_log_msg(__FILE__, __LINE__,
            "Could not allocate memory for the file list!\n");
        current_status(STATUS_NOMEM);
        *nfiles = -1;
        return((char **)NULL);
    }
    file_list[0] = NULL;

    /*  Copy gIngestInDir to dirname if it is not NULL.
     */

    if (dirname) {
        strcpy(dirname, gIngestInDir);
    }

    /*  Build the list of file extensions we are looking for
     */

    ext_list = build_extlist(&numext);

    /*  Open the directory and build our file list
     */

    print_debug(__FILE__, __LINE__,
        "Searching for files in directory %s\n", gIngestInDir);

    dirp = opendir(gIngestInDir);
    if (!dirp) {
        append_log_msg(__FILE__, __LINE__,
            "Error #%i opening directory %s\n -> %s\n",
            errno, gIngestInDir, strerror(errno));
        free(file_list);
        current_status(STATUS_NODIROPEN);
        *nfiles = -1;
        return((char **)NULL);
    }

    *nfiles = 0;
    while ((direntp = readdir(dirp)) != NULL ) {

        /*  Check if this file has an extension in our extension list
         */

        for (extpp = ext_list; *extpp != NULL; extpp++) {

            if (strlen(direntp->d_name) > strlen(*extpp)) {

                file_ext = direntp->d_name + strlen(direntp->d_name) - strlen(*extpp);

                if (strcmp(*extpp, file_ext) == 0) {

                    /*  This file has the proper extension so make sure
                     *  our file list has room to add it.
                     */

                    if (*nfiles > list_size - 1) {

                        list_size += increment_size;

                        file_list = (char **)realloc(file_list, list_size * sizeof(char *));

                        if (!file_list) {
                            append_log_msg(__FILE__, __LINE__,
                                "Could not reallocate memory for file list!\n");
                            closedir(dirp);
                            current_status(STATUS_NOMEM);
                            *nfiles = -1;
                            return((char **)NULL);
                        }
                    }

                    /*  Now we can store it in the file list.
                     */

                    file_list[*nfiles] = (char *)malloc((strlen(direntp->d_name) + 1) * sizeof(char));

                    if (!file_list[*nfiles]) {
                        append_log_msg(__FILE__, __LINE__,
                            "Could not allocate memory for file name: %s\n", direntp->d_name);
                        closedir(dirp);
                        current_status(STATUS_NOMEM);
                        *nfiles = -1;
                        return((char **)NULL);
                    }

                    strcpy(file_list[*nfiles], direntp->d_name);
                    (*nfiles)++;

                    print_debug(__FILE__, __LINE__,
                        "Added %s to the file list\n", direntp->d_name);

                    break;
                }
            }
        }
    }

    closedir(dirp);

    /*  Set the last element of file_list to NULL
     */

    file_list[*nfiles] = (char *)NULL;

    /*  Sort the file_list
     */

    qsort(file_list, *nfiles, sizeof(char *), namecompare);

    return(file_list);
}

/*******************************************************************************
*
* Description:
*   The free_filelist function will free the filelist created by build_filelist.
*
* Inputs:
*   filelist: The filelist created by build_filelist.
*
* Outputs:
*   None.
*
* Returns:
*   None.
*
*******************************************************************************/
void free_filelist(char **file_list)
{
    int i;

    if (file_list) {

        for (i = 0; file_list[i]; i++) {
            free(file_list[i]);
        }
        free(file_list);
    }
}

/*******************************************************************************
*
* Description:
*   The exit_ingest function cleans up after an ingest and exits. It is
*   responsible for: <blockquote><p>
*
*       updating the ingest status and history information <br>
*       writing the file and data stats to the log file    <br>
*       closing the log file                               <br>
*       mailing the messages if any were generated         <br>
*       closing the databases.                             </p></blockquote>
*
* Inputs:
*   platname:  The platform name we were working on.
*
*   status:    The current status of the ingest (1 = success, 0 = failure).
*
* Outputs:
*   None.
*
* Returns:
*   None.
*
*******************************************************************************/
void exit_ingest(int status)
{
    ProcStatus      *proc_status;
    time_t           last_started;
    time_t           last_successful;
    time_t           inst_exp_int;
    const char      *status_text;
    const char      *status_name;
    const char      *site;
    const char      *facility;
    const char      *proc_name;
    char            *hostname;
    char            *tdbvalue;
    int              disable_status_changed_mail;
    char             current_status_msg[512];
    char             mail_msg[512];

    char             uc_proc_name[32];
    char             uc_site[8];
    int              si;

    int found_files = 1;
    int db_connected;

    /*  Reconnect to the Database
     */

    db_connected = db_reconnect();

    if (db_connected) {

        /*  Get the process status from the database
         */

        proc_status = get_process_status();
        if (!proc_status || !proc_status->text) {

            print_debug(__FILE__, __LINE__,
                "No status for %s has ever been recorded\n", gTDBInstName);

            proc_status     = (ProcStatus *)NULL;
            last_started    = 0;
            last_successful = 0;
        }
        else {

            print_debug(__FILE__, __LINE__,
                "Previous Ingest Status: \"%s\"\n", proc_status->text);

            if (proc_status->last_started) {
                last_started = mktime(proc_status->last_started);
            }
            else {
                last_started = 0;
            }

            if (proc_status->last_successful) {
                last_successful = mktime(proc_status->last_successful);
            }
            else {
                last_successful = 0;
            }
        }
    }

    /*  Change the status to success if we were successful.
     */

    status_text = current_status(NULL);

    if (status == SUCCESS) {

        /*  Change current status to "good" unless it is one of the
         *  move_ingested_raw function errors.
         */

        if ((strcmp(status_text, STATUS_NULLDC)    != 0)
         && (strcmp(status_text, STATUS_NOMOVERAW) != 0)
         && (strcmp(status_text, STATUS_NOUTIME)   != 0)) {

            status_text = current_status(STATUS_GOOD);
        }
    }
    else if (db_connected) {

        /*  If the current status is "No files found" and the instrument
         *  expectation interval is greater than the difference between the
         *  last started time and the last successful we do not want to
         *  update the status.
         */

        if (strcmp(status_text, STATUS_NOFILES) == 0) {

            inst_exp_int = get_tdb_inst_exp_int(gTDBInstName);

            if (inst_exp_int &&
                ((last_started - last_successful) <= inst_exp_int)) {

                append_instrlog(
                    "No new files found but we are within the instrument expectation interval: %d seconds\n",
                    inst_exp_int);

                update_process_completed();

                found_files = 0;
            }
        }
    }

    /*  Build the current status message
     */

    site = get_process_site();
    for (si = 0; site[si] != '\0'; si++) {
        uc_site[si] = toupper(site[si]);
    }
    uc_site[si] = '\0';

    facility = get_process_facility();

    proc_name = get_process_name();
    for (si = 0; proc_name[si] != '\0'; si++) {
        uc_proc_name[si] = toupper(proc_name[si]);
    }
    uc_proc_name[si] = '\0';

    hostname = get_hostname();
    if (!hostname) {
        hostname = "unknown";
    }

    sprintf(current_status_msg,
        "Current Status:\n"
        "Proc:   %s.%s.%s\n"
        "Host:   %s\n"
        "Status: %s\n",
        uc_site, uc_proc_name, facility,
        hostname,
        status_text);

    if (db_connected) {

        /*  Send mail if the ingest status has changed.
         */

        disable_status_changed_mail = 0;

        tdbvalue = shared_tdb_fetch(DS_TDB, "disable_status_changed_mail");
        if (tdbvalue && (strcmp(tdbvalue, "off") != 0)) {
            disable_status_changed_mail = 1;
        }

        if (!proc_status || (strcmp(status_text, proc_status->text) != 0)) {

            if (found_files) {
                print_debug(__FILE__, __LINE__,
                    "Status for %s has changed\n", gTDBInstName);

                if (!disable_status_changed_mail) {

                    sprintf(mail_msg, "%s\nLast successful ingest completed at %s",
                        current_status_msg, ctime(&last_successful));

                    append_to_msg(INGEST_MSG, mail_msg);
                }
            }
        }
        else {
            print_debug(__FILE__, __LINE__,
                "Status for %s has not changed\n", gTDBInstName);
        }

        /*  Update the process status in the database
         */

        if (found_files) {

            if (strcmp(status_text, STATUS_GOOD) == 0) {
                status_name = "Success";
            }
            else {
                status_name = "Failure";
            }

            update_process_status(status_name, status_text);
        }
    }

    /*  Write stats to log file.
     */

    write_dc_stats();
    write_file_stats();

    /*  We are done with the database so clean up the connection.
     */

    db_finish();

    dsdb_free_process_location(gIngestLocation);
    dsdb_free_ds_classes(gIngestOutputs);

    print_debug(__FILE__, __LINE__,
        "Closed the database\n");

    /*  Mail the ingest and mentor messages.
     */

    if (gIngestCustodian) {
        mail_message(INGEST_MSG, gIngestCustodian);
    }

    if (gMentorCustodian) {
        mail_message(MENTOR_MSG, gMentorCustodian);
    }

    /*  Append the current status message to the log file and close it.
     */

    append_instrlog("\n%s", current_status_msg);
    close_instrlog();

    if (status == FAILURE) {
        exit(1);
    }

    exit(0);
}

/*****************************************************************************
*
* Description:
*   This function will be called anytime a signal which has been set up by
*   init_signal_handlers is caught. This routine will set the status and
*   call exit_ingest if it is possible to close and re-open the TDB. If the
*   TDB can not be re-opened it will log a message to the log file but it will
*   be impossible to update the status in the TDB.
*
* Inputs:
*   signal: The signal type.
*
*   si:     structure  containing the  reason why the signal was generated
*           (see siginfo(5)).
*
*   uc:     the  receiving process's  context when the signal was delivered
*           (see ucontext(5)).
*
* Outputs:
*   None.
*
* Returns:
*   None.
*
****************************************************************************/
void catch_sig(int sig, siginfo_t *si, void *uc)
{
    char msg[128];

    switch (sig) {

        case SIGQUIT:
            strcpy(msg, "SIGQUIT: Quit (see termio(7I))\n");
            current_status(STATUS_COREDUMP);
            break;
        case SIGILL:
            strcpy(msg, "SIGILL: Illegal Instruction\n");
            current_status(STATUS_COREDUMP);
            break;
        case SIGTRAP:
            strcpy(msg, "SIGTRAP: Trace or Breakpoint Trap\n");
            current_status(STATUS_COREDUMP);
            break;
        case SIGABRT:
            strcpy(msg, "SIGABRT: Abort\n");
            current_status(STATUS_COREDUMP);
            break;
        case SIGEMT:
            strcpy(msg, "SIGEMT: Emulation Trap\n");
            current_status(STATUS_COREDUMP);
            break;
        case SIGFPE:
            strcpy(msg, "SIGFPE: Arithmetic Exception\n");
            current_status(STATUS_COREDUMP);
            break;
        case SIGBUS:
            strcpy(msg, "SIGBUS: Bus Error\n");
            current_status(STATUS_COREDUMP);
            break;
        case SIGSEGV:
            strcpy(msg, "SIGSEGV: Segmentation Fault\n");
            current_status(STATUS_COREDUMP);
            break;
        case SIGSYS:
            strcpy(msg, "SIGSYS: Bad System Call\n");
            current_status(STATUS_COREDUMP);
            break;
        case SIGHUP:
            strcpy(msg, "SIGHUP: Hangup (see termio(7I))\n");
            current_status(STATUS_SIGNAL);
            break;
        case SIGINT:
            strcpy(msg, "SIGINT: Interrupt (see termio(7I))\n");
            current_status(STATUS_SIGNAL);
            break;
        case SIGPIPE:
            strcpy(msg, "SIGPIPE: Broken Pipe\n");
            current_status(STATUS_SIGNAL);
            break;
        case SIGALRM:
            strcpy(msg, "SIGALRM: Alarm Clock\n");
            current_status(STATUS_SIGNAL);
            break;
        case SIGTERM:
            strcpy(msg, "SIGTERM: Terminated\n");
            current_status(STATUS_SIGNAL);
            break;
        default:
            strcpy(msg, "Unknown Signal Type\n");
            current_status(STATUS_SIGNAL);
    }

    append_log_msg(__FILE__, __LINE__,
        "Received Signal %s\n", msg);

    exit_ingest(0);
}

/*****************************************************************************
*
* Description:
*   This function will limit the codedumpsize and setup the catch_sig function
*   to be the signal handler for the following signals: <blockquote><p>
*
*       SIGHUP  -> Hangup (see termio(7I))    <br>
*       SIGINT  -> Interrupt (see termio(7I)) <br>
*       SIGQUIT -> Quit (see termio(7I))      <br>
*       SIGILL  -> Illegal Instruction        <br>
*       SIGTRAP -> Trace or Breakpoint Trap   <br>
*       SIGABRT -> Abort                      <br>
*       SIGEMT  -> Emulation Trap             <br>
*       SIGFPE  -> Arithmetic Exception       <br>
*       SIGBUS  -> Bus Error                  <br>
*       SIGSEGV -> Segmentation Fault         <br>
*       SIGSYS  -> Bad System Call            <br>
*       SIGPIPE -> Broken Pipe                <br>
*       SIGALRM -> Alarm Clock                <br>
*       SIGTERM -> Terminated                 </p></blockquote>
*
* Inputs:
*   None.
*
* Outputs:
*   None.
*
* Returns:
*   None.
*
****************************************************************************/
int init_signal_handlers(void)
{
    static int initialized;

    struct rlimit   rl;
    struct sigaction act;

    if (initialized) {
        return(1);
    }
    initialized = 1;

    act.sa_handler = 0;

  /*  act.sa_mask = sigset_t(0); */
    act.sa_flags = (SA_SIGINFO);
    act.sa_sigaction = catch_sig;

    if (sigaction(SIGHUP,  &act, 0) != 0 ||   /* Hangup (see termio(7I))    */
        sigaction(SIGINT,  &act, 0) != 0 ||   /* Interrupt (see termio(7I)) */
        sigaction(SIGQUIT, &act, 0) != 0 ||   /* Quit (see termio(7I))      */
        sigaction(SIGILL,  &act, 0) != 0 ||   /* Illegal Instruction        */
        sigaction(SIGTRAP, &act, 0) != 0 ||   /* Trace or Breakpoint Trap   */
        sigaction(SIGABRT, &act, 0) != 0 ||   /* Abort                      */
        sigaction(SIGEMT,  &act, 0) != 0 ||   /* Emulation Trap             */
        sigaction(SIGFPE,  &act, 0) != 0 ||   /* Arithmetic Exception       */
        sigaction(SIGBUS,  &act, 0) != 0 ||   /* Bus Error                  */
        sigaction(SIGSEGV, &act, 0) != 0 ||   /* Segmentation Fault         */
        sigaction(SIGSYS,  &act, 0) != 0 ||   /* Bad System Call            */
        sigaction(SIGPIPE, &act, 0) != 0 ||   /* Broken Pipe                */
        sigaction(SIGALRM, &act, 0) != 0 ||   /* Alarm Clock                */
        sigaction(SIGTERM, &act, 0) != 0      /* Terminated                 */
       ) {

        append_log_msg(__FILE__, __LINE__,
            "Calling sigaction failed, error #%i: %s\n", errno, strerror(errno));
        current_status(STATUS_SIGNAL);
        return(0);
    }

      /*  set core limit size
   */
    rl.rlim_cur = COREDUMPSIZE;
    rl.rlim_max = COREDUMPSIZE;
    if (setrlimit(RLIMIT_CORE, &rl) == -1) {

        append_log_msg(__FILE__, __LINE__,
            "Calling setrlimit failed, error #%i: %s\n", errno, strerror(errno));
        current_status(STATUS_SIGNAL);
        return(0);
    }

    return(1);
}

/*******************************************************************************
*
* Description:
*   The bad_line function is used to report a bad line in the specified file.
*   It will count various types of bad data lines, depending on the linetype
*   passed.  If linetype is a REPORT type, this function will append a bad line
*   report to the INGEST_MSG.
*
* Inputs:
*  line:     The line number which was bad.
*
*  filename: The name of the file with a bad line.
*
*  linetype: The type of bad line which was encountered.
*
* Outputs:
*   None.
*
* Returns:
*   None.
*
*******************************************************************************/
void bad_line(int line, char *filename, int linetype)
{
    static int badline[BADLINE_MAX];
    char       errorstr[MAXSTRLEN];
    char       badline_report[MAXSTRLEN*64];
    int        badline_total = 0;
    int        i;

    if (linetype == BADLINE_REPORT) {
        for(i = 0; i < BADLINE_MAX; i++) {

          /*  Add all lines EXCEPT BADLINE_COMMENT
           */
            if (i != BADLINE_COMMENT) {
                badline_total += badline[i];
            }
        }

        if (badline_total) {

            sprintf(badline_report, "Bad data lines in file: %s\n", filename);
            sprintf(errorstr, "Bad number of elements: %d\n", badline[BADLINE_ELE]);
            strcat(badline_report,errorstr);
            sprintf(errorstr, "        Bad characters: %d\n", badline[BADLINE_ALPHA]);
            strcat(badline_report,errorstr);
            sprintf(errorstr, "              Bad date: %d\n", badline[BADLINE_DATE]);
            strcat(badline_report,errorstr);
            sprintf(errorstr, "       Bad Facility ID: %d\n", badline[BADLINE_FACID]);
            strcat(badline_report,errorstr);

          /*
           * We will not put the Comment Line count in our report for now
           *
           * sprintf(errorstr,"         Comment Lines: %d\n",badline[BADLINE_COMMENT]);
           * strcat(badline_report,errorstr);
           */

            sprintf(errorstr, "       TOTAL BAD LINES: %d\n", badline_total);
            strcat(badline_report, errorstr);
            append_log_msg(__FILE__, __LINE__, "%s", badline_report);

          /*  Reset the info
           */
            for(i = 0; i < BADLINE_MAX; i++) {
                badline[i] = 0;
            }
        }
    }
    else {
        sprintf(errorstr, "Improper DataLine (line %d) in %s", line, filename);
        append_to_msg(INGEST_MSG, errorstr);
        print_debug(__FILE__, __LINE__, "%s\n", errorstr);
        badline[linetype]++;
    }
}

/*******************************************************************************
*
* Description:
*   The get_full_raw_data_file_path function appends the given filename to the
*   raw data input directory.
*
* Inputs:
*   filename:  The name of the raw data file.
*
*   full_path: The pointer to the space to store the full path to the raw file.
*
* Outputs:
*   full_path: The full path to the raw data file.
*
* Returns:
*   1 = success, 0 = failure
*
*******************************************************************************/
int get_full_raw_data_file_path(char *filename, char *full_path)
{
    sprintf(full_path, "%s/%s", gIngestInDir, filename);
    return(1);
}

/*******************************************************************************
*
* Description:
*   The open_data_file function opens a file and gets a file pointer.
*
* Inputs:
*   filename: The name of the data file to open.
*
* Outputs:
*   fp:      The pointer to the open file.
*
* Returns:
*   1 = success, 0 = failure
*
*******************************************************************************/
int open_data_file(char *filename, FILE **fp)
{
    if ((*fp = fopen(filename, "r")) == NULL ) {
        current_status(STATUS_FOPEN);
        append_log_msg(__FILE__, __LINE__,
            "Could not open file: %s\n", filename);
        return(0);
    }

    return(1);
}

---