CSessionManager Class Reference

#include <SessionManager.h>

Public Member Functions
	CSessionManager (CRioTCP *TCPconnection)
	~CSessionManager ()
HRESULT	Open (const char *Username, const char *Password, RioSessionId *Session)
HRESULT	Close (const RioSessionId Session)
HRESULT	OpenStream (const RioSessionId Session, const RioStreamTraffic *Traffic, RioStreamId *Stream, int *MaxRequests)
HRESULT	CreateObject (const RioSessionId Session, const char *ObjectName, const short Type)
HRESULT	DeleteObject (const RioSessionId Session, const char *ObjectName)
HRESULT	RenameObject (const RioSessionId Session, const char *CurrentName, const char *NewName)
HRESULT	GetBlockSize (const RioSessionId Session, unsigned int *BlockSize)
HRESULT	GetnStorageNodes (const RioSessionId Session, short *nStorageNodes)
HRESULT	FirstObject (RioSessionId Session, signed char *DirectoryName, ObjectHandle *Handle, int *IsDirectory, int BufferSize, signed char *ObjectName)
HRESULT	ChangeDir (RioSessionId Session, signed char *Dir)
HRESULT	GetCurrentDir (RioSessionId Session, int size, signed char *Dir)
HRESULT	GetObjectInfo (RioSessionId Session, const char *ObjectName, ObjectInfo *ObjectInfo)
HRESULT	GetNumberOfDisks (const RioSessionId Session, unsigned int *NumberOfDisks)
HRESULT	GetNumberOfStorageNodes (const RioSessionId Session, unsigned int *NumberOfStorageNodes)
HRESULT	GetStorageNodeInfo (RioSessionId Session, RioStorageNodeInfo *StorageNodeInfo, unsigned int StorageNodeIndex)
HRESULT	SendNATMappings (int *addrs, int *ports, unsigned int size)
HRESULT	GetMonitorTable (char *UserName, vector< ClientData > *client_data, vector< StorageData > *storage_data)
HRESULT	GetNumberOfActiveAndMaxSessions (const RioSessionId Session, unsigned int *NumberOfActiveSessions, unsigned int *NumberOfMaxSessions)
HRESULT	SaveMeasures (const RioSessionId Session)
HRESULT	GetRTT (struct timeval *RTT_openConnection, struct timeval *RTT_openStream)
HRESULT	GetAverageRTT (struct timeval *average_RTT)
HRESULT	GetServerAddress (struct sockaddr_in **ServerAddress, unsigned int *ServerAddressSize)
	Esta funcao faz uma chamada remota a um procedimento do Servidor RIO para obter todos os pares IP, porta para os quais precisaremos enviar periodicamente mensagens Fake para garantir que os enderecos associados ao mapeamento continuarao validos.
HRESULT	CheckStreamControl (bool *IsImplemented)
	Esta funcao faz uma chamada remota a um procedimento do Servidor RIO para verificar se a versao do servidor suporta o controle de fluxo.
HRESULT	SearchLogsRequest (unsigned int SearchType, time_t StartTime, time_t EndTime, int ServerIP, int ServerPort, int ClientIP, int ClientPort, int ReqId)
	Nova funcao para solicitar uma busca em um conjunto de logs de um dos servidores.
HRESULT	ResultFileBlockRequest (int ServerIP, int ServerPort, int ClientIP, int ClientPort, unsigned long long int ResultFileId, unsigned int Block, int ReqId)
	Nova funcao para ler um bloco do arquivo com os resultados da busca.
HRESULT	RemoveResultFile (int ServerIP, int ServerPort, unsigned long long int ResultFileId)
	Nova funcao para informar ao servidor que o arquivo com o resultado da busca pode ser removido.
HRESULT	CreateUser (char *UserName, char *Password)
	Nova funcao para criar um usuario.
HRESULT	RemoveUser (char *UserName)
	Nova funcao para remover a senha do usuario.
HRESULT	ChangePassword (char *UserName, char *Password)
	Nova funcao para alterar a senha de um usuario.
HRESULT	GetUserList (vector< string > &UserList)
	Nova funcao para obter a lista com todos os usuarios.
	CSessionManager ()
	~CSessionManager ()
int	SaveMeasures ()
int	Initialize (SessionManagerConfig *Config)
void	InvalidateStorageNatMappings (int StorageId)
	Funcao para invalidar todos os mapeamentos dos clientes conectados para um servidor de armazenamento identificado pela ID passada como parametro.
void	SetNumberOfDisks (unsigned int NumberOfDisks)
	Funcao para alterar o valor do numero de discos do servidor.
Private Member Functions
int	CleanUp ()
void	PostITEvent (MonitorEvent *event)
void	GetMonitorTable (vector< ClientData > &, vector< StorageData > &)
void	KillConnectionThread ()
void	SetNATMapping (NATData server_map, int stor_id, NATData stor_map)
	SetNATMapping informa ao Router o mapeamento NAT de um cliente com um storage.
int	GetVideoDuration (char *VideoName)
	Le do arquivo cactimes que contem o tempo para tocar cada bloco do video.
Static Private Member Functions
static void *	ConnectionThread (void *param)
static void *	ClientThread (void *param)
Private Attributes
CRioTCP *	m_TCPconnection
struct timeval m_RTT_openConnection	m_RTT_openStream
unsigned int	m_BlockSize
unsigned int	m_NumberOfDisks
unsigned int	m_NumberOfStorageNodes
DiskMgr *	m_DiskMgr
char *	m_FileRoot
int	m_MaxSessions
CSystemManager *	m_SystemManager
CStreamManager *	m_StreamManager
CObjectManager *	m_ObjectManager
CUserManager *	m_UserManager
CRouter *	m_Router
NetMgr *	m_NetMgr
CNetInterface *	m_NetInterface
int	m_used
SessionEntry *	m_SessionTable
pthread_mutex_t	m_mutex
bool	m_initialized
ofstream	m_log
pthread_t	m_ConnectionThreadId
bool	m_threadStopEvent
SOCKADDR_IN *	m_ServerAddress
unsigned int	m_ServerAddressSize
int	m_ClientsTimeOut
CLogRotation *	m_LogRotation
char *	m_LogsDirectory
CSearchLogs *	m_SearchLogs
Friends
class	RioSession

---

Detailed Description

Definition at line 34 of file interface/SessionManager.h.

---

Constructor & Destructor Documentation

CSessionManager::CSessionManager

(

CRioTCP *

TCPconnection

)

Definition at line 43 of file interface/SessionManager.cpp.

{
    m_TCPconnection = TCPconnection;
    #ifdef WINDOWS
        m_RTT_openConnection.wSecond       = 0;
        m_RTT_openConnection.wMilliseconds = 0;
        m_RTT_openStream.wSecond           = 0;
        m_RTT_openStream.wMilliseconds     = 0;
    #else
        m_RTT_openConnection.tv_sec        = 0;
        m_RTT_openConnection.tv_usec       = 0;
        m_RTT_openStream.tv_sec            = 0;
        m_RTT_openStream.tv_usec           = 0;
    #endif
}

CSessionManager::~CSessionManager

(

)

Definition at line 59 of file interface/SessionManager.cpp.

{
}

CSessionManager::CSessionManager

(

)

Definition at line 85 of file server/SessionManager.cpp.

{
    m_BlockSize            = 0;
    m_NumberOfDisks        = 0;
    m_NumberOfStorageNodes = 0;
    m_DiskMgr              = NULL;
    m_FileRoot             = NULL;
    m_MaxSessions          = 0;
    m_StreamManager        = NULL;
    m_ObjectManager        = NULL;
    m_SystemManager        = NULL;
    m_UserManager          = NULL;
    m_Router               = NULL;
    m_TCPconnection        = NULL;
    m_NetMgr               = NULL;
    m_used                 = 0;
    m_SessionTable         = NULL;
    pthread_mutex_init( &m_mutex, NULL );
    m_initialized          = false;
    // m_log does not to be initialized
    m_ConnectionThreadId   = 0;
    m_threadStopEvent      = false;
    
    // Inicializa as variaveis m_ServerAddress e m_ServerAddressSize. Usado 
    // pelo suporte aos clientes atras de NAT.
    m_ServerAddress        = NULL;
    m_ServerAddressSize    = 0;
    
    // Inicializacao do novo parametro usado para indicar o tempo maximo que o 
    // servidor espera por uma requisicao de um cliente.
    m_ClientsTimeOut = 0; // Nao usa o timeout, isto e, igual ao que ocorria
                          // anteriormente.
                          
    // Inicializa o ponteiro para o objeto com os logs de acesso dos clientes
    m_LogRotation = NULL;
    
    // Inicializa o ponteiro para o objeto que faz as buscas nos logs de acesso 
    // dos clientes
    m_SearchLogs = NULL;
    
    // Inicializa o ponteiro da nova classe de gerenciamento de rede.
    m_NetInterface = NULL;
}

CSessionManager::~CSessionManager

(

)

---

Member Function Documentation

HRESULT CSessionManager::ChangeDir	(	RioSessionId	Session,
		signed char *	Dir
	)

Definition at line 1031 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error ChangeDir:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2 * MAX_LONG_STRING_SIZE + strlen ( ( char * )Dir )+1  + 1;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Set Directory name
    SetString( Parameter,( char * )Dir,&offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Set Maximum result size ( Size of buffer )
    ResultSize = MaxTCPDataSize;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerChangeDir,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );


    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::ChangePassword	(	char *	UserName,
		char *	Password
	)

Nova funcao para alterar a senha de um usuario.

Parameters:

	UserName	ponteiro para a string com o nome do usuario.
	Password	ponteiro para a string com a senha do usuario.

Returns:

S_OK se o usuario foi criado com sucesso ou um valor diferente de S_OK se algum erro ocorreu ao fazermos a chamada remota.

Definition at line 3019 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error ChangePassword:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = strlen( UserName ) + strlen( Password ) + 2;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set UserName
    SetString( Parameter, UserName, &offset );
    // Set Password
    SetString( Parameter, Password, &offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassUserManager,
                                    RioMethodUserManagerChangePassword,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result, ResultSize, &status, &offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::CheckStreamControl

(

bool *

IsImplemented

)

Esta funcao faz uma chamada remota a um procedimento do Servidor RIO para verificar se a versao do servidor suporta o controle de fluxo.

Parameters:

IsImplemented

ponteiro para um valor booleano que sera, apos a execucao da funcao, igual a true se a versao do servidor suporta o controle de fluxo, e false caso nao suporte o controle ou se algum outro erro (diferente do de metodo invalido) ocorreu ao fazer a chamada remota (neste caso, o retorno indicara o erro).

Returns:

S_OK se a chamada foi executada com sucesso (o erro de metodo invalido e usado para detectar se o servidor usa ou nao o controle de fluxo e nao e considerado aqui como um erro).

Definition at line 2509 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        #ifdef RIO_DEBUG1
        RioErr << "malloc error CheckStreamControl:" << strerror(errno) 
               << endl;
        #endif
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 0;

    // Faz a chamada remota a uma funcao do Servidor RIO para verificar se a
    // versao do servidor faz ou nao o controle de fluxo.
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerCheckStreamControl,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );


    free( Parameter );
    if( Result != NULL )
        free( Result );
    // check if call failed
    if( FAILED( status ) )
    {
        // Se ocorreu algum erro, ou o metodo nao existe, ou ocorreu algum
        // erro ao executar o metodo.
        *IsImplemented = false;
        if ( ( unsigned int ) status == ERROR_CONNECTIONMANAGER + 
                                        ERROR_INVALID_METHOD )
            return S_OK;
        else  
        {  
            if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
                status = ERROR_RIOPROXY + ERROR_MEMORY;
            return status;
        }
    }
    else
    {
        // Se o metodo foi executado com sucesso (isto e, ele existe), entao
        // a versao do servidor usa o controle de fluxo.
        *IsImplemented = true;
        return S_OK;
    }
    
}

