CUserManager Class Reference

#include <UserManager.h>

Public Member Functions
	CUserManager ()
	~CUserManager ()
int	Initialize (UserManagerConfig *Config)
int	Logon (char *UserName, char *Password, RioUser **User)
int	CreateUser (char *UserName, char *Password)
	Nova funcao para criar um novo usuario.
int	RemoveUser (char *UserName)
	Nova funcao para remover um dos usuarios do RIO.
int	ChangePassword (char *UserName, char *Password)
	Nova funcao para alterar a senha de um dos usuarios do RIO.
int	GetUserList (vector< string > &UserList)
	Nova funcao para obter a lista com todos os usuarios.
Data Fields
ofstream	m_log
Private Attributes
char *	m_UserRoot
char *	m_FileRoot
CMutex *	m_Mutex
bool	m_initialized
char	m_PasswdFileName [MaxPathSize]

---

Detailed Description

Definition at line 41 of file UserManager.h.

---

Constructor & Destructor Documentation

CUserManager::CUserManager

(

)

Definition at line 43 of file UserManager.cpp.

{
    m_Mutex       = new CMutex;
    m_FileRoot    = NULL;
    m_UserRoot    = NULL;
    m_initialized = false;
    // m_log does not need to be initialized
}

CUserManager::~CUserManager

(

)

Definition at line 53 of file UserManager.cpp.

{
    //if( m_PassFile != NULL )
    //    fclose( m_PassFile );
    if( m_FileRoot != NULL )    
        delete [] m_FileRoot;
    m_FileRoot = 0;
    if( m_UserRoot != NULL )    
        delete [] m_UserRoot;
    m_UserRoot = 0;
    delete m_Mutex;
    if( m_log.is_open() )
        m_log.close();
}

---

Member Function Documentation

int CUserManager::ChangePassword	(	char *	UserName,
		char *	Password
	)

Nova funcao para alterar a senha de um dos usuarios do RIO.

Parameters:

	UserName	ponteiro para o nome do usuario.
	Password	pontrito para a senha do usuario.

Returns:

S_OK se o a senha fou alterada com sucesso ou o codigo de erro caso nao tenha sido possivel alterar a senha do usuario.

Definition at line 778 of file UserManager.cpp.

