CRioSession Class Reference

#include <RioInterface.h>

Public Member Functions

 CRioSession ()
 ~CRioSession ()
RioResult Connect (const char *ServerMachine, const char *UserName, const char *Password, int RioServer)
RioResult Disconnect ()
RioResult CreateObject (const char *ObjectName, const short ObjectType, const RioSecurity *Security)
RioResult DeleteObject (const char *ObjectName)
RioResult RenameObject (const char *CurrentName, const char *NewName)
RioResult GetBlockSize (unsigned int *BlockSize)
RioResult ChangeDir (char *NewDir)
RioResult GetCurrentDir (char *Dir, const int SizeDir)
RioResult GetObjectInfo (const char *ObjectName, ObjectInfo *ObjectInfo)
char * GetServerName ()
RioResult GetNumberOfDisks (unsigned int *NumberOfDisks)
RioResult GetNumberOfStorageNodes (unsigned int *NumberOfStorageNodes)
RioResult GetNumberOfActiveAndMaxSessions (unsigned int *NumberOfActiveSessions, unsigned int *NumberOfMaxSessions)
RioResult SaveMeasures ()
RioResult GetStorageNodeInfo (RioStorageNodeInfo *StorageNodeInfo, unsigned int StorageNodeIndex)
RioResult GetMonitorTable (char *UserName, vector< ClientData > *client_data, vector< StorageData > *storage_data)
RioResult GetRTT (struct timeval *RTT_openConnection, struct timeval *RTT_openStream)
RioResult GetAverageRTT (struct timeval *RTT_average)
int getipaddr ()
bool isConnected (void)
RioResult GetId (RioSessionId *Id)
RioResult CheckStreamControl (bool *IsImplemented)
 Funcao que faz uma chamada remota a um procedimento do Servidor RIO para verificar se a versao do servidor suporta o controle de fluxo.
RioResult SearchLogs (unsigned int SearchType, time_t StartTime, time_t EndTime, int ServerIP, int ServerPort, char *ResultFileName, callback_t callback, void *callbackparam)
 Funcao para executar uma busca nos logs do servidor.
void GetServerAddress (struct sockaddr_in **ServerAddress, unsigned int *ServerAddressSize)
 Funcao para obter a lista de servidores associados a sessao.
int CheckServerAddress (char *ServerName, bool IsDispatcher, int *ServerIP, int *ServerPort)
 Funcao usada para verificar se o maquina cujo nome (que pode ser o IP ou o nome da maquina na Internet) passado como parametro e um dos servidores.
RioResult CreateUser (char *UserName, char *Password)
 Nova funcao para criar um usuario.
RioResult RemoveUser (char *UserName)
 Nova funcao para remover a senha do usuario.
RioResult ChangePassword (char *UserName, char *Password)
 Nova funcao para alterar a senha de um usuario.
RioResult GetUserList (vector< string > &UserList)
 Nova funcao para obter a lista com todos os usuarios.

Static Private Member Functions

static void ProcessSearchCmd (void *parm, char *pktp, int pktl)
 Funcao de callback usada para processar a mensagem do servidor do tipo TYPE_CMD para obter o tamanho do arquivo com o resultado da busca e o identificador deste arquivo.
static void FinalizeSearchCmd (void *parm, int result)
 Funcao de callback usada para finalizar o tratamento da mensagem do servidor do tipo TYPE_CMD para obter o tamanho do arquivo com o resultado da busca e o identificador deste arquivo.
static void FinalizeReadBlock (void *parm, int result)
 Funcao de callback usada para finalizar o recebimento de um bloco do arquivo.

Private Attributes

char * ServerName
RioSessionId m_SessionId
NetMgr * m_NetMgr
CSessionManager * m_SessionManager
CRioTCP * m_TCPconnection
int unsigned m_BlockSize
int m_MaxPktLen
struct sockaddr_in * m_ServerAddress
unsigned int m_ServerAddressSize
CNetInterface * m_NetInterface

Friends

class CRioStream
class CRioObject
class CRioDirectory

Detailed Description

Definition at line 144 of file RioInterface.h.

Constructor & Destructor Documentation

CRioSession::CRioSession (  ) 

Definition at line 59 of file RioSession.cpp.

00060 {
00061     #ifdef RIO_DEBUG1
00062     RioErr << "### [CRioSession - Constructor] Start" << endl;
00063     #endif
00064 
00065     m_SessionId.Version = -1;
00066     m_SessionId.Index   = -1;
00067     m_NetMgr            = NULL;
00068     m_SessionManager    = NULL;
00069     m_TCPconnection     = NULL;
00070     m_BlockSize         = 0;
00071     m_MaxPktLen         = 0;
00072 
00073     #ifdef RIO_DEBUG1
00074     RioErr << "### [CRioSession - Constructor] Finish" << endl;
00075     #endif
00076 
00077     // Inicializacos das novas variveis usadas pela implementacao que permite
00078     // clientes atras de NAT.
00079     m_ServerAddress = NULL;
00080     m_ServerAddressSize = 0;
00081     
00082     // Inicializa o novo ponteiro para a classe de gerenciamento de rede.
00083     m_NetInterface = NULL;
00084 }

CRioSession::~CRioSession (  ) 

Definition at line 86 of file RioSession.cpp.

00087 {
00088     // Variavel usada para armazenar o erro retornado pelas funcoes do RIO.
00089     RioResult RioStatus;
00090     
00091     #ifdef RIO_DEBUG1
00092     RioErr << "### [CRioSession - Destructor] Start" << endl;
00093     #endif
00094 
00095     if( isConnected() )
00096     {
00097         Disconnect();
00098     }
00099 
00100     if( m_NetMgr )
00101     {
00102         m_NetMgr->Stop();
00103         delete m_NetMgr;
00104         m_NetMgr = 0;
00105     }
00106     
00107     // Remove o objeto da nova classe de gerenciamento de rede.
00108     if( m_NetInterface != NULL )
00109     {
00110         RioStatus = m_NetInterface->Stop();
00111         #ifdef RIO_DEBUG2
00112         if( FAILED( RioStatus ) )
00113         {
00114             RioErr << "CRioSession::~CRioSession erro 0x" << hex << RioStatus 
00115                    << dec << " (" << GetErrorDescription( RioStatus ) 
00116                    << ") ao finalizar o objeto da classe CNetInterface."
00117                    << endl;             
00118         }
00119         #endif
00120         
00121         delete m_NetInterface;
00122         
00123         m_NetInterface = NULL;
00124     }
00125     
00126 
00127     #ifdef RIO_DEBUG1
00128     RioErr << "### [CRioSession - Destructor] Finish" << endl;
00129     #endif
00130 }

Member Function Documentation

RioResult CRioSession::ChangeDir ( char *  NewDir  ) 

Definition at line 896 of file RioSession.cpp.

00897 {
00898     #ifdef RIO_DEBUG1
00899     RioErr << "### [CRioSession - ChangeDir] Start" << endl;
00900     #endif
00901 
00902     // Check if we are connected
00903     if( !isConnected() )
00904     {
00905         #ifdef RIO_DEBUG1
00906         RioErr << "### [CRioSession - ChangeDir] Finish1" << endl;
00907         #endif
00908 
00909         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
00910     }
00911 
00912     // Call Session Manager Proxy
00913     HRESULT hResult;
00914     hResult = m_SessionManager->ChangeDir( m_SessionId,
00915                                             ( signed char* ) NewDir );
00916     if( FAILED( hResult ) )
00917     {
00918         #ifdef RIO_DEBUG1
00919         RioErr << "### [CRioSession - ChangeDir] Finish2" << endl;
00920         #endif
00921 
00922         return hResult;
00923     }
00924 
00925     #ifdef RIO_DEBUG1
00926     RioErr << "### [CRioSession - ChangeDir] Finish3" << endl;
00927     #endif
00928 
00929     return S_OK;
00930 }

RioResult CRioSession::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 2036 of file RioSession.cpp.

02037 {
02038     #ifdef RIO_DEBUG1
02039     RioErr << "### [CRioSession - ChangePassword] Start" << endl;
02040     #endif
02041 
02042     // Check if we are connected
02043     if( !isConnected() )
02044     {
02045         #ifdef RIO_DEBUG1
02046         RioErr << "### [CRioSession - ChangePassword] Finish1" << endl;
02047         #endif
02048 
02049         // Check if we are connected
02050         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
02051     }
02052 
02053     // Call Session Manager Proxy
02054     HRESULT hResult;
02055     hResult = m_SessionManager->ChangePassword( UserName, Password );
02056     if( FAILED( hResult ) )
02057     {
02058         #ifdef RIO_DEBUG1
02059         RioErr << "### [CRioSession - ChangePassword] Finish2" << endl;
02060         #endif
02061 
02062         return hResult;
02063     }
02064 
02065     #ifdef RIO_DEBUG1
02066     RioErr << "### [CRioSession - ChangePassword] Finish3" << endl;
02067     #endif
02068 
02069     return S_OK;
02070 }

int CRioSession::CheckServerAddress ( char *  ServerName,
bool  IsDispatcher,
int *  ServerIP,
int *  ServerPort 
)

Funcao usada para verificar se o maquina cujo nome (que pode ser o IP ou o nome da maquina na Internet) passado como parametro e um dos servidores.

No caso de ser um dos servidores, o seu par IP, porta e retornado nos ponteiros passados como parametro a funcao. Em caso contrario, sera retornado 0 em ambos os parametros.

Parameters:
ServerName nome da maquina a ser verificada.
IsDispatcher identifica se desejamos fazer uma busca nos logs do servidor de despacho. Isso sera usado para definir, quando existir um servidor de despacho e de armazenamento na mesma maquina, qual posicao de m_ServerAddress devera ser retornada.
ServerIP ponteiro para um inteiro que ira armazenar o endereco IP do servidor.
ServerPort ponteiro para um inteiro que ira armazenar a porta do servidor.
Returns:
-2 se nao foi possivel obter um endereco IP para a maquina, -1 se a maquina nao for um servidor de gerenciamento ou de armazenamento, e a posicao do servidor em m_ServerAddress em caso contrario. Caso existam, na mesma maquina, um servidor de despacho e um de armazenamento, a posicao retornada dependera de IsDispatcher.

Definition at line 1903 of file RioSession.cpp.

