kome::core::IniFile Class Reference

ini file management class More...

#include <IniFile.h>

Classes
class	IniFileManager
	IniFile object management class. More...

Public Member Functions
const char *	getFilePath ()
	gets file path More...
bool	decryptPassword (const char *pcPassword, char *pcDecrypt, const size_t szDecrypt)
	decrypt password More...
bool	encryptPassword (const char *pcPassword, char *pcEncrypt, const size_t szEncrypt)
	decrypt password More...
void	setString (const char *section, const char *key, const char *value)
	sets string value More...
const char *	getString (const char *section, const char *key, const char *defaultValue)
	gets string value More...
void	setBool (const char *section, const char *key, const bool value)
	sets boolean value More...
bool	getBool (const char *section, const char *key, const bool defaultValue)
	gets boolean value More...
void	setInt (const char *section, const char *key, const int value)
	sets integer number value More...
int	getInt (const char *section, const char *key, const int defaultValue)
	get integer number value More...
void	setDouble (const char *section, const char *key, const double value)
	sets real number value More...
double	getDouble (const char *section, const char *key, const double defaultValue)
	gets real number value More...
void	deleteValue (const char *section, const char *key)
	deletes value More...
unsigned int	getNumberOfSections ()
	gets the number of sections More...
const char *	getSection (const unsigned int index)
	gets section More...
unsigned int	getNumberOfParameters (const char *section)
	gets the number of parameters specified section More...
const char *	getParameterName (const char *section, const unsigned int index)
	gets parameter name More...
const char *	getParameterValue (const char *section, const unsigned int index)
	gets parameter value More...
bool	load (const char *path)
	load the ini file More...
bool	save (const char *path=NULL)
	save the ini file More...

Static Public Member Functions
static IniFile *	loadIniFile (const char *path)
	loads ini file and gets IniFile object. More...
static IniFile *	getIniFile (const char *path)
	gets ini file object. If specified file is not opened, this method calls loadIniFile method. More...
static void	saveAllIniFiles ()
	save all ini files

Protected Member Functions
	IniFile ()
	constructor
virtual	~IniFile ()
	destructor
Properties *	getProperties (const char *section)
	gets properties object specified section More...

Protected Attributes
std::string	m_filePath
std::vector< std::string >	m_sections
std::map< std::string, Properties >	m_sectionMap

Detailed Description

ini file management class

Definition at line 30 of file IniFile.h.

Member Function Documentation

bool kome::core::IniFile::decryptPassword	(	const char *	pcPassword,
		char *	pcDecrypt,
		const size_t	szDecrypt
	)

decrypt password

Parameters

[in]	pcPassword	encrypted password string
[in]	pcDecrypt	decrypted password string
[in]	szDecrypt	size of decrypt string buffer

Returns

If it succeeded to decrypt passsword, this method returns true.

Definition at line 91 of file IniFile.cpp.

{
    if  ( (char *)NULL == pcPassword || (char *)NULL == pcDecrypt )
    {
        return  false;
    }

    std::string strVal = pcPassword;
    if  ( -1 != strVal.find( "@@@" ) )
    {
        try
        {
            byte    bKey[AES::DEFAULT_KEYLENGTH];   // ���ʌ�
            byte    bIv[AES::BLOCKSIZE];            // IV

            // �L�[��IV�ɓK���Ȓl�ݒ肵�܂�
            //   �Í����E�������ɓ����l��ݒ肷��K�v������܂�
            memset( (void *)bKey, 0x01, AES::DEFAULT_KEYLENGTH );
            memset( (void *)bIv, 0x01, AES::BLOCKSIZE );

            //------------------------------------------------
            //                ������
            //------------------------------------------------
            int i = strVal.find_last_of( "@@@" );
            strVal = strVal.substr( i + 1,  ( strVal.length( ) - i ) );

            std::string strInputDec;
            HexDecoder  insHexDecode( new StringSink( strInputDec ) );
            insHexDecode.Put( (BYTE*)( strVal.c_str( ) ), strVal.size( ) );
            insHexDecode.MessageEnd( );

            // �������I�u�W�F�N�g�쐬
            CTR_Mode<AES>::Decryption   insDecryption;
            insDecryption.SetKeyWithIV( bKey, sizeof( bKey ), bIv );    // �L�[��IV�𕜍����I�u�W�F�N�g�ɐݒ�

            // �ϊ��t�B���^���쐬���A�Í����ƕ�����̏o�͐�o�b�t�@��n��
            std::string strOutputDec;
            StreamTransformationFilter  insStfDec( insDecryption, new StringSink( strOutputDec ) );
            insStfDec.Put( (BYTE*)strInputDec.c_str( ), strInputDec.size( ) );
            insStfDec.MessageEnd( );

            strVal = strOutputDec;
        }
        catch ( ... )
        {
        }
    }

    memset( (void *)pcDecrypt, 0x00, szDecrypt );
    if  ( szDecrypt <= strVal.length( ) )
    {
        return  false;
    }
    memcpy( (void *)pcDecrypt, (char *)strVal.c_str( ), strVal.length( ) );

    return  true;
}