int CSessionManager::CleanUp

(

)

[private]

Definition at line 375 of file server/SessionManager.cpp.

{
    KillConnectionThread();

    if( m_TCPconnection != 0 )
    {
         m_TCPconnection->Disconnect();
         delete m_TCPconnection;
         m_TCPconnection = 0;
    }

    if( m_FileRoot != NULL )
        delete[] m_FileRoot;
    m_FileRoot = NULL;

    m_initialized = false;

    return S_OK;
}

void * CSessionManager::ClientThread

(

void *

param

)

[static, private]

Definition at line 532 of file server/SessionManager.cpp.

{
    ClientThreadParameter *ClientParam    = ( ClientThreadParameter * ) Param;
    SOCKET                 sock           = ClientParam->Socket;
    SOCKADDR_IN            remoteAddress  = ClientParam->RemoteAddress;
    CSessionManager*       SessionManager = ClientParam->SessionManager;
    unsigned int          Class          = 0;
    unsigned int          Method         = 0;
    unsigned int          Size           = 0;
    HRESULT                Status         = 0;
    char                  *Parameter      = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char                  *Result         = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    unsigned int          ParameterSize  = MaxTCPDataSize;
    unsigned int          ResultSize     = MaxTCPDataSize;
    CRioTCP                TCPconnection;
    
    #ifdef RIO_DEBUG2
    RioErr << "CLIENTTHREADID " << syscall( SYS_gettid ) << endl;
    #endif

    //Initializing variables
    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );
    memset( Result   , 0, MaxTCPDataSize*sizeof( char ) );

    // First accept client connection
    Status = TCPconnection.AcceptConnection( sock, 
                                             SessionManager->m_ClientsTimeOut );
    if( FAILED( Status ) )
    {
        RioErr << "[ClientThread] Erro ao aceitar a conexao do cliente a "
               << "partir do IP "
               << inet_ntoa( ClientParam->RemoteAddress.sin_addr )
               << " e da porta " << ntohs( ClientParam->RemoteAddress.sin_port )
               << ". Terminando a thread do cliente!" << endl;

        if( SessionManager->m_log.is_open() )
        {
            char *info = myInfo();
            SessionManager->m_log << info
                                  << "Error accepting TCP connection at "
                                  << "ClienThread. Exiting Session thread."
                                  << endl;
            free( info );
        }
        free( Parameter );
        free( Result );

        delete ClientParam;

        return( 0 );
    }

    // This sessions/threads RioSession allocated right on this threads
    // stack -- if this thread ends then the RioSession destructor will
    // free anything opened by the session.

    RioSession Session( SessionManager, remoteAddress );

    // assign global session id now
    pthread_mutex_lock( &SessionManager->m_mutex );
    int i = SessionManager->m_MaxSessions;
    if( SessionManager->m_used < SessionManager->m_MaxSessions )
    {
        for( i = 0; i < SessionManager->m_MaxSessions; i++ )
        {
            if( SessionManager->m_SessionTable[i].Session.Index != -1 )
                continue;
            break;
        }
    }

    // if no session available fail this call
    if( i >= SessionManager->m_MaxSessions )
    {
        RioErr << "[ClientThread] Erro ao criar a sessao do cliente a "
               << "partir do IP "
               << inet_ntoa( ClientParam->RemoteAddress.sin_addr )
               << " e da porta " << ntohs( ClientParam->RemoteAddress.sin_port )
               << ": numero maximo de sessoes " << SessionManager->m_MaxSessions
               << " atingido! Terminando a thread do cliente!" << endl;

        if( SessionManager->m_log.is_open() )
        {
            char *info = myInfo();
            SessionManager->m_log << info
                                  << "Too many sessions opened."
                                  << " Refusing new session" << endl;
            free( info );
        }
        pthread_mutex_unlock( &SessionManager->m_mutex );
        Status = TCPconnection.ReceiveCall( &Class, &Method,
                                            Parameter, ParameterSize );
        Status = ERROR_SESSIONMANAGER + ERROR_MAX_SESSIONS;

        TCPconnection.SendCallError(Status);
        if( SessionManager->m_log.is_open() )
        {
            char *info = myInfo();
            SessionManager->m_log << info
                                  << "Exiting Session thread" << endl;
            free( info );
        }

        free( Parameter );
        free( Result );

        delete ClientParam;

        return 0;
    }

    Session.s_id = i;
    SessionManager->m_used++;
    // Salva uma linha no log, para informar que o cliente iniciou a sessao.
    Session.SaveLogLine( "Connected", "<<open session>>" );
    SessionManager->m_SessionTable[i].Session.Index = i;

    #ifdef RIO_DEBUG2
    struct tm *date;
    time_t segundos;

    struct in_addr clientip;
    clientip.s_addr = remoteAddress.sin_addr.s_addr;

    if( SessionManager->m_log.is_open() )
    {
        time( &segundos );
        date = localtime( &segundos );

        char *info = myInfo();
        SessionManager->m_log << info
                              << " New connection accepted. Active Sessions "
                              << SessionManager->m_used
                              << ". New client ip: " << inet_ntoa(clientip)
                              << " port: " <<  htons( remoteAddress.sin_port )
                              << endl;
        free( info );
    }
    #endif
    // ------------------------------------------------------------------------

    // Should not reset version since this should be incremented for
    // each new session using the same table entry (commented out)
    // SessionManager->m_SessionTable[i].Session.Version = 0;

    SessionManager->m_SessionTable[i].s_ptr = &Session;

    pthread_mutex_unlock( &SessionManager->m_mutex );

    while( true )
    {
        // Receive a client method call
        Status = TCPconnection.ReceiveCall( &Class, &Method, Parameter,
                                            ParameterSize );

        // Check if call was received successfully
        if( FAILED( Status ) )
        {
            if( Status == (int )(ERROR_RIOTCP + ERROR_CLOSED_CONNECTION) )
            {
                #ifdef RIO_DEBUG2
                RioErr << "[ClientThread] Fechando a conexao do cliente com o "
                       << "IP "
                       << inet_ntoa( ClientParam->RemoteAddress.sin_addr )
                       << " e a porta "
                       << ntohs( ClientParam->RemoteAddress.sin_port )
                       << ". Terminando a thread do cliente!" << endl;
                #endif

                if( SessionManager->m_log.is_open() )
                {
                    char *info = myInfo();
                    SessionManager->m_log << info
                                          << "Client exiting ... "
                                          << "Closing Connection." << endl;
                    free( info );
                }
            }
            else
            {
                #ifdef RIO_DEBUG2
                RioErr << "[ClientThread] Erro 0x" << hex << Status << dec
                       << " (" << GetErrorDescription( Status) << ") ao "
                       << "executar a funcao ReceiveCall para o cliente com o "
                       << "IP "
                       << inet_ntoa( ClientParam->RemoteAddress.sin_addr )
                       << " e a porta "
                       << ntohs( ClientParam->RemoteAddress.sin_port )
                       << ". Terminando a thread do cliente!" << endl;
                #endif

                if( SessionManager->m_log.is_open() )
                {
                    char *info = myInfo();
                    SessionManager->m_log << info
                                          << "ERROR on TCP connection receive. "
                                          << "Closing Connection: "
                                          << GetErrorDescription( Status )
                                          << endl;
                    free( info );
                }
            }
            // ----------------------------------------------------------------
            TCPconnection.Disconnect();
            if( SessionManager->m_log.is_open() )
            {
                char *info = myInfo();
                SessionManager->m_log << info
                                      << "Exiting Session thread" << endl;
                free( info );
            }

            free( Parameter );
            free( Result );

            delete ClientParam;

            return(0);
        }
        else // else do if( FAILED( Status ) )
        {
            Size = ResultSize;
            // execute method
            Status = Session.ExecuteCall( Class, Method,
                                          Parameter, ParameterSize,
                                          &Result, &Size );
            
            #ifdef RIO_DEBUG2                              
            RioErr << "CSessionManager::ClientThread enviando uma mensagem " 
                   << "de " << Size << " bytes." << endl;
            #endif                              
            // Return result or call error to client
            if( FAILED( Status ) )
            {
                char *info = myInfo();
                SessionManager->m_log << info
                                      << "Failed executing call. " << endl;
                free( info );

                Status = TCPconnection.SendCallError( Status );
            }
            else
            {
                Status = TCPconnection.SendResult(Result, Size);
            }

            // Volta ao tamanho original. Nao podemos ter um erro de memoria
            // neste caso, porque estamos reduzindo a memoria que foi alocada.
            if( Size > ResultSize )
            {
                #ifdef RIO_DEBUG2
                RioErr << "CSessionManager::ClientThread Reduzindo tamanho " 
                       << "alocado de " << Size << " bytes para " << ResultSize
                       << "  bytes " << endl;
                #endif       
                char *NewResult = ( char * ) realloc( Result, ResultSize );
                if( NewResult == NULL )
                    RioErr << "CSessionManager::ClientThread falhou em reduzir "
                           << "o tamanho da area alocada de " << Size 
                           << " para " << ResultSize << ". Tamanho mantido!"
                           << endl;
                else
                    Result = NewResult;            
            } 

            if( FAILED( Status ) )
            {
                RioErr << "[ClientThread] Erro ao enviar os resultados ao "
                       << "cliente com o IP "
                       << inet_ntoa( ClientParam->RemoteAddress.sin_addr )
                       << " e a porta "
                       << ntohs( ClientParam->RemoteAddress.sin_port )
                       << ". Terminando a thread do cliente!" << endl;

                // If anything goes wrong when sending result close
                // connection and abort thread
                TCPconnection.Disconnect();
                RioErr << "SessionManager - Exiting Session thread" << endl;

                free( Parameter );
                free( Result );

                delete ClientParam;

                return(0);
            }
        } // fim do else do if( FAILED( Status ) )
    } // fim do while( true )

    free( Parameter );
    free( Result );

    RioErr << "[ClientThread] A thread para o IP "
           << inet_ntoa( ClientParam->RemoteAddress.sin_addr )
           << " e a porta "
           << ntohs( ClientParam->RemoteAddress.sin_port )
           << "for terminada no final!" << endl;

    delete ClientParam;

    return( 0 );
}