01905 {
01906     // Armazena as informacoes lidas da maquina.
01907     struct hostent* hostaddress;
01908     // Armazena a posicao dos IPs em h_addr_list.
01909     int PosIP;
01910     // Variavel para armazenar um dos enderecos da maquina.
01911     in_addr HostIP;
01912     // Variavel para armazenar a posicao do servidor em m_ServerAddress.
01913     int PosServer;
01914     // Inicialmente supomos que o nome nao esta associado a um servidor
01915     *ServerIP = 0;
01916     *ServerPort = 0;
01917     PosServer = -1;
01918     // Tenta obter o par IP, porta do servidor cujo nome foi passado como 
01919     // parametro.
01920     hostaddress = gethostbyname( ServerName );
01921     if( hostaddress == NULL )
01922     { 
01923         // O nome da maquina nao existe.
01924         return -2;
01925     }
01926     // Procura o par IP, porta no vetor com o IP, porta dos servidores.
01927     for( unsigned int i = 0; i < m_ServerAddressSize; i++ )
01928     {
01929         PosIP = 0;
01930         while( hostaddress->h_addr_list[ PosIP ] != NULL )
01931         {
01932             // Inicializa a variavel HostIP com o IP dado na posicao PosIP do
01933             // vetor h_addr_list.
01934             memset( &HostIP, 0, sizeof( HostIP ) );
01935             memcpy( &HostIP, hostaddress->h_addr_list[ PosIP ], 
01936                     hostaddress->h_length );
01937             
01938             #ifdef RIO_DEBUG2       
01939             RioErr << "CRioSession::CheckServerAddress "
01940                    << "m_ServerAddress[ " << i << " ].sin_addr.s_addr = "
01941                    << inet_ntoa( m_ServerAddress[ i ].sin_addr ) << endl;
01942             RioErr << "CRioSession::CheckServerAddress "
01943                    << "hostaddress->h_addr_list[ " << PosIP << " ] = "
01944                    << inet_ntoa( HostIP ) << endl;
01945             #endif
01946 
01947             if( m_ServerAddress[ i ].sin_addr.s_addr == HostIP.s_addr )  
01948             {
01949                 *ServerIP = m_ServerAddress[ i ].sin_addr.s_addr;
01950                 *ServerPort = m_ServerAddress[ i ].sin_port;
01951                 PosServer = i;
01952                 if( ( i > 0 ) || ( ( i == 0 ) && ( IsDispatcher ) ) )
01953                     break;
01954             }
01955             PosIP++;
01956         }
01957     }
01958     return PosServer;
01959 }

RioResult CRioSession::CheckStreamControl ( bool *  IsImplemented  ) 

Funcao que 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). Obs: este funcao foi baseada nas outras funcoes da classe que usam alguma funcao do objeto m_SessionManager.
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 1292 of file RioSession.cpp.

01293 {
01294     #ifdef RIO_DEBUG1
01295     RioErr << "### [CRioSession - CheckStreamControl] Start" << endl;
01296     #endif
01297 
01298     // Check if we are connected
01299     if( !isConnected() )
01300     {
01301         #ifdef RIO_DEBUG1
01302         RioErr << "### [CRioSession - CheckStreamControl] Finish1" << endl;
01303         #endif
01304 
01305         // Check if we are connected
01306         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
01307     }
01308 
01309     // Call Session Manager Proxy
01310     HRESULT hResult;
01311     hResult = m_SessionManager->CheckStreamControl( IsImplemented );
01312     if( FAILED( hResult ) )
01313     {
01314         #ifdef RIO_DEBUG1
01315         RioErr << "### [CRioSession - CheckStreamControl] Finish2" << endl;
01316         #endif
01317 
01318         return hResult;
01319     }
01320 
01321     #ifdef RIO_DEBUG1
01322     RioErr << "### [CRioSession - CheckStreamControl] Finish3" << endl;
01323     #endif
01324 
01325     return S_OK;
01326 }

RioResult CRioSession::Connect ( const char *  ServerMachine,
const char *  UserName,
const char *  Password,
int  RioServer 
)

Definition at line 148 of file RioSession.cpp.