{
    char localUserName[ MaxPathSize ];
    char localPassword[ MaxPathSize ];
    int TotalFields;

    // Variavel com o descritor do arquivo a ser aberto.
    FILE *PassFile;

    if( ( strlen( UserName ) == 0 ) && ( strcmp( UserName, "guest" ) == 0 ) )
    {
        if( m_log.is_open() )
            m_log << " Invalid User " << UserName << endl;

        return ERROR_USERMANAGER + ERROR_INVALID_USER;
    }

    // Espera tenta obter o mutex para acessar o arquivo de modo exclusivo.
    m_Mutex->Wait();

    // Tenta abrir o arquivo para a leitura e escrita.
    PassFile = fopen( m_PasswdFileName, "r+" );
    if( PassFile != NULL )
    {
        while( ( TotalFields = fscanf( PassFile, "%s %s",
                                       localUserName, localPassword ) )
                                       != EOF )
        {
            if( ( TotalFields == 2) &&
                ( strcmp( localUserName, UserName ) == 0  ) )
                break;
            else if( TotalFields == 1 )
            {
                // A linha nao possui a senha. Note que se TotalFiels
                // for 0, isso provavelmente indica uma linha vazia.
                if( m_log.is_open() )
                    m_log << "User " << localUserName << " in file "
                          <<  m_PasswdFileName << " ignored because "
                          << "does not have a password!"<< endl;

            }
        }

        // Verifica se ocorreu algum erro ao acessar o arquivo (o scanf
        // pode ser abortado por fim do arquivo ou por um erro ao
        // acessar o arquivo).
        if( errno != 0 )
        {
            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Se o usuario existir, entao devemos retornar um erro.
            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            // Eu acho que podemos gerar somente um aviso, pois e
            // possivel que tenhamos conseguido achar com sucesso o
            // usuario no arquivo.
            if( m_log.is_open() )
                m_log << "Error " << errno << " (" << strerror( errno )
                      << ") when reading password file "
                      <<  m_PasswdFileName << "!"<< endl;

            return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
        }

        // Verifica se nao achamos nenhum usuario.
        if( strcmp( localUserName, UserName ) != 0 )
        {
            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Se o usuario nao existir, entao devemos retornar um erro.
            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

           if( m_log.is_open() )
               m_log << " User " << UserName << "not found!" << endl;

           return ERROR_USERMANAGER + ERROR_INVALID_USER;
        }

        // Volta para a posicao do arquivo com o nome do usuario.
        //if( fseek( PassFile, PosLastLine, SEEK_SET ) < 0 )
        if( fseek( PassFile,
                   -( strlen( localUserName ) + strlen( localPassword ) + 1 ),
                   SEEK_CUR ) < 0 )
        {
            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            if( m_log.is_open() )
                m_log << "Invalid User/Password [Failed to seek in "
                      << m_PasswdFileName << " file (errno=" << errno
                      << ",strerr=" << strerror( errno ) << ")!]"
                      << endl;

            return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;

        }

        // Encripta a senha
        char *cryptPass;
        char salt[ 3 ];

        // Unshuffling password
        for( unsigned int i = 0; i < strlen( Password ); i++ )
            Password[ i ] = ( ( Password[ i ] & 0x0F ) << 4 ) |
                            ( ( Password[ i ] & 0xF0 ) >> 4 );

        salt[ 0 ] = localPassword[ 0 ];
        salt[ 1 ] = localPassword[ 1 ];
        salt[ 2 ] = 0;
        cryptPass = crypt( Password, salt );

        if( cryptPass == NULL )
        {
            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Se o usuario existir, entao devemos retornar um erro.
            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            if( m_log.is_open() )
                m_log << "Invalid User/Password [Failed to encrypt "
                      << "user " << UserName << " password!]" << endl;

            return ERROR_USERMANAGER + ERROR_MEMORY;
        }

        // Altera a senha do usuario.
        if( fprintf( PassFile, "%s %s\n", UserName, cryptPass ) < 0 )
        {
            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            if( m_log.is_open() )
                m_log << "Invalid User/Password [Failed to save new "
                      << "user " << UserName << "password in "
                      << m_PasswdFileName << " file (errno=" << errno
                      << ",strerr=" << strerror( errno ) << ")!]"
                      << endl;

            return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
        }

        // Fecha o arquivo aberto.
        fclose( PassFile );

        // Libera o mutex para acessar o arquivo de modo exclusivo.
        m_Mutex->Release();
    }
    else
    {
        // Libera o mutex para acessar o arquivo de modo exclusivo.
        m_Mutex->Release();

        if( m_log.is_open() )
            m_log << "Invalid User/Password [Failed to open "
                  << m_PasswdFileName << " file (errno=" << errno
                  << ",strerr=" << strerror( errno ) << ")!]" << endl;

        return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
    }

    return S_OK;
}

int CUserManager::CreateUser	(	char *	UserName,
		char *	Password
	)

Nova funcao para criar um novo usuario.

Parameters:

	UserName	ponteiro para o nome do usuario.
	Password	pontrito para a senha do usuario.

Returns:

S_OK se o usuario foi criado com sucesso ou o codigo de erro caso o usuario nao tenha sido criado com sucesso.

Definition at line 337 of file UserManager.cpp.

