/*
 * Copyright (c) 2013-2016 Wind River Systems, Inc.
*
* SPDX-License-Identifier: Apache-2.0
*
 */

 /**
  * @file
  * Wind River CGTS Platform Maintenance ...
  *
  * /var/run/<daemon>.pid
  *
  * Also upon request can create a health check info file.
  *
  * /var/run/<daemon>.info
  *
  */

#include <stdlib.h>     /* for .. system           */
#include <unistd.h>     /* for .. close and usleep */
#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
#include <sys/stat.h>
#include <syslog.h>
#include <errno.h>
#include <openssl/md5.h>

using namespace std;

#include "daemon_common.h"
#include "daemon_option.h"
#include "nodeBase.h"

/* GNU Extension
 * program_invocation_name contains the name that was used to invoke the
 * calling program. This is the same as the value of argv[0] in main(),
 * with the difference that the scope of program_invocation_name is global.
 * program_invocation_short_name contains the basename component of name
 * that was used to invoke the calling program. That is, it is the same
 * value as program_invocation_name, with all text up to and including
 * the final slash (/), if any, removed.
 * These variables are automatically initialized by the glibc run-time
 * startup code.
 *
 * The daemon name info */
extern char *program_invocation_name;
extern char *program_invocation_short_name;

static char pid_filename  [MAX_FILENAME_LEN] ;
static char hc_filename   [MAX_FILENAME_LEN] ;

void daemon_files_fini ( void )
{
    close_syslog();
}

void daemon_health_test ( void )
{
    char file_str[2000] ;
    sprintf ( &file_str[0], "I'm healthy: Here is my config ...\n%s\n", daemon_stream_info ());
    daemon_healthcheck (&file_str[0]);
}

bool daemon_is_file_present ( const char * filename )
{
    struct stat p ;
    memset ( &p, 0 , sizeof(struct stat));
    stat ( filename, &p ) ;
    if ((p.st_ino != 0 ) && (p.st_dev != 0))
        return (true);
    else
        return (false);
}

void daemon_healthcheck ( const char * sig )
{
    FILE * hc_file_stream ;

    snprintf ( &hc_filename[0], MAX_FILENAME_LEN, "/var/run/%s.info",
                program_invocation_short_name );

    /* remove the old file */
    unlink (hc_filename);

    /* Create daemon healthcheck file */
    hc_file_stream = fopen (hc_filename, "w" ) ;
    if ( hc_file_stream == NULL )
    {
        wlog("Failed to open %s\n", hc_filename);
    }
    else if ( !fprintf (hc_file_stream,"%s\n", sig ))
    {
        wlog ("Failed to write to %s\n", hc_filename);
    }
    if ( hc_file_stream )
    {
        fflush (hc_file_stream);
        fclose (hc_file_stream);
    }
}

#define BUFFER 1024

int daemon_log_value ( const char * filename , const char * str, int val )
{
    FILE * file_stream = fopen (filename, "a" ) ;
    if ( file_stream != NULL )
    {
        fprintf ( file_stream,"%s %d\n", str, val );
        fflush (file_stream);
        fclose (file_stream);
        return (PASS);
    }
    return (FAIL_FILE_OPEN);
}

int daemon_log_value ( const char * filename , int val )
{
    FILE * file_stream = fopen (filename, "w" ) ;
    if ( file_stream != NULL )
    {
        fprintf ( file_stream,"%d\n", val );
        fflush (file_stream);
        fclose (file_stream);
        return (PASS);
    }
    return (FAIL_FILE_OPEN);
}

int daemon_log ( const char * filename , const char * str )
{
    FILE * file_stream = fopen (filename, "a" ) ;
    if ( file_stream != NULL )
    {
        fprintf ( file_stream,"%s\n", str );
        fflush (file_stream);
        fclose (file_stream);
        return (PASS);
    }
    return (FAIL_FILE_OPEN);
}

/* reads the first line of a file and if it contains a string
 * that represents an integer value then return it */
int daemon_get_file_int ( const char * filename )
{
    int    value = 0 ;
    FILE * __stream = fopen ( filename, "r" );
    if ( __stream != NULL )
    {
        int rc ;

        char   buffer     [MAX_CHARS_IN_INT];
        memset(buffer, 0 , MAX_CHARS_IN_INT);
        if ( fgets (buffer,MAX_CHARS_IN_INT, __stream) != NULL )
        {
            rc = sscanf ( &buffer[0], "%d",  &value );
            if ( rc >= 1 )
            {
                dlog ("%s contains number %d\n", filename, value );
            }
            else
            {
                wlog ("failed to sscanf integer from file:%s\n", filename );
            }
        }
        else
        {
            wlog ("failed to read integer from file:%s\n", filename );
        }
        fclose(__stream);
    }
    else
    {
        wlog ("failed to open file:%s\n", filename );
    }
    return ( value );
}

/* reads the first line of a file and returns it as a string */
string daemon_get_file_str ( const char * filename )
{
    string  value = "null" ;
    FILE * __stream = fopen ( filename, "r" );
    if ( __stream != NULL )
    {
        int rc ;

        char   buffer     [MAX_CHARS_ON_LINE];
        char   data       [MAX_CHARS_ON_LINE];
        memset(buffer, 0 , MAX_CHARS_ON_LINE);
        memset(data, 0 ,   MAX_CHARS_ON_LINE);
        if ( fgets (buffer,MAX_CHARS_ON_LINE, __stream) != NULL )
        {
            rc = sscanf ( &buffer[0], "%s", &data[0] );
            if ( rc >= 1 )
            {
                value = data ;
                dlog ("%s contains '%s'\n", filename, value.c_str());
            }
            else
            {
                wlog ("failed to sscanf string from file:%s\n", filename );
            }
        }
        else
        {
            wlog ("failed to read string from file:%s\n", filename );
        }
        fclose(__stream);
    }
    else
    {
        wlog ("failed to open file:%s\n", filename );
    }
    return ( value );
}