HRESULT CSessionManager::Close

(

const RioSessionId

Session

)

Definition at line 215 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error Close:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2*MAX_LONG_STRING_SIZE;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerClose,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

void * CSessionManager::ConnectionThread

(

void *

param

)

[static, private]

Definition at line 456 of file server/SessionManager.cpp.

{
    CRioTCP* TCPconnection;
    SOCKET ConnectedSocket;

    RioErr << "CONNECTIONTHREADID " << syscall( SYS_gettid ) << endl;

    // Get pointer to SessionManger (this)
    CSessionManager *SessionManager = (CSessionManager *) Param;

    // Get Socket
    TCPconnection = SessionManager->m_TCPconnection;
    while( true )
    {
        // Wait for client connection
        HRESULT hResult = TCPconnection->WaitConnection(&ConnectedSocket);

        // Check if thread should terminate
        if( SessionManager->m_threadStopEvent )
        {
            TCPconnection->Disconnect();
            return(0);
        }

        // Check if TCPconnection->WaitConnection() failed
        if( FAILED( hResult ) )
        {
            if( SessionManager->m_log.is_open() )
                SessionManager->m_log << "ConnectionThread: "
                                      << "Connection waiting failed" << endl;
            if( hResult != ( ( HRESULT ) ( ERROR_RIOTCP + ERROR_SOCKET_ACCEPT )
                            ) )
            {
                RioErr << "[ConnectionThread] Erro critico 0x" << hex
                       << hResult << dec << " ("
                       << GetErrorDescription( hResult ) << ") gerado. "
                       << "Forcando a finalizacao do servidor com um sinal "
                       << "SIGTERM." << endl;
                raise( SIGTERM );
            }
        }
        // Create thread to handle new client connection
        else
        {
            ClientThreadParameter *Param = new ClientThreadParameter();
            Param->Socket = ConnectedSocket;
            Param->SessionManager = SessionManager;
            pthread_t junk;
            pthread_attr_t attrib;

            // to correct ip problem (when using dhcp
            // the client's ip sent in the packet is wrong  )
            Param->RemoteAddress = TCPconnection->m_RemoteAddress;
            // to fix memory bug
            pthread_attr_init( &attrib );
            pthread_attr_setstacksize( &attrib, 6*PTHREAD_STACK_MIN );

            // ----------------------------------------------------------------
            if( pthread_create( &junk, &attrib, &ClientThread, (void*) Param ) )
            {
                delete Param;
                if( SessionManager->m_log.is_open() )
                    SessionManager->m_log << "ConnectionThread: "
                                          << "Failed to create client thread"
                                          << endl;
                shutdown( ConnectedSocket, 2 );
            }
            else
                pthread_detach( junk );
        }
    }

    return 0;
}

HRESULT CSessionManager::CreateObject	(	const RioSessionId	Session,
		const char *	ObjectName,
		const short	Type
	)