{
    char localUserName[ MaxPathSize ];
    char localPassword[ MaxPathSize ];
    int  result;
    struct stat mystat;
    char name [2*MaxPathSize+1];
    int TotalFields;

    // Variavel com o descritor do arquivo a ser aberto.
    FILE *PassFile;

    if( ( strlen( UserName ) == 0 ) || ( strcmp( UserName, "guest") == 0 ) )
    {
        if( m_log.is_open() )
            m_log << " Invalid User " << name << endl;
        return ERROR_USERMANAGER + ERROR_INVALID_USER;
    }

    strcpy( name, m_FileRoot );
    strcat( name, "/" );
    strcat( name, UserName );

    // Verifica se o diretorio do usuario ja existe. Se nao existir, vamos
    // cria-lo. Se ele existir e for um arquivo, damos um erro.
    result = stat( name, &mystat );

    if( ( result == 0 ) && ( !S_ISDIR( mystat.st_mode ) ) )
    {
        // Existe o /<UserName>, mas ele e um arquivo e nao um diretorio.
        if( m_log.is_open() )
            m_log << "Invalid User/Password [" << name << " is not a directory!"
                  << "]" << endl;

        return ERROR_USERMANAGER + ERROR_INVALID_USER_DIRECTORY;
    }
    else if( result < 0 )
    {
        // Nao existe o /<UserName>. Entao, vamos criar este diretorio.
        if( mkdir( name, 0700 ) != 0 )
        {
            if( m_log.is_open() )
                m_log << "Invalid User/Password [error " << errno << " ("
                      << strerror( errno ) << ") when trying to  create "
                      << "directory "<< name << "!]" << endl;

            return ERROR_USERMANAGER + ERROR_INVALID_USER_DIRECTORY;

        }
    }

    // Tenta obter o mutex para acessar o arquivo de modo exclusivo.
    m_Mutex->Wait();

    // Tenta abrir o arquivo para a leitura e escrita.
    PassFile = fopen( m_PasswdFileName, "r+" );
    if( PassFile != NULL )
    {
        while( ( TotalFields = fscanf( PassFile, "%s %s",
                                       localUserName, localPassword ) )
                                       != EOF )
        {
            if( ( TotalFields == 2) &&
                ( strcmp( localUserName, UserName ) == 0  ) )
            {
                // Fecha o arquivo aberto.
                fclose( PassFile );

                // Se o usuario existir, entao devemos retornar um erro.
                // Libera o mutex para acessar o arquivo de modo exclusivo.
                m_Mutex->Release();

                if( m_log.is_open() )
                    m_log << "Invalid User/Password [User " << UserName
                          << " already exists!]"<< endl;

                return ERROR_USERMANAGER + ERROR_USER_EXISTS;
            }
            else if( TotalFields == 1 )
            {
                // A linha nao possui a senha. Note que se TotalFiels
                // for 0, isso provavelmente indica uma linha vazia.
                if( m_log.is_open() )
                    m_log << "User " << localUserName << " in file "
                          <<  m_PasswdFileName << " ignored because "
                          << "does not have a password!"<< endl;

            }
        }

        // Verifica se ocorreu algum erro ao acessar o arquivo (o scanf
        // pode ser abortado por fim do arquivo ou por um erro ao
        // acessar o arquivo).
        if( errno != 0 )
        {
            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Se o usuario existir, entao devemos retornar um erro.
            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            // Eu acho que podemos gerar somente um aviso, pois e
            // possivel que tenhamos conseguido achar com sucesso o
            // usuario no arquivo.
            if( m_log.is_open() )
                m_log << "Error " << errno << " (" << strerror( errno )
                      << ") when reading password file "
                      <<  m_PasswdFileName << "!"<< endl;

            return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
        }

        // Salta para o final do arquivo.
        if( fseek( PassFile, 0, SEEK_END ) < 0 )
        {
            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Se o usuario existir, entao devemos retornar um erro.
            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            if( m_log.is_open() )
                m_log << "Invalid User/Password [Failed to seek in "
                      << m_PasswdFileName << " file (errno=" << errno
                      << ",strerr=" << strerror( errno ) << ")!]"
                      << endl;

            return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;

        }

        // Encripta a senha
        char *cryptPass;
        char salt[ 3 ];

        // Unshuffling password
        for( unsigned int i = 0; i < strlen( Password ); i++ )
            Password[ i ] = ( ( Password[ i ] & 0x0F) << 4 ) |
                            ( ( Password[ i ] & 0xF0) >> 4 );

        salt[ 0 ] = localPassword[ 0 ];
        salt[ 1 ] = localPassword[ 1 ];
        salt[ 2 ] = 0;
        cryptPass = crypt( Password, salt );

        if( cryptPass == NULL )
        {
            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Se o usuario existir, entao devemos retornar um erro.
            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            if( m_log.is_open() )
                m_log << "Invalid User/Password [Failed to encrypt "
                      << "user " << UserName << " password!]" << endl;

            return ERROR_USERMANAGER + ERROR_MEMORY;
        }

        // Adiciona o novo usuario ao final do arquivo (como a senha ja vem
        // encriptada, somente precisamos fazer a inversoes dos 4 bits
        // inferiores com os 4 bits superiores, como e feito na funcao
        // login). Note que, como varremos todo o arquivo, ja estamos no
        // final dele.
        if( fprintf( PassFile, "%s %s\n", UserName, cryptPass ) < 0 )
        {
            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Se o usuario existir, entao devemos retornar um erro.
            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            if( m_log.is_open() )
                m_log << "Invalid User/Password [Failed to save user/password  "
                      << "in " << m_PasswdFileName << " file (errno=" << errno
                      << ",strerr=" << strerror( errno ) << ")!]" << endl;

            return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
        }

        // Fecha o arquivo aberto.
        fclose( PassFile );

        // Libera o mutex para acessar o arquivo de modo exclusivo.
        m_Mutex->Release();
    }
    else
    {
        // Libera o mutex para acessar o arquivo de modo exclusivo.
        m_Mutex->Release();

        if( m_log.is_open() )
            m_log << "Invalid User/Password [Failed to open "
                  << m_PasswdFileName << " file (errno=" << errno << ",strerr="
                  << strerror( errno ) << ")!]" << endl;

        return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
    }

    return S_OK;
}