/* Stay here till we get the data we need */
/* Warning: Don't enable logging here     */
string daemon_nodetype ( void )
{
    for ( ; ; )
    {
        char   buffer[BUFFER];
        int    line = 0      ;
        string nodetype = "unknown" ;
        char   nodetype_str[BUFFER];

        memset ( &nodetype_str[0], 0 , BUFFER );
        /* open the configuration file */
        FILE * cfg_file_stream = fopen ( PLATFORM_CONF_FILE, "rb" );
        if ( cfg_file_stream != NULL )
        {
            int rc ;
            while ( fgets (buffer, BUFFER, cfg_file_stream) != NULL )
            {
                char* s = strstr ( buffer, "subfunction");
                if(s!=NULL)
                {
                    rc = sscanf ( &buffer[0], "subfunction=%1023s",  &nodetype_str[0] );
                    if ( rc == 1 )
                    {
                        nodetype = nodetype_str ;
                        fclose(cfg_file_stream);
                        return ( nodetype ) ;
                    }
                }
                line++ ;
            }
            /* Close the file */
            fclose(cfg_file_stream);
        }
        usleep (5000000);
    }
    return ( "" );
}

/* Read the integer value of rmem_max from /proc/sys/net/core/rmem_max */
int daemon_get_rmem_max ( void )
{
    #define RMEM_MAX_VALUE_SIZE (64)
    #define RMEM_MAX_FILENAME ((const char *)("/proc/sys/net/core/rmem_max"))

    int    value = 0 ;
    FILE * __stream = fopen ( RMEM_MAX_FILENAME, "r" );
    if ( __stream != NULL )
    {
        int rc ;

        char   buffer     [RMEM_MAX_VALUE_SIZE];
        memset(buffer, 0 , RMEM_MAX_VALUE_SIZE);
        if ( fgets (buffer,RMEM_MAX_VALUE_SIZE, __stream) != NULL )
        {
            rc = sscanf ( &buffer[0], "%d",  &value );
            if ( rc == 1 )
            {
                dlog1 ("mem_max:%d\n", value );
            }
        }
        fclose(__stream);
    }
    return ( value );
}

/*
 * Read the platform.conf file looking for the management_interface label.
 * If found return that value as string ; otherwise return empty string.
 *
 *  const char infra_mgmt_label [] = {"management_interface"} ;
 *
 * Stay here till we get the data we need
 * Warning: Don't enable logging here
 *
 **/
string daemon_mgmnt_iface ( void )
{
    for ( ; ; )
    {
        char   iface_str[BUFFER];
        char   buffer   [BUFFER];
        int    line  = 0        ;
        string iface = ""       ;

        memset ( iface_str, 0 , BUFFER );
        FILE * cfg_file_stream = fopen ( PLATFORM_CONF_FILE, "r" );
        if ( cfg_file_stream != NULL )
        {
            int rc ;
            while ( fgets (buffer, BUFFER, cfg_file_stream) != NULL )
            {
                char* s = strstr ( buffer, "management_interface");
                if(s!=NULL)
                {
                    rc = sscanf ( &buffer[0], "management_interface=%1023s",  &iface_str[0] );
                    if ( rc == 1 )
                    {
                        iface = iface_str ;
                        fclose(cfg_file_stream);
                        // ilog("Mgmnt iface : %s\n", iface.c_str() );
                        return ( iface ) ;
                    }
                }
                line++ ;
            }
            /* Close the file */
            fclose(cfg_file_stream);
        }
        usleep (5000000);
    }
    ilog("Mgmnt iface : none\n");
    return ( "" );
}


/****************************************************************************
 *
 * Name       : daemon_system_type
 *
 * Purpose    : Learn the system type
 *
 * Description: Read the platform.conf file looking for system type.
 *              If type is not Standard then refine the system type to
 *              one of the AIO variations.
 *
 *****************************************************************************/