00153 {
00154     #ifdef RIO_DEBUG1
00155     RioErr << "### [CRioSession - Connect] Start" << endl;
00156     #endif
00157 
00158     int rc;
00159     unsigned short TCPport;
00160 
00161     // Check if we are not already connected
00162     if( isConnected() )
00163     {
00164         #ifdef RIO_DEBUG1
00165         RioErr << "### [CRioSession - Connect] Finish1" << endl;
00166         #endif
00167 
00168         return ERROR_RIOSESSION + ERROR_SESSION_ALREADY_OPENED;
00169     }
00170     else
00171     {
00172         this->ServerName = strdup( ServerMachine );
00173 
00174         // If RioServer == 1, use RioTCPport to connect directly in RIOServer
00175         // else use RioTCPportPL to connect in PL
00176         if( RioServer == 1 )
00177             TCPport = RioTCPport;
00178         else
00179             TCPport = RioTCPportPL;
00180 
00181         // make TCP connection to server
00182         m_TCPconnection = new CRioTCP;
00183 
00184         RioResult hResult= m_TCPconnection->Connect( ServerMachine, TCPport );
00185 
00186         if( FAILED( hResult ) )
00187         {
00188             #ifdef RIO_DEBUG1
00189             RioErr << "### [CRioSession - Connect] Finish2" << endl;
00190             #endif
00191 
00192             return( hResult );
00193         }
00194 
00195         // create SessionManager Proxy
00196         m_SessionManager = new CSessionManager( m_TCPconnection );
00197 
00198         hResult = m_SessionManager->Open( UserName,
00199                                           Password,
00200                                           &m_SessionId );
00201 
00202         if( FAILED( hResult ) )
00203         {
00204             delete m_SessionManager;
00205             m_SessionManager = NULL;
00206 
00207             // Fecha a conexao TCP aberta.
00208             m_TCPconnection->Disconnect();
00209             delete m_TCPconnection;
00210             m_TCPconnection = NULL;
00211 
00212             #ifdef RIO_DEBUG1
00213             RioErr << "### [CRioSession - Connect] Finish3" << endl;
00214             #endif
00215 
00216             return hResult;
00217         }
00218         //    Open returns blocksize.
00219         else
00220         {
00221             m_BlockSize = hResult;
00222         }
00223 
00224         m_MaxPktLen = FRAGMENTSIZE;
00225 
00226         // init NetMgr path too
00227         m_NetMgr = new NetMgr();
00228 
00229         // ### need blocksize and maxpktl here..
00230         // ### need blocksize and maxpktl here..
00231         //
00232         #ifdef RIO_DEBUG_FILE
00233         // Um novo parametro foi adicionado a funcao Start da NetMgr: o 
00234         // nome do arquivo onde sera armazenado o log da RioNeti. Por default,
00235         // o valor passado a Connect sera NULL, e o nome do arquivo sera 
00236         // RIOClientEmul_<maquina>.<dominio>.log e sera armazenado no diretorio
00237         // onde o cliente, que executou a Connect, esta executando.
00238         rc = m_NetMgr->Start( 0, m_BlockSize, m_MaxPktLen, RioNetiLogPath );
00239         #else
00240         rc = m_NetMgr->Start( 0, m_BlockSize, m_MaxPktLen );
00241         #endif
00242         if( rc != 0 )
00243         {
00244             #ifdef RIO_DEBUG1
00245             RioErr << "### [CRioSession - Connect] Finish4" << endl;
00246             #endif
00247 
00248             return ERROR_RIOSESSION + ERROR_SOCKET_BIND;
00249         }
00250 
00251 
00252         if( RioServer )
00253         {
00254             
00255             // Tenta criar a lista com os enderecos IPs e as Portas dos servidores
00256             // (isto e, os enderecos do servidor RIO e dos Storage Servers).
00257             hResult = m_SessionManager->GetServerAddress( &m_ServerAddress,
00258                                                           &m_ServerAddressSize );
00259 
00260             if( FAILED( hResult ) )
00261             {
00262                 if( (unsigned int) hResult == ERROR_CONNECTIONMANAGER + 
00263                                               ERROR_INVALID_METHOD )
00264                 {
00265                     // Neste caso, o cliente esta se conectando ao servidor antigo.
00266                     // Nao vamos remover a sessao, e retornar um valor diferente
00267                     // de S_OK, para o cliente saber disso e informar ao usuario.
00268                     #ifdef RIO_DEBUG1
00269                     RioErr << "### [CRioSession - Connect] Finish5" << endl;
00270                     #endif
00271                     return( ERROR_RIOSESSION + ERROR_NO_MAPPING );
00272                 }
00273                 else 
00274                 {
00275                     delete m_SessionManager;
00276                     m_SessionManager =0;
00277                     #ifdef RIO_DEBUG1
00278                     RioErr << "### [CRioSession - Connect] Finish6" << endl;
00279                     #endif
00280                 }
00281                 return hResult;
00282             }
00283             
00284             // Tenta criar e inicializar o obejto da classe CNetInterface. 
00285             try
00286             {
00287                 // Tenta criar um objeto da classe (se falhar, a excecao 
00288                 // bad_alloc sera gerada e o codigo no catch sera executado.
00289                 m_NetInterface = new CNetInterface;
00290                  
00291                 // Tenta inicializar a nova classe de gerenciamento de rede.
00292                 //
00293                 // Obs: O que fazer com o timeout da conexao no cliente? Nao
00294                 // sabemos no cliente o timeout do servidor. Nao temos um 
00295                 // timeout, como ocorre na conexao principal (a qual e somente
00296                 // fechada pelo servidor)?
00297                 //
00298                 #ifdef RIO_DEBUG_FILE
00299                 rc = m_NetInterface->Start( m_ServerAddress, 
00300                                             m_ServerAddressSize, 0, 
00301                                             NETTCPTIMEOUTSECONDS, 
00302                                             NETTCPTIMEOUTSECONDS, 
00303                                             RioNetiLogPath );
00304                 #else
00305                 rc = m_NetInterface->Start( m_ServerAddress, 
00306                                             m_ServerAddressSize, 0,
00307                                             NETTCPTIMEOUTSECONDS, 
00308                                             NETTCPTIMEOUTSECONDS );
00309                 #endif
00310                 if( rc != 0 )
00311                 {
00312                     #ifdef RIO_DEBUG2
00313                     RioErr << "CRioSession::Connect Erro 0x" << hex << rc 
00314                            << dec << " (" << GetErrorDescription( rc ) 
00315                            << ") ao executar a funcao Start do objeto da "
00316                            << "classe CNetInterface. Usando a implementacao "
00317                            << "antiga!" << endl;
00318                     #endif
00319                     
00320                     // Remove a implementacao nova, pois nao conseguimos 
00321                     // inicializa-la. Quando tudo estiver implementado, 
00322                     // deveremos retornar um erro.
00323                     delete m_NetInterface;
00324                     
00325                     m_NetInterface = NULL;
00326 
00327                 }
00328             }
00329             catch( bad_alloc &ba )
00330             {
00331                     #ifdef RIO_DEBUG2
00332                     RioErr << "CRioSession::Connect erro de alocacao de "
00333                            << "memoria (bad_alloc, error=" << ba.what() 
00334                            << ") ao criar um objeto da classe CNetInterface. " 
00335                            << "Usando a implementacao antiga!" << endl;
00336                     #endif
00337 
00338                     m_NetInterface = NULL;
00339             }
00340             
00341             // Devemos agora chamar a funcao da classe NetMgr para solicitar ao
00342             // servidor o mapeamento do cliente no servidor e em cada storage
00343             #ifdef RIO_DEBUG1
00344             RioErr << "CRioSession::Connect executando a funcao RequestMapping "
00345                    << " com os parametros IP = " 
00346                    << inet_ntoa( m_ServerAddress[ 0 ].sin_addr ) 
00347                    << " e porta = " << ntohs( m_ServerAddress[ 0 ].sin_port ) 
00348                    << endl;
00349             #endif       
00350             m_NetMgr->RequestMultipleMappings( m_ServerAddress,
00351                                                m_ServerAddressSize );
00352             #ifdef RIO_DEBUG2
00353             // Imprime o mapeamento obtido.
00354             int IP, port;
00355             struct in_addr mapip;
00356             m_NetMgr->getmyaddrport( &IP, &port );
00357             mapip.s_addr = IP;
00358             RioErr << "CRioSession::Connect mapeamento IP = " 
00359                    << inet_ntoa( mapip ) << ", porta = " << ntohs( port ) 
00360                    << endl;
00361             #endif
00362             // Depois de criar a lista com os IPs e as portas para os quais 
00363             // precisamos e de obtermos os mapeamentos, passamos os mapeamentos
00364             // para o servidor e inicializamos a thread que os mantem ativos
00365             // Isso e feito somente se o cliente estiver atras de um NAT.
00366             if( m_NetMgr->IsBehindNAT() ) 
00367             {
00368                 #ifdef RIO_DEBUG1
00369                 RioErr << "CRioSession::Connect o cliente esta atras de um NAT" 
00370                        << endl;
00371                 #endif
00372 
00373                 // Chama a funcao que cria a thread para manter os enderecos
00374                 // associados ao mapeamento ativos.
00375                 //rc = m_NetMgr->CreateKeepaliveThread( m_ServerAddress, 
00376                 //                                      m_ServerAddressSize );
00377                 rc = m_NetMgr->CreateKeepaliveThread( );
00378                 if( rc )
00379                 {
00380                     #ifdef RIO_DEBUG1
00381                     RioErr << "### [CRioSession - Connect] Finish7" << endl;
00382                     #endif
00383                     return ERROR_RIOSESSION + ERROR_UNEXPECTED;
00384                 }
00385 
00386             }
00387             // Recebe os vetores que contem os mapeamentos IP/porta. Agora
00388             // (ao contrario de como ocorria nas versoes anteriores), 
00389             // precisaremos sempre enviar as informacoes obtidas, mesmo quando
00390             // o cliente nao estiver atras de NAT.
00391             // 
00392             int *IPs, *IPsDest;
00393             int *ports, *PortsDest;
00394             unsigned int TotalPairs;
00395             HRESULT status;
00396             
00397             m_NetMgr->getalladdrport( &IPs, &ports );
00398             
00399             // Tenta criar um vetor para passar os pares IPs, porta ao servidor.
00400             // se nao for possivel fazer isso, entao novamente nao usaremos a
00401             // nova classe (note que, no futuro, isto nao sera mais necessario,
00402             // e poderemos usar os valores passados pela funcao getalladdrport
00403             // do objeto da classe CNetInterface.
00404             
00405             // Inicializa os vetores IPsDest e PortsDest com NULL.
00406             IPsDest = NULL;
00407             PortsDest = NULL;
00408             TotalPairs = m_ServerAddressSize;
00409             
00410             // Se o objeto m_NetInterface foi criado com sucesso, entao 
00411             // deveremos enviar tambem os pares IP, porta das conexoes TCP.
00412             if( m_NetInterface != NULL )
00413             {
00414                 try
00415                 {
00416                     // Tenta criar os vetores.
00417                     IPsDest = new int[ 2 * m_ServerAddressSize ];
00418                     PortsDest =  new int[ 2 * m_ServerAddressSize  ];
00419                 
00420                     // Inicializa o vetor com os IPs e portas da NetMgr.
00421                     for( unsigned int i = 0; i < m_ServerAddressSize; i++ )
00422                     {
00423                         IPsDest[ i ] = IPs[ i ];
00424                         PortsDest[ i ] = ports[ i ];
00425                     }
00426                   
00427                     // Obtem os os pares IP, porta associados a nova conexao (o
00428                     // par do servidor nao sera usado).
00429 
00430                     m_NetInterface->getalladdrport( &IPs, &ports );
00431                 
00432                     // Inicializa o vetor com os IPs e portas da NetInterface (com
00433                     // excecao do par do servidor) .
00434                     for( unsigned int i = m_ServerAddressSize; 
00435                          i < 2 * m_ServerAddressSize; i++ )
00436                     {
00437                         IPsDest[ i ] = IPs[ i - m_ServerAddressSize ];
00438                         PortsDest[ i ] = ports[ i - m_ServerAddressSize ];
00439                     }
00440                 
00441                     TotalPairs = 2 * m_ServerAddressSize;
00442                 }
00443                 catch( bad_alloc &ba )
00444                 {
00445                     #ifdef RIO_DEBUG2
00446                     RioErr << "CRioSession::Connect erro de alocacao de "
00447                            << "memoria (bad_alloc, error=" << ba.what() 
00448                            << ") ao criar os vetores com os ips e as portas. " 
00449                            << "Usando a implementacao antiga!" << endl;
00450                     #endif
00451 
00452                     // Remove o vetor com os pares IPs, caso o erro de alocacao
00453                     // tenha ocorrido ao alocarmos o vetor com as portas.                
00454                     if( IPsDest != NULL )
00455                         delete[] IPsDest;
00456                 
00457                     IPsDest = NULL;
00458   
00459                     // Remove a implementacao nova, pois nao conseguimos 
00460                     // inicializa-la. Quando tudo estiver implementado, 
00461                     // deveremos retornar um erro.
00462                     delete m_NetInterface;
00463                     m_NetInterface = NULL;
00464                 }
00465             }
00466             
00467             // Passa os mapeamentos para o servidor
00468             if( ( IPsDest != NULL ) && ( PortsDest != NULL ) )
00469             {
00470                 #ifdef RIO_DEBUG2
00471                 in_addr ipdest;
00472                 // Imprime os pares IP, porta a serem enviados ao servidor.
00473                 RioErr << "CRioSession::Connect enviando os seguintes pares "
00474                        << "IP, porta ao servidor (total de " << TotalPairs
00475                        << " pares: ";
00476                 for( unsigned int i = 0; i < TotalPairs; i++ )
00477                 {
00478                     ipdest.s_addr = IPsDest[ i ];
00479                     RioErr << "(" << inet_ntoa( ipdest ) << ", " 
00480                            << ntohs( PortsDest[ i ] ) << ")";
00481                     if( i != ( TotalPairs - 1 ) )
00482                         RioErr << ", ";
00483                     else 
00484                         RioErr << "." << endl;
00485                 }       
00486                 #endif
00487                 
00488                 status = m_SessionManager->SendNATMappings( IPsDest, PortsDest, 
00489                                                             TotalPairs );
00490                                   
00491                 // Remove os vetores, pois eles ja foram usados.
00492                 delete[] IPsDest;
00493                 delete[] PortsDest;               
00494             }                      
00495             else
00496             {
00497                 #ifdef RIO_DEBUG2
00498                 in_addr ipdest;
00499                 // Imprime os pares IP, porta a serem enviados ao servidor.
00500                 RioErr << "CRioSession::Connect enviando os seguintes pares "
00501                        << "IP, porta ao servidor (total de " 
00502                        << m_ServerAddressSize << " pares: ";
00503                 for( unsigned int i = 0; i < m_ServerAddressSize; i++ )
00504                 {
00505                     ipdest.s_addr = IPs[ i ];
00506                     RioErr << "(" << inet_ntoa( ipdest ) << ", " 
00507                            << ntohs( ports[ i ] ) << ")";
00508                     if( i != ( m_ServerAddressSize - 1 ) )
00509                         RioErr << ", ";
00510                     else 
00511                         RioErr << "." << endl;
00512                 }       
00513                 #endif
00514 
00515                 status = m_SessionManager->SendNATMappings( IPs, ports, 
00516                                                           m_ServerAddressSize );
00517             }
00518             
00519             if( ( (unsigned int) status != ERROR_CONNECTIONMANAGER +
00520                                            ERROR_INVALID_METHOD ) &&
00521                 ( status != S_OK ) )
00522             {
00523                 #ifdef RIO_DEBUG1
00524                 RioErr << "### [CRioSession - Connect] Finish8" << endl;
00525                 #endif
00526                 return status;
00527             }
00528         }
00529         else
00530             m_NetInterface = NULL;
00531         
00532         #ifdef RIO_DEBUG1
00533         RioErr << "### [CRioSession - Connect] Finish10" << endl;
00534         #endif
00535         
00536         return S_OK;
00537     }// fim do else do if( isConnected() )
00538 }

RioResult CRioSession::CreateObject ( const char *  ObjectName,
const short  ObjectType,
const RioSecurity *  Security 
)

Definition at line 593 of file RioSession.cpp.

00596 {
00597     #ifdef RIO_DEBUG1
00598     RioErr << "### [CRioSession - CreateObject] Start" << endl;
00599     #endif
00600 
00601     // Check if we are connected
00602     if( !isConnected() )
00603     {
00604         #ifdef RIO_DEBUG1
00605         RioErr << "### [CRioSession - CreateObject] Finish1" << endl;
00606         #endif
00607 
00608         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
00609     }
00610 
00611     // Call Session Manager Proxy
00612     HRESULT hResult;
00613 
00614     hResult = m_SessionManager->CreateObject( m_SessionId,
00615                                             ObjectName,
00616                                             ObjectType );
00617 
00618     if( FAILED( hResult ) )
00619     {
00620         #ifdef RIO_DEBUG1
00621         RioErr << "### [CRioSession - CreateObject] Finish2" << endl;
00622         #endif
00623 
00624         return hResult;
00625     }
00626 
00627     #ifdef RIO_DEBUG1
00628     RioErr << "### [CRioSession - CreateObject] Finish3" << endl;
00629     #endif
00630 
00631     return S_OK;
00632 }

RioResult CRioSession::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 1962 of file RioSession.cpp.