int CUserManager::GetUserList

(

vector< string > &

UserList

)

Nova funcao para obter a lista com todos os usuarios.

Parameters:

USerList

vetor de strings (STL) no qual a lista de usuarios sera armazenada.

Returns:

S_OK caso a lista tenha sido gerada com sucesso ou o codigo de erro caso nao tenha sido possivel gerar a lista.

Definition at line 953 of file UserManager.cpp.

{
    char localUserName[ MaxPathSize ];
    char localPassword[ MaxPathSize ];
    int TotalFields;

    // Variavel com o descritor temporario do arquivo. Somente abrimos o arquivo
    // aqui para verificar se ele existe.
    FILE *PassFile;

    // Limpa a lista de usuarios.
    UserList.clear();

    try
    {
        UserList.push_back( string( "guest" ) );
    }
    catch( bad_alloc &ba )
    {
        if( m_log.is_open() )
            m_log << "Error bac_alloc (" << ba.what()
                  << ") when adding user guest to userlist!" << endl;

        // Limpa o vetor.
        UserList.clear();

        return ERROR_USERMANAGER + ERROR_MEMORY;

    }

    // Espera tenta obter o mutex para acessar o arquivo de modo exclusivo.
    m_Mutex->Wait();

    // Tenta abrir o arquivo para a leitura e escrita.
    PassFile = fopen( m_PasswdFileName, "r+" );
    if( PassFile != NULL )
    {
        while( ( TotalFields = fscanf( PassFile, "%s %s",
                                       localUserName, localPassword ) )
                                       != EOF )
        {
            if( TotalFields == 2)
            {
                try
                {
                    UserList.push_back( string( localUserName ) );
                }
                catch( bad_alloc &ba )
                {
                    if( m_log.is_open() )
                        m_log << "Error bac_alloc (" << ba.what()
                              << ") when adding a user " << localUserName
                              << " to userlist!" << endl;

                    // Fecha o arquivo aberto.
                    fclose( PassFile );

                    // Se o usuario existir, entao devemos retornar um erro.
                    // Libera o mutex para acessar o arquivo de modo exclusivo.
                    m_Mutex->Release();

                    // Limpa o vetor.
                    UserList.clear();

                    return ERROR_USERMANAGER + ERROR_MEMORY;

                }
            }
            else if( TotalFields == 1 )
            {
                // A linha nao possui a senha. Note que se TotalFiels
                // for 0, isso provavelmente indica uma linha vazia.
                if( m_log.is_open() )
                    m_log << "User " << localUserName << " in file "
                          <<  m_PasswdFileName << " ignored because "
                          << "does not have a password!"<< endl;

            }
        }

        // Fecha o arquivo aberto.
        fclose( PassFile );

        // Se o usuario existir, entao devemos retornar um erro.
        // Libera o mutex para acessar o arquivo de modo exclusivo.
        m_Mutex->Release();
    }
    else
    {
        // Libera o mutex para acessar o arquivo de modo exclusivo.
        m_Mutex->Release();

        if( m_log.is_open() )
            m_log << "Invalid User/Password [Failed to open "
                  << m_PasswdFileName << " file (errno=" << errno
                  << ",strerr=" << strerror( errno ) << ")!]" << endl;

        // Limpa o vetor.
        UserList.clear();

        return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
    }

    return S_OK;
}