#define SYSTEM_TYPE_PREFIX ((const char *)("System Type :"))
system_type_enum daemon_system_type ( void )
{
    char buffer  [BUFFER];
    system_type_enum system_type = SYSTEM_TYPE__CPE_MODE__SIMPLEX ;
    FILE * cfg_file_stream = fopen ( PLATFORM_CONF_FILE, "r" );
    if ( cfg_file_stream != NULL )
    {
        MEMSET_ZERO(buffer);
        while ( fgets (buffer, BUFFER, cfg_file_stream) != NULL )
        {
            if ( strstr ( buffer, "system_type") != NULL )
            {
                char   type_str[BUFFER];
                MEMSET_ZERO(type_str);
                if ( sscanf ( &buffer[0], "system_type=%1023s",  &type_str[0] ) == 1 )
                {
                    string type_string = type_str ;
                    if ( !type_string.empty() && ( type_string == "Standard"))
                    {
                        system_type = SYSTEM_TYPE__NORMAL ;
                    }
                    break ;
                }
            }
            MEMSET_ZERO(buffer);
        }
    }

    if ( cfg_file_stream )
    {
        /* Close the file */
        fclose(cfg_file_stream);
        cfg_file_stream = NULL ;
    }

    /* If system_type is updated to NORMAL then we are done.
     * Otherwise lets see what kind of AIO system mode we are running in. */
    if ( system_type != SYSTEM_TYPE__NORMAL )
    {
        cfg_file_stream = fopen ( PLATFORM_CONF_FILE, "r" );
        if ( cfg_file_stream != NULL )
        {
            MEMSET_ZERO(buffer);
            while ( fgets (buffer, BUFFER, cfg_file_stream) != NULL )
            {
                if ( strstr ( buffer, "system_mode") != NULL )
                {
                    char mode_str[BUFFER];
                    MEMSET_ZERO(mode_str);
                    if ( sscanf ( &buffer[0], "system_mode=%1023s",  &mode_str[0] ) == 1 )
                    {
                        string mode = mode_str ;
                        if ( !mode.empty() )
                        {
                            if ( mode.compare("duplex") == 0 )
                                system_type = SYSTEM_TYPE__CPE_MODE__DUPLEX ;
                            else if ( mode.compare("duplex-direct") == 0 )
                                system_type = SYSTEM_TYPE__CPE_MODE__DUPLEX_DIRECT ;
                            else if ( mode.compare("simplex") == 0 )
                                system_type = SYSTEM_TYPE__CPE_MODE__SIMPLEX ;
                            else
                            {
                                elog ("%s All-In-One system type ; mode unknown\n", SYSTEM_TYPE_PREFIX );
                                wlog ("... %s\n", buffer );
                            }
                        }
                        else
                        {
                            elog ("%s All-In-One system type ; mode empty\n", SYSTEM_TYPE_PREFIX );
                            wlog ("... %s\n", buffer );
                        }
                    }
                    break ;
                }
                MEMSET_ZERO(buffer);
            }
        }
    }

    if ( cfg_file_stream )
    {
        /* Close the file */
        fclose(cfg_file_stream);
    }

    switch ( system_type )
    {
        case SYSTEM_TYPE__NORMAL:
        {
            ilog("%s Standard System\n", SYSTEM_TYPE_PREFIX);
            break ;
        }
        case SYSTEM_TYPE__CPE_MODE__DUPLEX_DIRECT:
        {
            ilog ("%s All-in-one Duplex Direct Connect\n", SYSTEM_TYPE_PREFIX );
            break ;
        }
        case SYSTEM_TYPE__CPE_MODE__DUPLEX:
        {
            ilog ("%s All-in-one Duplex\n", SYSTEM_TYPE_PREFIX );
            break ;
        }
        case SYSTEM_TYPE__CPE_MODE__SIMPLEX:
        default:
        {
            ilog ("%s All-in-one Simplex \n", SYSTEM_TYPE_PREFIX );
            system_type = SYSTEM_TYPE__CPE_MODE__SIMPLEX ;
            break ;
        }
    }
    return ( system_type );
}


/* ********************************************************************
 *
 * Name:        daemon_infra_iface
 *
 * Description: Read the platform.conf file looking for the infra
 *              interface label. If found return that value as string ;
 *              otherwise return empty string.
 **/
string daemon_infra_iface ( void )
{
    char   buffer   [BUFFER];
    int    line  = 0        ;
    string iface = ""       ;

    FILE * cfg_file_stream = fopen ( PLATFORM_CONF_FILE, "r" );
    if ( cfg_file_stream != NULL )
    {
        int rc ;
        while ( fgets (buffer, BUFFER, cfg_file_stream) != NULL )
        {
            char* s = strstr ( buffer, "infrastructure_interface" );
            if(s!=NULL)
            {
                char iface_str[BUFFER];
                memset ( iface_str, 0 , BUFFER );
                rc = sscanf ( &buffer[0], "infrastructure_interface=%1023s", &iface_str[0] );
                if ( rc == 1 )
                {
                    iface = iface_str ;
                    fclose(cfg_file_stream);
                    // ilog("Infra iface : %s\n", iface.c_str() );
                    return ( iface ) ;
                }
            }
            line++ ;
        }
        /* Close the file */
        fclose(cfg_file_stream);
    }
    dlog("Infra iface : none\n");
    return ( "" );
}

/* *********************************************************************************
 *
 * Name       : daemon_sw_version
 *
 * Description: read the /etc/build.info file and extract the SW_VERSION value.
 *
 * Note: If the value is found surrounded by quotes then they are stripped.
 * Note: if the lable is not found then a empty string is returned.
 *
 * @return SW_VERSION string value
 *
 * Here is the head of the file with that label.
 *
 * root@controller-0:/opt# cat /etc/build.info
 *
 * SW_VERSION="14.08"    <-----------------------
 * BUILD_TARGET="Unknown"
 * BUILD_TYPE="Informal"
 * BUILD_ID="n/a"
 *
 ************************************************************************************/

string daemon_sw_version ( void )
{
    char   version_str[BUFFER];
    string version = "" ;
    int    line    = 0  ;

    const char build_info_filename[] = { "/etc/build.info" };
    FILE * fp = fopen (&build_info_filename[0], "r" ) ;
    if ( fp )
    {
        int   rc  = 0 ;
        char buffer[BUFFER];
        while ( fgets (buffer, BUFFER, fp ) != NULL )
        {
            memset ( version_str, 0 , BUFFER );
            char* s = strstr ( buffer, "SW_VERSION");
            if(s!=NULL)
            {
                rc = sscanf ( &buffer[0], "SW_VERSION=%1023s", &version_str[0] );
                if ( rc == 1 )
                {
                    /* Chop off the surrounding quotes if they exist */
                    if ( version_str[0] == '"' )
                    {
                        /* "12.34" -> 12.34 */
                        int len = strlen (version_str);
                        string temp = version_str ;
                        version = temp.substr ( 1, len-2 ) ;
                    }
                    else
                    {
                        version = version_str ;
                    }
                    fclose(fp);
                    return ( version ) ;
                }
            }
            line++ ;
        }
        /* Close the file */
        fclose(fp);
    }
    return ("");
}