Definition at line 472 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;

    if( Parameter == NULL )
    {
        RioErr << "malloc error CreateObject:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    HRESULT       status;
    ParameterSize = 2 * MAX_LONG_STRING_SIZE +
                        strlen( ObjectName )+1 +
                        MAX_SHORT_STRING_SIZE;

    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on ascii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Set Object Name
    SetString( Parameter,ObjectName,&offset );

    // Set Object type
    SetShort( Parameter,Type,&offset );

    // Update Parameter size to actual size ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                   RioMethodSessionManagerCreateObject,
                                   ParameterSize,
                                   Parameter,
                                   &ResultSize,
                                   &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::CreateUser	(	char *	UserName,
		char *	Password
	)

Nova funcao para criar um usuario.

Parameters:

	UserName	ponteiro para a string com o nome do usuario.
	Password	ponteiro para a string com a senha do usuario.

Returns:

S_OK se o usuario foi criado com sucesso ou um valor diferente de S_OK se algum erro ocorreu ao fazermos a chamada remota.

Definition at line 2869 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error CreateUser:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = strlen( UserName ) + strlen( Password ) + 2;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set UserName
    SetString( Parameter, UserName, &offset );
    // Set Password
    SetString( Parameter, Password, &offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassUserManager,
                                    RioMethodUserManagerCreateUser,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result, ResultSize, &status, &offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::DeleteObject	(	const RioSessionId	Session,
		const char *	ObjectName
	)

Definition at line 558 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error DeleteObject:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2 * MAX_LONG_STRING_SIZE +
                        strlen( ObjectName )+1;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Set Object Current  Name
    SetString( Parameter,ObjectName,&offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerDeleteObject,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::FirstObject	(	RioSessionId	Session,
		signed char *	DirectoryName,
		ObjectHandle *	Handle,
		int *	IsDirectory,
		int	BufferSize,
		signed char *	ObjectName
	)

Definition at line 897 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error FirstObject:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 3 * MAX_LONG_STRING_SIZE +
                    strlen( ( char * )DirectoryName ) + 1;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Set Directory name
    SetString( Parameter,( char * )DirectoryName,&offset );

    // Set Buffer size
    SetLong ( Parameter,BufferSize, &offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerFirstObject,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }


    if( FAILED( status ) )
    {
        free( Parameter );
        free( Result );

        return status;
    }

    // Get Object Hanlde
    if( !GetLong( Result,ResultSize,&( Handle->Version ),&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    if( !GetLong( Result,ResultSize,&( Handle->Index ),&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    // Get Directory flag
    if( !GetLong( Result,ResultSize, IsDirectory ,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    char *str = NULL;
    // Get Object Name
    if( !GetString( Result,ResultSize,&str,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    strcpy( ( char * )ObjectName, str );

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::GetAverageRTT

(

struct timeval *

average_RTT

)

Definition at line 2275 of file interface/SessionManager.cpp.

{
    int numRTT = 0;
    double averagems = 0;

    average_RTT->tv_sec  = m_RTT_openConnection.tv_sec;
    average_RTT->tv_usec = m_RTT_openConnection.tv_usec;

    if( ( m_RTT_openStream.tv_sec != 0 ) || ( m_RTT_openStream.tv_usec != 0 ) )
    {
        average_RTT->tv_sec  += m_RTT_openStream.tv_sec;
        average_RTT->tv_usec += m_RTT_openStream.tv_usec;
        numRTT = 1;
    }

    numRTT += 1;


    if( average_RTT->tv_usec > 1000000 )
    {
        average_RTT->tv_usec -= 1000000;
        average_RTT->tv_sec  += 1;
    }

    if( numRTT > 1 )
    {
        averagems = ( average_RTT->tv_sec * 1000.0 +
                      average_RTT->tv_usec / 1000.0 ) / numRTT;
        long double averagemicrosec = averagems * 1000;
        average_RTT->tv_sec =  ( unsigned int ) ( averagemicrosec / 1000000 );
        average_RTT->tv_usec =
                     ( unsigned int )( ( unsigned int )averagemicrosec % 1000000 );
    }
    return S_OK;
}

HRESULT CSessionManager::GetBlockSize	(	const RioSessionId	Session,
		unsigned int *	BlockSize
	)

Definition at line 725 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error GetBlockSize:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2 * MAX_LONG_STRING_SIZE;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerGetBlockSize,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    // Get Block Size
    if( !GetULong( Result,ResultSize,BlockSize,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::GetCurrentDir	(	RioSessionId	Session,
		int	size,
		signed char *	Dir
	)

Definition at line 1114 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error GetCurrentDir:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 3 * MAX_LONG_STRING_SIZE + 1;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Set Buffer size
    SetLong ( Parameter, size, &offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    //RioErr << "antes do CALL na SessionManager" << endl;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerGetCurrentDir,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    char *str;
    // Get current directory name
    if( !GetString( Result,ResultSize,&str,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    strcpy( ( char * )Dir,str );

    free( Parameter );
    free( Result );

    return status;
}

void CSessionManager::GetMonitorTable	(	vector< ClientData > &	clientTable,
		vector< StorageData > &	storageTable
	)			[private]

Definition at line 846 of file server/SessionManager.cpp.

{
    m_SystemManager->GetMonitorTable( clientTable, storageTable );
}

HRESULT CSessionManager::GetMonitorTable	(	char *	UserName,
		vector< ClientData > *	client_data,
		vector< StorageData > *	storage_data
	)

Definition at line 2065 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error GetStorageNodeInfo:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2*MAX_LONG_STRING_SIZE;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set Session Id
    SetString( Parameter,UserName,&offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerGetMonitorTable,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    unsigned short client_table_size, storage_table_size;
    // Get results from result buffer
    // Get method first value
    if( !GetUShort( Result,ResultSize,&client_table_size,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    // Get method second value
    if( !GetUShort( Result,ResultSize,&storage_table_size,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    int i;
    for( i = 0; i < client_table_size; i++)
    {
        ClientData data;
        char *ip, *video;
        if( !GetString( Result, ResultSize, &ip, &offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
        if( !GetUShort( Result, ResultSize, &(data.m_port), &offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
        if( !GetString( Result, ResultSize, &video, &offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
        if( !GetUShort( Result, ResultSize, &(data.m_time), &offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
        if( !GetUShort( Result, ResultSize, &(data.m_queue), &offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
        data.m_ip = ip;
        data.m_video = video;
        client_data->push_back( data );
    }

    for( i = 0; i < storage_table_size; i++)
    {
        StorageData data;
        char *ip, *hostname, *diskname;
        if( !GetString( Result, ResultSize, &ip, &offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
        if( !GetString( Result, ResultSize, &hostname, &offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
        if( !GetString( Result, ResultSize, &diskname, &offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
        if( !GetUShort( Result, ResultSize, &(data.m_queue), &offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
        data.m_ip = ip;
        data.m_hostname = hostname;
        data.m_diskname = diskname;
        storage_data->push_back( data );
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::GetnStorageNodes	(	const RioSessionId	Session,
		short *	nStorageNodes
	)

Definition at line 811 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error GetnStorageNodes:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2 * MAX_LONG_STRING_SIZE;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerGetnStorageNodes,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    // Get number of storage nodes
    if( !GetShort( Result,ResultSize,nStorageNodes,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::GetNumberOfActiveAndMaxSessions	(	const RioSessionId	Session,
		unsigned int *	NumberOfActiveSessions,
		unsigned int *	NumberOfMaxSessions
	)

Definition at line 1649 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error GetNumberOfActiveAndMaxSessions:"
               << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2 * MAX_LONG_STRING_SIZE;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                        RioMethodSessionManagerGetNumberOfActiveAndMaxSessions,
                        ParameterSize,
                        Parameter,
                        &ResultSize,
                        &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    // Get NumberOfActiveSessions
    if( !GetULong( Result,ResultSize,NumberOfActiveSessions,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    // Get NumberOfMaxSessions
    if( !GetULong( Result,ResultSize,NumberOfMaxSessions,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::GetNumberOfDisks	(	const RioSessionId	Session,
		unsigned int *	NumberOfDisks
	)

Definition at line 1475 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error GetNumberOfDisks:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2 * MAX_LONG_STRING_SIZE;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerGetNumberOfDisks,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    // Get NumberOfDisks
    if( !GetULong( Result,ResultSize,NumberOfDisks,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::GetNumberOfStorageNodes	(	const RioSessionId	Session,
		unsigned int *	NumberOfStorageNodes
	)

Definition at line 1562 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error GetNumberOfStorageNodes:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2 * MAX_LONG_STRING_SIZE;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                RioMethodSessionManagerGetNumberOfStorageNodes,
                                ParameterSize,
                                Parameter,
                                &ResultSize,
                                &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    // Get NumberOfStorageNodes
    if( !GetULong( Result,ResultSize,NumberOfStorageNodes,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::GetObjectInfo	(	RioSessionId	Session,
		const char *	ObjectName,
		ObjectInfo *	ObjectInfo
	)

Definition at line 1209 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    AccessTime     LastModificationTime;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error GetObjectInfo:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2*MAX_LONG_STRING_SIZE + strlen( ObjectName )+1 + 1;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Set Object name
    SetString( Parameter, ObjectName, &offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerGetObjectInfo,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    // Get Object Info

    short shortvalue;

    // Get Object type
    if( !GetShort( Result,ResultSize,&shortvalue,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    ObjectInfo->setType( shortvalue );

    // Get Permission
    if( !GetShort( Result,ResultSize,&shortvalue,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    ObjectInfo->setPermission( shortvalue );

    // Get Object Size
    unsigned int highpart;
    unsigned int lowpart;
    if( !GetULong( Result,ResultSize,&highpart,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_CONNECTIONMANAGER + ERROR_INVALID_METHOD_PARAM;
    }
    if( !GetULong( Result,ResultSize,&lowpart,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_CONNECTIONMANAGER + ERROR_INVALID_METHOD_PARAM;
    }
    ObjectInfo->setSize( ( ( ( RioObjectSize ) highpart ) << 32 ) | lowpart  );

    // Get Last modification time ( year )
    if( !GetShort( Result,ResultSize,&shortvalue,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    LastModificationTime.Year = shortvalue;

    // Get Last modification time ( month )
    if( !GetShort( Result,ResultSize,&shortvalue,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    LastModificationTime.Month = shortvalue;

    // Get Last modification time ( day of week )
    if( !GetShort( Result,ResultSize,&shortvalue,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    LastModificationTime.DayOfWeek = shortvalue;

    // Get Last modification time ( day )
    if( !GetShort( Result,ResultSize,&shortvalue,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    LastModificationTime.Day = shortvalue;

    // Get Last modification time ( hour )
    if( !GetShort( Result,ResultSize,&shortvalue,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    LastModificationTime.Hour = shortvalue;

    // Get Last modification time ( Minute )
    if( !GetShort( Result,ResultSize,&shortvalue,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    LastModificationTime.Minute = shortvalue;
    ObjectInfo->setTime( LastModificationTime );

    char *str;

    // Get Owner User Name
    if( !GetString( Result,ResultSize,&str,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    if( strlen( str ) <= ( unsigned int ) MaxObjectInfoNameSize )
    {
        ObjectInfo->setOwner( str );
    }
    else
    {
        char owner[MaxObjectInfoNameSize];
        strncpy ( owner,str,MaxObjectInfoNameSize );
        owner[MaxObjectInfoNameSize-1] = 0;
        ObjectInfo->setOwner( owner );
    }

    // Get Owner Group Name
    if( !GetString( Result,ResultSize,&str,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    if( strlen( str ) <= ( unsigned int ) MaxObjectInfoNameSize )
    {
        ObjectInfo->setGroup( str );
    }
    else
    {
        char group[MaxObjectInfoNameSize];
        strncpy ( group,str,MaxObjectInfoNameSize );
        group[MaxObjectInfoNameSize-1] = 0;
        ObjectInfo->setGroup( group );
    }
    
    // Get Video Rate (usado pela implementacao do controle de fluxo).
    unsigned int VideoRate;
    if( !GetULong( Result,ResultSize,&VideoRate,&offset ) )
    {
       #ifdef RIO_DEBUG2    
       RioErr << "CSessionManager::GetObjectInfo metodo nao possui a taxa. "
              << "Usando a taxa igual a 0" << endl;
       #endif
       VideoRate = 0;
    }
    ObjectInfo->setVideoRate( VideoRate );

    // Get MD5 checksum
    if( !GetString( Result,ResultSize,&str,&offset ) )
    {
        #ifdef RIO_DEBUG2   
        RioErr << "CSessionManager::GetObjectInfo metodo nao possui o MD5. "
               << "Usando um valor NULL" << endl;
        ObjectInfo->setMd5sum( NULL );
        #endif
    }
    else
    {
        if( strlen( str ) <= ( unsigned int ) MaxObjectInfoNameSize )
        {
            ObjectInfo->setMd5sum( str );
        }
        else
        {
            char md5[MaxObjectInfoNameSize];
            strncpy ( md5,str,MaxObjectInfoNameSize );
            md5[MaxObjectInfoNameSize-1] = 0;
            ObjectInfo->setMd5sum( md5 );
        }
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::GetRTT	(	struct timeval *	RTT_openConnection,
		struct timeval *	RTT_openStream
	)

Definition at line 2328 of file interface/SessionManager.cpp.

{
    RTT_openConnection->tv_sec  = m_RTT_openConnection.tv_sec;
    RTT_openConnection->tv_usec = m_RTT_openConnection.tv_usec;

    RTT_openStream->tv_sec      = m_RTT_openStream.tv_sec;
    RTT_openStream->tv_usec     = m_RTT_openStream.tv_usec;

    return S_OK;
}

HRESULT CSessionManager::GetServerAddress	(	struct sockaddr_in **	ServerAddress,
		unsigned int *	ServerAddressSize
	)

Esta funcao faz uma chamada remota a um procedimento do Servidor RIO para obter todos os pares IP, porta para os quais precisaremos enviar periodicamente mensagens Fake para garantir que os enderecos associados ao mapeamento continuarao validos.

Nota: esta funcao foi baseada na funcao Open da classe.

Parameters:

	ServerAddress	ponteiro para um ponteiro para um vetor que contera os enderecos (pares IP, porta) do Rio Server e dos Storage Servers.
	ServerAddressSize	ponteiro para a variavel que armazenara o tamanho deste vetor com os enderecos.

Returns:

S_OK se os enderecos foram obtidos com sucesso, e um valor de erro diferente de S_OK caso nao tenha sido possivel obter os enderecos.

Definition at line 2348 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;
    unsigned int IP, Size;
    unsigned short Port;
    int offset = 0;

    if( Parameter == NULL )
    {
        #ifdef RIO_DEBUG1
        RioErr << "malloc error GetServerAddress:" << strerror(errno) << endl;
        #endif
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    // Inicializa o retorno da funcao
    
    *ServerAddress = NULL;
    *ServerAddressSize = 0;

    // Set Maximum result size ( Size of buffer )
    //ResultSize = MaxTCPDataSize;

    ParameterSize = 0;

    // Faz a chamada remota a uma funcao do Servidor RIO para obter os IPs e
    // as portas dos servidores.
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerGetServerAddress,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );


    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    // Extrai da mensagem recebida como resposta a chamada anterior a
    // lista com os IPs e as portas dos servidores.
    
    offset = 0;
        
    // O primeiro campo da mensagem e o numero pares IP, porta da lista.
    if( !GetULong( Result, ResultSize, &Size, &offset ) )
    {
        free( Parameter );
        free( Result );

        #ifdef RIO_DEBUG1
        RioErr << "CSessionManager::GetServerAddress GetULong em Size" 
               << endl;
        #endif        

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    *ServerAddressSize = Size;

    #ifdef RIO_DEBUG1
    RioErr << "CSessionManager::GetServerAddress ServerAddressSize = " 
           << *ServerAddressSize << endl;
    #endif

    // Aloca o vetor que armazenara as estruturas com os enderecos dos
    // servidores.
    *ServerAddress = new sockaddr_in[ *ServerAddressSize ];
    if( *ServerAddress == NULL )
    {
        #ifdef RIO_DEBUG1
        RioErr << "CSessionManager::GetServerAddress Erro ao alocar o vetor" 
               << endl;
        #endif        
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }
        
    // Extrai o endereco IP e a porta de cada um dos servidores da mensagem.
    for( unsigned int i = 0; i <  *ServerAddressSize; i++ )
    {
        // Obtem o IP de um dos servidores.
        if( !GetULong( Result, ResultSize, &IP, &offset ) )
        {
            free( Parameter );
            free( Result );
            free( *ServerAddress );

            #ifdef RIO_DEBUG1
            RioErr << "CSessionManager::GetServerAddress GetULong em IP" 
                   << " no indice i = " << i << endl;
            #endif         

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
        // Obtem a porta de um dos servidores.
        if( !GetUShort( Result, ResultSize, &Port, &offset ) )
        {
            free( Parameter );
            free( Result );
            free( *ServerAddress );

            #ifdef RIO_DEBUG1
            RioErr << "CSessionManager::GetServerAddress GetUShort em Port" 
                   << " no indice i = " << i << endl;
            #endif         

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
        (*ServerAddress)[ i ].sin_family = AF_INET;
        (*ServerAddress)[ i ].sin_port = htons( Port );
        (*ServerAddress)[ i ].sin_addr.s_addr = htonl( IP );
                    
        #ifdef RIO_DEBUG1
        RioErr << "CSessionManager::GetServerAddress ServerAddress[" 
               << i << "].sin_port = " 
               << ntohs( (*ServerAddress)[ i ].sin_port ) << endl; 
        RioErr << "CSessionManager::GetServerAddress ServerAddress[" 
               << i << "].sin_addr.s_addr = " 
               << inet_ntoa( (*ServerAddress)[ i ].sin_addr ) << endl;
        #endif        

    }

    free( Parameter );
    free( Result );

    return S_OK;
}  

HRESULT CSessionManager::GetStorageNodeInfo	(	RioSessionId	Session,
		RioStorageNodeInfo *	StorageNodeInfo,
		unsigned int	StorageNodeIndex
	)

Definition at line 1824 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error GetStorageNodeInfo:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2*MAX_LONG_STRING_SIZE + sizeof( StorageNodeIndex );
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Set StorageNodeIndex
    SetLong( Parameter,StorageNodeIndex,&offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerGetStorageNodeInfo,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    // Get StorageNode Info
    char *str;

    // Get Hostname
    if( !GetString( Result,ResultSize,&str,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    if( strlen( str ) <= 60 )
    {
        strcpy( StorageNodeInfo->Hostname,str );
    }
    else
    {
        strncpy ( StorageNodeInfo->Hostname,str,60 );
        StorageNodeInfo->Hostname[59] = '\0';
    }

    short shortvalue;

    // Get NumberOfDisks
    if( !GetShort( Result,ResultSize,&shortvalue,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    StorageNodeInfo->NumberOfDisks = shortvalue;
    int i;
    // for each disk get DiskName, Size, FreeBlocks
    for( i = 0; i < shortvalue ; i++ ) {
        // Get Hostname
        if( !GetString( Result,ResultSize,&str,&offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
        if( strlen( str ) < MaxPathSize )
        {
        strcpy( StorageNodeInfo->Disks[i].DiskName,str );
        }
        else
        {
            strncpy ( StorageNodeInfo->Disks[i].DiskName,str, MaxPathSize-1 );
            StorageNodeInfo->Disks[i].DiskName[ MaxPathSize-1 ] = '\0';
        }
        // Get Disk Size
        unsigned int highpart;
        unsigned int lowpart;
        if( !GetULong( Result,ResultSize,&highpart,&offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_CONNECTIONMANAGER + ERROR_INVALID_METHOD_PARAM;
        }
        if( !GetULong( Result,ResultSize,&lowpart,&offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_CONNECTIONMANAGER + ERROR_INVALID_METHOD_PARAM;
        }
        StorageNodeInfo->Disks[i].Size =
                               ( ( ( RioObjectSize ) highpart ) << 32 ) | lowpart;
        // Get NumberOfFreeBlocks
        if( !GetULong( Result,ResultSize,
                       &StorageNodeInfo->Disks[i].NumberOfFreeBlocks,&offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
    }

    free( Parameter );
    free( Result );
    
    return status;
}

HRESULT CSessionManager::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 3095 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;
    unsigned int UserListSize;
    char *UserName;

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

    if( Parameter == NULL )
    {
        RioErr << "malloc error ChangePassword:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 0;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassUserManager,
                                    RioMethodUserManagerUserList,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result, ResultSize, &status, &offset ) )
    {
        free( Parameter );
        free( Result );


        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    // Se nao ocorreu um erro ao obter a lista, pega os nomes dos usuarios.
    if( !FAILED( status ) )
    {
        // Obtem o numero de usuarios no sistema.
        if( !GetULong( Result, ResultSize, &UserListSize, &offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }

        #ifdef RIO_DEBUG2
        RioErr << "CSessionManager::GetUserList tamanho recebido na mensagem: "
               << UserListSize << endl;
        #endif

        // Obtem cada um dos nomes dos usuarios, e os insere no vetor.
        for( unsigned int i = 0; i < UserListSize; i++ )
        {
            if( !GetString( Result, ResultSize, &UserName, &offset ) )
            {
                // Limpa o vetor.
                UserList.clear();

                free( Parameter );
                free( Result );

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

                return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
            }

            #ifdef RIO_DEBUG2
            RioErr << "CSessionManager::GetUserList Recebida a string "
                   << UserName << endl;
            #endif

            // Tenta adicionar o usuario a lista
            try
            {
                UserList.push_back( string( UserName ) );
            }
            catch( bad_alloc &ba )
            {
                free( Parameter );
                free( Result );

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

                return ERROR_RIOPROXY + ERROR_MEMORY;
            }
        }

        #ifdef RIO_DEBUG2
        // Mostra a lista recebida
        RioErr << "CSessionManager::GetUserList lista de usuarios recebida, com "
               << UserList.size() << " usuarios: ";
        for( unsigned int i = 0; i < UserList.size(); i++ )
        {
            RioErr << UserList[ i ];
            if( i != ( UserList.size() - 1 ) )
                RioErr << ",";
        }
        RioErr << endl;
        #endif

    }

    free( Parameter );
    free( Result );

    return status;
}

int CSessionManager::GetVideoDuration

(

char *

VideoName

)

[private]

Le do arquivo cactimes que contem o tempo para tocar cada bloco do video.

Este arquivo (cactimes) deve estar no mesmo diretorio do video, porem copiado pelo sistema de arquivos do linux e nao do RIO. Nao esta sendo utilizado atualmente mas sera mantido pois pode ser util no futuro.

Definition at line 858 of file server/SessionManager.cpp.

{
    int video_duration       = 0;
    double aux_video_duration = 0;
    double sum                = 0;

    char *auxpath;
    auxpath = new char[255];
    auxpath = strtok( VideoName, "." );

    char *path;
    path = new char[255];

    sprintf( path, "%s/%s.cactimes", m_FileRoot, auxpath );

    FILE *CACFile;

    if( ( CACFile = fopen ( path, "r" ) ) == NULL )
    {
        Rioperror( "fopen" );
    }
    else
    {
        while( 1 )
        {
            if( fscanf( CACFile, "%lf", &aux_video_duration ) != 1 )
            {
                RioErr << "CSessionManager::GetVideoDuration: aviso - erro ao "
                       << "ler o arquivo " << path << endl;
            }
            sum += aux_video_duration;

            if( feof( CACFile ) )
                break;
        }
    }

    video_duration = ( int ) sum;

    return( video_duration );
}

int CSessionManager::Initialize

(

SessionManagerConfig *

Config

)

Definition at line 157 of file server/SessionManager.cpp.

{
    pthread_attr_t attrib;

    // 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_SESSIONMANAGER + ERROR_INITIALIZED;
    }

    m_LogsDirectory = Config->LogsDirectory;
    
    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, m_LogsDirectory );
        strcat( LogFileName, LOGFILE );
        m_log.open( LogFileName );
        // Check if log file was opened successfully
        if( !m_log.is_open() )
        {
            return ERROR_SESSIONMANAGER + ERROR_LOGFILE ;
        }
    }

    m_SystemManager = Config->SystemManager;
    m_StreamManager = Config->StreamManager;
    m_ObjectManager = Config->ObjectManager;
    m_UserManager   = Config->UserManager;
    m_Router        = Config->Router;
    m_DiskMgr               = Config->diskMgr;
    m_NumberOfDisks         = Config->NumberOfDisks;
    m_NumberOfStorageNodes  = Config->NumberOfStorageNodes;
    // ------------------------------------------------------------------------
    RioErr << "Config->FileRoot " << Config->FileRoot<< endl;
    m_FileRoot = new char[ strlen( Config->FileRoot ) + 1 ];
    strcpy( m_FileRoot, Config->FileRoot );
    RioErr << "m_FileRoot " << m_FileRoot << endl;

    m_MaxSessions   = Config->MaxSessions;
    m_BlockSize     = Config->BlockSize;

    // Alocate Session table
    m_SessionTable = new SessionEntry[Config->MaxSessions];
    if( m_SessionTable == 0 )
    {
        if( m_log.is_open() )
            m_log << "Initialize(): Failed to allocate memory" << endl;

        m_ObjectManager = 0;
        m_StreamManager = 0;
        return ERROR_SESSIONMANAGER + ERROR_MEMORY;
    }

    // Initialize Session Table
    for( int i = 0; i < Config->MaxSessions; i++ )
    {
        m_SessionTable[i].Session.Index = -1;
        m_SessionTable[i].Session.Version = 0;
        m_SessionTable[i].s_ptr = 0;
    }

    m_used = 0;

    // Inicializa o campo m_ServerAddressSize inicialmente com o numero de
    // Storage Servers.
    m_DiskMgr->GetNumberOfStorageNodes( &m_ServerAddressSize );
    // Devemos considerar tambem o par IP, porta do Servidor RIO.
    m_ServerAddressSize = m_ServerAddressSize + 1;

    // Aloca o vetor que armazenara os pares IP, porta do Servidor RIO e dos
    // Storage Servers.     
    m_ServerAddress = new SOCKADDR_IN[ m_ServerAddressSize ];
    if( m_ServerAddress == NULL ) 
    {
        if( m_log.is_open() )
            m_log << "Initialize(): Failed to allocate memory" << endl;
        return ERROR_SESSIONMANAGER + ERROR_MEMORY;
    }
    // Inicializa o vetor com os IPs e as portas das maquinas.
    // A primeira entrada e inicializada com o par IP, porta do Servidor RIO,
    // obtido a partir da classe (a porta sempre e dada pela constante
    // RIOSERVERUDPPORT. Devemos envia-la ao cliente para permitir que
    // este independa do modo como o servidor foi compilado).
    m_ServerAddress[ 0 ].sin_family = AF_INET;
    m_ServerAddress[ 0 ].sin_port = htons( RIOSERVERUDPPORT );
    //m_ServerAddress[ 0 ].sin_addr.s_addr = m_StreamManager->GetNetMgrIPAddr();
    m_ServerAddress[ 0 ].sin_addr.s_addr = m_StreamManager->
                                                        GetNetInterfaceIPAddr();
    // Inicialia as outras entradas do vetor com o par IP, porta de cada um
    // dos Storage Servers a porta sempre e dada pela constante, usando
    // a funcao GetStorageServersAddress da classe DiskMgr.
    m_DiskMgr->GetStorageServersAddress( &m_ServerAddress[ 1 ] );
    // Inicializa o novo campo usado para indicar o tempo maximo que o servidor 
    // espera por uma requisicao de um cliente. Se a opcao nao for usada, ou se 
    // o seu valor for 0, entao nao teremos um tempo maximo (como ocorria 
    // antes).
    m_ClientsTimeOut = Config->ClientsTimeOut;

    m_TCPconnection = new CRioTCP;

    int hResult = m_TCPconnection->InitServer( RioTCPport );
    if( FAILED( hResult) )
    {
        if( m_log.is_open() )
            m_log << "Initialize(): Failed to Initialize server TCP connection,"
                  <<  " rc: " << hResult << endl;
        CleanUp();
        return hResult;
    }

    pthread_attr_init( &attrib );
    pthread_attr_setstacksize( &attrib, 2*PTHREAD_STACK_MIN );

    if( pthread_create( &m_ConnectionThreadId, &attrib, &ConnectionThread,
                        this ) )
    {
        if( m_log.is_open() )
        {
            m_log << "Start(): Failed to create thread (connection thread)"
                  << endl << "  ERROR: " << strerror(errno) << endl;
        }
        CleanUp();
        return ERROR_SESSIONMANAGER + ERROR_CREATE_THREAD;
    }

    // Inicializa o ponteiro para o objeto da classe NetMgr (m_NetMgr) com o
    // objeto criado ao inicializarmos o objeto da classe CStreamManager.
    m_NetMgr = m_StreamManager->getNetMgr();

    // Inicializa o ponteiro para o objeto da classe CNetInterface 
    // (m_NetInterface) com o objeto criado ao inicializarmos o objeto da classe
    // CStreamManager.
    m_NetInterface = m_StreamManager->getNetInterface();
    
    // Cria o objeto da classe CLogRotation, que ira armazenar os logs de acesso
    // dos clientes.
    // Cria o novo objeto da classe CLogRotation.
    m_LogRotation = new CLogRotation;
    if( m_LogRotation == NULL )
    {
        if( m_log.is_open() )
            m_log << "Initialize(): erro ao criar o objeto com os logs." 
                  << endl;
        CleanUp();
        return ERROR_SESSIONMANAGER + ERROR_MEMORY;
    }
    else
    {    
        // Define o nome para os prefixo dos logs.
        char LogFileNamePrefix[  MaxPathSize ];
        strcpy( LogFileNamePrefix, Config->LogsDirectory );
        strcat( LogFileNamePrefix, "ServerLog_" );
        // Adiciona o IP do servidor (a porta nao sera necessaria, pois dois 
        // servidores nao podem executar na mesma maquina).
        strcat( LogFileNamePrefix, inet_ntoa( m_ServerAddress[ 0 ].sin_addr ) );
        
        #ifdef RIO_DEBUG2 
        RioErr << "CSessionManager::Initialize LogFileNamePrefix = " 
               << LogFileNamePrefix << endl;
        #endif       
               
        if( m_LogRotation->Initialize( LogFileNamePrefix, 
                                       Config->MaxLogFileSize, 
                                       Config->MaxCombinedLogFilesSize,
                                       Config->SaveLogs ) != S_OK )
        {           
            if( m_log.is_open() )
                m_log << "Initialize(): erro ao inicializar o objeto com os "
                      << "logs." << endl;
            delete m_LogRotation;
            m_LogRotation = NULL;          
            CleanUp();
            return ERROR_SESSIONMANAGER + ERROR_INITIALIZE_LOGROTATION;
        }
        // Cria a nova classe para fazer buscas nos logs dos clientes.
        m_SearchLogs = new CSearchLogs;
        if( m_SearchLogs == NULL )
        {
            // Devemos ou nao parar o servidor neste caso?
            if( m_log.is_open() )
                m_log << "Initialize(): erro ao criar o objeto de busca nos "
                      << "logs."
                      << endl;
            delete m_LogRotation;
            m_LogRotation = NULL;          
            CleanUp();
            return ERROR_SESSIONMANAGER + ERROR_MEMORY;
        }     
        if( m_SearchLogs->Initialize( m_LogRotation, m_NetMgr, m_LogsDirectory, 
                                      "Server-", m_BlockSize, m_NetInterface ) 
                                      != S_OK )
        {
            // Devemos ou nao parar o servidor neste caso?
            if( m_log.is_open() )
                m_log << "Initialize(): erro ao inicializar o objeto de busca "
                      << "nos logs."
                      << endl;
            delete m_LogRotation;
            m_LogRotation = NULL;          
            delete m_SearchLogs;
            m_SearchLogs = NULL;          
            CleanUp();
            return ERROR_SESSIONMANAGER + ERROR_INITIALIZE_SEARCHLOGS;
        }                           
    }
    
    m_initialized = true;

    return S_OK;
}

void CSessionManager::InvalidateStorageNatMappings

(

int

StorageId

)

Funcao para invalidar todos os mapeamentos dos clientes conectados para um servidor de armazenamento identificado pela ID passada como parametro.

Parameters:

StorageId

Identificador do servidor de armazenamento.

Definition at line 915 of file server/SessionManager.cpp.

{
    NATData StorageNat;
    
    // Obtem o acesso exclusivo a estrutura m_SessionTable.
    pthread_mutex_lock( &m_mutex );
    // Varre as sessoes de todos os clientes conectados, invalidando os 
    // mapeamentos do servidor de armazenamento passado como parametro.
    for( int i = 0; i < m_MaxSessions; i++ )
        if( m_SessionTable[ i ].Session.Index != -1 )
        {
            StorageNat = m_Router->GetNATMapping( 
                                         m_SessionTable[ i ].s_ptr->s_ServerNat,
                                             StorageId );

            #ifdef RIO_DEBUG2         
            in_addr ip;                      
            ip.s_addr = StorageNat.nat_addr; 
            RioErr << "CSessionManager::InvalidateStorageNatMappings "
                   << " alterando endereco do servidor com a Id "  
                   << StorageId << " do IP " << inet_ntoa( ip ) << " e a porta "
                   << ntohs( StorageNat.nat_port ) << " para 0.0.0.0 e 0"
                   << endl;
            #endif       
                   
            // Altera o endereco para 255.255.255.255 (-1) e a porta para 0.                                     
            StorageNat.nat_addr = -1;                                  
            StorageNat.nat_port = 0;
            m_Router->SetNATMapping( m_SessionTable[ i ].s_ptr->s_ServerNat,
                                     StorageId, StorageNat );
            // Somente para confirmar a alteracao (REMOVER DEPOIS)                                  
            StorageNat = m_Router->GetNATMapping( 
                                         m_SessionTable[ i ].s_ptr->s_ServerNat,
                                             StorageId );

            #ifdef RIO_DEBUG2         
            ip.s_addr = StorageNat.nat_addr;          
            RioErr << "CSessionManager::InvalidateStorageNatMappings "
                   << " novo endereco para o servidor com a Id "  
                   << StorageId << ": IP " << inet_ntoa( ip ) << " e a porta "
                   << ntohs( StorageNat.nat_port ) << endl;
            #endif
            
            // Verifica se precisamos invalidar o mapeamento da nova 
            // implementacao de rede.
            //
            // TODO: Remover todo o codigo dentro do if a seguir, incluindo o 
            // comando if, quando a RioNeti e a NetMgr nao forem mais usadas.
            //
            if( m_Router->FindNATMapping( 
                                         m_SessionTable[ i ].s_ptr->s_ServerNat,
                                         StorageId + m_NumberOfStorageNodes ) )
            {
                StorageNat = m_Router->GetNATMapping( 
                                         m_SessionTable[ i ].s_ptr->s_ServerNat,
                                           StorageId + m_NumberOfStorageNodes );

                #ifdef RIO_DEBUG2         
                in_addr ip;                      
                ip.s_addr = StorageNat.nat_addr; 
                RioErr << "CSessionManager::InvalidateStorageNatMappings "
                       << " alterando endereco do servidor com a Id "   
                       << StorageId + m_NumberOfStorageNodes << " do IP " 
                       << inet_ntoa( ip ) << " e a porta "
                       << ntohs( StorageNat.nat_port ) << " para 0.0.0.0 e 0"
                       << endl;
                #endif       
                   
                // Altera o endereco para 255.255.255.255 (-1) e a porta para 0.                                     
                StorageNat.nat_addr = -1;                                  
                StorageNat.nat_port = 0;
                m_Router->SetNATMapping( m_SessionTable[ i ].s_ptr->s_ServerNat,
                                         StorageId + m_NumberOfStorageNodes, 
                                         StorageNat );
                // Somente para confirmar a alteracao (REMOVER DEPOIS)                                  
                StorageNat = m_Router->GetNATMapping( 
                                        m_SessionTable[ i ].s_ptr->s_ServerNat,
                                           StorageId + m_NumberOfStorageNodes );

                #ifdef RIO_DEBUG2         
                ip.s_addr = StorageNat.nat_addr;          
                RioErr << "CSessionManager::InvalidateStorageNatMappings "
                       << " novo endereco para o servidor com a Id "  
                       << StorageId + m_NumberOfStorageNodes << ": IP " 
                       << inet_ntoa( ip ) << " e a porta " 
                       << ntohs( StorageNat.nat_port ) << endl;
                #endif
            }
                                                 
        }
    // Libera o acesso exclusivo a estrutura m_SessionTable.
    pthread_mutex_unlock( &m_mutex );
}

void CSessionManager::KillConnectionThread

(

)

[private]

Definition at line 395 of file server/SessionManager.cpp.

{
    if( m_ConnectionThreadId != 0 )
    {
        // Signal event for thread termination
        m_threadStopEvent = 1;

        // make a connection to wake up the accept in RioTCP.WaitConnection
        char LocalName[256];
        hostent* LocalAddress;
        struct in_addr LocalIPaddress;
        int x_sock;
        if( gethostname( LocalName, 256 ) != 0 )
        {
            RioErr << "SessionManager.KillConnectionThread: gethostname failed "
                   << strerror(errno) << endl;
            goto closeit;
        }

        // Get host IP address
         LocalAddress = gethostbyname(LocalName);
        if( LocalAddress == 0 )
        {
            RioErr << "SessionManager.KillConnectionThread: gethostbyname failed "
                   << strerror(errno) << endl;
            goto closeit;
        }

        memcpy( &LocalIPaddress, LocalAddress->h_addr,
                sizeof( LocalIPaddress ) );

        // For connection thread closing socket should make the
        // thread exit the accept() call
        // {no it doesn't appear to on Linux, so first
        // {make a connection to wake up accept.    Since
        // {m_threadStopEvent is set, the connection thread will
        // {terminate once it wakes...

        x_sock = socket( AF_INET, SOCK_STREAM, 0 );
        SOCKADDR_IN xaddr;
        memset( &xaddr, 0, sizeof( xaddr ));
        xaddr.sin_family = AF_INET;
        xaddr.sin_addr.s_addr = LocalIPaddress.s_addr;
        xaddr.sin_port = htons(RioTCPport);

        connect( x_sock, (SOCKADDR*) &xaddr, sizeof( xaddr ));

    closeit:

        // closing TCP connection should make the
        // thread exit the WaitConnection() call
        m_TCPconnection->CloseSocket();

        // wait for thread to exit
        pthread_join( m_ConnectionThreadId, NULL );

        m_ConnectionThreadId = 0;
    }
}

HRESULT CSessionManager::Open	(	const char *	Username,
		const char *	Password,
		RioSessionId *	Session
	)

Definition at line 64 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error Open:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    #ifdef WINDOWS
    // Windows implementation
    struct _SYSTEMTIME RTT_aux;
    #else
    // Linux implementation
    struct timeval RTT_aux;
    #endif

    ParameterSize = strlen( UserName ) + strlen( Password ) +2;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set User name
    SetString( Parameter,UserName,&offset );
    // Set Password
    SetString( Parameter,Password,&offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    // calculating RTT
    #ifdef WINDOWS
    // Windows implementation
    GetSystemTime( &m_RTT_openConnection );
    #else
    // Linux implementation
    gettimeofday( &m_RTT_openConnection, 0 );
    #endif

    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerOpen,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    #ifdef WINDOWS
    // Windows implementation
    GetSystemTime( &RTT_aux );
    m_RTT_openConnection.wSecond = RTT_aux.wSecond - m_RTT_openConnection.wSecond;
    m_RTT_openConnection.wMilliseconds = RTT_aux.wMilliseconds - m_RTT_openConnection.wMilliseconds;
    if( m_RTT_openConnection.wMilliseconds < 0 )
    {
        m_RTT_openConnection.wSecond  -=  1;
        m_RTT_openConnection.wMilliseconds = m_RTT_openConnection.wMilliseconds + 1000000;
    }
    #else
    // Linux implementation
    gettimeofday( &RTT_aux, 0 );
    m_RTT_openConnection.tv_sec = RTT_aux.tv_sec - m_RTT_openConnection.tv_sec;
    m_RTT_openConnection.tv_usec = RTT_aux.tv_usec - m_RTT_openConnection.tv_usec;
    if( m_RTT_openConnection.tv_usec < 0 )
    {
        m_RTT_openConnection.tv_sec  -=  1;
        m_RTT_openConnection.tv_usec += 1000000;
    }
    #endif

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result, ResultSize, &status, &offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    // Get Session Id
    if( !GetLong( Result, ResultSize, &( Session->Version ), &offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    if( !GetLong( Result, ResultSize, &( Session->Index ), &offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    if( FAILED( status ) )
    {
        free( Parameter );
        free( Result );

        return status;
    }
    else
    {
        unsigned int BlockSize;
        if( !GetULong( Result, ResultSize, &BlockSize, &offset ) )
        {
            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }

        free( Parameter );
        free( Result );

        return ( int ) BlockSize;
    }
}

HRESULT CSessionManager::OpenStream	(	const RioSessionId	Session,
		const RioStreamTraffic *	Traffic,
		RioStreamId *	Stream,
		int *	MaxRequests
	)

Definition at line 291 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error OpenStream:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    #ifdef WINDOWS
    // Windows implementation
    _SYSTEMTIME RTT_aux;
    #else
    // Linux implementation
    struct timeval RTT_aux;
    #endif

    if( Traffic->Type == RIO_TRAFFIC_CBR )
    {
        ParameterSize = 2 * MAX_LONG_STRING_SIZE +
                        2 * MAX_SHORT_STRING_SIZE + MAX_ULONG_STRING_SIZE +
                            MAX_LONG_STRING_SIZE + MAX_DOUBLE_STRING_SIZE +
                            MAX_SHORT_STRING_SIZE;
    }
    else
    {
        ParameterSize = 2 * MAX_LONG_STRING_SIZE +
                        2 * MAX_SHORT_STRING_SIZE + MAX_ULONG_STRING_SIZE +
                            MAX_LONG_STRING_SIZE + MAX_ULONG_STRING_SIZE  +
                        MAX_SHORT_STRING_SIZE;
    }
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter, Session.Version, &offset );
    SetLong( Parameter, Session.Index, &offset );
    // Set Traffic description
    SetShort( Parameter, Traffic->Type, &offset );
    SetShort( Parameter, Traffic->Direction, &offset );
    SetULong( Parameter, Traffic->LogicalBlockSize, &offset );
    SetLong( Parameter, Traffic->MaxRequests, &offset );

    if( Traffic->Type == RIO_TRAFFIC_CBR )
    {
        SetDouble( Parameter, Traffic->TrafficCBR.Rate, &offset );
    }
    else if( Traffic->Type == RIO_TRAFFIC_VBR )
    {
        SetDouble( Parameter, Traffic->TrafficVBR.Rate, &offset );
    }
    else
    {
        SetULong( Parameter, Traffic->TrafficNRT.Reserved, &offset );
    }

    // Update Parameter size to actual size ( previously was maximum
    // possible size )
    ParameterSize = offset;

    // Call remote method
    // calculating RTT
    #ifdef WINDOWS
    // Windows implementation
    GetSystemTime( &m_RTT_openStream );
    #else
    // Linux implementation
    gettimeofday( &m_RTT_openStream, 0 );
    #endif

    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerOpenStream,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    #ifdef WINDOWS
    // Windows implementation
    GetSystemTime( &RTT_aux );
    m_RTT_openStream.wSecond = RTT_aux.wSecond - m_RTT_openStream.wSecond;
    m_RTT_openStream.wMilliseconds = RTT_aux.wMilliseconds -
                                     m_RTT_openStream.wMilliseconds;
    if( m_RTT_openStream.wMilliseconds < 0 )
    {
        m_RTT_openStream.wSecond  -= 1;
        m_RTT_openStream.wMilliseconds = m_RTT_openConnection.wMilliseconds +
                                         1000000;
    }
    #else
    // Linux implementation
    gettimeofday( &RTT_aux, 0 );
    m_RTT_openStream.tv_sec = RTT_aux.tv_sec - m_RTT_openStream.tv_sec;
    m_RTT_openStream.tv_usec = RTT_aux.tv_usec - m_RTT_openStream.tv_usec;
    if( m_RTT_openStream.tv_usec < 0 )
    {
        m_RTT_openStream.tv_sec  -= 1;
        m_RTT_openStream.tv_usec += 1000000;
    }
    #endif

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result, ResultSize, &status, &offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    // Get Stream id
    if( !GetLong( Result, ResultSize, &( Stream->Version ), &offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }
    if( !GetLong( Result, ResultSize, &( Stream->Index ), &offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    if( FAILED( status ) )
    {
        free( Parameter );
        free( Result );

        return status;
    }
    else
    {
        if( !GetLong( Result, ResultSize, MaxRequests, &offset ) )
        {
            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }

        free( Parameter );
        free( Result );

        return S_OK;
    }
}

void CSessionManager::PostITEvent

(

MonitorEvent *

event

)

[private]

Definition at line 853 of file server/SessionManager.cpp.

{
    m_SystemManager->PostITEvent( event );
}

HRESULT CSessionManager::RemoveResultFile	(	int	ServerIP,
		int	ServerPort,
		unsigned long long int	ResultFileId
	)

Nova funcao para informar ao servidor que o arquivo com o resultado da busca pode ser removido.

Parameters:

	ServerIp	endereco IP do servidor.
	ServerPort	porta (a UDP) usada por este servidor.
	ResultFileId	valor usado para identificar o arquivo com o resultado da busca no servidor, retornado quando recebemos a informacao de que a busca foi feita com sucesso.

Returns:

S_OK se o pedido de remocao do arquivo foi feito com sucesso, ou um valor diferente de S_OK se algum erro ocorreu.

Definition at line 2781 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;
    int           offset;

    if( Parameter == NULL )
    {
        #ifdef RIO_DEBUG1
        RioErr << "malloc error ResultFileBlockRequest:" << strerror(errno) 
               << endl;
        #endif
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2 * MAX_ULONG_STRING_SIZE + MAX_LONG_STRING_SIZE + 
                    MAX_SHORT_STRING_SIZE;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }
    
    offset = 0;

    // Armazena o IP do servidor.
    SetLong( Parameter, ServerIP, &offset );
    // Armazena a porta do servidor. 
    SetShort( Parameter, ServerPort, &offset );
    // Armazena a parte inferior do identificador  do arquivo.
    SetULong( Parameter, ( unsigned int ) ( ResultFileId & 0xFFFFFFFF ), 
              &offset );
    // Armazena a parte superior do identificador  do arquivo.
    SetULong( Parameter, ( unsigned int ) ( ResultFileId >> 32 ), &offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Faz a chamada remota a uma funcao do Servidor RIO para inicializar a 
    // solicitacao de busca.
    status = m_TCPconnection->Call( RioClassRouter,
                                    RioMethodRouterRemoveSearchResultFile,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
    }
    else
    {
        offset = 0;
        // Get results from result buffer
        // Get method return value
        if( Result == NULL )
            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    

        if( !GetLong( Result,ResultSize,&status,&offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
    }

    free( Result );

    return status;
}

HRESULT CSessionManager::RemoveUser

(

char *

UserName

)

Nova funcao para remover a senha do usuario.

Obs: devido ao servidor nao fazrer uma remocao do diretorio se ele nao estiver vazio, o diretorio do usuario nao sera removido.

Parameters:

UserName

ponteiro para a string com o nome do usuario.

Returns:

S_OK se o usuario foi criado com sucesso ou um valor diferente de S_OK se algum erro ocorreu ao fazermos a chamada remota.

Definition at line 2945 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error RemoveUser:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = strlen( UserName ) + 1;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set UserName
    SetString( Parameter, UserName, &offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassUserManager,
                                    RioMethodUserManagerRemoveUser,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result, ResultSize, &status, &offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::RenameObject	(	const RioSessionId	Session,
		const char *	CurrentName,
		const char *	NewName
	)

Definition at line 639 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error RenameObject:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2 * MAX_LONG_STRING_SIZE +
                        strlen( CurrentName )+1 +
                        strlen( NewName )+1;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Set Object Current  Name
    SetString( Parameter,CurrentName,&offset );

    // Set Object New Name
    SetString( Parameter,NewName,&offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerRenameObject,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::ResultFileBlockRequest	(	int	ServerIP,
		int	ServerPort,
		int	ClientIP,
		int	ClientPort,
		unsigned long long int	ResultFileId,
		unsigned int	Block,
		int	ReqId
	)

Nova funcao para ler um bloco do arquivo com os resultados da busca.

Parameters:

	ServerIp	endereco IP do servidor.
	ServerPort	porta (a UDP) usada por este servidor.
	ClientIp	endereco IP do cliente.
	ClientPort	porta (a UDP) usada por este cliente.
	ResultFileId	valor usado para identificar o arquivo com o resultado da busca no servidor, retornado quando recebemos a informacao de que a busca foi feita com sucesso.
	Block	numero do bloco que desejamos obter.
	ReqId	identificador que deve ser usado pelo servidor ao enviar o bloco do arquivo ao cliente.

Returns:

S_OK se o pedido do bloco foi feito com sucesso, ou um valor diferente de S_OK se o pedido nao foi feito com sucesso.

Definition at line 2679 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;
    int           offset;

    if( Parameter == NULL )
    {
        #ifdef RIO_DEBUG1
        RioErr << "malloc error ResultFileBlockRequest:" << strerror(errno) 
               << endl;
        #endif
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 3 * MAX_ULONG_STRING_SIZE + 3 * MAX_LONG_STRING_SIZE + 
                    2 * MAX_SHORT_STRING_SIZE;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }
    
    offset = 0;

    // Armazena o IP do servidor.
    SetLong( Parameter, ServerIP, &offset );
    // Armazena a porta do servidor. 
    SetShort( Parameter, ServerPort, &offset );
    // Armazena o IP do cliente.
    SetLong( Parameter, ClientIP, &offset );
    // Armazena a porta do cliente. 
    SetShort( Parameter, ClientPort, &offset );
    // Armazena a parte inferior do identificador  do arquivo.
    SetULong( Parameter, ( unsigned int ) ( ResultFileId & 0xFFFFFFFF ), 
              &offset );
    // Armazena a parte superior do identificador  do arquivo.
    SetULong( Parameter, ( unsigned int ) ( ResultFileId >> 32 ), &offset );
    // Armazena o numero do bloco a ser requisitado.
    SetLong( Parameter, Block, &offset );
    // Armazena o identificador para a resposta da solicitacao de busca.
    SetLong( Parameter, ReqId, &offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Faz a chamada remota a uma funcao do Servidor RIO para inicializar a 
    // solicitacao de busca.
    status = m_TCPconnection->Call( RioClassRouter,
                                    RioMethodRouterSearchResultDataRequest,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );


    free( Parameter );
    
    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
    }
    else
    {
        offset = 0;
        // Get results from result buffer
        // Get method return value
        if( Result == NULL )
            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    

        if( !GetLong( Result,ResultSize,&status,&offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
    }

    free( Result );

    return status;
}

int CSessionManager::SaveMeasures

(

)

Definition at line 836 of file server/SessionManager.cpp.

{
    int result1;

    result1 = m_StreamManager->SaveMeasures();

    return result1;
}

HRESULT CSessionManager::SaveMeasures

(

const RioSessionId

Session

)

Definition at line 1747 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error SaveMeasures:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2 * MAX_LONG_STRING_SIZE;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    // Set parameters on asii buffer
    // Set Session Id
    SetLong( Parameter,Session.Version,&offset );
    SetLong( Parameter,Session.Index,&offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassSessionManager,
                                    RioMethodSessionManagerSaveMeasures,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
        if( Result != NULL )
            free( Result );
        free( Parameter );

        return status;
    }

    offset = 0;
    // Get results from result buffer
    // Get method return value
    if( !GetLong( Result,ResultSize,&status,&offset ) )
    {
        free( Parameter );
        free( Result );

        return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    }

    free( Parameter );
    free( Result );

    return status;
}

HRESULT CSessionManager::SearchLogsRequest	(	unsigned int	SearchType,
		time_t	StartTime,
		time_t	EndTime,
		int	ServerIP,
		int	ServerPort,
		int	ClientIP,
		int	ClientPort,
		int	ReqId
	)

Nova funcao para solicitar uma busca em um conjunto de logs de um dos servidores.

Parameters:

	SearchType	tipo da busca, que por enquanto, pode ser SEARCHINTRAFFICLOGS para fazer busca nos logs com os trafegos de um dos servidores de armazenamento, ou SEARCHINCLIENTSLOGS para fazer uma busca nos logs com os comportamentos dos clientes do servidor de despacho.
	StartTime	Tempo inicial da busca (baseado no mesmo principio da funcao time da biblioteca do C, isto e, o tempo em segundos desde a Epoch (00:00:00 UTC, Janeiro 1 de 1970).
	EndTime	Tempo Final da busca (o mesmo princio do tempo inicial dado acima).
	ServerIp	endereco IP do servidor.
	ServerPort	porta (a UDP) usada por este servidor.
	ClientIp	endereco IP do cliente.
	ClientPort	porta (a UDP) usada por este cliente.
	ReqId	identificador que deve ser usado pelo servidor ao enviar o resultado da busca.

Returns:

S_OK se a solicitacao de busca foi inicializada com sucesso, ou um valor diferente de S_OK se a solicitacao nao foi iniciada com sucesso. No caso do fracasso, se o erro e ERROR_INVALID_METHOD, isso naoindicara um erro e sim, que o servidor nao possui suporte para fazer as buscas.

Definition at line 2578 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;
    int           offset;

    if( Parameter == NULL )
    {
        #ifdef RIO_DEBUG1
        RioErr << "malloc error SearchLogsRequest:" << strerror(errno) 
               << endl;
        #endif
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 3 * MAX_LONG_STRING_SIZE + 3 * MAX_ULONG_STRING_SIZE + 
                    2 * MAX_SHORT_STRING_SIZE;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }
    
    offset = 0;

    // Armazena o tipo da busca na mensagem.
    SetULong( Parameter, SearchType, &offset );
    // Armazena o tempo inicial da busca na mensagem.
    SetULong( Parameter, ( unsigned int ) StartTime, &offset );
    // Armazena o tempo Final na mensagem.
    SetULong( Parameter, ( unsigned int ) EndTime, &offset );
    // Armazena o IP do servidor.
    SetLong( Parameter, ServerIP, &offset );
    // Armazena a porta do servidor. 
    SetShort( Parameter, ServerPort, &offset );
    // Armazena o IP do cliente.
    SetLong( Parameter, ClientIP, &offset );
    // Armazena a porta do cliente. 
    SetShort( Parameter, ClientPort, &offset );
    // Armazena o identificador para a resposta da solicitacao de busca.
    SetLong( Parameter, ReqId, &offset );

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Faz a chamada remota a uma funcao do Servidor RIO para inicializar a 
    // solicitacao de busca.
    status = m_TCPconnection->Call( RioClassRouter,
                                    RioMethodRouterSearchLogsRequest,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );


    free( Parameter );

    // check if call failed
    if( FAILED( status ) )
    {
        if( ( unsigned int ) status == ( ERROR_RIOTCP + ERROR_MEMORY ) )
            status = ERROR_RIOPROXY + ERROR_MEMORY;
    }
    else
    {
        offset = 0;
        // Get results from result buffer
        // Get method return value
        if( Result == NULL )
            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
    

        if( !GetLong( Result,ResultSize,&status,&offset ) )
        {
            free( Parameter );
            free( Result );

            return ERROR_RIOPROXY + ERROR_MESSAGE_DATA_FORMAT;
        }
    }

    free( Result );

    return status;
}

HRESULT CSessionManager::SendNATMappings	(	int *	addrs,
		int *	ports,
		unsigned int	size
	)

Definition at line 1989 of file interface/SessionManager.cpp.

{
    char          *Parameter = (char*) malloc( MaxTCPDataSize*sizeof(char) );
    char          *Result;
    unsigned int  ParameterSize;
    unsigned int  ResultSize;
    HRESULT        status;

    if( Parameter == NULL )
    {
        RioErr << "malloc error GetStorageNodeInfo:" << strerror(errno) << endl;
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_MEMORY;
    }

    memset( Parameter, 0, MaxTCPDataSize*sizeof( char ) );

    ParameterSize = 2 * size * MAX_LONG_STRING_SIZE;
    // Check if Parameter buffer is large enough
    if( ParameterSize > ( unsigned int ) MaxTCPDataSize )
    {
        free( Parameter );

        return ERROR_RIOPROXY + ERROR_CALL_MESSAGE_OVERFLOW;
    }

    int offset = 0;

    #ifdef RIO_DEBUG2
    RioErr << "[CSessionManager] Sending mappings to server" << endl;
    #endif
    // Set parameters on asii buffer
    for( unsigned int i = 0; i < size; i++ )
    {
        #ifdef RIO_DEBUG2
        struct in_addr ip;
        ip.s_addr = addrs[i];
        RioErr << "[CSessionManager] Mapping #" << i << ": "
               << inet_ntoa(ip) << ", " << htons(ports[i]) << endl;
        #endif
        // Set IP
        SetLong( Parameter, addrs[i], &offset );
        // Set Port
        SetLong( Parameter, ports[i], &offset );
    }

    // Update Parameter size to actual size
    // ( previously was maximum possible size )
    ParameterSize = offset;

    // Call remote method
    status = m_TCPconnection->Call( RioClassRouter,
                                    RioMethodRouterSetNATMappings,
                                    ParameterSize,
                                    Parameter,
                                    &ResultSize,
                                    &Result );

    // check if call failed
    if( FAILED( status ) )
    {
        // Se ocorreu algum erro, ou o metodo nao existe, ou ocorreu algum
        // erro ao executar o metodo.
        return status;
    }

    free( Parameter );
    free( Result );
    
    return status;
}

void CSessionManager::SetNATMapping	(	NATData	server_map,
		int	stor_id,
		NATData	stor_map
	)			[private]

SetNATMapping informa ao Router o mapeamento NAT de um cliente com um storage.

Sao enviados o mapeamento NAT do cliente com o servidor, o id do storage e o mapeamento NAT do cliente com o storage considerado.

Parameters:

	server_map	estrutura identificando o mapeamento do servidor de gerenciamento.
	stor_id	identificador do servidor de armazenamento.
	stor_map	estrutura identificando o mapeamento do servidor de armazenamento com o identificador stor_id.

Definition at line 903 of file server/SessionManager.cpp.

{
    m_Router->SetNATMapping( server_map, stor_id, stor_map );
}

void CSessionManager::SetNumberOfDisks

(

unsigned int

NumberOfDisks

)

Funcao para alterar o valor do numero de discos do servidor.

Ela foi necessaria porque, quando os servidores de armazenamento inicializam apos o servidor.

Parameters:

NumberOfDisks

novo numero de discos.

Definition at line 1012 of file server/SessionManager.cpp.

{
    m_NumberOfDisks = NumberOfDisks;
}

---

Friends And Related Function Documentation

friend class RioSession [friend]

Definition at line 478 of file server/SessionManager.h.

---

Field Documentation

unsigned int CSessionManager::m_BlockSize [private]

Definition at line 396 of file server/SessionManager.h.

int CSessionManager::m_ClientsTimeOut [private]

Definition at line 436 of file server/SessionManager.h.

pthread_t CSessionManager::m_ConnectionThreadId [private]

Definition at line 424 of file server/SessionManager.h.

DiskMgr* CSessionManager::m_DiskMgr [private]

Definition at line 401 of file server/SessionManager.h.

char* CSessionManager::m_FileRoot [private]

Definition at line 404 of file server/SessionManager.h.

bool CSessionManager::m_initialized [private]

Definition at line 421 of file server/SessionManager.h.

ofstream CSessionManager::m_log [private]

Definition at line 422 of file server/SessionManager.h.

CLogRotation* CSessionManager::m_LogRotation [private]

Definition at line 440 of file server/SessionManager.h.

char* CSessionManager::m_LogsDirectory [private]

Definition at line 444 of file server/SessionManager.h.

int CSessionManager::m_MaxSessions [private]

Definition at line 407 of file server/SessionManager.h.

pthread_mutex_t CSessionManager::m_mutex [private]

Definition at line 420 of file server/SessionManager.h.

CNetInterface* CSessionManager::m_NetInterface [private]

Definition at line 416 of file server/SessionManager.h.

NetMgr* CSessionManager::m_NetMgr [private]

Definition at line 415 of file server/SessionManager.h.

unsigned int CSessionManager::m_NumberOfDisks [private]

Definition at line 399 of file server/SessionManager.h.

unsigned int CSessionManager::m_NumberOfStorageNodes [private]

Definition at line 400 of file server/SessionManager.h.

CObjectManager* CSessionManager::m_ObjectManager [private]

Definition at line 411 of file server/SessionManager.h.

CRouter* CSessionManager::m_Router [private]

Definition at line 413 of file server/SessionManager.h.

struct timeval m_RTT_openConnection CSessionManager::m_RTT_openStream [private]

Definition at line 239 of file interface/SessionManager.h.

CSearchLogs* CSessionManager::m_SearchLogs [private]

Definition at line 448 of file server/SessionManager.h.

SOCKADDR_IN* CSessionManager::m_ServerAddress [private]

Definition at line 426 of file server/SessionManager.h.

unsigned int CSessionManager::m_ServerAddressSize [private]

Definition at line 431 of file server/SessionManager.h.

SessionEntry* CSessionManager::m_SessionTable [private]

Definition at line 419 of file server/SessionManager.h.

CStreamManager* CSessionManager::m_StreamManager [private]

Definition at line 410 of file server/SessionManager.h.

CSystemManager* CSessionManager::m_SystemManager [private]

Definition at line 409 of file server/SessionManager.h.

CRioTCP * CSessionManager::m_TCPconnection [private]

Definition at line 235 of file interface/SessionManager.h.

bool CSessionManager::m_threadStopEvent [private]

Definition at line 425 of file server/SessionManager.h.

int CSessionManager::m_used [private]

Definition at line 418 of file server/SessionManager.h.

CUserManager* CSessionManager::m_UserManager [private]

Definition at line 412 of file server/SessionManager.h.

---

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

• interface/SessionManager.h
• server/SessionManager.h
• interface/SessionManager.cpp
• server/SessionManager.cpp