int CUserManager::Initialize

(

UserManagerConfig *

Config

)

Definition at line 73 of file UserManager.cpp.

{
    // Variavel com o descritor temporario do arquivo. Somente abrimos o arquivo
    // aqui para verificar se ele existe.
    FILE *PassFile;

    if( Config->GenerateLogs )
    {
        // Variavel usada para compor o nome do arquivo com o log.
        char LogFileName[ MaxPathSize ];
        // Compoe o nome do arquivo com o log.
        strcpy( LogFileName, Config->LogsDirectory );
        strcat( LogFileName, LOGFILE );
        m_log.open( LogFileName );
    }

    // Check if not initialized yet
    if( m_initialized )
    {
        if( m_log.is_open() )
            m_log << "Initialize(): Tried to initialize component "
                  << "already initialized" << endl;

        return ERROR_USERMANAGER + ERROR_INITIALIZED;
    }

    // check if mutex to control table access was successfully created
    if( !m_Mutex->IsOpen() )
    {
        if( m_log.is_open() )
            m_log << "Initialize(): Failed to create mutex" << endl;

        return ERROR_USERMANAGER + ERROR_CREATE_MUTEX;
    }

    // Alteracao para ler o arquivo de senhas de um diretorio qualquer,
    // diferente de onde o servidor esta. 
    // Compoe o nome do arquivo com as senhas.
    strcpy( m_PasswdFileName, Config->ConfigsDirectory );
    strcat( m_PasswdFileName, PASSWDFILE );

    // Vou deixar isso somente para verificar se o arquivo existe e pode ser
    // lido ou escrito.
    PassFile = fopen( m_PasswdFileName, "r+" );
    if( PassFile == NULL )
    {
        RioErr << "Initialize(): Failed to check password file" << endl;
        return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
    }

    // Fecha o arquivo aberto.
    fclose( PassFile );

    m_FileRoot = new char[strlen( Config->FileRoot ) + 1];
    strcpy( m_FileRoot, Config->FileRoot );

    m_UserRoot = new char[strlen( Config->UserRoot ) + 1];
    strcpy( m_UserRoot, Config->UserRoot );

    m_initialized = true;

    return S_OK;
}

int CUserManager::Logon	(	char *	UserName,
		char *	Password,
		RioUser **	User
	)

Definition at line 138 of file UserManager.cpp.