/****************************************************************************
 *
 * Name       : daemon_bmc_hosts_file
 *
 * Description: Insert the software version into the path to the bmc hosts
 *              file and return the file path as a string.
 *
 ****************************************************************************/
string daemon_bmc_hosts_dir ( void )
{
    string fn = "/opt/platform/config/" ;
    string version = daemon_sw_version();
    if ( !version.empty() )
    {
         version.append("/");
    }
    fn.append(version);
    return(fn);
}
string daemon_bmc_hosts_file ( void )
{
    string fn = "/opt/platform/config/" ;
    string version = daemon_sw_version();
    if ( !version.empty() )
    {
         version.append("/");
    }
    fn.append(version);
    fn.append(BM_DNSMASQ_FILENAME);
    return(fn);
}

/****************************************************************************
 *
 * Name       : daemon_get_iface_master
 *
 * Description: Get the master interface name for the supplied
 *              physical interface.
 *
 ****************************************************************************/
char master_interface [BUFFER] ;
char * daemon_get_iface_master ( char * iface_slave_ptr )
{
    FILE * file_ptr ;
    char   buffer[BUFFER];

    string iface_master = "/sys/class/net/" ;
    iface_master.append (iface_slave_ptr) ;
    iface_master.append ("/master/uevent");

    /* Create daemon healthcheck file */
    file_ptr = fopen ( iface_master.data(), "r" ) ;
    if ( file_ptr != NULL )
    {
        while ( fgets ( buffer, BUFFER, file_ptr ) != NULL )
        {
            char* s = strstr ( buffer, "INTERFACE");
            if ( s != NULL )
            {
                memset ( &master_interface[0], 0, BUFFER );
                int rc = sscanf ( &buffer[0], "INTERFACE=%1023s",
                         &master_interface[0] );
                if ( rc == 1 )
                {
                    fclose(file_ptr);
                    return ( &master_interface[0] );
                }
            }
        }
        fclose(file_ptr);
    }
    return ( iface_slave_ptr );
}

string daemon_md5sum_file ( const char * file )
{
    struct stat p ;
    string md5sum = "" ;

    memset ( &p, 0 , sizeof(struct stat));
    stat ( file, &p ) ;
    if ((p.st_ino != 0 ) && (p.st_dev != 0))
    {
        /* add 256 bytes to the buffer just in case there are
         * additions to the file by the time we start reading it */
        int len = p.st_size+0x100 ;

        char * buf_ptr = (char*)malloc(len) ;
        char * buf_ptr_save = buf_ptr ;
        if ( buf_ptr )
        {
            dlog ("%s is %ld bytes\n", file, p.st_size );

            /* Open and read the file data */
            FILE * file_ptr = fopen ( file, "r" ) ;
            if ( file_ptr != NULL )
            {
                size_t l ;
                unsigned char digest[MD5_DIGEST_LENGTH];
                char md5str         [MD5_STRING_LENGTH];
                memset ( &digest, 0, MD5_DIGEST_LENGTH);
                memset ( &md5str, 0, MD5_STRING_LENGTH);

                while ( fgets ( (char*)buf_ptr, BUFFER, file_ptr ) != NULL )
                {
                    l = strnlen ( buf_ptr_save, len );
                    buf_ptr = buf_ptr_save+l ;
                }
                MD5 ( (unsigned char*)buf_ptr_save, strlen(buf_ptr_save), (unsigned char*)&digest);

                for(int i = 0; i < MD5_DIGEST_LENGTH; i++)
                    sprintf(&md5str[i*2], "%02x", (unsigned int)digest[i]);

                dlog ("md5 digest: %s\n", md5str );
                dlog3 ("file: %s\n", buf_ptr_save );

                fclose(file_ptr);
                md5sum = md5str ;
            }
            else
            {
                elog ("%s file open failed\n", file );
            }
            free (buf_ptr_save);
        }
        else
        {
            elog ("failed to allocate buffer memory for %s file md5sum calc\n", file );
        }
    }
    else
    {
        wlog ("%s file not present\n", file );
    }
    return ( md5sum );
}