01963 {
01964     #ifdef RIO_DEBUG1
01965     RioErr << "### [CRioSession - CreateUser] Start" << endl;
01966     #endif
01967 
01968     // Check if we are connected
01969     if( !isConnected() )
01970     {
01971         #ifdef RIO_DEBUG1
01972         RioErr << "### [CRioSession - CreateUser] Finish1" << endl;
01973         #endif
01974 
01975         // Check if we are connected
01976         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
01977     }
01978 
01979     // Call Session Manager Proxy
01980     HRESULT hResult;
01981     hResult = m_SessionManager->CreateUser( UserName, Password );
01982     if( FAILED( hResult ) )
01983     {
01984         #ifdef RIO_DEBUG1
01985         RioErr << "### [CRioSession - CreateUser] Finish2" << endl;
01986         #endif
01987 
01988         return hResult;
01989     }
01990 
01991     #ifdef RIO_DEBUG1
01992     RioErr << "### [CRioSession - CreateUser] Finish3" << endl;
01993     #endif
01994 
01995     return S_OK;
01996 }

RioResult CRioSession::DeleteObject ( const char *  ObjectName  ) 

Definition at line 634 of file RioSession.cpp.

00635 {
00636     #ifdef RIO_DEBUG1
00637     RioErr << "### [CRioSession - DeleteObject] Start" << endl;
00638     #endif
00639 
00640     // Check if we are connected
00641     if( !isConnected() )
00642     {
00643         #ifdef RIO_DEBUG1
00644         RioErr << "### [CRioSession - DeleteObject] Finish1" << endl;
00645         #endif
00646 
00647         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
00648     }
00649 
00650     // Call Session Manager Proxy
00651     HRESULT hResult;
00652     hResult = m_SessionManager->DeleteObject( m_SessionId,
00653                                             ObjectName );
00654     if( FAILED( hResult ) )
00655     {
00656         #ifdef RIO_DEBUG1
00657         RioErr << "### [CRioSession - DeleteObject] Finish2" << endl;
00658         #endif
00659 
00660         return hResult;
00661     }
00662 
00663     #ifdef RIO_DEBUG1
00664     RioErr << "### [CRioSession - DeleteObject] Finish3" << endl;
00665     #endif
00666 
00667     return S_OK;
00668 }

RioResult CRioSession::Disconnect (  ) 

Definition at line 541 of file RioSession.cpp.

00542 {
00543     #ifdef RIO_DEBUG1
00544     RioErr << "### [CRioSession - Disconnect] Start" << endl;
00545     #endif
00546 
00547     // Check if we are connected
00548     if( !isConnected() )
00549     {
00550         #ifdef RIO_DEBUG1
00551         RioErr << "### [CRioSession - Disconnect] Finish1" << endl;
00552         #endif
00553 
00554         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
00555     }
00556 
00557     HRESULT hResult;
00558     HRESULT lastresult = S_OK;
00559 
00560     // Close Session
00561     hResult = m_SessionManager->Close( m_SessionId );
00562     if( FAILED( hResult ) )
00563     {
00564         lastresult = hResult;
00565     }
00566 
00567     // Delete Session Manager Proxy
00568     delete m_SessionManager;
00569     m_SessionManager = 0;
00570 
00571     // Close TCP connection and delete CRioTCP class
00572     m_TCPconnection->Disconnect();
00573 
00574     delete m_TCPconnection;
00575     m_TCPconnection = 0;
00576 
00577     #ifdef RIO_DEBUG1
00578     RioErr << "### [CRioSession - Disconnect] Finish2" << endl;
00579     #endif
00580 
00581     // Remove o vetor com os enderecos do servidores. Usado para permitir o
00582     // uso de clientes atras de NAT.
00583     if( m_ServerAddress != NULL )
00584          delete[] m_ServerAddress;
00585               
00586     m_ServerAddress = NULL;
00587     m_ServerAddressSize = 0;
00588     
00589     return lastresult;
00590 }

void CRioSession::FinalizeReadBlock ( void *  parm,
int  result 
) [static, private]

Funcao de callback usada para finalizar o recebimento de um bloco do arquivo.

Esta funcao somente chama a callback (dada na estrutura SearchLogsData) somente quando o ultimo bloco for recebido ou quando um erro ocorrer (isso sera indicado pelo parametro result passado a callback).

Parameters:
parm ponteiro para um objeto da estrutura SearchLogsData com as informacoes do comando de busca.
result valor indicando se a execucao do comando foi bem ou mau sucedida.

Definition at line 1706 of file RioSession.cpp.

01707 {
01708     int ReqId;
01709     SearchLogsData *SearchData;
01710     unsigned int TotalBlocks, WriteSize;
01711     bool LastBlock;
01712     CRioSession *session;
01713     HRESULT hResult;
01714     
01715     SearchData = ( SearchLogsData * ) parm;
01716     session = SearchData->session;
01717 
01718     if( result != S_OK )
01719     {
01720         #ifdef RIO_DEBUG2
01721         RioErr << "CRioSession::FinalizeReadBlock a leitura do bloco " 
01722                << SearchData->CurrentBlock << " do arquivo de busca com o " 
01723                << "identificador " << SearchData->ResultFileId 
01724                << " falhou. Removendo o arquivo " << SearchData->ResultFileName
01725                << " associado ao identificador e chamando a callback com "
01726                << " um erro" << endl;
01727         #endif       
01728         // Se ocorreu algum erro no recebimento do bloco atual, entao remove o 
01729         // arquivo com o resultado (se isso ainda nao foi feito, e chama a 
01730         // callback com um erro).
01731         if( SearchData->ResultFile != NULL )
01732         {
01733             fclose( SearchData->ResultFile );
01734             remove( SearchData->ResultFileName );
01735             SearchData->ResultFile = NULL;
01736         }
01737         SearchData->callback( SearchData->callbackparam, SEARCHLOGSERROR );
01738         delete[] SearchData->ResultFileName;
01739         delete[] SearchData->BlockBuffer;
01740         delete SearchData;
01741     } 
01742     else
01743     {
01744         // Se nenhum erro ocorreu, salva o bloco (parcialmente ou totalmente,
01745         // dependendo de este ser ou nao o ultimo bloco do arquivo pois, neste
01746         // caso, o final do arquivo pode ser maior do que o bloco).
01747         TotalBlocks = ( SearchData->ResultFileSize + session->m_BlockSize - 1 ) 
01748                       / session->m_BlockSize;
01749         #ifdef RIO_DEBUG2
01750         RioErr << "CRioSession::FinalizeReadBlock O bloco " 
01751                << SearchData->CurrentBlock << " foi recebido com sucesso (de "
01752                << "um total de " << TotalBlocks << " blocos). Ainda faltam " 
01753                <<  TotalBlocks - SearchData->CurrentBlock - 1 << " blocos para "
01754                << "serem recebidos" << endl; 
01755         #endif
01756         if( SearchData->CurrentBlock < TotalBlocks - 1 )
01757         {
01758             WriteSize = session->m_BlockSize;
01759             LastBlock = false;
01760         }
01761         else
01762         {
01763             WriteSize = SearchData->ResultFileSize - SearchData->CurrentBlock * 
01764                         session->m_BlockSize;  
01765             LastBlock = true;
01766         }
01767         #ifdef RIO_DEBUG2
01768         RioErr << "CRioSession::FinalizeReadBlock tentando salvar o bloco "
01769                << SearchData->CurrentBlock << " no arquivo " 
01770                << SearchData->ResultFileName << endl;
01771         #endif       
01772         // Salva o bloco recebido (talvez parcialmente, se este for o ultimo
01773         // bloco) no arquivo.
01774         if( fwrite( SearchData->BlockBuffer, sizeof( char ), WriteSize,
01775                     SearchData->ResultFile ) != WriteSize )
01776         {
01777             #ifdef RIO_DEBUG2
01778             RioErr << "CRioSession::FinalizeReadBlock Erro ao salvar o bloco "
01779                    << SearchData->CurrentBlock << " no arquivo " 
01780                    << SearchData->ResultFileName << ": " << errno << "(" 
01781                    << strerror( errno ) << ")" << endl;
01782                    
01783             #endif       
01784             fclose( SearchData->ResultFile );
01785             remove( SearchData->ResultFileName );
01786             SearchData->ResultFile = NULL;
01787             SearchData->callback( SearchData->callbackparam, SEARCHLOGSERROR );
01788             delete[] SearchData->ResultFileName;
01789             delete[] SearchData->BlockBuffer;
01790             delete SearchData;
01791         } 
01792         // Verifica se este e o ultimo bloco. Caso nao seja, fazemos o pedido do
01793         // outro bloco e, caso seja, fechamos o arquivo,  enviamos uma mensagem
01794         // ao servidor informando que o arquivo pode ser removido e chamados a
01795         // callback informando que a busca foi feita com sucesso.
01796         if( LastBlock )
01797         {
01798             #ifdef RIO_DEBUG2
01799             RioErr << "CRioSession::FinalizeReadBlock O bloco " 
01800                    << SearchData->CurrentBlock << " e o ultimo do arquivo " 
01801                    << SearchData->ResultFileName << ". Vamos entao fechar o "
01802                    << "arquivo, tentar remover o log no servidor e chamar "
01803                    << "a callback com sucesso" << endl;
01804                    
01805             #endif       
01806             fclose( SearchData->ResultFile );
01807             // Call Session Manager Proxy
01808             hResult = session->m_SessionManager->RemoveResultFile( 
01809                                                            SearchData->ServerIP,
01810                                                          SearchData->ServerPort,
01811                                                      SearchData->ResultFileId );
01812             if( FAILED( hResult ) )
01813             {
01814                 RioErr << "CRioSession::FinalizeReadBlock aviso erro ao tentar "
01815                        << "remover o arquivo com o identificador " 
01816                        << SearchData->ResultFileId << endl;
01817             }
01818             SearchData->ResultFile = NULL;
01819             SearchData->callback( SearchData->callbackparam, SEARCHLOGSSUCESS );
01820             delete[] SearchData->ResultFileName;
01821             delete[] SearchData->BlockBuffer;
01822             delete SearchData;
01823         }
01824         else
01825         {
01826             // Requisita o proximo bloco do arquivo.
01827             SearchData->CurrentBlock++;
01828             #ifdef RIO_DEBUG2
01829             RioErr << "CRioSession::FinalizeReadBlock O bloco " 
01830                    << SearchData->CurrentBlock << " nao e o ultimo do arquivo " 
01831                    << SearchData->ResultFileName << ". Vamos entao tentar "
01832                    << "pedir o proximo bloco " << SearchData->CurrentBlock 
01833                    << " deste arquivo" << endl;
01834                    
01835             #endif       
01836             // Inicializa a solicitacao para a leitura do proximo bloco do 
01837             // arquivo com os resultados da busca (o ultimo parametro, o 1, 
01838             // indica que desejamos usar ACKS ao receber os fragmentos do 
01839             // bloco, isto e, que o envio dos dados nao deve ser em tempo real.
01840             if( session->m_NetInterface != NULL )
01841                 ReqId = session->m_NetInterface->ExpectBlock( 
01842                                                         SearchData->BlockBuffer, 
01843                                                            session->m_BlockSize, 
01844                                                              &FinalizeReadBlock, 
01845                                                           ( void * ) SearchData, 
01846                                                              1 ); 
01847             else
01848                 ReqId = session->m_NetMgr->ExpectBlock( SearchData->BlockBuffer, 
01849                                                         session->m_BlockSize, 
01850                                                         &FinalizeReadBlock, 
01851                                                         ( void * ) SearchData, 
01852                                                         1 ); 
01853    
01854             // Call Session Manager Proxy
01855             hResult = session->m_SessionManager->ResultFileBlockRequest( 
01856                                                            SearchData->ServerIP,
01857                                                          SearchData->ServerPort,
01858                                                            SearchData->ClientIP,
01859                                                          SearchData->ClientPort,
01860                                                        SearchData->ResultFileId, 
01861                                                        SearchData->CurrentBlock,
01862                                                                    ReqId );
01863             if( FAILED( hResult ) )
01864             {
01865                 #ifdef RIO_DEBUG2
01866                 RioErr << "CRioSession::FinalizeReadBlock Erro " << hResult 
01867                        << " ao pedir o bloco " << SearchData->CurrentBlock 
01868                        << ". O arquivo parcial " << SearchData->ResultFileName 
01869                        << " sera removido e a callback sera chamada com um "
01870                        << "erro." << endl;
01871                 #endif       
01872                 // Cancela o recebimento do bloco (isso ira remover o arquivo).
01873                 if( session->m_NetInterface != NULL )
01874                     session->m_NetInterface->CancelExpect( ReqId, hResult );
01875                 else
01876                     session->m_NetMgr->CancelExpect( ReqId, hResult );
01877                 // Se ocorreu algum erro ao pedir o proximo bloco, entao remove
01878                 // o arquivo com o resultado (se isso ainda nao foi feito, e  
01879                 // chama a callback com um erro).
01880                 if( SearchData->ResultFile != NULL )
01881                 {
01882                     fclose( SearchData->ResultFile );
01883                     remove( SearchData->ResultFileName );
01884                     SearchData->ResultFile = NULL;
01885                 }
01886                 // Chama a callback informando que ocorreu um erro ao executar 
01887                 // a busca.
01888                 SearchData->callback( SearchData->callbackparam, 
01889                                       SEARCHLOGSERROR );
01890                 delete[] SearchData->ResultFileName;
01891                 delete[] SearchData->BlockBuffer;
01892                 delete SearchData;
01893             }
01894         }
01895     }
01896     return;
01897 }