{
    char localUserName[ MaxPathSize ];
    char localPassword[ MaxPathSize ];
    int  result;
    struct stat mystat;
    char name [2*MaxPathSize+1];
    int TotalFields;

    // Variavel com o descritor do arquivo a ser aberto.
    FILE *PassFile;

    // be sure he doesn't have anyone
    *User = 0;

    RioUser *newuser = new RioUser( this );
    if( newuser == 0 )
    {
        if( m_log.is_open() )
            m_log << " Error when allocating RioUser! " << UserName << endl;

        return ERROR_USERMANAGER + ERROR_MEMORY;
    }

    if( strlen( UserName ) == 0 )
    {
        if( m_log.is_open() )
            m_log << " Invalid User " << UserName << endl;

        return ERROR_USERMANAGER + ERROR_INVALID_USER;
    }

    if( strcmp( UserName, "guest" ) != 0 )
    {
        // Espera tenta obter o mutex para acessar o arquivo de modo
        // exclusivo.
        m_Mutex->Wait();

        // Tenta abrir o arquivo para a leitura.
        PassFile = fopen( m_PasswdFileName, "r" );
        if( PassFile != NULL )
        {
            while( ( TotalFields = fscanf( PassFile, "%s %s",
                                           localUserName, localPassword ) )
                                           != EOF )
            {
                if( ( TotalFields == 2) &&
                    ( strcmp( localUserName, UserName ) == 0  ) )
                    break;
                else if( TotalFields == 1 )
                {
                    // A linha nao possui a senha. Note que se TotalFiels
                    // for 0, isso provavelmente indica uma linha vazia.
                    if( m_log.is_open() )
                        m_log << "User " << localUserName << " in file "
                              <<  m_PasswdFileName << " ignored because "
                              << "does not have a password!"<< endl;

                }
            }

            // Verifica se ocorreu algum erro ao acessar o arquivo (o scanf
            // pode ser abortado por fim do arquivo ou por um erro ao
            // acessar o arquivo).
            if( errno != 0 )
            {
                // Eu acho que podemos gerar somente um aviso, pois e
                // possivel que tenhamos conseguido achar com sucesso o
                // usuario no arquivo.
                if( m_log.is_open() )
                    m_log << "Error " << errno << " (" << strerror( errno )
                          << ") when reading password file "
                          <<  m_PasswdFileName << "!"<< endl;
            }

            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            if( strcmp( localUserName, UserName ) == 0 )
            {
                char *cryptPass;
                char salt[ 3 ];

                // Unshuffling password
                for( unsigned int i = 0; i < strlen( Password ); i++ )
                    Password[ i ] = ( (Password[ i ] & 0x0F) << 4 ) |
                                    ( (Password[ i ] & 0xF0) >> 4 );

                salt[ 0 ] = localPassword[ 0 ];
                salt[ 1 ] = localPassword[ 1 ];
                salt[ 2 ] = 0;
                cryptPass = crypt( Password, salt );

                if( cryptPass == NULL )
                {
                    if( m_log.is_open() )
                        m_log << "Invalid User/Password [Failed to encrypt "
                              << "user " << UserName << " password!]"
                              << endl;

                    return ERROR_USERMANAGER + ERROR_MEMORY;
                }

                if( strcmp( localPassword, cryptPass ) != 0 )
                {
                    if( m_log.is_open() )
                        m_log << "Invalid User/Password " << name << endl;

                    return ERROR_USERMANAGER + ERROR_INVALID_USER;
                }
            }
            else
            {
                if( m_log.is_open() )
                    m_log << "Invalid User/Password " << name << endl;

                return ERROR_USERMANAGER + ERROR_INVALID_USER;
            }
        }
        else
        {
            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            if( m_log.is_open() )
                m_log << "Invalid User/Password [Failed to open "
                      << m_PasswdFileName << " file (errno=" << errno
                      << ",strerr=" << strerror( errno ) << ")!]" << endl;

            return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
        }
    }

    // Verifica se o diretorio do usuario existe
    strcpy( name, m_FileRoot );
    strcat( name, "/" );
    strcat( name, UserName );

    result = stat( name, &mystat );

    if( ( result == 0 ) && ( !S_ISDIR( mystat.st_mode ) ) )
    {
        if( m_log.is_open() )
            m_log << "Invalid User/Password [" << name << " is not a directory!"
                  << "]" << endl;

        return ERROR_USERMANAGER + ERROR_INVALID_USER_DIRECTORY;
    }
    else if( result != 0 )
    {
        if( m_log.is_open() )
            m_log << "Invalid User/Password [stat for file " << name
                  << " returned error " << errno << " (" << strerror( errno )
                  << ")!]" << endl;

        return ERROR_USERMANAGER + ERROR_INVALID_USER_DIRECTORY;
    }

    newuser->user_home = new char[strlen( UserName ) + 1];
    if( newuser->user_home == 0 )
    {
        delete newuser;
        if( m_log.is_open() )
            m_log << " Error when allocating home user string path! "
                  << UserName << endl;

        return ERROR_USERMANAGER + ERROR_MEMORY;
    }

    newuser->user = new char[strlen( UserName ) + 1];
    if( newuser->user == 0 )
    {
        delete[] newuser->user_home;
        delete newuser;
        if( m_log.is_open() )
            m_log << " Error when allocating user string! "
                  << UserName << endl;

        return ERROR_USERMANAGER + ERROR_MEMORY;
    }

    strcpy( newuser->user_home, UserName );
    strcpy( newuser->user, UserName );

    #ifdef RIO_DEBUG2
    if( m_log.is_open() )
        m_log << "User " << newuser->user_home << " log on." << endl;
    #endif

    // - permissions/capabilities
    *User = newuser;

    return S_OK;
}