void kome::core::IniFile::deleteValue	(	const char *	section,
		const char *	key
	)

deletes value

Parameters

[in]	section	parameter section
[in]	key	parameter key

Definition at line 277 of file IniFile.cpp.

                                                                {
    // create string object
    std::string sec = NVL( section, "" );

    // check the map
    if( m_sectionMap.find( sec ) == m_sectionMap.end() ) {
        return;
    }

    // delete
    m_sectionMap[ sec ].deleteParameter( key );
    if( m_sectionMap[ sec ].getNumberOfProperties() == 0 ) {
        m_sectionMap.erase( sec );

        for( std::vector< std::string >::iterator it = m_sections.begin(); it != m_sections.end(); it++ )
        {
            if (!it->compare( sec ))
            {
                m_sections.erase(it);
                break;
            }
        }
    }
}

bool kome::core::IniFile::encryptPassword	(	const char *	pcPassword,
		char *	pcEncrypt,
		const size_t	szEncrypt
	)

decrypt password

Parameters

[in]	pcPassword	plain text password string
[in]	pcEncrypt	encrypted password string
[in]	szEncrypt	size of encrypt string buffer

Returns

If it succeeded to encrypt passsword, this method returns true.

Definition at line 149 of file IniFile.cpp.

{
    if  ( (char *)NULL == pcPassword || (char *)NULL == pcEncrypt )
    {
        return  false;
    }

    std::string strVal = pcPassword;
    try
    {
        byte    bKey[AES::DEFAULT_KEYLENGTH];   // ���ʌ�
        byte    bIv[AES::BLOCKSIZE];            // IV

        // �L�[��IV�ɓK���Ȓl�ݒ肵�܂�
        //   �Í����E�������ɓ����l��ݒ肷��K�v������܂�
        memset( (void *)bKey, 0x01, AES::DEFAULT_KEYLENGTH );
        memset( (void *)bIv, 0x01, AES::BLOCKSIZE );

        //------------------------------------------------
        //                ����
        //------------------------------------------------
        // �Í����I�u�W�F�N�g�쐬
        CTR_Mode<AES>::Encryption   insEncryptor;
        insEncryptor.SetKeyWithIV( bKey, sizeof( bKey ), bIv );     // �L�[��IV���Í����I�u�W�F�N�g�ɐݒ�

        // �ϊ��t�B���^���쐬���A�����ƕϊ���̏o�͐�o�b�t�@��n���܂�
        std::string strInputEnc = strVal;
        std::string strOutputEnc;
        StreamTransformationFilter insStfEnc( insEncryptor, new StringSink( strOutputEnc ) );
        insStfEnc.Put( (BYTE*)( strInputEnc.c_str( ) ), strInputEnc.size( ) );
        insStfEnc.MessageEnd( );

        // �Í������ꂽ���m��Hex�`���ɕϊ����܂�
        std::string strHex;
        HexEncoder  insHexEncode( new StringSink( strHex ) );
        insHexEncode.Put( (BYTE*)( strOutputEnc.c_str( ) ), strOutputEnc.size( ) );
        insHexEncode.MessageEnd( );

        strVal.clear( );
        strVal.append( "@@@" );
        strVal.append( strHex );
    }
    catch ( ... )
    {
    }

    memset( (void *)pcEncrypt, 0x00, szEncrypt );
    if  ( szEncrypt <= strVal.length( ) )
    {
        return  false;
    }
    memcpy( (void *)pcEncrypt, (char *)strVal.c_str( ), strVal.length( ) );

    return  true;

}