void CRioSession::FinalizeSearchCmd ( void *  parm,
int  result 
) [static, private]

Funcao de callback usada para finalizar o tratamento da mensagem do servidor do tipo TYPE_CMD para obter o tamanho do arquivo com o resultado da busca e o identificador deste arquivo.

A callback dada na estrutura SearchLogsData e chamada se algum erro ocorreu quando a busca foi feita ou se a busca terminou com sucesso mais nenhum reultado foi encontrado (isso sera indicado pelo parametro result passado a callback).

Parameters:
parm ponteiro para um objeto da estrutura SearchLogsData com as informacoes do comando de busca.
result valor indicando se a execucao do comando foi bem ou mau sucedida.

Definition at line 1581 of file RioSession.cpp.

01582 {
01583     int ReqId;
01584     HRESULT hResult;
01585     SearchLogsData *SearchData;
01586     CRioSession *session;
01587     
01588     SearchData = ( SearchLogsData * ) parm;
01589     session = SearchData->session;
01590     
01591     // Verifica se a busca teve ou nao sucesso ou se ocorreu um erro ao receber
01592     // os dados e, em caso de sucesso, retorna os dados nos parametros passados
01593     // pela funcao.
01594 
01595     if( result != S_OK ) 
01596     {
01597         #ifdef RIO_DEBUG2
01598         RioErr << "CRioSession::FinalizeSearchCmd execucao da busca terminou "
01599                << "com erro: result = " << result << endl;
01600         #endif       
01601         // Chama a callback informando que ocorreu um erro ao executar a busca.
01602         SearchData->callback( SearchData->callbackparam, SEARCHLOGSERROR );
01603         delete[] SearchData->ResultFileName;
01604         delete[] SearchData->BlockBuffer;
01605         delete SearchData;
01606     }
01607     else if( SearchData->ResultFileSize == 0 )
01608     {
01609         // A busca foi terminada com sucesso mas nenhum resultado foi 
01610         // encontrado.
01611         #ifdef RIO_DEBUG2
01612         RioErr << "CRioSession::FinalizeSearchCmd execucao da busca terminou "
01613                << "com sucesso, mas nenhum resultado foi encontrado" << endl;
01614         #endif       
01615         SearchData->callback( SearchData->callbackparam, SEARCHLOGSFAILED );
01616         delete[] SearchData->ResultFileName;
01617         delete[] SearchData->BlockBuffer;
01618         delete SearchData;
01619     }
01620     else
01621     {
01622         // Se nao ocorreu nenhum erro, entao abrimos o arquivo e fazemos o 
01623         // pedido do primeiro bloco do arquivo. 
01624         // Abre o arquivo para escrita.
01625         #ifdef RIO_DEBUG2
01626         RioErr << "CRioSession::FinalizeSearchCmd execucao da busca terminou "
01627                << "com sucesso, e o arquivo " << SearchData->ResultFileName 
01628                << " com o resultado, com tamanho de " 
01629                << SearchData->ResultFileSize << " bytes e identificador igual "
01630                << "a " << SearchData->ResultFileId << " comecara a ser "
01631                << "copiado do servidor" << endl;
01632         #endif       
01633         SearchData->ResultFile = fopen( SearchData->ResultFileName, "w" );
01634         if( SearchData->ResultFile == NULL )
01635         {
01636             #ifdef RIO_DEBUG2
01637             RioErr << "CRioSession::FinalizeSearchCmd erro " << errno 
01638                    << "(" << strerror( errno ) << ") ao abrir o arquivo "
01639                    << SearchData->ResultFileName << " para escrita" << endl;
01640             #endif       
01641             // Se nao conseguirmos o arquivo, chamamos a callback com um erro.
01642             SearchData->callback( SearchData->callbackparam, SEARCHLOGSERROR );
01643             delete[] SearchData->ResultFileName;
01644             delete[] SearchData->BlockBuffer;
01645             delete SearchData;
01646         }
01647         // Inicializa a solicitacao para a leitura do primeiro bloco do arquivo
01648         // com os resultados da busca (o ultimo parametro, o 1, indica que 
01649         // desejamos usar ACKS ao receber os fragmentos do bloco, isto e, que
01650         // o envio dos dados nao deve ser em tempo real.
01651         if( session->m_NetInterface != NULL )
01652             ReqId = session->m_NetInterface->ExpectBlock( 
01653                                                         SearchData->BlockBuffer, 
01654                                                           session->m_BlockSize, 
01655                                                           &FinalizeReadBlock, 
01656                                                           ( void * ) SearchData, 
01657                                                           1 ); 
01658         else
01659             ReqId = session->m_NetMgr->ExpectBlock( SearchData->BlockBuffer, 
01660                                                     session->m_BlockSize, 
01661                                                     &FinalizeReadBlock, 
01662                                                     ( void * ) SearchData, 1 ); 
01663  
01664         #ifdef RIO_DEBUG2
01665         RioErr << "CRioSession::FinalizeSearchCmd Pedido de bloco 0 do arquivo " 
01666                << "iniciado com a id " << ReqId << endl;
01667         #endif       
01668         // Call Session Manager Proxy
01669         hResult = session->m_SessionManager->ResultFileBlockRequest( 
01670                                                            SearchData->ServerIP,
01671                                                          SearchData->ServerPort,
01672                                                            SearchData->ClientIP,
01673                                                          SearchData->ClientPort,
01674                                                        SearchData->ResultFileId, 
01675                                                                      0, ReqId );
01676         if( FAILED( hResult ) )
01677         {
01678             // Cancela o recebimento do bloco (isso ira remover o arquivo).
01679             if( session->m_NetInterface != NULL )
01680                 session->m_NetMgr->CancelExpect( ReqId, hResult );
01681             else
01682                 session->m_NetInterface->CancelExpect( ReqId, hResult );
01683             #ifdef RIO_DEBUG2
01684             RioErr << "CRioSession::FinalizeSearchCmd Erro ao executar o "
01685                    << " pedido do bloco 0 com a id " << ReqId << ". O pedido "
01686                    << "foi cancelado!" << endl;
01687             #endif       
01688             // Chama a callback informando que ocorreu um erro ao executar a 
01689             // busca.
01690             SearchData->callback( SearchData->callbackparam, SEARCHLOGSERROR );
01691             delete[] SearchData->ResultFileName;
01692             delete[] SearchData->BlockBuffer;
01693             delete SearchData;
01694         }
01695         #ifdef RIO_DEBUG2
01696         else
01697             RioErr << "CRioSession::FinalizeSearchCmd Pedido do bloco 0 com a " 
01698                    << "id " << ReqId << " foi executado com suceso" << endl;
01699         #endif       
01700     }
01701     return;
01702 }

RioResult CRioSession::GetAverageRTT ( struct timeval *  RTT_average  ) 

Definition at line 843 of file RioSession.cpp.

00844 {
00845     #ifdef RIO_DEBUG1
00846     RioErr << "### [CRioSession - GetAverageRTT2] Start" << endl;
00847     #endif
00848 
00849     HRESULT hResult;
00850     hResult = m_SessionManager->GetAverageRTT( RTT_average );
00851     if( FAILED( hResult ) )
00852     {
00853         #ifdef RIO_DEBUG1
00854         RioErr << "### [CRioSession - GetAverageRTT2] Finish1" << endl;
00855         #endif
00856 
00857         return hResult;
00858     }
00859 
00860     #ifdef RIO_DEBUG1
00861     RioErr << "### [CRioSession - GetAverageRTT2] Finish2" << endl;
00862     #endif
00863 
00864     return S_OK;
00865 }

RioResult CRioSession::GetBlockSize ( unsigned int *  BlockSize  ) 

Definition at line 708 of file RioSession.cpp.