// generate a md5sum signature for the Shadow entry
// returns the password hash and aging in the shadowinfo
string get_shadow_signature ( char * shadowfile , const char * username,
                              char *shadowinfo, size_t infolen)
{
    char buffer[BUFFER];

    /* Open the specified file file Create daemon healthcheck file */
    FILE * file_ptr = fopen ( shadowfile, "r" ) ;

    if ( file_ptr != NULL )
    {
        /* Clear the buffer - start fresh */
        memset ( &buffer, 0, BUFFER );

        while ( fgets ( buffer, BUFFER, file_ptr ) != NULL )
        {
            char* s = strstr ( buffer, username);
            if ( s != NULL )
            {
                int result;
                char user[BUFFER], password[BUFFER], aging[BUFFER];
                unsigned char digest[MD5_DIGEST_LENGTH];
                char md5str         [MD5_STRING_LENGTH];

                /* Fields are separated by ':'.  The first field is the
                 * user. We need to only isolate the password and aging
                 * fields since these are the only ones that'd be
                 * propagated across host nodes. By specifically tracking
                 * these we prevent config-out-of-date alarms for other fields
                 */
                
                /*
                 * The following line should be changed to add width limits:
                 * (However, not changing it yet because of risk.)
                 * result = sscanf(buffer, "%1023[^:]:%1023[^:]:%*[^:]:%*[^:]:%1023[^:]",
                 */
                result = sscanf(buffer, "%[^:]:%[^:]:%*[^:]:%*[^:]:%[^:]",
                user, password, aging);
                if ( result != 3 || strcmp(user, username) != 0 )
                {
                    /* Sanity */
                    continue;
                }

                /* at max, both password[] and aging[] include BUFFER chars (BUFFER-1 
                 * meaningful chars and one "\0" as tail). when they are combined with
                 * ":" and put into shadowEntry by snprintf (..., "%s:%s", ...), 
                 * shadowEntry has 2 chars (":" + "\0") at least and BUFFER*2 chars at most:
                 *     BUFFER-1 chars copied from password
                 *     ":"
                 *     BUFFER-1 chars copied from aging, and 
                 *     one tail "\0"
                 */
                char shadowEntry[BUFFER*2] = {0};
                snprintf (shadowEntry, sizeof(shadowEntry), 
                          "%s:%s", password, aging);

                int ret = snprintf(shadowinfo, infolen, "%s", shadowEntry);
                if (ret >= (int)infolen)
                {
                    fclose(file_ptr);
                    elog("insufficient space in shadow buffer(%d) for %d bytes\n",
                         (int)infolen, ret);
                    return ( "" );
                }
    
                memset ( &digest, 0, MD5_DIGEST_LENGTH );
                memset ( &md5str, 0, MD5_STRING_LENGTH );
                MD5 ((unsigned char*) shadowEntry, strlen(shadowEntry), (unsigned char*)&digest);

                for(int i = 0; i < MD5_DIGEST_LENGTH; i++)
                    sprintf(&md5str[i*2], "%02x", (unsigned int)digest[i]);

                dlog ("user value: %s\n", shadowEntry);
                dlog ("md5 digest: %s\n", md5str );

                fclose(file_ptr);
                string md5sum = md5str ;
                return ( md5sum );
            }
            else
            {
                /* Clear the buffer - start fresh */
                memset ( &buffer, 0, BUFFER );
            }
        }
        fclose(file_ptr);
    }
    return ( "" );

}

/* Introduced for process monitor daemon to allow quiet
 * close of the log file before a process respawn */
void daemon_logfile_close ( void )
{
    return ;
}

/* Introduced for process monitor daemon to allow quiet
 * re-open of the log file after a respawn of a process */
void daemon_logfile_open  ( void )
{
    return ;
}

/****************************************************************************
 *
 * Name       : daemon_remove_file
 *
 * Description: Remove the specified file if it exists.
 *
 *****************************************************************************/

void daemon_remove_file ( const char * filename )
{
    if ( daemon_is_file_present ( filename ))
    {
        if ( remove(filename) )
        {
            elog ("failed to remove file '%s' ; (%d:%m)\n", filename, errno);
        }
        else
        {
            if ( daemon_is_file_present ( filename ) )
            {
                elog ("failed to remove file '%s' ; still present\n", filename );
            }
            else
            {
                dlog3 ("removed %s\n", filename );
            }
        }
    }
    else
    {
        dlog3 ("no remove required ; file '%s' not present\n", filename );
    }
}

/****************************************************************************
 *
 * Name       : daemon_make_dir
 *
 * Description: Create the specified full path directory.
 *
 *****************************************************************************/

void daemon_make_dir ( const char * dir )
{
    struct stat st ;
    MEMSET_ZERO(st);
    if (stat(dir, &st) == -1)
    {
        if ( mkdir (dir, 0755) != 0 )
        {
            elog ("failed to create directory '%s' ; (%d:%m)\n", dir, errno );
        }
    }
}

/****************************************************************************
 *
 * Name       : daemon_rename_file
 *
 * Description: Rename the specified file from old to new name.
 *
 * Warnings   : If the target rename filename exists then it is removed first.
 * 
 *****************************************************************************/

void daemon_rename_file ( const char * path, const char * old_filename, const char * new_filename )
{
    if ( path )
    {
        string _old = path ;
        _old.append("/");
        _old.append(old_filename);
        if ( daemon_is_file_present ( _old.data() ) == true )
        {
            string _new = path ;
            _new.append("/");
            _new.append(new_filename);

            if ( daemon_is_file_present ( _new.data() ) == true )
            {
                dlog ("removing '%s' prior to rename\n", _new.c_str());
                daemon_remove_file ( _new.data() );
            }
            if ( rename ( _old.data(), _new.data()) == 0)
	        {
		        dlog ("file rename : %s -> %s\n", old_filename, new_filename);
	        }
	        else
	        {
		        elog ( "Error renaming %s -> %s (%d:%m)\n", old_filename, new_filename, errno );
            }
        }
        else
        {
            elog ("rename failed ; '%s' not found\n", _old.c_str());
        }
	}
}