bool kome::core::IniFile::getBool	(	const char *	section,
		const char *	key,
		const bool	defaultValue
	)

gets boolean value

Parameters

[in]	section	parameter section
[in]	key	parameter key
[in]	defaultValue	default value

Returns

parameter value. (If there is not specified parameter or value is not integer number, this method returns defaultValue.)

Definition at line 221 of file IniFile.cpp.

                                                                                     {
    // create string object
    std::string sec = NVL( section, "" );

    // search section
    if( m_sectionMap.find( sec ) == m_sectionMap.end() ) {
        return defaultValue;
    }

    // get parameter
    return m_sectionMap[ sec ].getBoolValue( key, defaultValue );
}

double kome::core::IniFile::getDouble	(	const char *	section,
		const char *	key,
		const double	defaultValue
	)

gets real number value

Parameters

[in]	section	parameter section
[in]	key	parameter key
[in]	defaultValue	default value

Returns

parameter value. (If there is not specified parameter or value is not real number, this method returns defaultValue.)

Definition at line 319 of file IniFile.cpp.

                                                                                           {
    // create string object
    std::string sec = NVL( section, "" );

    // search section
    if( m_sectionMap.find( sec ) == m_sectionMap.end() ) {
        return defaultValue;
    }

    // get parameter
    return m_sectionMap[ sec ].getDoubleValue( key, defaultValue );
}

const char * kome::core::IniFile::getFilePath

(

)

gets file path

Returns

file path

Definition at line 59 of file IniFile.cpp.

                                 {
    return m_filePath.c_str();
}

static IniFile * kome::core::IniFile::getIniFile ( const char *  path )

static

gets ini file object. If specified file is not opened, this method calls loadIniFile method.

Parameters

[in]

path

ini file path.

Returns

ini file information object.

Definition at line 579 of file IniFile.cpp.

                                               {
    // manager
    IniFileManager& mgr = IniFileManager::getInstance();

    // absolutepath
    std::string p = absolutepath( path );

    // get object from map
    IniFile* iniFile = mgr.getFile( p.c_str() );
    if( iniFile == NULL ) {
        if( fileexists( p.c_str() ) ) { // load file
            iniFile = loadIniFile( p.c_str() );
        }
        else {  // create new file
            iniFile = new IniFile();
            iniFile->m_filePath = p;
            mgr.setFile( iniFile );
        }
    }

    return iniFile;
}

Here is the call graph for this function:

int kome::core::IniFile::getInt	(	const char *	section,
		const char *	key,
		const int	defaultValue
	)

get integer number value

Parameters

[in]	section	parameter section
[in]	key	parameter key
[in]	defaultValue	default value

Returns

parameter value. (If there is not specified parameter or value is not integer number, this method returns defaultValue.)

Definition at line 249 of file IniFile.cpp.

                                                                                  {
    // create string object
    std::string sec = NVL( section, "" );

    // search section
    if( m_sectionMap.find( sec ) == m_sectionMap.end() ) {
        return defaultValue;
    }

    // get parameter
    return m_sectionMap[ sec ].getIntValue( key, defaultValue );
}

unsigned int kome::core::IniFile::getNumberOfParameters

(

const char *

section

)

gets the number of parameters specified section

Parameters

[in]

section

parameter section

Returns

the number of parameters specified section

Definition at line 348 of file IniFile.cpp.

                                                                 {
    // get properties
    Properties* properties = getProperties( section );

    // get size
    if( properties == NULL ) {
        return 0;
    }
    return properties->getNumberOfProperties();
}

Here is the call graph for this function:

unsigned int kome::core::IniFile::getNumberOfSections

(

)

gets the number of sections

Returns

the number of sections

Definition at line 333 of file IniFile.cpp.

                                          {
    return m_sections.size();
}

const char * kome::core::IniFile::getParameterName	(	const char *	section,
		const unsigned int	index
	)

gets parameter name

Parameters

[in]	section	parameter section
[in]	index	parameter index

Returns

parameter name specified section and index (If the section or the index is illegal, this method returns NULL.)

Definition at line 360 of file IniFile.cpp.

                                                                                     {
    // get properties
    Properties* properties = getProperties( section );

    // get parameter name
    if( properties == NULL ) {
        return NULL;
    }
    return properties->getKey( index );
}

Here is the call graph for this function:

const char * kome::core::IniFile::getParameterValue	(	const char *	section,
		const unsigned int	index
	)

gets parameter value

Parameters

[in]	section	parameter section
[in]	index	parameter index

Returns

parameter value specified section and index (If the section or the index is illegal, this method returns NULL.)

Definition at line 372 of file IniFile.cpp.

                                                                                      {
    // get properties
    Properties* properties = getProperties( section );

    // get parameter name
    if( properties == NULL ) {
        return NULL;
    }
    return properties->getValue( index );
}

Here is the call graph for this function:

Properties * kome::core::IniFile::getProperties ( const char *  section )

protected

gets properties object specified section

Parameters

[in]

section

section

Returns

