00001 /* 00002 * Copyright (C) 2009, Edmundo Albuquerque de Souza e Silva. 00003 * 00004 * This file may be distributed under the terms of the Q Public License 00005 * as defined by Trolltech AS of Norway and appearing in the file 00006 * LICENSE.QPL included in the packaging of this file. 00007 * 00008 * THIS FILE IS PROVIDED AS IS WITH NO WARRANTY OF ANY KIND, INCLUDING 00009 * THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR 00010 * PURPOSE. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, 00011 * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING 00012 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, 00013 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION 00014 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 00015 * 00016 * Thanks: Jose Renato Santos 00017 * 00018 */ 00019 00020 /////////////////////////////////////////////////////////////////////////////// 00021 // RioInterface.h: RIO INTERFACE 00022 /////////////////////////////////////////////////////////////////////////////// 00023 00024 #ifndef __RIOINTERFACE_H_ 00025 #define __RIOINTERFACE_H_ 00026 00027 #include <fstream> 00028 #include <vector> 00029 00030 #ifdef WINDOWS 00031 #include <winsock2.h> 00032 #else 00033 #include <sys/time.h> 00034 #include "RioUnix.h" 00035 #endif 00036 00037 #include "RioMutex.h" 00038 #include "RioSemaphore.h" 00039 #include "RioTypes.h" 00040 #include "NetMgr.h" 00041 #include "td4types.h" 00042 #include "ObjectInfo.h" 00043 00044 #include "RioInterfaceTypes.h" 00045 00046 // Nova unidade com a nova classe de transferencia de dados. 00047 #include "NetInterface.h" 00048 00049 using namespace std; 00050 00051 /* Classes needed for private members */ 00052 class CSessionManager; 00053 class CStreamManager; 00054 class CObjectManager; 00055 class CRouter; 00056 class CRioTCP; 00057 00058 class BufferStream; 00059 00060 class CRioSession; 00061 00062 struct StrRequest 00063 { 00064 u32 Id; 00065 u32 IPaddress; 00066 u16 Port; 00067 u32 Size; 00068 char* Data; 00069 RioBlock Block; 00070 RioRequest* RequestRioServer; 00071 void* ObjectRioServer; 00072 void (*CallBackFunction)(void *parm, int result); 00073 u16 StreamTraffic; 00074 }; 00075 00076 struct ClientData 00077 { 00078 string m_ip; 00079 unsigned short m_port; 00080 string m_video; 00081 unsigned short m_time; //total connection time 00082 unsigned short m_queue; 00083 }; 00084 00085 struct StorageData 00086 { 00087 string m_ip; 00088 string m_hostname; 00089 string m_diskname; 00090 unsigned short m_queue; 00091 }; 00092 00093 // Nova estrutura usada pelas callbacks usadas para implementar a nova 00094 // funcionalidade de busca nos arquivos de logs dos servidores. 00095 00096 struct SearchLogsData 00097 { 00098 // Ponteiro para a sessao a qual a busca esta associada. 00099 CRioSession *session; 00100 // Endereco IP do servidor para o qual desejamos solicitar a busca. 00101 int ServerIP; 00102 // Porta UDP do servidor para o qual desejamos solicitar a busca. 00103 int ServerPort; 00104 // Endereco IP do cliente que requisitou a busca (com o servidor de 00105 // despacho). 00106 int ClientIP; 00107 // Porta UDP do cliente que requisitou a busca (com o servidor de 00108 // despacho). 00109 int ClientPort; 00110 // Tamanho do arquivo com o resultado da busca. O tamanho 0 indica que a 00111 // busca nao teve sucesso. 00112 unsigned int ResultFileSize; 00113 // Identificador do arquivo com o resultado da busca que deve, caso a busca 00114 // tenha tido sucesso (ou seja, ResultFileSize e maior do que 0), ser usado 00115 // para obter os blocos do arquivo. 00116 unsigned long long int ResultFileId; 00117 // Resultado do tratamento da mensagem TYPE_CMD usada para receber o 00118 // resultado da busca. 00119 int ResultCmd; 00120 // Nome do arquivo com o resultado da busca. 00121 char *ResultFileName; 00122 // Proximo bloco a ser copiado do arquivo. 00123 unsigned int CurrentBlock; 00124 // Ponteiro para o buffer que recebera cada um dos blocos do arquivo. 00125 char *BlockBuffer; 00126 // Descritor do arquivo. 00127 FILE *ResultFile; 00128 // Callback a ser chamada quando a busca (e o arquivo for copiado, em caso 00129 // de sucesso) terminar. 00130 callback_t callback; 00131 // Parametro, definido por quem fez a solicitacao da busca, passado a 00132 // callback. 00133 void *callbackparam; 00134 }; 00135 00136 /* 00137 *============================================================================= 00138 * 00139 * CRioSession: represents Session to access the RIO Storage System 00140 * 00141 *============================================================================= 00142 */ 00143 00144 class CRioSession 00145 { 00146 public: 00147 CRioSession(); 00148 ~CRioSession(); 00149 00150 #ifdef RIO_DEBUG_FILE 00151 // Foi adicionado um novo parametro a funcao Connect se a opcao 00152 // RIO_DEBUG_FILE estiver sendo usada: RioNetiLogPath, que define o nome 00153 // completo do arquivo que armazenara o log da RioNeti. O valor default, 00154 // igual a NULL, define que o log deve ser armazenado no diretório em 00155 // que o cliente esta sendo executado, com o nome padrao de 00156 // RIOClientEmul_<maquina>.<dominio>.log. Note que se a opcao 00157 // RIO_DEBUG_FILE nao for usada, a RioNeti usara a RioErr e, com isso, 00158 // a saida sera em stderr (a nao ser que esta saida tenha sido 00159 // redirecionada para um arquivo). 00160 RioResult Connect ( /*[in]*/ /*[string]*/ const char* ServerMachine, 00161 /*[in]*/ /*[string]*/ const char* UserName, 00162 /*[in]*/ /*[string]*/ const char* Password, 00163 /*[in]*/ /*[string]*/ int RioServer, 00164 /*[in]*/ /*[string]*/ const char* RioNetiLogPath 00165 = NULL ); 00166 #else 00167 RioResult Connect ( /*[in]*/ /*[string]*/ const char* ServerMachine, 00168 /*[in]*/ /*[string]*/ const char* UserName, 00169 /*[in]*/ /*[string]*/ const char* Password, 00170 /*[in]*/ /*[string]*/ int RioServer ); 00171 #endif 00172 00173 RioResult Disconnect (); 00174 00175 RioResult CreateObject ( /*[in][string]*/ const char* ObjectName, 00176 /*[in]*/ const short ObjectType, 00177 /*[in]*/ const RioSecurity* Security); 00178 00179 RioResult DeleteObject ( /*[in][string]*/ const char* ObjectName); 00180 RioResult RenameObject ( /*[in][string]*/ const char* CurrentName, 00181 /*[in][string]*/ const char* NewName); 00182 RioResult GetBlockSize ( /*[out]*/ unsigned int* BlockSize); 00183 RioResult ChangeDir ( /*[in]*/ char* NewDir); 00184 RioResult GetCurrentDir ( /*[out]*/ char* Dir, 00185 /*[in]*/ const int SizeDir); 00186 RioResult GetObjectInfo ( /*[in]*/ const char* ObjectName, 00187 /*[out]*/ ObjectInfo* ObjectInfo); 00188 char *GetServerName (); 00189 00190 RioResult GetNumberOfDisks(/*{out}*/ unsigned int* NumberOfDisks ); 00191 RioResult GetNumberOfStorageNodes(unsigned int* NumberOfStorageNodes); 00192 RioResult GetNumberOfActiveAndMaxSessions( 00193 /*[out]*/ unsigned int* NumberOfActiveSessions, 00194 /*[out]*/ unsigned int* NumberOfMaxSessions); 00195 RioResult SaveMeasures(); 00196 RioResult GetStorageNodeInfo( RioStorageNodeInfo* StorageNodeInfo, 00197 unsigned int StorageNodeIndex ); 00198 RioResult GetMonitorTable( char *UserName, 00199 vector<ClientData> *client_data, 00200 vector<StorageData> *storage_data ); 00201 00202 /* to be used at CAC */ 00203 #ifdef WINDOWS 00204 RioResult GetRTT( struct _SYSTEMTIME* RTT_openConnection, 00205 struct _SYSTEMTIME* RTT_openStream); 00206 RioResult GetAverageRTT( struct _SYSTEMTIME* RTT_average ); 00207 #else 00208 RioResult GetRTT( struct timeval* RTT_openConnection, 00209 struct timeval* RTT_openStream); 00210 RioResult GetAverageRTT( struct timeval* RTT_average ); 00211 #endif 00212 /* ----------------------------------------------------- */ 00213 int getipaddr(); 00214 bool isConnected( void ); 00215 00216 RioResult GetId (/*[out]*/ RioSessionId* Id); 00217 00218 /** 00219 * Funcao que faz uma chamada remota a um procedimento do Servidor RIO 00220 * para verificar se a versao do servidor suporta o controle de fluxo. 00221 * @param IsImplemented ponteiro para um valor booleano que sera, apos a 00222 * execucao da funcao, igual a true se a versao do servidor suporta o 00223 * controle de fluxo, e false caso nao suporte o controle ou se algum 00224 * outro erro (diferente do de metodo invalido) ocorreu ao fazer a 00225 * chamada remota (neste caso, o retorno indicara o erro). 00226 * Obs: este funcao foi baseada nas outras funcoes da classe que usam 00227 * alguma funcao do objeto m_SessionManager. 00228 * @return S_OK se a chamada foi executada com sucesso (o erro de metodo 00229 * invalido e usado para detectar se o servidor usa ou nao o controle de 00230 * fluxo e nao e considerado aqui como um erro). 00231 */ 00232 RioResult CheckStreamControl( bool *IsImplemented ); 00233 /** 00234 * Funcao para executar uma busca nos logs do servidor 00235 * @param SearchType tipo da busca, que por enquanto, pode ser 00236 * SEARCHINTRAFFICLOGS para fazer busca nos logs com os trafegos de um 00237 * dos servidores de armazenamento, ou SEARCHINCLIENTSLOGS para fazer 00238 * uma busca nos logs com os comportamentos dos clientes do servidor de 00239 * despacho. 00240 * @param StartTime Tempo inicial da busca (baseado no mesmo principio 00241 * da funcao time da biblioteca do C, isto e, o tempo em segundos desde 00242 * a Epoch (00:00:00 UTC, Janeiro 1 de 1970). 00243 * @param EndTime Tempo Final da busca (o mesmo princio do tempo 00244 * inicial dado acima). 00245 * @param ServerIp endereco IP do servidor. 00246 * @param ServerPort porta (a UDP) usada por este servidor. 00247 * @param SearchResult ponteiro para uma variavel booleana que sera 00248 * true se a busca teve sucesso ou false em caso contrario. Se a busca 00249 * teve sucesso, ela sera armazenada no arquivo cujo nome e dado pelo 00250 * parametro ResultFileName. 00251 * @param ResultFileName nome (caminho completo) do arquivo que 00252 * armazenara o resultado da busca. 00253 * @param callback funcao de callback a ser chamada quando a busca for 00254 * completada e, em caso de sucesso, o arquivo de log ser completamente 00255 * copiado do servidor. 00256 * @param callpackparam parametro, definido por que fez esta chamada, 00257 * passado quando a callback for chamada. 00258 * @result S_OK se a busca foi inicializa com sucesso, ou um valor 00259 * diferente de S_OK caso algum erro ocorra. 00260 */ 00261 RioResult SearchLogs( unsigned int SearchType, time_t StartTime, 00262 time_t EndTime, int ServerIP, int ServerPort, 00263 char *ResultFileName, callback_t callback, 00264 void *callbackparam ); 00265 /** 00266 * Funcao para obter a lista de servidores associados a sessao. A 00267 * posicao 0 tera o servidor de despacho, e as outras posicoes 00268 * terao os servidores de armazenamento. 00269 * Obs: Nao remova o ponteiro, pois retornamos a referencia usada pela 00270 * classe RioSession. 00271 * @param ServerAddress ponteiro para um ponteiro de estruturas do 00272 * tipo sockaddr_in com os enderecos IP e as portas dos servidores. 00273 * @param ServerAddressSize ponteiro para um inteiro nao sinalizado 00274 * que armazenara o tamanho de ServerAddress 00275 */ 00276 void GetServerAddress( struct sockaddr_in **ServerAddress, 00277 unsigned int *ServerAddressSize ); 00278 /** 00279 * Funcao usada para verificar se o maquina cujo nome (que pode ser 00280 * o IP ou o nome da maquina na Internet) passado como parametro e um 00281 * dos servidores. No caso de ser um dos servidores, o seu par IP, 00282 * porta e retornado nos ponteiros passados como parametro a funcao. 00283 * Em caso contrario, sera retornado 0 em ambos os parametros. 00284 * @param ServerName nome da maquina a ser verificada. 00285 * @param IsDispatcher identifica se desejamos fazer uma busca nos 00286 * logs do servidor de despacho. Isso sera usado para definir, quando 00287 * existir um servidor de despacho e de armazenamento na mesma 00288 * maquina, qual posicao de m_ServerAddress devera ser retornada. 00289 * @param ServerIP ponteiro para um inteiro que ira armazenar o 00290 * endereco IP do servidor. 00291 * @param ServerPort ponteiro para um inteiro que ira armazenar a 00292 * porta do servidor. 00293 * @result -2 se nao foi possivel obter um endereco IP para a maquina, 00294 * -1 se a maquina nao for um servidor de gerenciamento ou de 00295 * armazenamento, e a posicao do servidor em m_ServerAddress em caso 00296 * contrario. Caso existam, na mesma maquina, um servidor de 00297 * despacho e um de armazenamento, a posicao retornada dependera de 00298 * IsDispatcher. 00299 */ 00300 int CheckServerAddress( char *ServerName, bool IsDispatcher, 00301 int *ServerIP, int *ServerPort ); 00302 00303 /** 00304 * Nova funcao para criar um usuario. 00305 * @param UserName ponteiro para a string com o nome do usuario. 00306 * @param Password ponteiro para a string com a senha do usuario. 00307 * @return S_OK se o usuario foi criado com sucesso ou um valor 00308 * diferente de S_OK se algum erro ocorreu ao fazermos a chamada 00309 * remota. 00310 */ 00311 RioResult CreateUser( char *UserName, char *Password ); 00312 00313 /** 00314 * Nova funcao para remover a senha do usuario. 00315 * 00316 * Obs: devido ao servidor nao fazrer uma remocao do diretorio se ele 00317 * nao estiver vazio, o diretorio do usuario nao sera removido. 00318 * 00319 * @param UserName ponteiro para a string com o nome do usuario. 00320 * @return S_OK se o usuario foi criado com sucesso ou um valor 00321 * diferente de S_OK se algum erro ocorreu ao fazermos a chamada 00322 * remota. 00323 */ 00324 RioResult RemoveUser( char *UserName ); 00325 00326 /** 00327 * Nova funcao para alterar a senha de um usuario. 00328 * @param UserName ponteiro para a string com o nome do usuario. 00329 * @param Password ponteiro para a string com a senha do usuario. 00330 * @return S_OK se o usuario foi criado com sucesso ou um valor 00331 * diferente de S_OK se algum erro ocorreu ao fazermos a chamada 00332 * remota. 00333 */ 00334 RioResult ChangePassword( char *UserName, char *Password ); 00335 00336 /** 00337 * Nova funcao para obter a lista com todos os usuarios. 00338 * @param USerList vetor de strings (STL) no qual a lista de usuarios 00339 * sera armazenada. 00340 * @return S_OK caso a lista tenha sido gerada com sucesso ou o codigo 00341 * de erro caso nao tenha sido possivel gerar a lista. 00342 */ 00343 RioResult GetUserList( vector< string > &UserList ); 00344 00345 private: 00346 char *ServerName; 00347 RioSessionId m_SessionId; 00348 NetMgr *m_NetMgr; 00349 CSessionManager *m_SessionManager; 00350 CRioTCP *m_TCPconnection; 00351 int unsigned m_BlockSize; 00352 int m_MaxPktLen; 00353 00354 struct sockaddr_in *m_ServerAddress; /* Vetor com os enderecos (IP, 00355 porta) das maquinas para as 00356 quais precisamos enviar 00357 periodicamente pacotes Fake. */ 00358 unsigned int m_ServerAddressSize; /* Numero de maquinas no 00359 vetor m_ServerAddress. */ 00360 CNetInterface *m_NetInterface; /* Ponteiro para o objeto da nova classe 00361 de gerenciamento de rede. */ 00362 00363 /** 00364 * Funcao de callback usada para processar a mensagem do servidor do 00365 * tipo TYPE_CMD para obter o tamanho do arquivo com o resultado da 00366 * busca e o identificador deste arquivo. 00367 * @param parm ponteiro para um objeto da estrutura SearchLogsData com 00368 * as informacoes do comando de busca. 00369 * @param pktp ponteiro para o inicio do pacote com o resultado da 00370 * busca. 00371 * @param pktl tamanho do pacote apontado por pktp. 00372 */ 00373 static void ProcessSearchCmd( void *parm, char *pktp, int pktl ); 00374 /** 00375 * Funcao de callback usada para finalizar o tratamento da mensagem do 00376 * servidor do tipo TYPE_CMD para obter o tamanho do arquivo com o 00377 * resultado da busca e o identificador deste arquivo. A callback dada 00378 * na estrutura SearchLogsData e chamada se algum erro ocorreu quando 00379 * a busca foi feita ou se a busca terminou com sucesso mais nenhum 00380 * reultado foi encontrado (isso sera indicado pelo parametro result 00381 * passado a callback). 00382 * @param parm ponteiro para um objeto da estrutura SearchLogsData com 00383 * as informacoes do comando de busca. 00384 * @param result valor indicando se a execucao do comando foi bem ou 00385 * mau sucedida. 00386 */ 00387 static void FinalizeSearchCmd( void *parm, int result ); 00388 /** 00389 * Funcao de callback usada para finalizar o recebimento de um bloco 00390 * do arquivo. Esta funcao somente chama a callback (dada na estrutura 00391 * SearchLogsData) somente quando o ultimo bloco for recebido ou 00392 * quando um erro ocorrer (isso sera indicado pelo parametro result 00393 * passado a callback). 00394 * @param parm ponteiro para um objeto da estrutura SearchLogsData com 00395 * as informacoes do comando de busca. 00396 * @param result valor indicando se a execucao do comando foi bem ou 00397 * mau sucedida. 00398 */ 00399 static void FinalizeReadBlock( void *parm, int result ); 00400 00401 friend class CRioStream; 00402 friend class CRioObject; 00403 friend class CRioDirectory; 00404 }; 00405 00406 /* 00407 *============================================================================= 00408 *CRioStream: Represents stream of RIO object data 00409 *============================================================================= 00410 */ 00411 class CRioStream 00412 { 00413 public: 00414 CRioStream(); 00415 ~CRioStream(); 00416 00417 RioResult Open (/*[in]*/ const RioStreamTraffic* Traffic, 00418 /*[in]*/ CRioSession* RioSession); 00419 RioResult Close (); 00420 RioResult MaxRequests(); 00421 RioResult CanStart(); 00422 bool SetMulticastSocket( unsigned short multicastport, 00423 char *multicast_addr, 00424 void *callback = 0, 00425 BufferStream *buffer_stream = 0, 00426 int enable_join = 1); 00427 static void MulticastCallBack(void *parm, int result); 00428 void LeaveGroup( unsigned short multicastport ); 00429 void LeaveAllGroups( void ); 00430 int FreeBlock( unsigned int block_id, 00431 RioStreamType traffic ); 00432 int FreePendentBlocks( bool useCache, int nBuffers ); 00433 bool thereAreFragments( RioBlock block ); 00434 void Getmyaddr( int *my_address, int *my_port ); 00435 RioTrafficType GetTrafficType(); 00436 CRioSession *GetRioSession(); 00437 00438 #ifdef RIO_DEBUG2 00439 void printDebug( short debugCode, string message = "" ); 00440 #endif 00441 00442 private: 00443 void *client_callback; 00444 bool m_opened; 00445 RioStreamId m_StreamId; 00446 RioTrafficType m_StreamType; 00447 unsigned int m_BlockSize; 00448 int m_myaddr; 00449 int m_myport; 00450 CRioSession *m_RioSession; 00451 NetMgr *m_NetMgr; 00452 CStreamManager *m_StreamManager; 00453 CRouter *m_Router; 00454 CRioTCP *m_TCPconnection; 00455 00456 CNetInterface *m_NetInterface; /* Ponteiro para o objeto da nova classe 00457 de gerenciamento de rede. */ 00458 00459 RioResult Read( RioRequest *Request, int ObjectId, 00460 RioStreamType traffic = UNICASTTRAFFIC ); 00461 RioResult Read( RioRequest *Request, int ObjectId, int sendack, 00462 RioStreamType traffic, int ip , int port ); 00463 RioResult Write( RioRequest *Request, int ObjectId); 00464 RioResult MulticastRead( RioBlock block, int ObjectId , int sendack, 00465 RioStreamType traffic ); 00466 RioResult MulticastDataRequest(RioBlock block, int ObjectId, 00467 RequestOperation ReqOp, int sendack, 00468 RioStreamType traffic, int ip, 00469 int port ); 00470 00471 int CancelExpect (int reqid); 00472 RioResult DataRequest( RioRequest *Request, int ObjectId, 00473 RequestOperation, 00474 RioStreamType traffic = UNICASTTRAFFIC ); 00475 00476 /* para enviar ip do cliente */ 00477 /* RioResult DataRequest( RioRequest *Request, int ObjectId, 00478 RequestOperation, int sendack , 00479 RioStreamType traffic ); */ 00480 RioResult DataRequest( RioRequest *Request, int ObjectId, 00481 RequestOperation, int sendack, 00482 RioStreamType traffic, 00483 int ip , int port ); 00484 00485 RioResult GetBlockSize (unsigned int* BlockSize); 00486 RioResult GetId (RioStreamId* Id); 00487 static void callback(void *parm, int result); 00488 00489 void FreeMembers(); 00490 00491 friend class CRioObject; 00492 }; 00493 00494 /* 00495 *============================================================================= 00496 *CRioObject: class to access objects 00497 *============================================================================= 00498 */ 00499 class CRioObject 00500 { 00501 public: 00502 CRioObject(); 00503 ~CRioObject(); 00504 00505 RioResult Open (/*[in]*//*[string]*/ const char* ObjectName, 00506 /*[in]*/ const RioAccess Access, 00507 /*[in]*/ CRioStream* RioStream); 00508 00509 #ifdef WINDOWS 00510 RioResult Open (/*[in]*//*[string]*/const char* ObjectName, 00511 /*[in]*/ const RioAccess Access, 00512 struct _SYSTEMTIME RTT_average, 00513 int BufferSize, 00514 /*[in]*/ CRioStream* RioStream, 00515 ofstream &m_log); 00516 #else 00517 RioResult Open (/*[in]*//*[string]*/ const char* ObjectName, 00518 /*[in]*/ const RioAccess Access, 00519 struct timeval RTT_average, 00520 int BufferSize, 00521 /*[in]*/ CRioStream* RioStream, 00522 ofstream &m_log); 00523 #endif 00524 00525 int CancelExpect (int reqid); 00526 RioResult Close (); 00527 RioResult StreamRead ( /*[in]*/ RioRequest* Request, 00528 RioStreamType traffic = UNICASTTRAFFIC ); 00529 RioResult StreamRead ( /*[in]*/ RioRequest* Request, int sendack, 00530 RioStreamType traffic, int ip = 0, 00531 int port = 0 ); 00532 RioResult MulticastStreamRead( RioBlock block, int sendack, 00533 RioStreamType traffic ); 00534 RioResult GetMulticastInfo( int *Flag_Requests, 00535 int *PID); 00536 #ifdef RIO_DEBUG2 00537 void printDebug( short debugCode, string message = "" ); 00538 #endif 00539 00540 /* If enable_join arg is 0, the host doesn't join the multicast group */ 00541 bool SetMulticastSocket( unsigned short multicastport, 00542 char *multicast_addr, 00543 void *callback = 0, 00544 BufferStream *buffer_stream = 0, 00545 int enable_join = 1); 00546 void LeaveGroup( unsigned short multicastport ); 00547 void LeaveAllGroups( void ); 00548 00549 RioResult StreamWrite (/*[in]*/ RioRequest* Request); 00550 RioResult SetSize (/*[in]*/ const RioObjectSize Size, 00551 /*[in]*/ char *md5sum ); 00552 RioResult GetSize (/*[out]*/ RioObjectSize* Size); 00553 int FreeBlock( unsigned int block_id, RioStreamType traffic ); 00554 int FreePendentBlocks( bool useCache, int nBuffers ); 00555 bool thereAreFragments( RioBlock block ); 00556 CRioStream *GetObjectStream(); 00557 void Getmyaddr( int *my_address, int *my_port ); 00558 00559 // Funcoes usadas pela implementacao do controle de fluxo. 00560 00561 /** 00562 * GetVideoRate retorna a taxa de transmissao (em Kbps) do video. 00563 * @param VideoRate ponteiro para o inteiro nao sinalizado que 00564 * armazenara a taxa de transmissao do video. 00565 * @return erro se nao foi possivel chamar o metodo ou se algum erro 00566 * ocorreu ao executar o metodo. 00567 */ 00568 RioResult GetVideoRate( /*[out]*/ unsigned int *VideoRate ); 00569 /** 00570 * SetVideoRate altera a taxa de transmissao (em Kbps) do video. 00571 * @param VideoRate nova taxa de transmissao do video. 00572 * @return erro se nao foi possivel chamar o metodo ou se algum erro 00573 * ocorreu ao executar o metodo. 00574 */ 00575 RioResult SetVideoRate( /*[in]*/ const unsigned int VideoRate ); 00576 00577 // Funcao usada pela implementacao que permite o reinicio dos 00578 // servidores. 00579 00580 /** 00581 * Funcao usada para realocar os blocos fisicos do bloco logico passado 00582 * como parametro 00583 * @param Block identificadao do bloco logico. 00584 * @return S_OK se a realocacao foi feita com sucesso ou um valor 00585 * diferente de S_OK se algum erro ocorreu. 00586 */ 00587 RioResult ReallocBlocks( /*[in]*/ const RioBlock Block ); 00588 00589 private: 00590 CRioStream *m_RioStream; 00591 CRouter *m_Router; 00592 CObjectManager *m_ObjectManager; 00593 CRioTCP *m_TCPconnection; 00594 int m_ObjectId; 00595 ObjectHandle m_ObjectHandle; 00596 unsigned int m_BlockSize; 00597 RioObjectSize m_ObjectSize; 00598 bool m_opened; 00599 int m_FlagRequests; 00600 char *m_ipmulticast; 00601 int m_PID; 00602 void FreeMembers(); 00603 // Taxa de transmissao do video (se o objeto for um arquivo .mpg) 00604 unsigned int m_VideoRate; 00605 }; 00606 00607 /* 00608 *============================================================================= 00609 * CRioDirectory: class to access directories 00610 *============================================================================= 00611 * Beware: "IsDirectory" is always returned false, 00612 * use session->GetObjectInfo to determine type 00613 * ### directory should be changed to: 00614 * - have open and read instead of first implying open 00615 * - not return anything but names (no type) 00616 * - have additional call (at RioSession level? 00617 * which will get type or make it part of objinfo?) 00618 */ 00619 class CRioDirectory 00620 { 00621 public: 00622 CRioDirectory(); 00623 ~CRioDirectory(); 00624 00625 RioResult FirstObject ( /*[in]*//*[string]*/ char* DirectoryName, 00626 /*[in]*/ const int BufferSize, 00627 /*[out]*/ char* ObjectName, 00628 /*[out]*/ int* IsDirectory, 00629 /*[in]*/ CRioSession* RioSession ); 00630 RioResult NextObject ( /*[in]*/ const int BufferSize, 00631 /*[out]*/ char* ObjectName, 00632 /*[out]*/ int* IsDirectory); 00633 RioResult Close (); 00634 private: 00635 CObjectManager *m_ObjectManager; 00636 CRioTCP *m_TCPconnection; 00637 ObjectHandle m_ObjectHandle; 00638 bool m_opened; 00639 void FreeMembers(); 00640 }; 00641 00642 #endif /* __RIOINTERFACE_H_ */