void daemon_remove_pidfile ( void )
{
    const char* cmd_str = "rm -f ";
    size_t cmd_len = sizeof(cmd_str);
    char str [MAX_FILENAME_LEN+cmd_len] ;
    snprintf (str, sizeof(str), "rm -f %s", pid_filename);
    int rc = system (str);
    if ( rc )
    {
       wlog ("system command to remove %s returned %d\n", &pid_filename[0], rc );
    }
}

int daemon_create_pidfile ( void )
{
    FILE * pid_file_stream  = (FILE *)(NULL);

    snprintf ( &pid_filename[0], MAX_FILENAME_LEN, "/var/run/%s.pid",
                program_invocation_short_name );

    /* Create PID file */
    pid_t mypid = getpid();

    /* Check for another instance running by trying to open in read only mode.
     * If it opens then there "may" be another process running.
     * If it opens then read the pid and see if that pID exists.
     * If it does then this is a duplicate process so exit. */
    pid_file_stream = fopen (&pid_filename[0], "r" ) ;
    if ( pid_file_stream )
    {
        int   rc  = 0 ;
        pid_t pid = 0 ;
        char buffer[BUFFER];
        if ( fgets ( buffer, BUFFER, pid_file_stream) != NULL )
        {
            rc = sscanf ( &buffer[0], "%d",  &pid );
            if ( rc == 1 )
            {
                rc = kill ( pid, 0 );
                if ( rc == 0 )
                {
                    syslog ( LOG_INFO, "Refusing to start duplicate process (pid:%d)\n", pid);
                    fclose (pid_file_stream);
                    daemon_files_fini ();
                    exit (0);
                }
            }
        }
    }

    if ( pid_file_stream )
        fclose (pid_file_stream);

    /* if we got here then we are ok to run */
    pid_file_stream = fopen (pid_filename, "w" ) ;

    if ( pid_file_stream == NULL )
    {
        syslog ( LOG_ERR, "Failed to open or create %s\n", pid_filename);
        return ( FAIL_PID_OPEN );
    }
    else if (!fprintf (pid_file_stream,"%d", mypid))
    {
        syslog ( LOG_ERR, "Failed to write pid file for %s\n", pid_filename );
        fclose ( pid_file_stream ) ;
        return ( FAIL_FILE_WRITE ) ;
    }
    fflush (pid_file_stream);
    fclose (pid_file_stream);
    return (PASS);
}

string daemon_read_file ( const char * filename )
{
    string data = "" ;
    int lines = 0 ;
    if ( daemon_is_file_present ( filename ) == true )
    {
        FILE * _stream = fopen ( filename, "r" );
        if ( _stream )
        {
            char buffer   [BUFFER];
            MEMSET_ZERO(buffer);
            while ( fgets (buffer, BUFFER, _stream) )
            {
                data.append(buffer);
                if ( ++lines > 100 )
                {
                    wlog ("%s file to big ; aborting\n", filename );
                    break ;
                }
                MEMSET_ZERO(buffer);
            }
            fclose (_stream);
        }
    }
    return data ;
}

/***************************************************************************
 *
 * Don't return from this call until the specified file exists
 * or the timeout is exceeded. In the timeout case a FAIL_TIMEOUT
 * is returned.
 *
 * Warning: Timeout timer is not yet implemented
 *
 ***************************************************************************/
int daemon_wait_for_file ( const char * filename, int timeout )
{
    UNUSED(timeout) ;
    if ( filename )
    {
        int count = 0 ;
        for ( ; ; )
        {
            daemon_signal_hdlr ();
            if ( daemon_is_file_present( filename ))
                return PASS ;
            sleep (MTC_SECS_2);
            wlog_throttled ( count, 60, "Waiting for %s\n", filename);
        }
    }
    return (FAIL_TIMEOUT);
}

int daemon_files_init ( void )
{
    /* Create PID file */
    pid_t mypid = getpid();
    ilog   ("--- Daemon Start-Up --- pid:%d\n", mypid);
    daemon_init_fit ();
    return ( PASS );
}

/*****************************************************************************************
 *
 * #######  ###  #######      #####   #     #  ######   ######   #######  ######   #######
 * #         #      #        #     #  #     #  #     #  #     #  #     #  #     #     #
 * #         #      #        #        #     #  #     #  #     #  #     #  #     #     #
 * #####     #      #         #####   #     #  ######   ######   #     #  ######      #
 * #         #      #              #  #     #  #        #        #     #  #   #       #
 * #         #      #        #     #  #     #  #        #        #     #  #    #      #
 * #        ###     #         #####    #####   #        #        #######  #     #     #
 *
 *****************************************************************************************/

#ifdef WANT_FIT_TESTING
static daemon_fit_type __fit_info ;
#endif

#ifdef WANT_HIT_THROTTLE
int throttle_max   ;
int throttle_count ;
#endif

void daemon_print_fit ( void )
{
#ifdef WANT_FIT_TESTING
    if ( __fit_info.code )
    {
        if ( !daemon_get_cfg_ptr()->testmode )
        {
            slog ("%s FIT Mode Not Enabled ; need to enable testmode\n",
                      __fit_info.host.c_str());

            daemon_init_fit ( );
        }
        else if ( __fit_info.hits == 0 )
        {
            daemon_init_fit ();
        }
        else
        {
            slog ("%s FIT Add:%d '%s' with '%s' %d times\n",
                   __fit_info.host.empty() ? "any" : __fit_info.host.c_str(),
                   __fit_info.code,
                   __fit_info.name.empty() ? "n/a" : __fit_info.name.c_str(),
                   __fit_info.data.empty() ? "n/a" : __fit_info.data.c_str(),
                   __fit_info.hits);
        }
    }
#endif
}