properties object specified section. (If there isn't section specified name, this method returns NULL.)

Definition at line 303 of file IniFile.cpp.

                                                        {
    // check the parameter
    if( section == NULL  ) {
        return NULL;
    }

    // check the map
    if( m_sectionMap.find( section ) == m_sectionMap.end() ) {
        return NULL;
    }

    // get properties
    return &m_sectionMap[ section ];
}

const char * kome::core::IniFile::getSection

(

const unsigned int

index

)

gets section

Parameters

[in]

index

section index

Returns

section specified index (If the index is illegal, this method returns NULL.)

Definition at line 338 of file IniFile.cpp.

                                                          {
    // check the parameter
    if( index >= m_sections.size() ) {
        return NULL;
    }

    return m_sections[ index ].c_str();
}

const char * kome::core::IniFile::getString	(	const char *	section,
		const char *	key,
		const char *	defaultValue
	)

gets string value

Parameters

[in]	section	parameter section
[in]	key	parameter key
[in]	defaultValue	default value

Returns

parameter value. (If there is not specified parameter, this method returns defaultValue.)

Definition at line 78 of file IniFile.cpp.

                                                                                               {
    // create string object
    std::string sec = NVL( section, "" );

    // search section
    if( m_sectionMap.find( sec ) == m_sectionMap.end() ) {
        return defaultValue;
    }

    // get parameter
    return m_sectionMap[ sec ].getStringValue( key, defaultValue );
}

bool kome::core::IniFile::load

(

const char *

path

)

load the ini file

Parameters

[in]

path

ini file path

Returns

If it succeeded to load the file, this method returns true.

Definition at line 384 of file IniFile.cpp.

                                     {
    // log
    LOG_INFO( FMT( "Loading INI file... [%s]", NVL( path, "" ) ) );

    // check file
    if( !checkfile( path ) ) {
        LOG_WARN( FMT( "Illegal path [%s]", NVL( path, "" ) ) );
        return false;
    }

    // clear
    m_sections.clear();
    m_sectionMap.clear();
    m_filePath.clear();

    // open
    std::string p = absolutepath( path );
    FILE* fp = fileopen( p.c_str(), "r" );
    if( fp == NULL ) {
        LOG_WARN( FMT( "Failed to open the file. [%s]", NVL( path, "" ) ) );
        return false;
    }
    m_filePath = p;

    // read
    char line[ INI_LINE_BUFFER_SIZE ];
    Properties* params = NULL;
    std::string section;

    while( fgets( line, INI_LINE_BUFFER_SIZE, fp ) != NULL ) {  // read line
        // read line
        line[ INI_LINE_BUFFER_SIZE - 1 ] = '\0';

        if( line[ 0 ] == '#' || line[ 0 ] == ';' ) {    // comment
            continue;
        }

        // trim
        std::string l = trimstring( line );
        memcpy( line, l.c_str(), l.length() );
        line[ l.length() ] = '\0';
        
        if( line[ 0 ] == '[' ) {    // section
            char* c = strstr( line, "]" );
            if( c != NULL ) {
                *c = '\0';
            }
            c = strstr( line, "[" );
            if( c != NULL ) {
                *c = '\0';
            }

            section = std::string( line + 1 );
            params = NULL;
        }
        else {
            char* key = line;
            char* value = strstr( line, "=" );
            if( value != NULL ) {
                *value = '\0';
                value++;

                if( params == NULL ) {
                    params = &m_sectionMap[ section ];
                    m_sections.push_back( section );
                }
                // >>>>>>   @Date:2014/02/07    <Add>   A.Ozaki
                //
                // �p�X���[�h�̕���������
                //   �A�v���P�[�V�������́A���������ꂽ���e��ۗL����悤�ɕύX
                //   �������Ώۂ́A
                //     key:"PASSWORD"/"COMMON_DB_PASSWORD"
                //     value:�擪�R������"@@@"�Ŏn�܂�
                //
                std::string strKey = tolowercase( key );
                std::string strValue = value;
                if  ( ( 0 == strKey.compare( "password" ) ||
                    0 == strKey.compare( "common_db_password" ) )
                    && -1 != strValue.find( "@@@" ) )
                {
                    char    cBuff[256];

                    if  ( true == decryptPassword( strValue.c_str( ), cBuff, sizeof( cBuff ) ) )
                    {
                        strValue = cBuff;
                    }
                }
//              params->setValue( key, value );
                params->setValue( key, strValue.c_str( ) );
                //
                // <<<<<<   @Date:2014/02/07    <Add>   A.Ozaki
            }
        }
    }

    // close
    fclose( fp );

    return true;
}

Here is the call graph for this function:

static IniFile * kome::core::IniFile::loadIniFile ( const char *  path )

static

loads ini file and gets IniFile object.

Parameters

[in]

path

ini file path

Returns

ini file information object.

Definition at line 555 of file IniFile.cpp.

                                                { 
    // manager
    IniFileManager& mgr = IniFileManager::getInstance();

    // absolute path
    std::string p = absolutepath( path );

    // get object from map
    IniFile* iniFile = mgr.getFile( path );
    if( iniFile == NULL ) { // create new object
        iniFile = new IniFile();
        if( iniFile->load( p.c_str() ) ) {  // success
            mgr.setFile( iniFile );
        }
        else{   // fail
            delete iniFile;
            iniFile = NULL;
        }
    }

    return iniFile;
}

Here is the call graph for this function:

bool kome::core::IniFile::save

(

const char *

path = NULL

)

save the ini file

Parameters

[in]

path

ini file path. (If path is NULL, it is saved to the same place as the loaded file.)

Returns

If it succeeded to save the file, this method returns true.

Definition at line 486 of file IniFile.cpp.

                                     {
    // absolutepath 
    std::string p = absolutepath( NVL( path, m_filePath.c_str() ) );

    // log
    LOG_INFO( FMT( "Saving INI file... [%s]", p.c_str() ) );

    // file open
    FILE* fp = fileopen( p.c_str(), "w" );
    if( fp == NULL ) {
        LOG_ERROR(
            FMT(
                "Failed to open the file. [%s]",
                p.c_str()
            )
        );
        return false;
    }

    // write to file
    for( unsigned int i = 0; i < m_sections.size(); i++ ) {
        // write section
        std::string section = m_sections[ i ];

        if( !section.empty() ) {
            fprintf( fp, "[%s]\n", section.c_str() );
        }

        // write Properties
        Properties* params = &m_sectionMap[ section ];
        for( unsigned int i = 0; i < params->getNumberOfProperties(); i++ ) {
            // >>>>>>   @Date:2014/02/07    <Add>   A.Ozaki
            //
            // �p�X���[�h�̈Í�������
            //   ini�t�@�C���ɏo�͂���Ƃ��ɈÍ������܂�
            //   �Í����Ώۂ́A
            //     key:"PASSWORD"/"COMMON_DB_PASSWORD"
            //     value:"none"�ȊO
            //
            std::string strKey = tolowercase( params->getKey( i ) );
            std::string strValue = params->getValue( i );
            if  ( ( 0 == strKey.compare( "password" ) || 0 == strKey.compare( "common_db_password" ) )
                && ( 0 != strValue.compare( "none" ) ) )
            {
                char    cBuff[256];

                if  ( true == encryptPassword( params->getValue( i ), cBuff, sizeof( cBuff ) ) )
                {
                    strValue = cBuff;
                }
            }
//          fprintf( fp, "%s=%s\n", params->getKey( i ), params->getValue( i ) );
            fprintf( fp, "%s=%s\n", params->getKey( i ), strValue.c_str( ) );

            //
            // <<<<<<   @Date:2014/02/07    <Add>   A.Ozaki
        }

        fprintf( fp, "\n" );
    }

    // close
    fflush( fp );
    fclose( fp );

    return true;
}

Here is the call graph for this function:

void kome::core::IniFile::setBool	(	const char *	section,
		const char *	key,
		const bool	value
	)

sets boolean value

Parameters

[in]	section	parameter section
[in]	key	parameter key
[in]	value	parameter value

Definition at line 207 of file IniFile.cpp.

                                                                              {
    // create string object
    std::string sec = NVL( section, "" );

    // set section
    if( m_sectionMap.find( sec ) == m_sectionMap.end() ) {
        m_sections.push_back( sec );
    }

    // set value
    m_sectionMap[ sec ].setValue( key, ( value ? "true" : "false" ) );
}

void kome::core::IniFile::setDouble	(	const char *	section,
		const char *	key,
		const double	value
	)

sets real number value

Parameters

[in]	section	parameter section
[in]	key	parameter key
[in]	value	parameter value

Definition at line 263 of file IniFile.cpp.

                                                                                  {
    // create string object
    std::string sec = NVL( section, "" );

    // set section
    if( m_sectionMap.find( sec ) == m_sectionMap.end() ) {
        m_sections.push_back( sec );
    }

    // set value
    m_sectionMap[ sec ].setValue( key, FMT( "%f", value ).c_str() );
}

void kome::core::IniFile::setInt	(	const char *	section,
		const char *	key,
		const int	value
	)

sets integer number value

Parameters

[in]	section	parameter section
[in]	key	parameter key
[in]	value	parameter value

Definition at line 235 of file IniFile.cpp.

                                                                            {
    // create string object
    std::string sec = NVL( section, "" );

    // set section
    if( m_sectionMap.find( sec ) == m_sectionMap.end() ) {
        m_sections.push_back( sec );
    }

    // set value
    m_sectionMap[ sec ].setValue( key, FMT( "%d", value ).c_str() );
}

void kome::core::IniFile::setString	(	const char *	section,
		const char *	key,
		const char *	value
	)

sets string value

Parameters

[in]	section	parameter section
[in]	key	parameter key
[in]	value	parameter value

Definition at line 64 of file IniFile.cpp.

                                                                                 {
    // create string object
    std::string sec = NVL( section, "" );

    // set section
    if( m_sectionMap.find( sec ) == m_sectionMap.end() ) {
        m_sections.push_back( sec );
    }

    // set value
    m_sectionMap[ sec ].setValue( key, value );
}

Member Data Documentation

std::string kome::core::IniFile::m_filePath

protected

file path

Definition at line 54 of file IniFile.h.

std::map< std::string, Properties > kome::core::IniFile::m_sectionMap

protected

section Properties map (section -> Properties)

Definition at line 60 of file IniFile.h.

std::vector< std::string > kome::core::IniFile::m_sections

protected

the array of section

Definition at line 57 of file IniFile.h.

---

The documentation for this class was generated from the following files:

• CoreToolkits/IniFile.h
• CoreToolkits/IniFile.cpp