int CUserManager::RemoveUser

(

char *

UserName

)

Nova funcao para remover um dos usuarios do RIO.

Parameters:

UserName

ponteiro para o nome do usuario.

Returns:

S_OK se o usuario foi removido com sucesso ou o codigo de erro caso nao tenha sido possivel remover o usuario.

Definition at line 545 of file UserManager.cpp.

{
    char localUserName[ MaxPathSize ];
    char localPassword[ MaxPathSize ];
    int TotalFields;
    // Armazena o nome do arquivo temporario.
    char NewFileName[ MaxPathSize ];

    // Variavel com o descritor do arquivo a ser aberto.
    FILE *PassFile;
    FILE *NewPassFile;

    if( ( strlen( UserName ) == 0 ) && ( strcmp( UserName, "guest" ) == 0 ) )
    {
        if( m_log.is_open() )
            m_log << " Invalid User " << UserName << endl;

        return ERROR_USERMANAGER + ERROR_INVALID_USER;
    }

    // Define o nome do novo arquivo (fiz isso para evitar dependencia do /tmp).
    strcpy( NewFileName, m_PasswdFileName );
    strcat( NewFileName, "." );
    strcat( NewFileName, "new" );

    // Espera tenta obter o mutex para acessar o arquivo de modo exclusivo.
    m_Mutex->Wait();

    // Tenta abrir o arquivo para a leitura.
    PassFile = fopen( m_PasswdFileName, "r" );
    if( PassFile != NULL )
    {
        while( ( TotalFields = fscanf( PassFile, "%s %s",
                                       localUserName, localPassword ) )
                                       != EOF )
        {
            if( ( TotalFields == 2) &&
                ( strcmp( localUserName, UserName ) == 0  ) )
                break;
            else if( TotalFields == 1 )
            {
                // A linha nao possui a senha. Note que se TotalFiels
                // for 0, isso provavelmente indica uma linha vazia.
                if( m_log.is_open() )
                    m_log << "User " << localUserName << " in file "
                          <<  m_PasswdFileName << " ignored because "
                          << "does not have a password!"<< endl;

            }
        }

        // Verifica se ocorreu algum erro ao acessar o arquivo (o scanf
        // pode ser abortado por fim do arquivo ou por um erro ao
        // acessar o arquivo).
        if( errno != 0 )
        {
            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Se o usuario existir, entao devemos retornar um erro.
            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            // Eu acho que podemos gerar somente um aviso, pois e
            // possivel que tenhamos conseguido achar com sucesso o
            // usuario no arquivo.
            if( m_log.is_open() )
                m_log << "Error " << errno << " (" << strerror( errno )
                      << ") when reading password file "
                      <<  m_PasswdFileName << "!"<< endl;

            return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
        }

        // Verifica se nao achamos nenhum usuario.
        if( strcmp( localUserName, UserName ) != 0 )
        {
            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Se o usuario nao existir, entao devemos retornar um erro.
            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

           if( m_log.is_open() )
               m_log << " User " << UserName << "not found!" << endl;

           return ERROR_USERMANAGER + ERROR_INVALID_USER;
        }

        // Posiciona o arquivo de senhas na primeira linha (o inicio do
        // arquivo).
        if( fseek( PassFile, 0, SEEK_SET ) < 0 )
        {
            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Se o usuario existir, entao devemos retornar um erro.
            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            if( m_log.is_open() )
                m_log << "Invalid User/Password [Failed to seek in "
                      << m_PasswdFileName << " file (errno=" << errno
                      << ",strerr=" << strerror( errno ) << ")!]"
                      << endl;

            return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;

        }

        // Abre o novo arquivo para escrita, sobreescrevendo-o se ele ja
        // existir.
        NewPassFile = fopen( NewFileName, "w+" );
        if( NewPassFile == NULL )
        {
            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            if( m_log.is_open() )
                m_log << "Invalid User/Password [Failed to open "
                      << m_PasswdFileName << " file (errno=" << errno
                      << ",strerr=" << strerror( errno ) << ")!]" << endl;

            return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
        }

        // Copia todas as linhas do arquivo de senhas, com excecao da linha com
        // o usuario removido.
        while( ( TotalFields = fscanf( PassFile, "%s %s",
                                       localUserName, localPassword ) )
                                       != EOF )
        {
            if( ( TotalFields > 0 ) &&
                ( strcmp( localUserName, UserName ) != 0  ) )
            {
                 // Como nao e o usuario procurado, copiamos a linha para o novo
                 // arquivo (mesmo com um erro).

                 // Se nao existe a senha, a inicializamos com a string vazia.
                 if( TotalFields == 1 )
                     strcmp( localPassword, "" );

                 // Salva a linha no novo arquivo.
                 // Altera a senha do usuario.
                 if( fprintf( NewPassFile, "%s %s\n", localUserName,
                              localPassword ) < 0 )
                 {
                     // Fecha o arquivo aberto das novas senhas.
                     fclose( NewPassFile );

                     // Fecha o arquivo aberto.
                     fclose( PassFile );

                        // Libera o mutex para acessar o arquivo de modo exclusivo.
                    m_Mutex->Release();

                    if( m_log.is_open() )
                         m_log << "Invalid User/Password [Failed to save new "
                               << "user " << UserName << "password in "
                               << m_PasswdFileName << " file (errno=" << errno
                               << ",strerr=" << strerror( errno ) << ")!]"
                               << endl;

                     return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
                 }
            }
        }

        // Verifica se ocorreu algum erro ao acessar o arquivo (o scanf
        // pode ser abortado por fim do arquivo ou por um erro ao
        // acessar o arquivo).
        if( errno != 0 )
        {
            // Fecha o arquivo aberto das novas senhas.
            fclose( NewPassFile );

            // Fecha o arquivo aberto.
            fclose( PassFile );

            // Remove o arquivo criado.
            remove( NewFileName );

            // Se o usuario existir, entao devemos retornar um erro.
            // Libera o mutex para acessar o arquivo de modo exclusivo.
            m_Mutex->Release();

            // Eu acho que podemos gerar somente um aviso, pois e
            // possivel que tenhamos conseguido achar com sucesso o
            // usuario no arquivo.
            if( m_log.is_open() )
                m_log << "Error " << errno << " (" << strerror( errno )
                      << ") when reading password file "
                      <<  m_PasswdFileName << "!"<< endl;

            return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
        }

        // Fecha o arquivo aberto das novas senhas.
        fclose( NewPassFile );

        // Fecha o arquivo aberto.
        fclose( PassFile );

        // Remove o arquivo antigo.
        remove( m_PasswdFileName );

        // Move o arquivo novo criado para o arquivo original.
        rename( NewFileName, m_PasswdFileName );

        // Libera o mutex para acessar o arquivo de modo exclusivo.
        m_Mutex->Release();
    }
    else
    {
        // Libera o mutex para acessar o arquivo de modo exclusivo.
        m_Mutex->Release();

        if( m_log.is_open() )
            m_log << "Invalid User/Password [Failed to open "
                  << m_PasswdFileName << " file (errno=" << errno
                  << ",strerr=" << strerror( errno ) << ")!]" << endl;

        return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
    }

    return S_OK;
}

---

Field Documentation

char* CUserManager::m_FileRoot [private]

Definition at line 45 of file UserManager.h.

bool CUserManager::m_initialized [private]

Definition at line 49 of file UserManager.h.

ofstream CUserManager::m_log

Definition at line 102 of file UserManager.h.

CMutex* CUserManager::m_Mutex [private]

Definition at line 48 of file UserManager.h.

char CUserManager::m_PasswdFileName[MaxPathSize] [private]

Definition at line 52 of file UserManager.h.

char* CUserManager::m_UserRoot [private]

Definition at line 44 of file UserManager.h.

---

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

• UserManager.h
• UserManager.cpp