void daemon_hits_fit ( int hits )
{
#ifdef WANT_FIT_TESTING
    __fit_info.hits += hits ;
    daemon_print_fit ();
#else
    UNUSED(hits);
#endif
}

void daemon_init_fit ( void )
{
#ifdef WANT_FIT_TESTING
    ilog ("FIT Inactive\n");
    __fit_info.code = 0 ;
    __fit_info.host.clear() ;
    __fit_info.name.clear() ;
    __fit_info.proc.clear() ;
    __fit_info.data.clear() ;
    __fit_info.hits = 0 ;

    /* Indicate that the fit is unloaded */
    if ( daemon_is_file_present ( "/var/run/fit") )
        daemon_log ( "/var/run/fit/fitdone", "done" );

#endif
}

/* called by processes that don't match the fit proc name */
void daemon_ignore_fit ( void )
{
#ifdef WANT_FIT_TESTING
    __fit_info.code = 0 ;
    __fit_info.host.clear() ;
    __fit_info.name.clear() ;
    __fit_info.proc.clear() ;
    __fit_info.data.clear() ;
    __fit_info.hits = 0 ;

#endif
}

void daemon_handle_hit ( void )
{
#ifdef WANT_FIT_TESTING
    if ( __fit_info.code )
    {
        --__fit_info.hits ;

#ifdef WANT_HIT_THROTTLE
        ilog_throttled (throttle_count, throttle_max, "%s FIT Hit:%d '%s' with '%s' %d times remaining\n",
               __fit_info.host.empty() ? "any" : __fit_info.host.c_str(),
               __fit_info.code,
               __fit_info.name.empty() ? "n/a" : __fit_info.name.c_str(),
               __fit_info.data.empty() ? "n/a" : __fit_info.data.c_str(),
               __fit_info.hits);
#else
        slog ("%s FIT Hit:%d '%s' with '%s' %d times remaining\n",
               __fit_info.host.empty() ? "any" : __fit_info.host.c_str(),
               __fit_info.code,
               __fit_info.name.empty() ? "n/a" : __fit_info.name.c_str(),
               __fit_info.data.empty() ? "n/a" : __fit_info.data.c_str(),
               __fit_info.hits);
#endif
        if ( __fit_info.hits == 0 )
            daemon_ignore_fit ();
        else
            daemon_log_value ( "/var/run/fit/fithits", "hits =", __fit_info.hits );
    }
#endif
}


/* Read the fit file if its present and load its fit info */
int  daemon_load_fit ( void )
{
#ifdef WANT_FIT_TESTING
    if ( __fit_info.code )
    {
        return (PASS);
    }

    if ( daemon_is_file_present ( FIT__INIT_FILE ) == true )
    {
        daemon_rename_file ( FIT__INIT_FILEPATH, FIT__INIT_FILENAME, FIT__INIT_FILENAME_RENAMED );
        daemon_init_fit ();
    }

    if ( daemon_is_file_present ( FIT__INFO_FILE ) == false ) return (PASS);

    bool correct_process = false ;
    bool valid_code = false ;

    FILE * _stream = fopen ( FIT__INFO_FILE, "r" );
    if ( _stream )
    {
        char buffer   [BUFFER];
        memset (buffer, 0 , BUFFER );
        while ( fgets (buffer, BUFFER, _stream) )
        {
            if (( correct_process == false ) &&
                ( strstr ( buffer, "proc=" )))
            {
                char _str[BUFFER];
                memset ( _str, 0 , BUFFER );
                int chars = 0 ;
                if ( ( chars = sscanf ( &buffer[0], "proc=%1023s", &_str[0] ) ) == 1 )
                {
                    string proc = program_invocation_short_name ;
                    if ( proc.compare(_str) == 0 )
                    {
                        __fit_info.proc = proc ;
                        correct_process = true ;
                    }
                    else
                    {
                        break ;
                    }
                }
                else
                {
                    daemon_ignore_fit ();
                    // ilog ("%d [%s:%s]\n", chars, program_invocation_short_name , _str);
                }
            }
            else if ( strstr ( buffer, "code=" ) )
            {
                if ( sscanf ( &buffer[0], "code=%d", &__fit_info.code ) == 1 )
                {
                    valid_code = true ;
                }
            }
            else if ( strstr ( buffer, "hits=" ) )
            {
                if ( sscanf ( &buffer[0], "hits=%d", &__fit_info.hits ) == 1 )
                {
#ifdef WANT_HIT_THROTTLE
                    throttle_count =  0 ;

                    if ( __fit_info.hits > 10 )
                        throttle_max = 10 ;
                    else
                        throttle_max = 1  ;
#else
                    ;
#endif
                }
            }
            else if ( strstr ( buffer, "host=" ) )
            {
                char _str1[MAX_CHARS_HOSTNAME+1];
                char _str2[MAX_CHARS_HOSTNAME+1];
                char _str3[MAX_CHARS_HOSTNAME+1];
                char _str4[MAX_CHARS_HOSTNAME+1];
                memset ( _str1, 0 , MAX_CHARS_HOSTNAME+1 );
                memset ( _str2, 0 , MAX_CHARS_HOSTNAME+1 );
                memset ( _str3, 0 , MAX_CHARS_HOSTNAME+1 );
                memset ( _str4, 0 , MAX_CHARS_HOSTNAME+1 );
                int rc = sscanf ( &buffer[0], "host=%32s %32s %32s %32s", &_str1[0], &_str2[0], &_str3[0], &_str4[0] );
                if ( rc )
                {
                    __fit_info.host = _str1 ;
                    if ( rc > 1 )
                    {
                        __fit_info.host.append(" ");
                        __fit_info.host.append(_str2 );
                    }
                    if ( rc > 2 )
                    {
                        __fit_info.host.append(" ");
                        __fit_info.host.append(_str3);
                    }
                    if ( rc > 3 )
                    {
                        __fit_info.host.append(" ");
                        __fit_info.host.append(_str4);
                    }
                }
            }
            else if ( strstr ( buffer, "name=" ) )
            {
                char _str1[60];
                char _str2[60];
                char _str3[60];
                memset ( _str1, 0 , 60 );
                memset ( _str2, 0 , 60 );
                memset ( _str3, 0 , 60 );
                int rc = sscanf ( &buffer[0], "name=%59s %59s %59s", &_str1[0], &_str2[0], &_str3[0] );
                if ( rc )
                {
                    __fit_info.name = _str1 ;
                    if ( rc > 1 )
                    {
                        __fit_info.name.append(" ");
                        __fit_info.name.append(_str2 );
                    }
                    if ( rc > 2 )
                    {
                        __fit_info.name.append(" ");
                        __fit_info.name.append(_str3);
                    }
                }
            }
            else if ( strstr ( buffer, "data=" ) )
            {
                char _str[BUFFER];
                memset ( _str, 0 , BUFFER );
                if ( sscanf ( &buffer[0], "data=%1023s", &_str[0] ) == 1 )
                {
                    __fit_info.data = _str ;
                }
            }
            memset (buffer, 0 , BUFFER );
        } /* end while */
        fclose(_stream);

    }
    if ( !correct_process )
    {
        return (PASS);
    }

    daemon_print_fit ();

    if ( !valid_code )
    {
        elog ( "FIT file parse error (%d)\n", valid_code );
        daemon_init_fit ();
    }
    else
    {
        daemon_log_value   ( "/var/run/fit/fithits", "hits =", __fit_info.hits );
        daemon_remove_file ( "/var/run/fit/fitdone" );
    }
    daemon_rename_file ( FIT__INFO_FILEPATH, FIT__INFO_FILENAME, FIT__INFO_FILENAME_RENAMED );

#endif
    return (PASS);
}