00709 {
00710     #ifdef RIO_DEBUG1
00711     RioErr << "### [CRioSession - GetBlockSize] Start" << endl;
00712     #endif
00713 
00714     // Call Session Manager Proxy
00715 
00716     // eliminating 1 RTT ------------------------------------
00717     if( m_BlockSize != 0 )
00718     {
00719         *BlockSize = m_BlockSize;
00720 
00721         #ifdef RIO_DEBUG1
00722         RioErr << "### [CRioSession - GetBlockSize] Finish1" << endl;
00723         #endif
00724 
00725         return S_OK;
00726     }
00727     // ------------------------------------------------------------------------
00728 
00729     HRESULT hResult;
00730 
00731     hResult = m_SessionManager->GetBlockSize( m_SessionId,BlockSize );
00732 
00733     if( FAILED( hResult ) )
00734     {
00735         #ifdef RIO_DEBUG1
00736         RioErr << "### [CRioSession - GetBlockSize] Finish2" << endl;
00737         #endif
00738 
00739         return hResult;
00740     }
00741 
00742     #ifdef RIO_DEBUG1
00743     RioErr << "### [CRioSession - GetBlockSize] Finish3" << endl;
00744     #endif
00745 
00746     return S_OK;
00747 }

RioResult CRioSession::GetCurrentDir ( char *  Dir,
const int  SizeDir 
)

Definition at line 933 of file RioSession.cpp.

00934 {
00935     #ifdef RIO_DEBUG1
00936     RioErr << "### [CRioSession - GetCurrentDir] Start" << endl;
00937     #endif
00938 
00939     // Check if we are connected
00940     if( !isConnected() )
00941     {
00942         #ifdef RIO_DEBUG1
00943         RioErr << "### [CRioSession - GetCurrentDir] Finish1" << endl;
00944         #endif
00945 
00946         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
00947     }
00948 
00949     // Call Session Manager Proxy
00950     HRESULT hResult;
00951 
00952     hResult = m_SessionManager->GetCurrentDir( m_SessionId,
00953                                                 SizeDir,
00954                                                 ( signed char* ) Dir );
00955     if( FAILED( hResult ) )
00956     {
00957         #ifdef RIO_DEBUG1
00958         RioErr << "### [CRioSession - GetCurrentDir] Finish2" << endl;
00959         #endif
00960 
00961         return hResult;
00962     }
00963 
00964     #ifdef RIO_DEBUG1
00965     RioErr << "### [CRioSession - GetCurrentDir] Finish3" << endl;
00966     #endif
00967 
00968     return S_OK;
00969 
00970 }

RioResult CRioSession::GetId ( RioSessionId *  Id  ) 

Definition at line 869 of file RioSession.cpp.

00870 {
00871     #ifdef RIO_DEBUG1
00872     RioErr << "### [CRioSession - GetId] Start" << endl;
00873     #endif
00874 
00875     // Check if we are connected
00876     if( !isConnected() )
00877     {
00878         Id = NULL;
00879 
00880         #ifdef RIO_DEBUG1
00881         RioErr << "### [CRioSession - GetId] Finish1" << endl;
00882         #endif
00883 
00884         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
00885     }
00886 
00887     *Id = * ( ( RioSessionId* ) &m_SessionId );
00888 
00889     #ifdef RIO_DEBUG1
00890     RioErr << "### [CRioSession - GetId] Finish2" << endl;
00891     #endif
00892 
00893     return S_OK;
00894 }

int CRioSession::getipaddr (  ) 

Definition at line 1244 of file RioSession.cpp.

01245 {
01246     #ifdef RIO_DEBUG1
01247     RioErr << "### [CRioSession - getipaddr] Single" << endl;
01248     #endif
01249 
01250     // Eu nao alterei esta chamada porque ela retorna o IP do cliente associado
01251     // ao servidor de despacho, e porque estamos, temporariamente enquanto a
01252     // classe NetMgr ainda e usada (para as copias em tempo real e o multicast),
01253     // o IP associado a ela do cliente e o que esta sendo passado ao servidor.
01254     return m_NetMgr->getipaddr();
01255 }

RioResult CRioSession::GetMonitorTable ( char *  UserName,
vector< ClientData > *  client_data,
vector< StorageData > *  storage_data 
)

Definition at line 1129 of file RioSession.cpp.

01132 {
01133     #ifdef RIO_DEBUG1
01134     RioErr << "### [CRioSession - GetMonitorTable] Start" << endl;
01135     #endif
01136 
01137     // Check if we are connected
01138     if( !isConnected() )
01139     {
01140         #ifdef RIO_DEBUG1
01141         RioErr << "### [CRioSession - GetMonitorTable] Finish1" << endl;
01142         #endif
01143 
01144         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
01145     }
01146 
01147     // Call Session Manager Proxy
01148     HRESULT hResult;
01149     hResult = m_SessionManager->GetMonitorTable( UserName,
01150                                                  client_data,
01151                                                  storage_data );
01152     if( FAILED( hResult ) )
01153     {
01154         #ifdef RIO_DEBUG1
01155         RioErr << "### [CRioSession - GetMonitorTable] Finish2" << endl;
01156         #endif
01157 
01158         return hResult;
01159     }
01160 
01161     #ifdef RIO_DEBUG1
01162     RioErr << "### [CRioSession - GetMonitorTable] Finish3" << endl;
01163     #endif
01164 
01165     return S_OK;
01166 }

RioResult CRioSession::GetNumberOfActiveAndMaxSessions ( unsigned int *  NumberOfActiveSessions,
unsigned int *  NumberOfMaxSessions 
)

Definition at line 1169 of file RioSession.cpp.

01172 {
01173     #ifdef RIO_DEBUG1
01174     RioErr << "### [CRioSession - GetNumberOfActiveAndMaxSessions] Start" << endl;
01175     #endif
01176 
01177     // Check if we are connected
01178     if( !isConnected() )
01179     {
01180         #ifdef RIO_DEBUG1
01181         RioErr << "### [CRioSession - GetNumberOfActiveAndMaxSessions] Finish1" << endl;
01182         #endif
01183 
01184         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
01185     }
01186 
01187     // Call Session Manager Proxy
01188     HRESULT hResult;
01189     hResult = m_SessionManager->GetNumberOfActiveAndMaxSessions( m_SessionId,
01190                                 NumberOfActiveSessions,  NumberOfMaxSessions );
01191     if( FAILED( hResult ) )
01192     {
01193         #ifdef RIO_DEBUG1
01194         RioErr << "### [CRioSession - GetNumberOfActiveAndMaxSessions] Finish2" << endl;
01195         #endif
01196 
01197         return hResult;
01198     }
01199 
01200     #ifdef RIO_DEBUG1
01201     RioErr << "### [CRioSession - GetNumberOfActiveAndMaxSessions] Finish3" << endl;
01202     #endif
01203 
01204     return S_OK;
01205 }

RioResult CRioSession::GetNumberOfDisks ( unsigned int *  NumberOfDisks  ) 

Definition at line 1013 of file RioSession.cpp.

01014 {
01015     #ifdef RIO_DEBUG1
01016     RioErr << "### [CRioSession - GetNumberOfDisks] Start" << endl;
01017     #endif
01018 
01019     // Check if we are connected
01020     if( !isConnected() )
01021     {
01022         #ifdef RIO_DEBUG1
01023         RioErr << "### [CRioSession - GetNumberOfDisks] Finish1" << endl;
01024         #endif
01025 
01026         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
01027     }
01028 
01029     // Call Session Manager Proxy
01030     HRESULT hResult;
01031     hResult = m_SessionManager->GetNumberOfDisks( m_SessionId, NumberOfDisks );
01032 
01033     if( FAILED( hResult ) )
01034     {
01035         #ifdef RIO_DEBUG1
01036         RioErr << "### [CRioSession - GetNumberOfDisks] Finish2" << endl;
01037         #endif
01038 
01039         return hResult;
01040     }
01041 
01042     #ifdef RIO_DEBUG1
01043     RioErr << "### [CRioSession - GetNumberOfDisks] Finish3" << endl;
01044     #endif
01045 
01046     return S_OK;
01047 }

RioResult CRioSession::GetNumberOfStorageNodes ( unsigned int *  NumberOfStorageNodes  ) 

Definition at line 1051 of file RioSession.cpp.

01053 {
01054     #ifdef RIO_DEBUG1
01055     RioErr << "### [CRioSession - GetNumberOfStorageNodes] Start" << endl;
01056     #endif
01057 
01058     // Check if we are connected
01059     if( !isConnected() )
01060     {
01061         #ifdef RIO_DEBUG1
01062         RioErr << "### [CRioSession - GetNumberOfStorageNodes] Finish1" << endl;
01063         #endif
01064 
01065         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
01066     }
01067 
01068     // Call Session Manager Proxy
01069     HRESULT hResult;
01070     hResult = m_SessionManager->GetNumberOfStorageNodes( m_SessionId,
01071                                                          NumberOfStorageNodes );
01072     if( FAILED( hResult ) )
01073     {
01074         #ifdef RIO_DEBUG1
01075         RioErr << "### [CRioSession - GetNumberOfStorageNodes] Finish2" << endl;
01076         #endif
01077 
01078         return hResult;
01079     }
01080 
01081     #ifdef RIO_DEBUG1
01082     RioErr << "### [CRioSession - GetNumberOfStorageNodes] Finish3" << endl;
01083     #endif
01084 
01085     return S_OK;
01086 }

RioResult CRioSession::GetObjectInfo ( const char *  ObjectName,
ObjectInfo *  ObjectInfo 
)

Definition at line 973 of file RioSession.cpp.

00975 {
00976     #ifdef RIO_DEBUG1
00977     RioErr << "### [CRioSession - GetObjectInfo] Start" << endl;
00978     #endif
00979 
00980     // Check if we are connected
00981     if( !isConnected() )
00982     {
00983         #ifdef RIO_DEBUG1
00984         RioErr << "### [CRioSession - GetObjectInfo] Finish1" << endl;
00985         #endif
00986 
00987         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
00988     }
00989 
00990     // Call Session Manager Proxy
00991     HRESULT hResult;
00992     hResult = m_SessionManager->GetObjectInfo( m_SessionId, ObjectName,
00993                                                ObjectInfo );
00994 
00995     if( FAILED( hResult ) )
00996     {
00997         #ifdef RIO_DEBUG1
00998         RioErr << "### [CRioSession - GetObjectInfo] Finish2" << endl;
00999         #endif
01000 
01001         return hResult;
01002     }
01003 
01004     #ifdef RIO_DEBUG1
01005     RioErr << "### [CRioSession - GetObjectInfo] Finish3" << endl;
01006     #endif
01007 
01008     return S_OK;
01009 }

RioResult CRioSession::GetRTT ( struct timeval *  RTT_openConnection,
struct timeval *  RTT_openStream 
)

Definition at line 787 of file RioSession.cpp.

