Narcissus/nwipe
2
0
Fork 0
mirror of https://github.com/martijnvanbrummelen/nwipe.git synced 2026-02-20 13:42:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
1220eca2efc53087a0b3bd93bde5fe41cfad8bc8
nwipe/src/conf.c
PartialVolume 499ad925ae Fix_segfault_on_first_run_as_non_root 
Incorrectly trying to close a uninitialised file
pointer stream when the file could not be opened.
2023-11-02 19:47:53 +00:00

621 lines
21 KiB
C
Raw Blame History

/*
* conf.c: functions that handle the nwipe.conf configuration file
* and the creation of the nwipe_customers.csv file. nwipe.conf uses
* libconfig format, while nwipe_customers.csv uses comma separted
* values. CSV is used so that the user can build there own customer
* listing using spreadsheets rather than enter all the customer
* information via the nwipe GUI interface.
*
* Copyright PartialVolume <https://github.com/PartialVolume>.
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License as published by the Free Software
* Foundation, version 2.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
*
*
*/
#include <libconfig.h>
#include <unistd.h>
#include <sys/types.h>
#include "nwipe.h"
#include "context.h"
#include "logging.h"
#include "method.h"
#include "options.h"
#include "conf.h"
config_t nwipe_cfg;
config_setting_t *nwipe_conf_setting, *group_organisation, *root, *group, *previous_group, *setting;
const char* nwipe_conf_str;
char nwipe_config_directory[] = "/etc/nwipe";
char nwipe_config_file[] = "/etc/nwipe/nwipe.conf";
char nwipe_customers_file[] = "/etc/nwipe/nwipe_customers.csv";
char nwipe_customers_file_backup[] = "/etc/nwipe/nwipe_customers.csv.backup";
char nwipe_customers_file_backup_tmp[] = "/etc/nwipe/nwipe_customers.csv.backup.tmp";
/*
* Checks for the existence of nwipe.conf and nwipe_customers.csv
* If either one does not exist, they are created and formatted
* with a basic configuration.
*/
int nwipe_conf_init()
{
FILE* fp_config;
FILE* fp_customers;
config_init( &nwipe_cfg );
char nwipe_customers_initial_content[] =
"\"Customer Name\";\"Contact Name\";\"Customer Address\";\"Contact Phone\"\n"
"\"Not Applicable\";\"Not Applicable\";\"Not Applicable\";\"Not Applicable\"\n";
/* Read /etc/nwipe/nwipe.conf. If there is an error, determine whether
* it's because it doesn't exist. If it doesn't exist create it and
* populate it with a basic structure.
*/
/* Does the /etc/nwipe/nwipe.conf file exist? If not, then create it */
if( access( nwipe_config_file, F_OK ) == 0 )
{
nwipe_log( NWIPE_LOG_INFO, "Nwipes config file %s exists", nwipe_config_file );
/* Read the nwipe.conf configuration file and report any errors */
nwipe_log( NWIPE_LOG_INFO, "Reading nwipe's config file %s", nwipe_config_file );
if( !config_read_file( &nwipe_cfg, nwipe_config_file ) )
{
nwipe_log( NWIPE_LOG_ERROR,
"Syntax error: %s:%d - %s\n",
config_error_file( &nwipe_cfg ),
config_error_line( &nwipe_cfg ),
config_error_text( &nwipe_cfg ) );
}
}
else
{
nwipe_log( NWIPE_LOG_WARNING, "%s does not exist", nwipe_config_file );
/* We assume the /etc/nwipe directory doesn't exist, so try to create it */
mkdir( nwipe_config_directory, 0755 );
/* create the nwipe.conf file */
if( !( fp_config = fopen( nwipe_config_file, "w" ) ) )
{
nwipe_log( NWIPE_LOG_ERROR, "Failed to create %s", nwipe_config_file );
}
else
{
nwipe_log( NWIPE_LOG_INFO, "Created %s", nwipe_config_file );
fclose( fp_config );
}
}
root = config_root_setting( &nwipe_cfg );
/**
* If they don't already exist, populate nwipe.conf with groups, settings and values.
* This will also fill in missing group or settings if they have been corrupted or
* accidently deleted by the user. It will also update an existing nwipe.conf
* file as new groups and settings are added to nwipe. If new settings are added
* to nwipes conf file they MUST appear below in this list of groups and settings.
*/
nwipe_conf_populate( "Organisation_Details.Business_Name", "Not Applicable (BN)" );
nwipe_conf_populate( "Organisation_Details.Business_Address", "Not Applicable (BA)" );
nwipe_conf_populate( "Organisation_Details.Contact_Name", "Not Applicable (BCN)" );
nwipe_conf_populate( "Organisation_Details.Contact_Phone", "Not Applicable (BCP)" );
nwipe_conf_populate( "Organisation_Details.Op_Tech_Name", "Not Applicable (OTN)" );
/**
* Add PDF Certificate/Report settings
*/
nwipe_conf_populate( "PDF_Certificate.PDF_Enable", "ENABLED" );
nwipe_conf_populate( "PDF_Certificate.PDF_Preview", "DISABLED" );
/**
* The currently selected customer that will be printed on the report
*/
nwipe_conf_populate( "Selected_Customer.Customer_Name", "Not Applicable (CN)" );
nwipe_conf_populate( "Selected_Customer.Customer_Address", "Not Applicable (CA)" );
nwipe_conf_populate( "Selected_Customer.Contact_Name", "Not Applicable (CCN)" );
nwipe_conf_populate( "Selected_Customer.Contact_Phone", "Not Applicable (CP)" );
/**
* Write out the new configuration.
*/
if( !config_write_file( &nwipe_cfg, nwipe_config_file ) )
{
nwipe_log( NWIPE_LOG_ERROR, "Failed to write nwipe config to %s", nwipe_config_file );
}
else
{
nwipe_log( NWIPE_LOG_INFO, "Sucessfully written nwipe config to %s", nwipe_config_file );
}
/* Read the nwipe.conf configuration file and report any errors */
if( !config_read_file( &nwipe_cfg, nwipe_config_file ) )
{
nwipe_log( NWIPE_LOG_ERROR,
"Syntax error: %s:%d - %s\n",
config_error_file( &nwipe_cfg ),
config_error_line( &nwipe_cfg ),
config_error_text( &nwipe_cfg ) );
}
/* -----------------------------------------------------------------------------
* Now check nwipe_customers.csv exists, if not create it with a basic structure
*/
if( access( nwipe_customers_file, F_OK ) == 0 )
{
nwipe_log( NWIPE_LOG_INFO, "Nwipes customer file %s exists", nwipe_customers_file );
}
else
{
nwipe_log( NWIPE_LOG_WARNING, "%s does not exist", nwipe_customers_file );
/* We assume the /etc/nwipe directory doesn't exist, so try to create it */
mkdir( nwipe_config_directory, 0755 );
/* create the nwipe_customers.csv file */
if( !( fp_customers = fopen( nwipe_customers_file, "w" ) ) )
{
nwipe_log( NWIPE_LOG_ERROR, "Failed to create %s", nwipe_customers_file );
}
else
{
nwipe_log( NWIPE_LOG_INFO, "Created %s", nwipe_customers_file );
/* Now populate the csv header and first entry, Lines 1 and 2 */
if( fwrite( nwipe_customers_initial_content, sizeof( nwipe_customers_initial_content ), 1, fp_customers )
== 1 )
{
nwipe_log( NWIPE_LOG_INFO, "Populated %s with basic config", nwipe_customers_file );
}
else
{
nwipe_log( NWIPE_LOG_ERROR, "Failed to write basic config to %s", nwipe_customers_file );
}
fclose( fp_customers );
}
}
return ( 0 );
}
void save_selected_customer( char** customer )
{
/* This function saves the user selected customer
* to nwipe's config file /etc/nwipe/nwipe.conf
* for later use by the PDF creation functions.
*/
int idx;
int field_count;
int field_idx;
char field_1[FIELD_LENGTH];
char field_2[FIELD_LENGTH];
char field_3[FIELD_LENGTH];
char field_4[FIELD_LENGTH];
/* zero the field strings */
for( idx = 0; idx < FIELD_LENGTH; idx++ )
field_1[idx] = 0;
for( idx = 0; idx < FIELD_LENGTH; idx++ )
field_2[idx] = 0;
for( idx = 0; idx < FIELD_LENGTH; idx++ )
field_3[idx] = 0;
for( idx = 0; idx < FIELD_LENGTH; idx++ )
field_4[idx] = 0;
/* Extract the field contents from the csv string
*/
idx = 0;
field_idx = 0;
field_count = 1;
while( *( *customer + idx ) != 0 && field_count < NUMBER_OF_FIELDS + 1 )
{
/* Start of a field? */
if( *( *customer + idx ) == '\"' )
{
idx++;
while( *( *customer + idx ) != '\"' && *( *customer + idx ) != 0 )
{
if( field_count == 1 && field_idx < ( FIELD_LENGTH - 1 ) )
{
field_1[field_idx++] = *( *customer + idx );
}
else
{
if( field_count == 2 && field_idx < ( FIELD_LENGTH - 1 ) )
{
field_2[field_idx++] = *( *customer + idx );
}
else
{
if( field_count == 3 && field_idx < ( FIELD_LENGTH - 1 ) )
{
field_3[field_idx++] = *( *customer + idx );
}
else
{
if( field_count == 4 && field_idx < ( FIELD_LENGTH - 1 ) )
{
field_4[field_idx++] = *( *customer + idx );
}
}
}
}
idx++;
}
if( *( *customer + idx ) == '\"' )
{
/* Makesure the field string is terminated */
switch( field_count )
{
case 1:
field_1[field_idx] = 0;
break;
case 2:
field_2[field_idx] = 0;
break;
case 3:
field_3[field_idx] = 0;
break;
case 4:
field_4[field_idx] = 0;
break;
}
field_count++;
field_idx = 0;
}
}
idx++;
}
/* All 4 fields present? */
if( field_count != NUMBER_OF_FIELDS + 1 )
{
nwipe_log( NWIPE_LOG_ERROR,
"Insuffient fields in customer entry, expected %i, actual(field_count) %i, idx=%i",
NUMBER_OF_FIELDS,
field_count,
idx );
return;
}
/* -------------------------------------------------------------
* Write the fields to nwipe's config file /etc/nwipe/nwipe.conf
*/
if( ( setting = config_lookup( &nwipe_cfg, "Selected_Customer.Customer_Name" ) ) )
{
config_setting_set_string( setting, field_1 );
}
else
{
nwipe_log( NWIPE_LOG_ERROR, "Can't find \"Selected Customers.Customer_Name\" in %s", nwipe_config_file );
}
if( ( setting = config_lookup( &nwipe_cfg, "Selected_Customer.Customer_Address" ) ) )
{
config_setting_set_string( setting, field_2 );
}
else
{
nwipe_log( NWIPE_LOG_ERROR, "Can't find \"Selected Customers.Customer_Address\" in %s", nwipe_config_file );
}
if( ( setting = config_lookup( &nwipe_cfg, "Selected_Customer.Contact_Name" ) ) )
{
config_setting_set_string( setting, field_3 );
}
else
{
nwipe_log( NWIPE_LOG_ERROR, "Can't find \"Selected Customers.Contact_Name\" in %s", nwipe_config_file );
}
if( ( setting = config_lookup( &nwipe_cfg, "Selected_Customer.Contact_Phone" ) ) )
{
config_setting_set_string( setting, field_4 );
}
else
{
nwipe_log( NWIPE_LOG_ERROR, "Can't find \"Selected Customers.Contact_Phone\" in %s", nwipe_config_file );
}
/* Write out the new configuration. */
if( !config_write_file( &nwipe_cfg, nwipe_config_file ) )
{
nwipe_log( NWIPE_LOG_ERROR, "Failed to write user selected customer to %s", nwipe_config_file );
}
else
{
nwipe_log( NWIPE_LOG_INFO, "Populated %s with user selected customer", nwipe_config_file );
}
}
int nwipe_conf_update_setting( char* group_name_setting_name, char* setting_value )
{
/* You would call this function of you wanted to update an existing setting in nwipe.conf, i.e
*
* nwipe_conf_update_setting( "PDF_Certificate.PDF_Enable", "ENABLED" )
*
* It is NOT used for creating a new group or setting name.
*/
/* -------------------------------------------------------------
* Write the field to nwipe's config file /etc/nwipe/nwipe.conf
*/
if( ( setting = config_lookup( &nwipe_cfg, group_name_setting_name ) ) )
{
config_setting_set_string( setting, setting_value );
}
else
{
nwipe_log(
NWIPE_LOG_ERROR, "Can't find group.setting_name %s in %s", group_name_setting_name, nwipe_config_file );
return 1;
}
/* Write the new configuration to nwipe.conf
*/
if( !config_write_file( &nwipe_cfg, nwipe_config_file ) )
{
nwipe_log( NWIPE_LOG_ERROR, "Failed to write %s to %s", group_name_setting_name, nwipe_config_file );
return 2;
}
else
{
nwipe_log( NWIPE_LOG_INFO,
"Updated %s with value %s in %s",
group_name_setting_name,
setting_value,
nwipe_config_file );
}
return 0;
} // end nwipe_conf_update_setting()
int nwipe_conf_read_setting( char* group_name_setting_name, const char** setting_value )
{
/* You would call this function if you wanted to read a settings value in nwipe.conf, i.e
*
* const char ** pReturnString;
* nwipe_conf_read_setting( "PDF_Certificate", "PDF_Enable", pReturnString );
*
*/
/* Separate group_name_setting_name i.e "PDF_Certificate.PDF_Enable" string
* into two separate strings by replacing the period with a NULL.
*/
int return_status;
int length = strlen( group_name_setting_name );
char* group_name = malloc( length );
char* setting_name = malloc( length );
int idx = 0;
while( group_name_setting_name[idx] != 0 && group_name_setting_name[idx] != '.' )
{
if( group_name_setting_name[idx] == '.' )
{
break;
}
idx++;
}
memcpy( group_name, group_name_setting_name, idx );
strcpy( setting_name, &group_name_setting_name[idx + 1] );
if( !( setting = config_lookup( &nwipe_cfg, group_name ) ) )
{
nwipe_log( NWIPE_LOG_ERROR, "Can't find group name %s.%s in %s", group_name, setting_name, nwipe_config_file );
return_status = -1;
}
else
{
/* Retrieve data from nwipe.conf */
if( CONFIG_TRUE == config_setting_lookup_string( setting, setting_name, setting_value ) )
{
return_status = 0; /* Success */
}
else
{
nwipe_log(
NWIPE_LOG_ERROR, "Can't find setting_name %s.%s in %s", group_name, setting_name, nwipe_config_file );
return_status = -2;
}
}
free( group_name );
free( setting_name );
return ( return_status );
} // end nwipe_conf_read_setting()
int nwipe_conf_populate( char* path, char* value )
{
/* This function will check that a path containing a group or multiple groups that lead to a setting all exist,
* if they don't exist, the group/s, settings and associated value are created.
*
* The path, a string consisting of one or more groups separted by a period symbol
* '.' with the final element in the path being the setting name. For instance the path might be
* PDF_Certificate.PDF_Enable. Where PDF_Certificate is the group name and PDF_Enable is the setting name.
* If one or other don't exist then they will be created.
*
* An arbitary depth of four groups are allowed for nwipe's configuration file, although we only currently, as of
* October 2023 use a depth of one group. The number of groups can be increased in the future if required by
* changing the definition MAX_GROUP_DEPTH in conf.h
*/
char* path_copy;
char* path_build;
char* group_start[MAX_GROUP_DEPTH + 2]; // A pointer to the start of each group string
char* setting_start;
int idx; // General index
int group_count; // Counts the number of groups in the path
/* Initialise the pointers */
memset( group_start, 0, MAX_GROUP_DEPTH + 2 );
memset( &setting_start, 0, 1 );
/* Allocate enough memory for a copy of the path and initialise to zero */
path_copy = calloc( strlen( path ) + 1, sizeof( char ) );
path_build = calloc( strlen( path ) + 1, sizeof( char ) );
/* Duplicate the path */
strcpy( path_copy, path );
/* Create individual strings by replacing the period '.' with NULL, counting the number of groups. */
idx = 0;
group_count = 0;
/* pointer to first group */
group_start[group_count] = path_copy;
while( *( path_copy + idx ) != 0 )
{
if( group_count > MAX_GROUP_DEPTH )
{
nwipe_log( NWIPE_LOG_ERROR,
"Too many groups in path, specified = %i, allowed = %i ",
group_count,
MAX_GROUP_DEPTH );
return 1;
}
if( *( path_copy + idx ) == '.' )
{
*( path_copy + idx ) = 0;
group_count++;
group_start[group_count] = path_copy + idx + 1;
}
idx++;
}
/* setting_start points to a string that represents the setting to be created */
setting_start = group_start[group_count];
/* Remove the last entry from group_start as that would be the setting and not a group */
group_start[group_count] = 0;
if( group_count == 0 )
{
nwipe_log( NWIPE_LOG_ERROR, "No groups specified in path, i.e. no period . separator found." );
return 2;
}
/**
* Now determine whether the group/s in the path exist, if not create them.
*/
idx = 0;
while( group_start[idx] != 0 )
{
strcat( path_build, group_start[idx] );
if( !( group = config_lookup( &nwipe_cfg, path_build ) ) )
{
if( idx == 0 )
{
group = config_setting_add( root, path_build, CONFIG_TYPE_GROUP );
previous_group = group;
}
else
{
group = config_setting_add( previous_group, group_start[idx], CONFIG_TYPE_GROUP );
previous_group = group;
}
if( group )
{
nwipe_log( NWIPE_LOG_INFO, "Created group [%s] in %s", path_build, nwipe_config_file );
}
else
{
nwipe_log( NWIPE_LOG_ERROR, "Failed to create group [%s] in %s", path_build, nwipe_config_file );
}
}
else
{
previous_group = group;
}
idx++;
if( group_start[idx] != 0 )
{
strcat( path_build, "." );
}
}
/**
* And finally determine whether the setting already exists, if not create it and assign the value to it
*/
/* Does the full path exist ? i.e AAA.BBB */
if( ( group = config_lookup( &nwipe_cfg, path_build ) ) )
{
/* Does the path and setting exist? AAA.BBB.SETTING_NAME */
if( !( setting = config_lookup( &nwipe_cfg, path ) ) )
{
/* Add the new SETTING_NAME */
if( ( setting = config_setting_add( group, setting_start, CONFIG_TYPE_STRING ) ) )
{
nwipe_log( NWIPE_LOG_INFO, "Created setting name %s in %s", path, nwipe_config_file );
}
else
{
nwipe_log(
NWIPE_LOG_ERROR, "Failed to create setting name %s in %s", setting_start, nwipe_config_file );
}
if( config_setting_set_string( setting, value ) == CONFIG_TRUE )
{
nwipe_log( NWIPE_LOG_INFO, "Set value for %s in %s to %s", path, nwipe_config_file, value );
}
else
{
nwipe_log( NWIPE_LOG_ERROR, "Failed to set value for %s in %s to %s", path, nwipe_config_file, value );
}
}
else
{
if( nwipe_options.verbose )
{
nwipe_log( NWIPE_LOG_INFO, "Setting already exists [%s] in %s", path, nwipe_config_file );
}
}
}
else
{
nwipe_log( NWIPE_LOG_INFO, "Couldn't find constructed path [%s] in %s", path_build, nwipe_config_file );
}
free( path_copy );
free( path_build );
return 0;
}
void nwipe_conf_close()
{
config_destroy( &nwipe_cfg );
}
Reference in New Issue View Git Blame Copy Permalink