/* Check for fault insertion */
bool daemon_want_fit ( int code )
{
#ifdef WANT_FIT_TESTING
    if ( __fit_info.hits > 0)
    {
        if ( daemon_get_cfg_ptr()->testmode )
        {
            if ( __fit_info.code )
            {
                //ilog ("hits %d code %d:%d\n", __fit_info.hits, __fit_info.code, code);
                if ( __fit_info.code == code )
                {
                    daemon_handle_hit ();
                    return (true) ;
                }
            }
        }
    }
#else
    UNUSED(code);
#endif
   return (false);
}

bool daemon_want_fit ( int code, string host )
{
#ifdef WANT_FIT_TESTING
    if ( __fit_info.hits > 0 )
    {
        if ( daemon_get_cfg_ptr()->testmode )
        {
            if ( __fit_info.code == code )
            {
                //ilog ("%s:%s hits %d code %d:%d\n", host.c_str(), __fit_info.host.c_str() , __fit_info.hits, __fit_info.code, code);
                if (( __fit_info.code == code ) &&
                    ( __fit_info.host.find(host) != std::string::npos ))
                {
                    daemon_handle_hit ();
                    return (true) ;
                }
            }
        }
    }
#else
    UNUSED(code);
    UNUSED(host);
#endif
    return (false);
}

bool daemon_want_fit ( int code, string host, string name )
{
#ifdef WANT_FIT_TESTING
    if ( __fit_info.hits > 0 )
    {
        if ( daemon_get_cfg_ptr()->testmode )
        {
            if ( __fit_info.code == code )
            {
                //ilog ("%s:%s <%s:%s> hits %d code %d:%d\n", host.c_str(), __fit_info.host.c_str(), name.c_str(), __fit_info.name.c_str(), __fit_info.hits, __fit_info.code, code);
                if (( __fit_info.code == code ) &&
                    (( __fit_info.host.find(host) != std::string::npos ) || ( host == "any" )) &&
                     ( __fit_info.name.find(name) != std::string::npos ))
                {
                    daemon_handle_hit ();
                    return (true) ;
                }
            }
        }
    }
#else
    UNUSED(code);
    UNUSED(host);
    UNUSED(name);
#endif
    return (false);
}

bool daemon_want_fit ( int code, string host, string name, string & data )
{
#ifdef WANT_FIT_TESTING
    if ( __fit_info.hits > 0 )
    {
        if ( daemon_get_cfg_ptr()->testmode )
        {
            if ( __fit_info.code == code )
            {
                //ilog ("%s:%s <%s:%s> hits %d code %d:%d\n", host.c_str(), __fit_info.host.c_str(), name.c_str(), __fit_info.name.c_str(), __fit_info.hits, __fit_info.code, code);
                if (( __fit_info.code == code ) &&
                    (( __fit_info.host.find(host) != std::string::npos ) || ( host == "any" )) &&
                     ( __fit_info.name.find(name) != std::string::npos))
                {
                    data = __fit_info.data ;
                    daemon_handle_hit ();
                    return (true) ;
                }
            }
        }
    }
#else
    UNUSED(code);
    UNUSED(host);
    UNUSED(name);
    UNUSED(data);
#endif
    return (false);
}