00789 {
00790     #ifdef RIO_DEBUG1
00791     RioErr << "### [CRioSession - GetRTT2] Start" << endl;
00792     #endif
00793 
00794     HRESULT hResult;
00795     hResult = m_SessionManager->GetRTT( RTT_openConnection, RTT_openStream );
00796     if( FAILED( hResult ) )
00797     {
00798         #ifdef RIO_DEBUG1
00799         RioErr << "### [CRioSession - GetRTT2] Finish1" << endl;
00800         #endif
00801 
00802         return hResult;
00803     }
00804 
00805     #ifdef RIO_DEBUG1
00806     RioErr << "### [CRioSession - GetRTT2] Finish2" << endl;
00807     #endif
00808 
00809     return S_OK;
00810 }

void CRioSession::GetServerAddress ( struct sockaddr_in **  ServerAddress,
unsigned int *  ServerAddressSize 
)

Funcao para obter a lista de servidores associados a sessao.

A posicao 0 tera o servidor de despacho, e as outras posicoes terao os servidores de armazenamento. Obs: Nao remova o ponteiro, pois retornamos a referencia usada pela classe RioSession.

Parameters:
ServerAddress ponteiro para um ponteiro de estruturas do tipo sockaddr_in com os enderecos IP e as portas dos servidores.
ServerAddressSize ponteiro para um inteiro nao sinalizado que armazenara o tamanho de ServerAddress

Definition at line 1516 of file RioSession.cpp.

01518 {
01519     *ServerAddress = m_ServerAddress;
01520     *ServerAddressSize = m_ServerAddressSize;
01521 }

char * CRioSession::GetServerName (  ) 

Definition at line 749 of file RioSession.cpp.

00750 {
00751     #ifdef RIO_DEBUG1
00752     RioErr << "### [CRioSession - GetServerName] Single" << endl;
00753     #endif
00754 
00755     return ServerName;
00756 }

RioResult CRioSession::GetStorageNodeInfo ( RioStorageNodeInfo *  StorageNodeInfo,
unsigned int  StorageNodeIndex 
)

Definition at line 1089 of file RioSession.cpp.

01091 {
01092     #ifdef RIO_DEBUG1
01093     RioErr << "### [CRioSession - GetStorageNodeInfo] Start" << endl;
01094     #endif
01095 
01096     // Check if we are connected
01097     if( !isConnected() )
01098     {
01099         #ifdef RIO_DEBUG1
01100         RioErr << "### [CRioSession - GetStorageNodeInfo] Finish1" << endl;
01101         #endif
01102 
01103         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
01104     }
01105 
01106     // Call Session Manager Proxy
01107     HRESULT hResult;
01108     hResult = m_SessionManager->GetStorageNodeInfo( m_SessionId,
01109                                                     StorageNodeInfo,
01110                                                     StorageNodeIndex );
01111     if( FAILED( hResult ) )
01112     {
01113         #ifdef RIO_DEBUG1
01114         RioErr << "### [CRioSession - GetStorageNodeInfo] Finish2" << endl;
01115         #endif
01116 
01117         return hResult;
01118     }
01119 
01120     #ifdef RIO_DEBUG1
01121     RioErr << "### [CRioSession - GetStorageNodeInfo] Finish3" << endl;
01122     #endif
01123 
01124     return S_OK;
01125 }

RioResult CRioSession::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 2073 of file RioSession.cpp.

02074 {
02075     #ifdef RIO_DEBUG1
02076     RioErr << "### [CRioSession - GetUserList] Start" << endl;
02077     #endif
02078 
02079     // Check if we are connected
02080     if( !isConnected() )
02081     {
02082         #ifdef RIO_DEBUG1
02083         RioErr << "### [CRioSession - GetUserList] Finish1" << endl;
02084         #endif
02085 
02086         // Check if we are connected
02087         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
02088     }
02089 
02090     // Call Session Manager Proxy
02091     HRESULT hResult;
02092     hResult = m_SessionManager->GetUserList( UserList );
02093     if( FAILED( hResult ) )
02094     {
02095         #ifdef RIO_DEBUG1
02096         RioErr << "### [CRioSession - GetUserList] Finish2" << endl;
02097         #endif
02098 
02099         return hResult;
02100     }
02101 
02102     #ifdef RIO_DEBUG1
02103     RioErr << "### [CRioSession - ChangePassword] Finish3" << endl;
02104     #endif
02105 
02106     return S_OK;
02107 }

bool CRioSession::isConnected ( void   ) 

Definition at line 1258 of file RioSession.cpp.

01259 {
01260     #ifdef RIO_DEBUG1
01261     RioErr << "### [CRioSession - isConnected] Start" << endl;
01262     #endif
01263 
01264     bool isConnected = true;
01265 
01266     if( m_TCPconnection == NULL )
01267         isConnected = false;
01268     else
01269     {
01270         isConnected = m_TCPconnection->isConnected();
01271     }
01272 
01273     #ifdef RIO_DEBUG1
01274     RioErr << "### [CRioSession - isConnected] Finish1" << endl;
01275     #endif
01276 
01277     return isConnected;
01278 }

void CRioSession::ProcessSearchCmd ( void *  parm,
char *  pktp,
int  pktl 
) [static, private]

Funcao de callback usada para processar a mensagem do servidor do tipo TYPE_CMD para obter o tamanho do arquivo com o resultado da busca e o identificador deste arquivo.

Parameters:
parm ponteiro para um objeto da estrutura SearchLogsData com as informacoes do comando de busca.
pktp ponteiro para o inicio do pacote com o resultado da busca.
pktl tamanho do pacote apontado por pktp.

Definition at line 1526 of file RioSession.cpp.

01527 {
01528     SearchLogsData *SearchData;
01529     
01530     SearchData = ( SearchLogsData * ) parm;
01531     
01532     // O tamanho do pacote deve ser de 12 bytes (4 para o tamanho do arquivo e 
01533     // 8 para o identificador do arquivo).
01534     if( pktl == sizeof( int ) + sizeof( unsigned long long int ) )
01535     {
01536         #ifdef RIO_DEBUG2
01537         // Imprime o conteudo do comando
01538         RioErr << "CRioSession::ProcessSearchCmd pktp = ";
01539         char Hex[ 3 ]; // 2 bytes para o chare hexa  + 1 para o terminador. 
01540         for( unsigned int i = 0; i < sizeof( int ) + 
01541                                      sizeof( unsigned long long int ); i++ )
01542         {
01543             sprintf( Hex, "%02X", ( unsigned char ) pktp[ i ] );
01544             RioErr << Hex << " ";
01545         }
01546         RioErr << ", sizeof( pktp ) = " << pktl << endl;
01547         #endif
01548         // Os primeiros 4 bytes contem o tamanho do arquivo.
01549         SearchData->ResultFileSize = *( ( int * ) pktp );
01550         // Os ultimos 8 bytes contem o identificador do arquivo.
01551         SearchData->ResultFileId = *( ( unsigned long long int * ) 
01552                                       &pktp[ sizeof( int ) ] ); 
01553         #ifdef RIO_DEBUG2
01554         RioErr << "CRioSession::ProcessSearchCmd os dados da busca foram "
01555                << "corretamente recebidos. Tamanho do arquivo de busca e de "
01556                << "(0 indica que a busca nao teve sucesso) " 
01557                << SearchData->ResultFileSize << ", e identificador do arquivo "
01558                << "de busca e igual a (0 indica que ocorreu um erro ao "
01559                << "executar a busca) " << SearchData->ResultFileId << endl;
01560         #endif       
01561     } 
01562     else
01563     {
01564         // Se o tamanho for diferente de sizeof( int ) + 
01565         // sizeof( unsigned long long int ) (em geral, igual a 12), o tamanho do 
01566         // pacote e invalido e vamos tratar disso como se a busca nao tivesse 
01567         // tido sucesso.
01568         #ifdef RIO_DEBUG2
01569         RioErr << "CRioSession::ProcessSearchCmd os dados da busca foram "
01570                << "incorretamente recebidos. A busca sera ignorada!"
01571                << endl;
01572         #endif       
01573         SearchData->ResultFileSize = 0;
01574         SearchData->ResultFileId = 0;
01575     }
01576 }

RioResult CRioSession::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 1999 of file RioSession.cpp.

02000 {
02001     #ifdef RIO_DEBUG1
02002     RioErr << "### [CRioSession - RemoveUser] Start" << endl;
02003     #endif
02004 
02005     // Check if we are connected
02006     if( !isConnected() )
02007     {
02008         #ifdef RIO_DEBUG1
02009         RioErr << "### [CRioSession - RemoveUser] Finish1" << endl;
02010         #endif
02011 
02012         // Check if we are connected
02013         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
02014     }
02015 
02016     // Call Session Manager Proxy
02017     HRESULT hResult;
02018     hResult = m_SessionManager->RemoveUser( UserName );
02019     if( FAILED( hResult ) )
02020     {
02021         #ifdef RIO_DEBUG1
02022         RioErr << "### [CRioSession - RemoveUser] Finish2" << endl;
02023         #endif
02024 
02025         return hResult;
02026     }
02027 
02028     #ifdef RIO_DEBUG1
02029     RioErr << "### [CRioSession - RemoveUser] Finish3" << endl;
02030     #endif
02031 
02032     return S_OK;
02033 }

RioResult CRioSession::RenameObject ( const char *  CurrentName,
const char *  NewName 
)

Definition at line 670 of file RioSession.cpp.

00672 {
00673     #ifdef RIO_DEBUG1
00674     RioErr << "### [CRioSession - RenameObject] Start" << endl;
00675     #endif
00676 
00677     // Check if we are connected
00678     if( !isConnected() )
00679     {
00680         #ifdef RIO_DEBUG1
00681         RioErr << "### [CRioSession - RenameObject] Finish1" << endl;
00682         #endif
00683 
00684         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
00685     }
00686 
00687     // Call Session Manager Proxy
00688     HRESULT hResult;
00689     hResult = m_SessionManager->RenameObject( m_SessionId,
00690                                             CurrentName,
00691                                             NewName );
00692     if( FAILED( hResult ) )
00693     {
00694         #ifdef RIO_DEBUG1
00695         RioErr << "### [CRioSession - RenameObject] Finish2" << endl;
00696         #endif
00697 
00698         return hResult;
00699     }
00700 
00701     #ifdef RIO_DEBUG1
00702     RioErr << "### [CRioSession - RenameObject] Finish3" << endl;
00703     #endif
00704 
00705     return S_OK;
00706 }

RioResult CRioSession::SaveMeasures (  ) 

Definition at line 1208 of file RioSession.cpp.

01209 {
01210     #ifdef RIO_DEBUG1
01211     RioErr << "### [CRioSession - SaveMeasures] Start" << endl;
01212     #endif
01213 
01214     // Check if we are connected
01215     if( !isConnected() )
01216     {
01217         #ifdef RIO_DEBUG1
01218         RioErr << "### [CRioSession - SaveMeasures] Finish1" << endl;
01219         #endif
01220 
01221         // Check if we are connected
01222         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
01223     }
01224 
01225     // Call Session Manager Proxy
01226     HRESULT hResult;
01227     hResult = m_SessionManager->SaveMeasures( m_SessionId );
01228     if( FAILED( hResult ) )
01229     {
01230         #ifdef RIO_DEBUG1
01231         RioErr << "### [CRioSession - SaveMeasures] Finish2" << endl;
01232         #endif
01233 
01234         return hResult;
01235     }
01236 
01237     #ifdef RIO_DEBUG1
01238     RioErr << "### [CRioSession - SaveMeasures] Finish3" << endl;
01239     #endif
01240 
01241     return S_OK;
01242 }

RioResult CRioSession::SearchLogs ( unsigned int  SearchType,
time_t  StartTime,
time_t  EndTime,
int  ServerIP,
int  ServerPort,
char *  ResultFileName,
callback_t  callback,
void *  callbackparam 
)

Funcao para executar uma busca nos logs do servidor.

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.
SearchResult ponteiro para uma variavel booleana que sera true se a busca teve sucesso ou false em caso contrario. Se a busca teve sucesso, ela sera armazenada no arquivo cujo nome e dado pelo parametro ResultFileName.
ResultFileName nome (caminho completo) do arquivo que armazenara o resultado da busca.
callback funcao de callback a ser chamada quando a busca for completada e, em caso de sucesso, o arquivo de log ser completamente copiado do servidor.
callpackparam parametro, definido por que fez esta chamada, passado quando a callback for chamada.
Returns:
S_OK se a busca foi inicializa com sucesso, ou um valor diferente de S_OK caso algum erro ocorra.

Definition at line 1336 of file RioSession.cpp.

01340 {
01341     // Identificador (da estrutura de transferencia, na nova implementacao) 
01342     // associada a copia.
01343     int ReqId;
01344     // Armazena o endereco IP e a porta do cliente.
01345     int ClientIP, ClientPort;
01346     // Estrutura com as informacoes necessarias a busca;
01347     SearchLogsData *SearchData;
01348     // Armazena a posicao do servidor no vetor m_ServerAddress.
01349     int PosServer;
01350     
01351     #ifdef RIO_DEBUG1
01352     RioErr << "### [CRioSession - SearchLogs] Start" << endl;
01353     #endif
01354 
01355     // Check if we are connected
01356     if( !isConnected() )
01357     {
01358         #ifdef RIO_DEBUG1
01359         RioErr << "### [CRioSession - SearchLogs] Finish1" << endl;
01360         #endif
01361 
01362         // Check if we are connected
01363         return ERROR_RIOSESSION + ERROR_SESSION_NOT_OPENED;
01364     }
01365     
01366     // Aloca uma nova estrutura para tratar da mensagem da busca.
01367     
01368     SearchData = new SearchLogsData;
01369 
01370     if( SearchData == NULL )
01371     {
01372         #ifdef RIO_DEBUG1
01373         RioErr << "### [CRioSession - SearchLogs] Finish2" << endl;
01374         #endif
01375 
01376         return ERROR_RIOSESSION + ERROR_MEMORY;
01377     }
01378     
01379     // Procura a posicao do par IP, porta da maquina para a qual desejamos 
01380     // fazer a busca no vetor m_ServerAddress com os pares IP, porta dos
01381     // servidores, para obtermos o par IP, porta correto para o cliente.
01382     PosServer = -1;
01383     for( unsigned int Pos = 0; Pos < m_ServerAddressSize; Pos++ )
01384         if( ( m_ServerAddress[ Pos ].sin_addr.s_addr == 
01385               ( unsigned int ) ServerIP ) &&
01386             ( m_ServerAddress[ Pos ].sin_port == ( unsigned int ) ServerPort ) )
01387         {
01388             PosServer = Pos;
01389             break;
01390         }
01391         
01392     // Verifica se o par IP, porta e valido e, caso seja invalido, retorna com
01393     // um erro.
01394     if( PosServer == -1 )
01395     {
01396         #ifdef RIO_DEBUG1
01397         RioErr << "### [CRioSession - SearchLogs] Finish3" << endl;
01398         #endif
01399 
01400         return ERROR_RIOSESSION + ERROR_INVALID_HOST;
01401     }    
01402 
01403     // Obtem o IP, porta da conexao UDP do cliente com o servidor de despacho
01404     // (vamos passar sempre este IP pois vamos usar a mesma ideia para os
01405     // servidores de armazenamento usada ao requisitarmos blocos de arquivos 
01406     // ao servidor).
01407 
01408     if( m_NetInterface != NULL )
01409         m_NetInterface->getmyaddrport( &ClientIP, &ClientPort, PosServer );
01410     else
01411         m_NetMgr->getmyaddrport( &ClientIP, &ClientPort, PosServer );
01412         
01413     // Verifica se o servidor a ser usado nao esta desabilitado (se isso 
01414     // ocorrer, ClientIP sera -1 e ClientPort sera 0.
01415     if( ( ClientIP == -1 ) && ( ClientPort == 0 ) )
01416     {
01417         #ifdef RIO_DEBUG1
01418         RioErr << "### [CRioSession - SearchLogs] Finish4" << endl;
01419         #endif
01420 
01421         return ERROR_RIOSESSION + ERROR_SERVICE_TEMPORARY_UNAVAILABLE;
01422     }
01423 
01424     // Inicializa a estrutura com as informacoes sobre a busca.
01425     SearchData->session = this;
01426     SearchData->ServerIP = ServerIP;
01427     SearchData->ServerPort = ServerPort;
01428     SearchData->ClientIP = ClientIP;
01429     SearchData->ClientPort = ClientPort;
01430     SearchData->ResultFileSize = 0;
01431     SearchData->ResultFileId = 0;
01432     SearchData->ResultFileName = new char[ strlen( ResultFileName ) + 1 ];
01433     if( SearchData->ResultFileName == NULL )
01434     {
01435         delete SearchData;
01436 
01437         #ifdef RIO_DEBUG1
01438         RioErr << "### [CRioSession - SearchLogs] Finish5" << endl;
01439         #endif
01440 
01441         return ERROR_RIOSESSION + ERROR_MEMORY;
01442     }
01443     strcpy( SearchData->ResultFileName, ResultFileName );
01444     SearchData->CurrentBlock = 0;
01445     SearchData->ResultFile = NULL;
01446     SearchData->callback = callback;
01447     SearchData->callbackparam = callbackparam;
01448     // Aloca o buffer para receber o bloco.
01449     SearchData->BlockBuffer = new char[ m_BlockSize ];
01450     if( SearchData->BlockBuffer == NULL )
01451     {
01452         delete[] SearchData->ResultFileName;
01453         delete SearchData;
01454        
01455         #ifdef RIO_DEBUG1
01456         RioErr << "### [CRioSession - SearchLogs] Finish6" << endl;
01457         #endif
01458 
01459         return ERROR_RIOSESSION + ERROR_MEMORY;
01460     }
01461     
01462     #ifdef RIO_DEBUG2
01463     in_addr ip;
01464     ip.s_addr = SearchData->ClientIP;
01465     RioErr << "CRioSession::SearchLog iniciando a busca do tipo " 
01466            << SearchType << " do tempo " << StartTime << " ate o tempo " 
01467            << EndTime << " do cliente com o IP " << inet_ntoa( ip ) 
01468            << " e a porta " << ntohs( SearchData->ClientPort ) 
01469            << " para o servidor com o IP ";
01470     ip.s_addr = SearchData->ServerIP;
01471     RioErr << inet_ntoa( ip ) << " e a porta " 
01472            << ntohs( SearchData->ServerPort ) << endl;  
01473     #endif
01474 
01475     // Inicializa a espera pelo resultado da busca (usando a funcao ExpectCmd
01476     // da classe RioNeti).
01477     
01478     if( m_NetInterface != NULL )
01479         ReqId = m_NetInterface->ExpectCmd( &FinalizeSearchCmd, 
01480                                            ( void * ) SearchData, 
01481                                            &ProcessSearchCmd );
01482     else
01483         ReqId = m_NetMgr->ExpectCmd( &FinalizeSearchCmd, ( void * ) SearchData, 
01484                                      &ProcessSearchCmd );
01485 
01486     // Call Session Manager Proxy
01487     HRESULT hResult;
01488     hResult = m_SessionManager->SearchLogsRequest( SearchType, StartTime, 
01489                                                    EndTime, ServerIP,  
01490                                                    ServerPort, ClientIP, 
01491                                                    ClientPort, ReqId );
01492     if( FAILED( hResult ) )
01493     {
01494         #ifdef RIO_DEBUG1
01495         RioErr << "### [CRioSession - SearchLogsRequest] Finish7" << endl;
01496         #endif
01497 
01498         if( m_NetInterface != NULL )
01499             m_NetInterface->CancelExpect( ReqId, hResult );
01500         else
01501             m_NetMgr->CancelExpect( ReqId, hResult );
01502 
01503         return hResult;
01504     }
01505 
01506     #ifdef RIO_DEBUG1
01507     RioErr << "### [CRioSession - SearchLogsRequest] Finish8" << endl;
01508     #endif
01509 
01510     return S_OK;
01511 }

Friends And Related Function Documentation

friend class CRioDirectory [friend]

Definition at line 403 of file RioInterface.h.

friend class CRioObject [friend]

Definition at line 402 of file RioInterface.h.

friend class CRioStream [friend]

Definition at line 401 of file RioInterface.h.

Field Documentation

int unsigned CRioSession::m_BlockSize [private]

Definition at line 351 of file RioInterface.h.

int CRioSession::m_MaxPktLen [private]

Definition at line 352 of file RioInterface.h.

CNetInterface* CRioSession::m_NetInterface [private]

Definition at line 360 of file RioInterface.h.

NetMgr* CRioSession::m_NetMgr [private]

Definition at line 348 of file RioInterface.h.

struct sockaddr_in* CRioSession::m_ServerAddress [private]

Definition at line 354 of file RioInterface.h.

unsigned int CRioSession::m_ServerAddressSize [private]

Definition at line 358 of file RioInterface.h.

RioSessionId CRioSession::m_SessionId [private]

Definition at line 347 of file RioInterface.h.

CSessionManager* CRioSession::m_SessionManager [private]

Definition at line 349 of file RioInterface.h.

CRioTCP* CRioSession::m_TCPconnection [private]

Definition at line 350 of file RioInterface.h.

char* CRioSession::ServerName [private]

Definition at line 346 of file RioInterface.h.

The documentation for this class was generated from the following files:
Generated on Wed Jul 4 16:03:33 2012 for RIO by  doxygen 1.6.3