#include <NetInterface.h>
Public Member Functions | |
| CNetInterface () | |
| Construtor da classe CNetInterface, usado para criar um novo objeto da classe. | |
| ~CNetInterface () | |
| Destrutor da classe CNetInterface, usado para deletar um objeto da classe. | |
| RioResult | Start (struct sockaddr_in *ServerAddress, unsigned int ServerAddressSize, time_t ConnectionTimeOut=0, unsigned int ReceiveTimeOut=0, unsigned int SendTimeOut=0) |
| Funcao usada para inicializar a classe usada pelo cliente. | |
| RioResult | Start (int ServerPort, time_t ConnectionTimeOut=0, unsigned int ReceiveTimeOut=0, unsigned int SendTimeOut=0, CLogRotation *LogRotation=NULL) |
| Funcao usada para inicializar a classe usada pelo servidor ou o storage. | |
| RioResult | Stop () |
| Funcao para parar o funcionamento do objeto da classe, parando todas as threads que tenham sido criadas por um objeto de uma das classes derivadas da CNet e tambem todas as estruturas alocadas. | |
| void | getmyaddrport (int *ipaddr, int *port, int server=0) |
| Funcao para obter o IP e a porta do servidor passado como parametro. | |
| void | getalladdrport (int **ipaddr, int **port) |
| Funcao para retornar os pares IP, porta associados ao objeto da classe. | |
| int | getipaddr () |
| Funcao para retornar o endereco IP associado ao objeto da classe. | |
| void | SendCmd (int ipadr, int port, TTransferID TransferID, char *cmdp, int cmdl, callback_t callback, void *callbackparm) |
| Funcao para enviar uma mensagem do tipo comando ao endereco ipadr, port destino, passando o comando dado em cmdp (com o tamanho de cmdl). | |
| void | SendResult (int ipadr, int port, TTransferID TransferID, int result) |
| Funcao para enviar uma mensagem do tipo resultado ao endereco ipadr, port destino, passando o resultado dado em result. | |
| void | SendBlock (int ipadr, int port, TTransferID TransferID, char *bufadr, int buflen, callback_t callback, void *callbackparm, bool UseTCP=true, unsigned int VideoRate=0) |
| Funcao para enviar um bloco de um dos arquivos armazenados em um dos storages do RIO, ou para enviar um bloco de um arquivo resultante de uma busca nos logs, para o par ipadr, port do destino. | |
| TTransferID | ExpectBlock (char *buf, int len, callback_t callback, void *callbackparm, int sendack=1, int IP=0, int Port=0) |
| Funcao para criar uma nova estrutura de transferencia para esperar por um bloco a ser enviado pelo outro lado da conexao. | |
| int | CancelExpect (TTransferID TransferID, int result) |
| Cancela a espera por dados em uma estrutura de transferencia criada anteriormente (sem chamar a callback). | |
| void | TellId (int ipadr, int port, TTransferID TransferID, int tellip, int tellport, TTransferID tellTTransferID, callback_t callback, void *callbackparm) |
| Envia ao outro lado da conexao, usando um comando, as informacoes necessarias para que este lado envie um bloco. | |
| void | GetBlock (int ipadr, int port, TTransferID TransferID, char *bufadr, int buflen, callback_t callback, void *callbackparm) |
| Funcao para esperar por um bloco vindo do outro lado da conexao. | |
| TTransferID | ExpectTellId (char *buf, int len, callback_t callback, void *callbackparm, int IP=0, int Port=0) |
| Funcao para esperar por IDs enviadas por cada servidor de armazenamento, quando enviamos blocos para o sistema RIO. | |
| int | FreeBlock (unsigned int block_id, RioStreamType traffic) |
| Funcao para informar que nao desejamos mais esperar por um bloco enviado por tempo real e que a callback passada ao receber o bloco deve ser chamada mesmo que todos os fragmentos nao tenham ainda sido recebidos. | |
| int | FreePendentBlocks (bool useCache, int nBuffers) |
| Funcao para informar que nao desejamos mais esperar por um conjunto de blocos dado em nBuffers enviados em tempo real e que cada callback passada associada a cada bloco da cache deve ser chamada. | |
| bool | thereAreFragments (RioBlock block) |
| Funcao para verificar se fragmentos foram recebidos para o bloco passado como parametro. | |
| void | Getmyaddr (int *my_address, int *my_port) |
| Retorna o par IP, Porta associado ao objeto NetInterface. | |
| void | setLogRotation (CLogRotation *LogRotation) |
| Funcao para definir o objeto (do tipo CLogRotation) a ser usado para armazenar as estatisticas de envio de pacotes. | |
| TTransferID | ExpectCmd (callback_t callback, void *callbackparm, cmdcallback_t cmdcallback, int IP=0, int Port=0) |
| Nova chamada para esperar pelo recebimento de um comando vindo do outro lado da conexao. | |
| void | SendRst (int ipadr, int port, TTransferID TransferID, int result) |
| Esta funcao e usada para enviar uma mensagem com um codigo de erro para cancelar um pedido pendende (note que este erro, ao contrario da mensagem enviada por SendResult, indica que um erro ocorreu durante o processamento das IDs de transferencia). | |
| void | ProcessData (int IP, int Port, char *Data, unsigned int DataSize) |
| Esta funcao e chamada pelo objeto de uma das classes de rede (NetTCP ou NetUDP) ao receber dados pela rede. | |
| void | SendDataCompleted (int IP, int Port, void *Param) |
| Esta Funcao sera chamada pelo objeto de uma das classes de rede (NetTCP ou NetUDP) quando os dados tiverem sido enviados para um endereco (com ou sem sucesso). | |
| void | ProcessError (int IP, int Port, RioResult RioError, const char *Msg, EErrorType ErrorType, void *Param) |
| Esta funcao e chamada quando algum erro ocorrer com a transferencia de dados. | |
| void | ConnectionClosed (int IP, int Port, EClosedType ClosedType) |
| Esta funcao e chamada pelo objeto de uma das classes de rede (NetTCP ou NetUDP) quando a conexao com a par IP, port for fechada. | |
| bool | FindIPAndPort (int IP, int Port, bool UseTCP=true) |
| Funcao para verificar se um dado par IP, Porta esta ou nao associado a uma conexao do objeto desta classe. | |
Static Public Member Functions | |
| static void | dumppkt (const char *label, char *data, int datal) |
| Funcao usada para imprimir um buffer (em geral, dados recebidos pela conexao). | |
Static Public Attributes | |
| static debugCerr | m_log |
Private Member Functions | |
| RioResult | StartNetTcp (SNetTcpConfig *NetConfig) |
| Funcao usada para criar e inicializar o objeto derivado da classe classes CNetTcp. | |
| RioResult | StartNetUdp (SNetUdpConfig *NetConfig) |
| Funcao usada para criar e inicializar o objeto derivado da classe classes CNetUdp. | |
| RioResult | StartTransferInfo () |
| Funcao usada para criar um novo objeto da classe CTransferInfo. | |
| RioResult | SendData (int IP, int Port, callback_t FinalizeCallback, void *FinalizeCallbackParam, char *Data, unsigned int DataSize, EDataType DataType, bool UseTCP, TTransferID DestTransferID, TTransferID *TransferID=NULL) |
| Funcao para criar uma nova estrutura de transferencia e enviar os dados passados como parametro, anexando no inicio dos dados o cabecalho que informa o tipo de dados (passado como parametro) e o identificador da transferencia do outro lado da conexao para a qual os dados serao enviados. | |
| RioResult | FindIP (int *IP) |
| Funcao para descobrir, dentre todas as interfaces de rede da maquina, a que tiver um IP diferente de 127.0.0.1. | |
Static Private Member Functions | |
| static void | ProcessTransferIDs (void *CmdParam, char *Command, int CommandSize) |
| Funcao de callback usada pela funcao ExpectTellId para processar os identificadores recebidos dos servidores de armazenamento e enviar, usando estes identificadores, os blocos para os servidores de armazenamento. | |
| static void | FinalizeSendBlocks (void *Param, int Result) |
| Funcao de callback chamada quando uma estrutura de transferencia associada ao envio dos blocos aos servidores de armazenamento (criada pela chamada ExpectTellId) receber uma mensagem do tipo RESULTDATA do servidor de despacho informando que todos os servidores de armazenamento reportaram que receberam o bloco (corretamente ou nao). | |
Private Attributes | |
| bool | m_Started |
| CNetTcp * | m_NetTcp |
| CNetUdp * | m_NetUdp |
| CTransferInfo * | m_TransferInfo |
| pthread_mutex_t | m_MapMutex |
Friends | |
| class | CTransferInfo |
Definition at line 357 of file NetInterface.h.
| CNetInterface::CNetInterface | ( | ) |
Construtor da classe CNetInterface, usado para criar um novo objeto da classe.
Definition at line 602 of file NetInterface.cpp.
00603 { 00604 #ifdef RIO_DEBUG1 00605 RioErr << "[CNetInterface - Construtor] Start" << endl; 00606 #endif 00607 00608 // Inicializa as variaveis do objeto da classe. 00609 m_NetTcp = NULL; 00610 m_NetUdp = NULL; 00611 m_Started = false; 00612 m_TransferInfo = NULL; 00613 // m_TransferInfoMap nao precisa ser inicializado. 00614 00615 // Inicializa o mutex do hash. 00616 pthread_mutex_init( &m_MapMutex, NULL ); 00617 00618 #ifdef RIO_DEBUG1 00619 RioErr << "[CNetInterface - Construtor] Finish" << endl; 00620 #endif 00621 }
| CNetInterface::~CNetInterface | ( | ) |
Destrutor da classe CNetInterface, usado para deletar um objeto da classe.
Definition at line 624 of file NetInterface.cpp.
00625 { 00626 #ifdef RIO_DEBUG1 00627 INTERFACELOG << "[CNetInterface - Destrutor] Start" << endl; 00628 #endif 00629 00630 // Se a classe estiver inicializada, para a classe. 00631 if( m_Started ) 00632 Stop(); 00633 00634 // Destroi o mutex do mapa. 00635 pthread_mutex_destroy( &m_MapMutex ); 00636 00637 #ifdef RIO_DEBUG1 00638 INTERFACELOG << "[CNetInterface - Destrutor] Finish" << endl; 00639 #endif 00640 }
| int CNetInterface::CancelExpect | ( | TTransferID | TransferID, | |
| int | result | |||
| ) |
Cancela a espera por dados em uma estrutura de transferencia criada anteriormente (sem chamar a callback).
| TransferID | identificador da transferencia a ser cancelada. | |
| result | eu nao tenho certeza deste parametro, mas ele parece que nao foi usado mas passaria, se a callback fosse chamada ao cancelarmos a transferencia, o motivo do cancelamento. A funcao da RioNeti nao usa este parametro. |
Definition at line 1834 of file NetInterface.cpp.
01835 { 01836 // Armazena o resultado ao executarmos as funcoes do RIO. 01837 RioResult RioStatus; 01838 01839 // Obs: qual valor a funcao deve retornar? A funcao da RioNeti sempre 01840 // retorna 1, mas todas as chamadas da funcao ignoram o parametro, entao 01841 // talvez seja melhor a funcao ser do tipo void. 01842 01843 #ifdef RIO_DEBUG1 01844 INTERFACELOG << "[CNetInterface - CancelExpect] Start" << endl; 01845 #endif 01846 01847 // Tenta remover a ID TransferID. 01848 RioStatus = m_TransferInfo->RemoveTransfer( TransferID ); 01849 if( FAILED( RioStatus ) ) 01850 { 01851 #ifdef RIO_DEBUG2 01852 INTERFACELOG << "CNetInterface::CancelExpect erro 0x" << hex 01853 << RioStatus << dec << " (" 01854 << GetErrorDescription( RioStatus ) << ") ao cancelar uma " 01855 << "estrutura com o ID " << TransferID << " para esperar " 01856 << "por dados." << endl; 01857 #endif 01858 01859 #ifdef RIO_DEBUG1 01860 INTERFACELOG << "[CNetInterface - CancelExpect] Finish1" << endl; 01861 #endif 01862 01863 return 0; 01864 } 01865 01866 #ifdef RIO_DEBUG2 01867 INTERFACELOG << "CNetInterface::CancelExpect cancelando a transferencia " 01868 << "com a ID " << TransferID << "." << endl; 01869 #endif 01870 01871 #ifdef RIO_DEBUG1 01872 INTERFACELOG << "[CNetInterface - CancelExpect] Finish2" << endl; 01873 #endif 01874 01875 return 1; 01876 }
| void CNetInterface::ConnectionClosed | ( | int | IP, | |
| int | Port, | |||
| EClosedType | ClosedType | |||
| ) |
Esta funcao e chamada pelo objeto de uma das classes de rede (NetTCP ou NetUDP) quando a conexao com a par IP, port for fechada.
Os motivos atuais, dados pelo tipo ClosedType, sao:
CONNECTIONCLOSED: a conexao foi fechada pelo outro lado. CONNECTIONTIMEOUT: a conexao foi fechada por timeout.
| IP | endereco IP da maquina associada ao socket com o erro. | |
| Port | porta associada ao socket com erro | |
| timeout | se for true a conexao foi fechada por timeout e, se for false, a conexao foi fechada pelo outro lado da conexao. |
Definition at line 3497 of file NetInterface.cpp.
03498 { 03499 // Define o erro passado a funcao FinalizeAllTransfers do objeto da classe 03500 // CTransferInfo 03501 RioResult RioError; 03502 // Armazena o resultado da execucao da funcao FinalizeAllTransfers. 03503 RioResult RioStatus; 03504 03505 #ifdef RIO_DEBUG1 03506 INTERFACELOG << "[CNetInterface - ConnectionClosed] Start" << endl; 03507 #endif 03508 03509 #ifdef RIO_DEBUG2 03510 // Armazena uma copia do IP para ser usadao pela funcao inet_ntoa. 03511 in_addr ip; 03512 03513 ip.s_addr = IP; 03514 03515 INTERFACELOG << "CNetInterface::ConnectionClosed Fechando todas as " 03516 << "conexoes ativas para o IP " << inet_ntoa( ip ) << " e a " 03517 << "porta " << ntohs( Port ) << " devido a: "; 03518 #endif 03519 03520 switch( ClosedType ) 03521 { 03522 // Neste caso, a conexao foi fechada localmente. 03523 case CONNECTIONCLOSEDLOCALLY: 03524 #ifdef RIO_DEBUG2 03525 INTERFACELOG << "conexao fechada localmente!"; 03526 #endif 03527 03528 RioError = ERROR_NETINTERFACE + ERROR_CLOSED_CONNECTION; 03529 break; 03530 03531 // Neste caso, a conexao foi fechada pelo outro lado. 03532 case CONNECTIONCLOSEDREMOTELLY: 03533 #ifdef RIO_DEBUG2 03534 INTERFACELOG << "conexao fechada pelo outro lado!"; 03535 #endif 03536 03537 RioError = ERROR_NETINTERFACE + ERROR_CLOSED_CONNECTION; 03538 break; 03539 03540 // Neste caso, a conexao foi fechada devido a um timeout. 03541 case CONNECTIONTIMEOUT: 03542 #ifdef RIO_DEBUG2 03543 INTERFACELOG << "conexao fechada por timeout!"; 03544 #endif 03545 03546 RioError = ERROR_NETINTERFACE + ERROR_SOCKET_CLOSED; 03547 break; 03548 03549 // Neste caso, temos um erro de implementacao, pois foi passado um tipo 03550 // nao valido a funcao de callback. 03551 default: 03552 #ifdef RIO_DEBUG2 03553 INTERFACELOG << "nao sei, pois o parametro " << ClosedType 03554 << "passado nao foi definido!"; 03555 #endif 03556 03557 RioError = ERROR_NETINTERFACE + ERROR_INVALID_PARAM; 03558 break; 03559 03560 } 03561 03562 #ifdef RIO_DEBUG2 03563 INTERFACELOG << " Fechando todas as conexoes do endereco!" << endl; 03564 03565 if( this == NULL ) 03566 INTERFACELOG << "CNetInterface::ConnectionClosed this NULL!" 03567 << endl; 03568 03569 if( m_TransferInfo == NULL ) 03570 INTERFACELOG << "CNetInterface::ConnectionClosed m_TransferInfo NULL!" 03571 << endl; 03572 #endif 03573 03574 // Executa a funcao FinalizeAllTransfers para finalizarmos todas as 03575 // trasnferencias pendentes. 03576 RioStatus = m_TransferInfo->FinalizeAllTransfers( IP, Port, UNDEFINEDTYPE, 03577 RioError ); 03578 #ifdef RIO_DEBUG2 03579 if( FAILED( RioStatus ) ) 03580 { 03581 INTERFACELOG << "CNetInterface::ConnectionClosed erro 0x" << hex 03582 << RioStatus << dec << " (" 03583 << GetErrorDescription( RioStatus ) << ") ao executar a " 03584 << "a funcao FinalizeAllTransfers para o par IP " 03585 << inet_ntoa( ip ) << " e a porta " << ntohs( Port ) << "." 03586 << endl; 03587 } 03588 #endif 03589 03590 #ifdef RIO_DEBUG1 03591 INTERFACELOG << "[CNetInterface - ConnectionClosed] Finish" << endl; 03592 #endif 03593 }
| void CNetInterface::dumppkt | ( | const char * | label, | |
| char * | data, | |||
| int | datal | |||
| ) | [static] |
Funcao usada para imprimir um buffer (em geral, dados recebidos pela conexao).
| label | string a ser impressa antes do conteudo do pacote. | |
| data | dados do pacote a serem impressos | |
| datal | tamanho em bytes dos dados. |
Definition at line 2422 of file NetInterface.cpp.
02423 { 02424 int off; 02425 int i; 02426 char *s; 02427 char line[100]; 02428 02429 RioErr << label; 02430 02431 off = 0; 02432 do 02433 { 02434 s = line; 02435 s += sprintf(s,"%4.4x ", (unsigned) off); 02436 02437 for(i = 0; i < 16 && i < datal; i++, data++) 02438 { 02439 s += sprintf(s, "%2.2x", (unsigned)(*data & 0xff)); 02440 if((i & 3) == 3) 02441 { 02442 *s++ = ' '; 02443 } 02444 } 02445 02446 *s++ = '\n'; 02447 *s++ = '\0'; 02448 02449 if(off > 0x20 && off < 0x5a0) 02450 ; 02451 else 02452 RioErr << line; 02453 02454 datal -= 16; 02455 off += 16; 02456 } while(datal > 0); 02457 02458 RioErr << endl; 02459 02460 }
| TTransferID CNetInterface::ExpectBlock | ( | char * | buf, | |
| int | len, | |||
| callback_t | callback, | |||
| void * | callbackparm, | |||
| int | sendack = 1, |
|||
| int | IP = 0, |
|||
| int | Port = 0 | |||
| ) |
Funcao para criar uma nova estrutura de transferencia para esperar por um bloco a ser enviado pelo outro lado da conexao.
| buf | ponteiro para o lugar onde o bloco, quando recebido, sera armazenado. | |
| len | tamanho em blocos do bloco que estamos esperando. | |
| callback | callback a ser chamada quando o bloco for recebido. | |
| callbackparm | parametro a ser passado a callback | |
| sendack | se um ack deve ou nao ser enviado. Como a copia TCP nao possui acks por nao dividir o bloco em fragmentos (como fara a copia em UDP com retransmissao, se implementarmos), este parametro sera ignorado e somente estara aqui porque pode ser futuramente usado). | |
| IP | endereco IP para o qual o bloco deveria ter sido enviado (este parametro novo possui um valor default de 0, para compatibilidade com as chamadas anteriores). | |
| Port | porta para a qual o bloco deveria ter sido enviado (este parametro novo possui um valor default de 0, para compatibilidade com as chamadas anteriores). |
Definition at line 1770 of file NetInterface.cpp.
01773 { 01774 // Armazena o resultado ao executarmos as funcoes do RIO. 01775 RioResult RioStatus; 01776 // Armazena o identificador para a estrutura criada para receber o bloco. 01777 TTransferID TransferID; 01778 01779 #ifdef RIO_DEBUG2 01780 // Usado para armazenar o IP para impressao. 01781 in_addr ip; 01782 01783 ip.s_addr = IP; 01784 #endif 01785 01786 #ifdef RIO_DEBUG1 01787 INTERFACELOG << "[CNetInterface - ExpectBlock] Start" << endl; 01788 #endif 01789 01790 RioStatus = m_TransferInfo->NewTransfer( IP, Port, callback, callbackparm, 01791 NULL, NULL, buf, len, 01792 RECEIVINGDATA, NULLTRANSFERID, 01793 &TransferID ); 01794 if( FAILED( RioStatus ) ) 01795 { 01796 // O que deveremos fazer neste caso? A RioNeti nao trata de erros de 01797 // alocacao de um NetBuf. Eu estou retornado um identificador invalido 01798 // (com o valor -1). 01799 01800 // O que devemos fazer neste caso? A RioNeti nao trata de erros de 01801 // identificador invalido. Como uma callback e chamada, eu acho que 01802 // precisaremos chamar a callback. O erro tambem esta adqeuado (o motivo 01803 // provavelmente sera erro de memoria)? 01804 callback( callbackparm, ERROR_NETINTERFACE + ERROR_MEMORY ); 01805 01806 #ifdef RIO_DEBUG2 01807 INTERFACELOG << "CNetInterface::ExpectBlock erro 0x" << hex << RioStatus 01808 << dec << " (" << GetErrorDescription( RioStatus ) << ") " 01809 << "ao criar uma estrutura para esperar por um bloco " 01810 << "associado ao endereco IP " << inet_ntoa( ip ) 01811 << " e a porta " << ntohs( Port ) << "." << endl; 01812 #endif 01813 01814 #ifdef RIO_DEBUG1 01815 INTERFACELOG << "[CNetInterface - ExpectBlock] Finish1" << endl; 01816 #endif 01817 01818 return NULLTRANSFERID; 01819 } 01820 01821 #ifdef RIO_DEBUG2 01822 INTERFACELOG << "CNetInterface::ExpectBlock esperando bloco associado ao " 01823 << "endereco IP " << inet_ntoa( ip ) << " e a porta " 01824 << ntohs( Port ) << " com a ID " << TransferID << "." << endl; 01825 #endif 01826 01827 #ifdef RIO_DEBUG1 01828 INTERFACELOG << "[CNetInterface - ExpectBlock] Finish2" << endl; 01829 #endif 01830 01831 return TransferID; 01832 }
| TTransferID CNetInterface::ExpectCmd | ( | callback_t | callback, | |
| void * | callbackparm, | |||
| cmdcallback_t | cmdcallback, | |||
| int | IP = 0, |
|||
| int | Port = 0 | |||
| ) |
Nova chamada para esperar pelo recebimento de um comando vindo do outro lado da conexao.
Obs: Esta funcao esta atualmente sendo usada pela parte do codigo do RIO que recebe os blocos do arquivo com o resultado de uma das buscas nos logs. Sera que nao e melhor criar uma funcao que processe o comando na classe NetInterface (e uma funcao tambem na classe NetMgr) e fazer com que a busca nos logs chame esta funcao? Isso pode ser feito depois de fazermos os testes da nova implementacao do TCP.
| callback | callback a ser chamada quando o objeto NetBuf criado for removido. | |
| callbackparm | parametro a ser passado a callback. | |
| cmdcallback | callback a ser chamada quando recebermos a resposta com o tamanho do arquivo de busca e o identificador deste arquivo. | |
| IP | endereco IP para o qual o bloco deveria ter sido enviado (este parametro novo possui um valor default de 0, para compatibilidade com as chamadas anteriores). | |
| Port | porta para a qual o bloco deveria ter sido enviado (este parametro novo possui um valor default de 0, para compatibilidade com as chamadas anteriores). |
Definition at line 2589 of file NetInterface.cpp.
02592 { 02593 // Armazena o resultado ao executarmos as funcoes do RIO. 02594 RioResult RioStatus; 02595 // Armazdna o identificador para a estrutura criada para receber o bloco. 02596 TTransferID TransferID; 02597 02598 #ifdef RIO_DEBUG2 02599 // Usado para armazenar o IP para impressao. 02600 in_addr ip; 02601 02602 ip.s_addr = IP; 02603 #endif 02604 02605 #ifdef RIO_DEBUG1 02606 INTERFACELOG << "[CNetInterface - ExpectCmd] Start" << endl; 02607 #endif 02608 02609 RioStatus = m_TransferInfo->NewTransfer( IP, Port, callback, callbackparm, 02610 cmdcallback, callbackparm, 02611 NULL, NULL, RECEIVINGDATA, 02612 NULLTRANSFERID, &TransferID ); 02613 if( FAILED( RioStatus ) ) 02614 { 02615 // O que deveremos fazer neste caso? A RioNeti nao trata de erros de 02616 // alocacao de um NetBuf. Eu estou retornado um identificador invalido 02617 // (com o valor -1). 02618 02619 // O que devemos fazer neste caso? A RioNeti nao trata de erros de 02620 // identificador invalido. Como uma callback e chamada, eu acho que 02621 // precisaremos chamar a callback. O erro tambem esta adqeuado (o motivo 02622 // provavelmente sera erro de memoria)? 02623 callback( callbackparm, ERROR_NETINTERFACE + ERROR_MEMORY ); 02624 02625 #ifdef RIO_DEBUG2 02626 INTERFACELOG << "CNetInterface::ExpectCmd erro 0x" << hex << RioStatus 02627 << dec << " (" << GetErrorDescription( RioStatus ) << ") " 02628 << "ao criar uma estrutura para esperar por um comando " 02629 << "associado ao endereco IP " << inet_ntoa( ip ) 02630 << " e a porta " << ntohs( Port ) << "." << endl; 02631 #endif 02632 02633 #ifdef RIO_DEBUG1 02634 INTERFACELOG << "[CNetInterface - ExpectCmd] Finish1" << endl; 02635 #endif 02636 02637 return NULLTRANSFERID; 02638 } 02639 02640 #ifdef RIO_DEBUG2 02641 INTERFACELOG << "CNetInterface::ExpectCmd Experando um comando do " 02642 << "endereco IP " << inet_ntoa( ip ) << " e da porta " 02643 << ntohs( Port ) << " usando a transferencia com a ID " 02644 << TransferID << "." << endl; 02645 #endif 02646 02647 #ifdef RIO_DEBUG1 02648 INTERFACELOG << "[CNetInterface - ExpectCmd] Finish2" << endl; 02649 #endif 02650 02651 return TransferID; 02652 }
| TTransferID CNetInterface::ExpectTellId | ( | char * | buf, | |
| int | len, | |||
| callback_t | callback, | |||
| void * | callbackparm, | |||
| int | IP = 0, |
|||
| int | Port = 0 | |||
| ) |
Funcao para esperar por IDs enviadas por cada servidor de armazenamento, quando enviamos blocos para o sistema RIO.
Recebemos diversas IDs porque precisamos enviar um bloco para cada replicacao.
| buf | ponteiro com os dados do bloco a ser enviado. | |
| len | tamanho em bytes do bloco. | |
| callback | callback a ser chamada quando todos os blocos forem enviados com sucesso. | |
| callbackparm | parametro a ser passado quando a callback for chamada | |
| IP | endereco IP para o qual o bloco deveria ter sido enviado (este parametro novo possui um valor default de 0, para compatibilidade com as chamadas anteriores). | |
| Port | porta para a qual o bloco deveria ter sido enviado (este parametro novo possui um valor default de 0, para compatibilidade com as chamadas anteriores). |
Definition at line 2327 of file NetInterface.cpp.
02330 { 02331 // Ponteiro para a estrutura com as informacoes para processarmos os 02332 // comandos enviados pelos servidores de armazenamento necessarios para 02333 // obtermos os identificadores de transferencia para o envio dos blocos. 02334 TTellIdData *TellIdData; 02335 02336 #ifdef RIO_DEBUG2 02337 // Usado para armazenar o IP para impressao. 02338 in_addr ip; 02339 02340 ip.s_addr = IP; 02341 #endif 02342 02343 #ifdef RIO_DEBUG1 02344 INTERFACELOG << "[CNetInterface - ExpectTellId] Finish3" << endl; 02345 #endif 02346 02347 // Tenta alocar uma estrutura do tipo TTellIdData, com as informacoes a 02348 // serem usadas quando a callback interna da classe for chamada para 02349 // processar os dados. 02350 try 02351 { 02352 TellIdData = new TTellIdData; 02353 } 02354 catch( bad_alloc& ba ) 02355 { 02356 #ifdef RIO_DEBUG2 02357 INTERFACELOG << "CNetInterface::ExpectTellId erro de alocacao de " 02358 << "memoria (bad_alloc, error = " << ba.what() << ") ao " 02359 << "criar uma nova estrutura TTellIdData. Retornando " 02360 << "um identificador invalido e chamando a callback com " 02361 << "o erro ERROR_NETINTERFACE + ERROR_MEMORY." << endl; 02362 #endif 02363 02364 // Chama a callback para informar o erro (isso esta correto?) 02365 callback( callbackparm, ERROR_NETINTERFACE + ERROR_MEMORY ); 02366 02367 #ifdef RIO_DEBUG1 02368 INTERFACELOG << "[CNetInterface - ExpectTellId] Finish1" << endl; 02369 #endif 02370 02371 return NULLTRANSFERID; 02372 } 02373 02374 // Inicializa a estrutura com os valores a serem usados quando cada ID de 02375 // transferencia de um servidor de armazenamento for recebida. 02376 TellIdData->Buffer = buf; 02377 TellIdData->BufferSize = len; 02378 TellIdData->callback = callback; 02379 TellIdData->callbackparm = callbackparm; 02380 TellIdData->NetInterface = this; 02381 TellIdData->SentDataTransfer = ExpectCmd( FinalizeSendBlocks, 02382 ( void * ) TellIdData, 02383 ProcessTransferIDs, IP, Port ); 02384 if( TellIdData->SentDataTransfer == NULLTRANSFERID ) 02385 { 02386 #ifdef RIO_DEBUG2 02387 INTERFACELOG << "CNetInterface::ExpectTellId erro ao executar a funcao " 02388 << "ExpectCmd. Retornando umum identificador invalido e " 02389 << "chamando a callback com o erro " 02390 << "ERROR_NETINTERFACE + ERROR_MEMORY." << endl; 02391 #endif 02392 02393 // Remove a estrutura NewData. 02394 delete TellIdData; 02395 02396 // Chama a callback para informar o erro (isso esta correto?) 02397 callback( callbackparm, ERROR_NETINTERFACE + ERROR_MEMORY ); 02398 02399 #ifdef RIO_DEBUG1 02400 INTERFACELOG << "[CNetInterface - ExpectTellId] Finish2" << endl; 02401 #endif 02402 02403 return NULLTRANSFERID; 02404 } 02405 02406 #ifdef RIO_DEBUG2 02407 INTERFACELOG << "CNetInterface::ExpectTellId esperando por uma ID do " 02408 << "endereco IP " << inet_ntoa( ip ) << " e da porta " 02409 << ntohs( Port ) << ", usando a transfencia com a ID " 02410 << TellIdData->SentDataTransfer << "." << endl; 02411 #endif 02412 02413 #ifdef RIO_DEBUG1 02414 INTERFACELOG << "[CNetInterface - ExpectTellId] Finish3" << endl; 02415 #endif 02416 02417 return TellIdData->SentDataTransfer; 02418 }
| void CNetInterface::FinalizeSendBlocks | ( | void * | Param, | |
| int | Result | |||
| ) | [static, private] |
Funcao de callback chamada quando uma estrutura de transferencia associada ao envio dos blocos aos servidores de armazenamento (criada pela chamada ExpectTellId) receber uma mensagem do tipo RESULTDATA do servidor de despacho informando que todos os servidores de armazenamento reportaram que receberam o bloco (corretamente ou nao).
Obs: A callback passada originalmente a funcao ExpectTellId sera chamada se isResultReceived for true (indicando que a chamada FinalizeSendBlocks foi executada) e se SentBlockCount for 0 (indicando que recebemos a confirmacao de envio do bloco para cada servidor de armazenamento que enviou uma ID de transferencia). Esta verificacao e feita aqui e na funcao SendBlockCompleted para evitarmos dependencia da ordem do recebimento da mensagem RESULTDATA e das confirmacoes do recebimento dos blocos).
| Param | parametro passado quando a funcao ExpectTellId foi chamada (mais uma vez um ponteiro para uma estrutura do tipo TTellIdData). | |
| Result | resultado do recebimento do dado com um resultado (S_OK ou o codigo do erro caso tenha ocorrido algum erro receber o dado com o resultado). |
Definition at line 2183 of file NetInterface.cpp.
02184 { 02185 // Ponteiro para a estrutura com as informacoes para processarmos os 02186 // comandos enviados pelos servidores de armazenamento necessarios para 02187 // obtermos os identificadores de transferencia para o envio dos blocos. 02188 TTellIdData *TellIdData; 02189 02190 // Obtem o ponteiro para a estrutura NewData. 02191 TellIdData = ( TTellIdData * ) Param; 02192 02193 #ifdef RIO_DEBUG1 02194 STATICINTERFACELOG << "[CNetInterface - FinalizeSendBlocks] Start" << endl; 02195 #endif 02196 02197 #ifdef RIO_DEBUG2 02198 // Imprime o erro passado na mensagem RESULTDATA 02199 STATICINTERFACELOG << "CNetInterface::FinalizeSendBlocks callback chamada " 02200 << "com o erro 0x" << hex << Result << dec << " ( " 02201 << GetErrorDescription( Result ) << "), associada a " 02202 << "transferencia com a ID " 02203 << TellIdData->SentDataTransfer << "." << endl; 02204 #endif 02205 02206 // Chama a callback para informar que os blocos foram (ou nao) enviados com 02207 // sucesso aos storages. 02208 #ifdef RIO_DEBUG2 02209 STATICINTERFACELOG << "CNetInterface::FinalizeSendBlocks como o servidor " 02210 << "enviou a mensagem RESULTDATA, entao todos os blocos " 02211 << "foram enviados (pois o servidor somente envia a " 02212 << "mensagem depois de todos os storages confirmarem " 02213 << "o envio dos blocos, mesmo que algum erro ocorra!" 02214 << "Chamando a callback passada a funcao ExpectTellID " 02215 << "com o resultado 0x" << hex << Result << dec 02216 << " (" << GetErrorDescription( Result ) << ")." << endl; 02217 #endif 02218 02219 TellIdData->callback( TellIdData->callbackparm, Result ); 02220 02221 #ifdef RIO_DEBUG1 02222 STATICINTERFACELOG << "[CNetInterface - FinalizeSendBlocks] Finish" << endl; 02223 #endif 02224 }
| RioResult CNetInterface::FindIP | ( | int * | IP | ) | [private] |
Funcao para descobrir, dentre todas as interfaces de rede da maquina, a que tiver um IP diferente de 127.0.0.1.
Se nao existir uma interface com um IP diferente deste, entao este IP sera retornado. Obs: O codigo desta funcao foi copiado da RioNeti. Depois podemos ver se existe um modo melhor de fazer a mesma tarefa.
| IP | ponteiro para o endereco no qual o IP sera armazenado. |
Definition at line 2229 of file NetInterface.cpp.
02230 { 02231 #ifdef RIO_DEBUG1 02232 RioErr << "[CNetInterface - FindIP] Start" << endl; 02233 #endif 02234 02235 struct if_nameindex *iflist = NULL; 02236 struct if_nameindex *listsave = NULL; 02237 struct ifreq ifreq; 02238 int auxsock = 0; 02239 struct sockaddr_in sa; 02240 char localhost_ip[IP_STRING_SIZE] = ""; 02241 02242 if( ( auxsock = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 ) 02243 { 02244 *IP = 0; 02245 02246 #ifdef RIO_DEBUG2 02247 RioErr << "CNetInterface::FindIP erro " << errno << " (" 02248 << strerror( errno ) << ") ao criar o socket temporario que " 02249 << "sera usado para obtermos os possiveis enderecos IP da " 02250 << "maquina" << endl; 02251 #endif 02252 02253 #ifdef RIO_DEBUG1 02254 RioErr << "[CNetInterface - FindIP] Finish1" << endl; 02255 #endif 02256 02257 return ERROR_NETINTERFACE + ERROR_SOCKET_CREATE; 02258 } 02259 02260 // returns pointer to dynamically allocated list of structs 02261 listsave = if_nameindex(); 02262 iflist = listsave; 02263 02264 for( ; *(char *)iflist != 0; iflist++ ) 02265 { 02266 // copy in the interface name to look up address of 02267 strncpy( ifreq.ifr_name, iflist->if_name, IF_NAMESIZE ); 02268 02269 // get the address for this interface 02270 if( ioctl( auxsock, SIOCGIFADDR, &ifreq ) < 0 ) 02271 { 02272 // blank IP address 02273 if( errno != 99 ) 02274 { 02275 *IP = 0; 02276 02277 #ifdef RIO_DEBUG2 02278 RioErr << "CNetInterface::FindIP erro " << errno << " (" 02279 << strerror( errno ) << ") ao executar a funcao ioctl " 02280 << "sobre o socket ao obtermos os possiveis enderecos " 02281 << "IP da maquina." << endl; 02282 #endif 02283 02284 #ifdef RIO_DEBUG1 02285 RioErr << "[CNetInterface - FindIP] Finish2" << endl; 02286 #endif 02287 02288 return ERROR_NETINTERFACE + ERROR_IOCTL_FAILED; 02289 } 02290 } 02291 02292 // Take a valid address 02293 memset( &sa, 0, sizeof( struct sockaddr_in ) ); 02294 memcpy( &sa, &ifreq.ifr_addr, sizeof( struct sockaddr_in ) ); 02295 strcpy( localhost_ip, inet_ntoa( sa.sin_addr ) ); 02296 02297 #ifdef RIO_DEBUG2 02298 RioErr << "CNetInterface::FindIP endereco IP associado a placa: " 02299 << localhost_ip << endl; 02300 #endif 02301 02302 if( strcmp( "127.0.0.1", localhost_ip ) != 0 ) 02303 break; // Take the first IP different from 127.0.0.1 02304 } 02305 02306 if_freenameindex( listsave ); 02307 close( auxsock ); 02308 02309 *IP = sa.sin_addr.s_addr; 02310 02311 #ifdef RIO_DEBUG2 02312 RioErr << "CNetInterface::FindIP ip achado com sucesso. O IP escolhido " 02313 << "foi o " << inet_ntoa( sa.sin_addr ) << "." << endl; 02314 #endif 02315 02316 #ifdef RIO_DEBUG1 02317 RioErr << "[CNetInterface - FindIP] Finish3" << endl; 02318 #endif 02319 02320 return S_OK; 02321 }
| bool CNetInterface::FindIPAndPort | ( | int | IP, | |
| int | Port, | |||
| bool | UseTCP = true | |||
| ) |
Funcao para verificar se um dado par IP, Porta esta ou nao associado a uma conexao do objeto desta classe.
| IP | IP a ser verificado. | |
| Port | Porta a ser verificada. | |
| UseTCP | valor booleano que, se false, indica que o bloco deve ser enviado em tempo real (via UDP sem retransmissao) e, se for true, indica que o bloco deve ser enviado em tempo nao real (usando a conexao TCP). Este paramtro e opcional e tem o valor default de true (usar a conexao TCP). |
Definition at line 3597 of file NetInterface.cpp.
03598 { 03599 // Armazena o resultado da chamada da funcao FindIPAndPort do objeto da 03600 // classe CNetTcp ou do objeto da classe CNetUdp (isso dependera do tipo 03601 // de trafego dado por StreamTraffic). 03602 bool isIpAndPortFound; 03603 // Armazena o resultado da execucao da funcao FindIPAndPort. 03604 RioResult RioStatus; 03605 03606 #ifdef RIO_DEBUG1 03607 INTERFACELOG << "[CNetInterface - FindIPAndPort] Start" << endl; 03608 #endif 03609 03610 #ifdef RIO_DEBUG2 03611 // Armazena uma copia do IP para ser usadao pela funcao inet_ntoa. 03612 in_addr ip; 03613 03614 ip.s_addr = IP; 03615 #endif 03616 03617 #ifdef RIO_DEBUG2 03618 INTERFACELOG << "CNetInterface::FindIPAndPort procurando pelo IP " 03619 << inet_ntoa( ip ) << " e a porta " << ntohs( Port ) 03620 << "." << endl; 03621 #endif 03622 03623 // Verificamos o tipo de trafego porque a busca devera ser feita no objeto 03624 // da classe CNetTcp se o trafego for em tempo nao real, e no objeto da 03625 // classe CNetUdp em caso contrario. 03626 if( UseTcp ) 03627 { 03628 // No caso do trafego em tempo nao real, usamos a funcao da classe TCP. 03629 RioStatus = m_NetTcp->FindIPAndPort( IP, Port, &isIpAndPortFound ); 03630 } 03631 else 03632 { 03633 // No caso do trafego em tempo nao real, usamos a funcao da classe UDP. 03634 // 03635 // Obs: como a classe ainda nao esta implementada, a chamada da funcao 03636 // esta comentada e uma atribuicao padrao de erro de implementacao esta 03637 // no seu lugar. Quando a classe for implementada, a linha a seguir 03638 // deve ser descomentada e a linha seguinte a ela deve ser removida 03639 // (isso foi feito porque m_NetUdp e um ponteiro NULL). 03640 // RioStatus = m_NetUdp->FindIPAndPort( IP, Port, &isIpAndPortFound ); 03641 RioStatus = ERROR_NETUDP + ERROR_NOT_IMPLEMENTED; 03642 } 03643 03644 if( FAILED( RioStatus ) ) 03645 { 03646 #ifdef RIO_DEBUG2 03647 INTERFACELOG << "CNetInterface::FindIPAndPort erro 0x" << hex 03648 << RioStatus << dec << " (" 03649 << GetErrorDescription( RioStatus ) << ") ao executar a " 03650 << "a funcao FindIPAndPort para o par IP " 03651 << inet_ntoa( ip ) << " e a porta " << ntohs( Port ) << "." 03652 << endl; 03653 #endif 03654 03655 isIpAndPortFound = false; 03656 } 03657 03658 #ifdef RIO_DEBUG2 03659 INTERFACELOG << "CNetInterface::FindIPAndPort o IP " << inet_ntoa( ip ) 03660 << " e a porta " << ntohs( Port ) 03661 << ( ( isIpAndPortFound ) ? " foram" : " nao foram" ) 03662 << " achados!" << endl; 03663 #endif 03664 03665 #ifdef RIO_DEBUG1 03666 INTERFACELOG << "[CNetInterface - FindIPAndPort] Finish" << endl; 03667 #endif 03668 03669 return isIpAndPortFound; 03670 }
| int CNetInterface::FreeBlock | ( | unsigned int | block_id, | |
| RioStreamType | traffic | |||
| ) |
Funcao para informar que nao desejamos mais esperar por um bloco enviado por tempo real e que a callback passada ao receber o bloco deve ser chamada mesmo que todos os fragmentos nao tenham ainda sido recebidos.
Obs: Como ainda nao implementamos a classe CNetUdp, que sera a responsavel pela copia em tempo real, esta funcao ira retornar 0 se for chamada, e imprimira um erro se RIO_DEBUG2 estiver sendo usado.
| block_id | identificador do bloco (provavelmente o identificador da estrutura de transferencia associada ao recebimento deste bloco). | |
| traffic | tipo de trafego (UNICASTTRAFFIC ou MULTICASTTRAFFIC). |
Definition at line 2465 of file NetInterface.cpp.
02466 { 02467 #ifdef RIO_DEBUG1 02468 INTERFACELOG << "[CNetInterface - FreeBlock] Start" << endl; 02469 #endif 02470 02471 #ifdef RIO_DEBUG2 02472 INTERFACELOG << "[CNetInterface::FreeBlock] Esta funcao nao esta " 02473 << "implementada! Retornado o valor 0!" << endl; 02474 #endif 02475 02476 #ifdef RIO_DEBUG1 02477 INTERFACELOG << "[CNetInterface - FreeBlock] Finish" << endl; 02478 #endif 02479 02480 return 0; 02481 }
| int CNetInterface::FreePendentBlocks | ( | bool | useCache, | |
| int | nBuffers | |||
| ) |
Funcao para informar que nao desejamos mais esperar por um conjunto de blocos dado em nBuffers enviados em tempo real e que cada callback passada associada a cada bloco da cache deve ser chamada.
Obs: Como ainda nao implementamos a classe CNetUdp, que sera a responsavel pela copia em tempo real, esta funcao ira retornar 0 se for chamada, e imprimira um erro se RIO_DEBUG2 estiver sendo usado.
| useCache | valor booleando indicando se estamos usando ou nao uma cache de blocos. | |
| nBuffers | buffer com as informacoes dos blocos para os quais nao desejamos mais esperar. |
Definition at line 2486 of file NetInterface.cpp.
02487 { 02488 #ifdef RIO_DEBUG1 02489 INTERFACELOG << "[CNetInterface - FreePendentBlocks] Start" << endl; 02490 #endif 02491 02492 #ifdef RIO_DEBUG2 02493 INTERFACELOG << "[CNetInterface::FreePendentBlocks] Esta funcao nao esta " 02494 << "implementada! Retornado o valor 0!" << endl; 02495 #endif 02496 02497 #ifdef RIO_DEBUG1 02498 INTERFACELOG << "[CNetInterface - FreePendentBlocks] Finish" << endl; 02499 #endif 02500 02501 return 0; 02502 }
| void CNetInterface::getalladdrport | ( | int ** | ipaddr, | |
| int ** | port | |||
| ) |
Funcao para retornar os pares IP, porta associados ao objeto da classe.
Se o objeto estiver associado a um cliente, entao todos os pares IP, porta do cliente nos servidores serao retornados. Caso o objeto esteja associado ao servidor, sera retornado um ponteiro para um inteiro com o IP do servidor e um outro ponteiro para um inteiro com a porta na qual os clientes devem se conectar ao servidor.
| ipaddr | ponteiro para armazenar os enderecos IPs. | |
| port | ponteiro para armazenar as portas. |
Definition at line 1473 of file NetInterface.cpp.
01474 { 01475 // Armazena o resultado da funcao GetAllIPsAndPorts do objeto da classe 01476 // CNet. 01477 RioResult RioStatus; 01478 01479 #ifdef RIO_DEBUG1 01480 INTERFACELOG << "[CNetInterface - getalladdrport] Start" << endl; 01481 #endif 01482 01483 if( !m_Started ) 01484 { 01485 #ifdef RIO_DEBUG2 01486 INTERFACELOG << "CNetInterface::getalladdrport o objeto nao foi " 01487 << "inicializado." << endl; 01488 #endif 01489 01490 *ipaddr = NULL; 01491 *port = NULL; 01492 01493 #ifdef RIO_DEBUG1 01494 INTERFACELOG << "[CNetInterface - getalladdrport] Finish1" << endl; 01495 #endif 01496 01497 return; 01498 } 01499 01500 // Obs: Mudar de m_NetTcp para m_NetUdp quando a classe for implementada. 01501 RioStatus = m_NetTcp->GetAllIPsAndPorts( ipaddr, port ); 01502 #ifdef RIO_DEBUG2 01503 if( FAILED( RioStatus ) ) 01504 { 01505 INTERFACELOG << "CNetInterface::getalladdrport aviso: erro 0x" 01506 << RioStatus << " (" << GetErrorDescription( RioStatus ) 01507 << ") ao executar a funcao GetAllIPsAndPorts do objeto da " 01508 << "classe CNet. Erro ignorado porque esta funcao nao " 01509 << "retorna um valor!" << endl; 01510 } 01511 01512 INTERFACELOG << "CNetInterface::getalladdrport retornando todos os pares " 01513 << "IP, porta associados ao objeto da classe." << endl; 01514 #endif 01515 01516 #ifdef RIO_DEBUG1 01517 INTERFACELOG << "[CNetInterface - getalladdrport] Finish2" << endl; 01518 #endif 01519 }
| void CNetInterface::GetBlock | ( | int | ipadr, | |
| int | port, | |||
| TTransferID | TransferID, | |||
| char * | bufadr, | |||
| int | buflen, | |||
| callback_t | callback, | |||
| void * | callbackparm | |||
| ) |
Funcao para esperar por um bloco vindo do outro lado da conexao.
| ipadr | endereco IP para onde a ID deve ser enviada. | |
| port | porta neste endereco para onde a ID deve ser enviada. | |
| TransferID | identificador da estrutura de transferencia no endereco destino associada ao recebimento do comando com a ID que devera ser processado. | |
| bufadr | ponteiro para o endereco que armazenara o bloco recebido do outro lado. | |
| buflen | tamanho esperado para o bloco. | |
| callback | callback a ser chamada quando o bloco for recebido. | |
| callbackparm | parametro a ser passado quando a callback for chamada. |
Definition at line 1929 of file NetInterface.cpp.
01932 { 01933 // Armazena o identificador para a estrutura criada para esperar pelo 01934 // termino do comando que envia as informacoes ao outro lado. 01935 TTransferID AuxTransferID; 01936 // Armazena o par IP, porta associado ao storage. 01937 int ipstor, portstor; 01938 // Armazena o resultado da chamada a uma funcao do RIO. 01939 RioResult RioStatus; 01940 01941 #ifdef RIO_DEBUG2 01942 // Usado para armazenar o IP para impressao. 01943 in_addr ip; 01944 #endif 01945 01946 #ifdef RIO_DEBUG1 01947 INTERFACELOG << "[CNetInterface - GetBlock] Start" << endl; 01948 #endif 01949 01950 // Obtem o par IP, porta do storage. 01951 RioStatus = m_NetTcp->GetIPAndPort( &ipstor, &portstor ); 01952 if( FAILED( RioStatus ) ) 01953 { 01954 // Ocorreu um erro ao obter o par IP, porta do storage. 01955 // 01956 // Obs: Devemos, assim como na NetMgr, copiar estes pares IP, porta em 01957 // algum campo do objeto? 01958 // 01959 01960 #ifdef RIO_DEBUG2 01961 INTERFACELOG << "CNetInterface::GetBlock erro 0x" << hex << RioStatus 01962 << dec << " (" << GetErrorDescription( RioStatus ) 01963 << ") ao obter o par IP, porta do storage." << endl; 01964 #endif 01965 01966 #ifdef RIO_DEBUG1 01967 INTERFACELOG << "[CNetInterface - GetBlock] Finish1" << endl; 01968 #endif 01969 01970 return; 01971 01972 } 01973 01974 // Executa a funcao ExpectBlock para informar, ao outro lado, que estamos 01975 // esperando pelo recebimento de um bloco. 01976 AuxTransferID = ExpectBlock( bufadr, buflen, callback, callbackparm, 0, 01977 ipadr, port ); 01978 if( AuxTransferID == NULLTRANSFERID ) 01979 { 01980 // Um erro ocorreu ao criar uma nova estrutura para receber os dados. 01981 // A callback ja foi chamada na funcao ExpectBlock para informar o erro. 01982 01983 #ifdef RIO_DEBUG2 01984 INTERFACELOG << "CNetInterface::GetBlock erro ao criar uma nova " 01985 << "estrutura de transferencia para esperar por um bloco. " 01986 << endl; 01987 #endif 01988 01989 #ifdef RIO_DEBUG1 01990 INTERFACELOG << "[CNetInterface - GetBlock] Finish2" << endl; 01991 #endif 01992 01993 return; 01994 } 01995 01996 #ifdef RIO_DEBUG2 01997 ip.s_addr = ipadr; 01998 INTERFACELOG << "CNetInterface::GetBlock esperando por um bloco do IP " 01999 << inet_ntoa( ip ) << " e a porta " << ntohs( port ) 02000 << " usando a estrutura de transferencia com a ID " 02001 << AuxTransferID << ". Identificacao da transferencia " 02002 << "passada como parametro " << TransferID << "." << endl; 02003 02004 INTERFACELOG << "CNetInterface::GetBlock Antes de executar TellId, usando " 02005 << "os parametros " << inet_ntoa( ip ) << ", " << ntohs( port ) 02006 << ", " << TransferID; 02007 fflush( stderr ); 02008 ip.s_addr = ipstor; 02009 INTERFACELOG << inet_ntoa( ip ) << ", " << ntohs( portstor ) << ", " 02010 << AuxTransferID << "NULL, NULL." << endl; 02011 #endif 02012 02013 // Agora vamos informar a ID da transferencia ao outro lado. 02014 TellId( ipadr, port, TransferID, ipstor, portstor, AuxTransferID, NULL, 02015 NULL ); 02016 02017 #ifdef RIO_DEBUG2 02018 INTERFACELOG << "CNetInterface::GetBlock Depois de executar TellId" << endl; 02019 #endif 02020 02021 #ifdef RIO_DEBUG1 02022 INTERFACELOG << "[CNetInterface - GetBlock] Finish2" << endl; 02023 #endif 02024 }
| int CNetInterface::getipaddr | ( | ) |
Funcao para retornar o endereco IP associado ao objeto da classe.
No caso do cliente, sera retornado o IP associado ao servidor de despacho e, no caso do servidor, o IP associado ao servidor.
Definition at line 1524 of file NetInterface.cpp.
01525 { 01526 // Armazena o resultado ao executarmos as funcoes do RIO. 01527 RioResult RioStatus; 01528 // Usado para armazenar o IP obtido pela funcao GetIPAndPort. 01529 int IP; 01530 01531 #ifdef RIO_DEBUG2 01532 // Armazena uma copia do endereco IP para ser impressa. 01533 in_addr ip; 01534 #endif 01535 01536 #ifdef RIO_DEBUG1 01537 INTERFACELOG << "[CNetInterface - getipaddr] Start" << endl; 01538 #endif 01539 01540 if( !m_Started ) 01541 { 01542 #ifdef RIO_DEBUG2 01543 INTERFACELOG << "CNetInterface::getipaddr o objeto nao foi " 01544 << "inicializado." << endl; 01545 #endif 01546 01547 #ifdef RIO_DEBUG1 01548 INTERFACELOG << "[CNetInterface - getipaddr] Finish1" << endl; 01549 #endif 01550 01551 return 0; 01552 } 01553 01554 // Obs: Mudar de m_NetTcp para m_NetUdp quando a classe for implementada. 01555 RioStatus = m_NetTcp->GetIPAndPort( &IP, NULL ); 01556 #ifdef RIO_DEBUG2 01557 if( FAILED( RioStatus ) ) 01558 { 01559 INTERFACELOG << "CNetInterface::getipaddr aviso: erro 0x" 01560 << RioStatus << " (" << GetErrorDescription( RioStatus ) 01561 << ") ao executar a funcao GetIPAndPort do objeto da " 01562 << "classe CNet. Erro ignorado porque esta funcao nao " 01563 << "retorna um valor!" << endl; 01564 } 01565 01566 ip.s_addr = IP; 01567 INTERFACELOG << "CNetInterface::getipaddr retornando o IP " 01568 << inet_ntoa( ip ) << " associado ao servidor de despacho." 01569 << endl; 01570 #endif 01571 01572 #ifdef RIO_DEBUG1 01573 INTERFACELOG << "[CNetInterface - getipaddr] Finish2" << endl; 01574 #endif 01575 01576 return IP; 01577 }
| void CNetInterface::Getmyaddr | ( | int * | my_address, | |
| int * | my_port | |||
| ) |
Retorna o par IP, Porta associado ao objeto NetInterface.
No cliente, este par e o par IP, porta associado ao servidor de despacho e, no servidor, o par IP, porta usado para enviar/receber dados para o/do servidor.
Obs: Como nesta nova classe esta funcao e equivalente a funcao getmyaddrport com o parametro server igual a 0 (que e o seu valor default, sera que nao deveremos substituir todas as chamadas a Getmyaddr por getmyaddrport? Esta funcao simplesmente chama a fincao getmyaddrport.
Definition at line 2525 of file NetInterface.cpp.
02526 { 02527 #ifdef RIO_DEBUG2 02528 // Usado para armazenar o IP para impressao. 02529 in_addr ip; 02530 #endif 02531 02532 #ifdef RIO_DEBUG1 02533 INTERFACELOG << "[CNetInterface - Getmyaddr] Start" << endl; 02534 #endif 02535 02536 getmyaddrport( my_address, my_port, 0 ); 02537 02538 #ifdef RIO_DEBUG2 02539 ip.s_addr = *my_address; 02540 INTERFACELOG << "CNetInterface::Getmyaddr obtido o IP " << inet_ntoa( ip ) 02541 << "e a porta " << ntohs( *my_port ) << " associada ao " 02542 << "servidor de despacho." << endl; 02543 #endif 02544 02545 #ifdef RIO_DEBUG1 02546 INTERFACELOG << "[CNetInterface - Getmyaddr] Finish" << endl; 02547 #endif 02548 }
| void CNetInterface::getmyaddrport | ( | int * | ipaddr, | |
| int * | port, | |||
| int | server = 0 | |||
| ) |
Funcao para obter o IP e a porta do servidor passado como parametro.
Por default, sera obtido o par IP, porta do servidor com o identificador 0 (no caso do cliente, o par IP, porta do cliente no servidor de despacho).
| ipaddr | ponteiro para armazenar o endereco IP. | |
| port | ponteiro para armazenar a porta. | |
| server | identificador do servidor para o qual desejamos obter o par IP, porta. Para o servidor, qualquer valor diferente de 0 nao retornara valores. Para o cliente, o valor 0 se refere ao servidor de despacho e os valores de 1 ate o numero de servidores de armazenamento a cada um dos servidores de armazenamento (na mesma ordem em que eles estao no arquivo de configuracao do servidor de despacho, mas o cliente nao precisa saber disso). |
Definition at line 1412 of file NetInterface.cpp.
01413 { 01414 // Armazena o resultado ao executarmos as funcoes do RIO. 01415 RioResult RioStatus; 01416 01417 #ifdef RIO_DEBUG2 01418 // Armazena uma copia do endereco IP para ser impressa. 01419 in_addr ip; 01420 #endif 01421 01422 #ifdef RIO_DEBUG1 01423 INTERFACELOG << "[CNetInterface - getmyaddrport] Start" << endl; 01424 #endif 01425 01426 if( !m_Started ) 01427 { 01428 #ifdef RIO_DEBUG2 01429 INTERFACELOG << "CNetInterface::getmyaddrport o objeto nao foi " 01430 << "inicializado." << endl; 01431 #endif 01432 01433 *ipaddr = 0; 01434 *port = 0; 01435 01436 #ifdef RIO_DEBUG1 01437 INTERFACELOG << "[CNetInterface - getmyaddrport] Finish1" << endl; 01438 #endif 01439 01440 return; 01441 } 01442 01443 // Obs: Mudar de m_NetTcp para m_NetUdp quando a classe for implementada. 01444 RioStatus = m_NetTcp->GetIPAndPort( ipaddr, port, server ); 01445 #ifdef RIO_DEBUG2 01446 if( FAILED( RioStatus ) ) 01447 { 01448 INTERFACELOG << "CNetInterface::getmyaddrport aviso: erro 0x" 01449 << RioStatus << " (" << GetErrorDescription( RioStatus ) 01450 << ") ao executar a funcao GetIPAndPort do objeto da " 01451 << "classe CNet. Erro ignorado porque esta funcao nao " 01452 << "retorna um valor!" << endl; 01453 } 01454 01455 ip.s_addr = *ipaddr; 01456 INTERFACELOG << "CNetInterface::getmyaddrport retornando o IP " 01457 << inet_ntoa( ip ) << " e porta " << ntohs( *port ) 01458 << " associado ao servidor com a ID " << server << "." 01459 << endl; 01460 #endif 01461 01462 #ifdef RIO_DEBUG1 01463 INTERFACELOG << "[CNetInterface - getmyaddrport] Finish2" << endl; 01464 #endif 01465 }
| void CNetInterface::ProcessData | ( | int | IP, | |
| int | Port, | |||
| char * | Data, | |||
| unsigned int | DataSize | |||
| ) |
Esta funcao e chamada pelo objeto de uma das classes de rede (NetTCP ou NetUDP) ao receber dados pela rede.
| IP | endereco IP da maquina que enviou os dados. | |
| Port | porta a partir da qual o pacote foi enviado a partir da maquina que enviou estes dados | |
| Data | Dados enviados. | |
| DataSize | Tamanho dos dados. Obs: Um tamanho igual a 0 indicara que a conexao foi fechada pelo outro lado. Neste caso, a funcao devera fazer as tarefas necessarias para fechar a conexao associada aos dados. |
Definition at line 2705 of file NetInterface.cpp.
02707 { 02708 // Armazena o resultado da execucao das funcoes do RIO. 02709 RioResult RioStatus; 02710 // Armazena o IP guardado na estrutura da transferencia com o ID TransferID. 02711 int IPTransfer; 02712 // Armazena a porta guardada na estrutura da transferencia com o ID 02713 // TransferID. 02714 int PortTransfer; 02715 // Armazena a callback de finalizacao associada a transferencia. 02716 callback_t FinalizeCallback; 02717 // Armazena o parametro que deve ser passado quando a callback 02718 // FinalizeCallback for chamada. 02719 void *FinalizeCallbackParam; 02720 // Armazena a callback de processamento de dados recebidos (somente usada 02721 // quando mensagens com comandos, do tipo CMDDATA, sao enviadas para o 02722 // outro lado). 02723 cmdcallback_t ProcessCallback; 02724 // Armazena o parametro que deve ser passado quando a callback 02725 // ProcessCallbackParam for chamada. 02726 void *ProcessCallbackParam; 02727 // Armazena o ponteiro para os dados que foram enviados (e aqui que vamos 02728 // remover este buffer, apos chamarmos a callback FinalizeCallback). 02729 char *DataTransfer; 02730 // Armazena o tamanho em bytes dos dados apontados por Data. 02731 unsigned int DataTransferSize; 02732 // Armazena o tipo da transferencia (se e para envio de dados, o correto 02733 // para esta chamada ou recebimento de dados, que seria incorreto para 02734 // esta chamada). 02735 ETransferType TransferType; 02736 // Armazena uma copia do IP para ser usadao pela funcao inet_ntoa do 02737 // parametro IP e uma copia, tambem para ser usada pela funcao inet_ntoa, 02738 // do parametro IPTransfer. 02739 in_addr ip, ipt; 02740 // Estrutura que armazenara o cabecalho recebido pela conexao de rede. 02741 SDataHeader DataHeader; 02742 // Define se a estrutura associada a transferencia deve ou nao ser removida 02743 // (isso nao ocorrera para as mensagens do tipo CMDDATA). 02744 bool RemoveTrasnfer; 02745 // Armazena os resultados ou erros recebidos pelas mensagens RSTDATA e 02746 // RESULTDATA, que devem ser passados a callback de finalizacao. 02747 int Result; 02748 02749 #ifdef RIO_DEBUG1 02750 INTERFACELOG << "[CNetInterface - ProcessData] Start" << endl; 02751 #endif 02752 02753 // Inicializa ip com a copia do IP. 02754 ip.s_addr = IP; 02755 02756 // Primeiramente verificamos se os dados possuem bytes suficientes para o 02757 // cabecalho mais um dado. 02758 if( DataSize < ( DATAHEADERSIZE + 1 ) ) 02759 { 02760 // Os dados recebidos nao possuem bytes suficientes para o cabecalho 02761 // mais algum conteudo (de pelo menos 1 byte). Entao os dados nao foram 02762 // enviados corretamente pelo outro lado da conexao. 02763 02764 INTERFACELOG << "CNetInterface::ProcessData os dados nao foram " 02765 << "corretamente recebidos para a transferencia associada " 02766 << "ao IP " << inet_ntoa( ip ) << " e a porta " 02767 << ntohs( Port ) << ". Nenhuma callback sera chamada! " 02768 << "Ignorando a mensagem!" << endl; 02769 02770 #ifdef RIO_DEBUG1 02771 INTERFACELOG << "[CNetInterface - ProcessData] Finish1" << endl; 02772 #endif 02773 02774 return; 02775 } 02776 02777 // Copia o cabecalho dos dados. 02778 memcpy( &DataHeader, Data, DATAHEADERSIZE ); 02779 02780 // Converte os campos da ordem de bytes da rede para a ordem de bytes da 02781 // maquina. 02782 DataHeader.DataTransferID = ntohl( DataHeader.DataTransferID ); 02783 DataHeader.DataType = ntohs( DataHeader.DataType ); 02784 DataHeader.SourceTransferID = ntohl( DataHeader.SourceTransferID ); 02785 02786 // Atualiza o ponteiro Data para apontar para os dados efetivamente enviados 02787 // do outro lado (sem o cabecalho), assim como o tamanho dos dados dado em 02788 // DataSize. 02789 Data = &Data[ DATAHEADERSIZE ]; 02790 DataSize = DataSize - DATAHEADERSIZE; 02791 02792 #ifdef RIO_DEBUG2 02793 INTERFACELOG << "CNetInterface::ProcessData Recebida uma mensagem do IP " 02794 << inet_ntoa( ip ) << " e da porta " << ntohs( Port ) 02795 << " para a estrutura de trasnferencia com o ID " 02796 << DataHeader.DataTransferID << " com o tipo " 02797 << DataHeader.DataType << " a partir da estrutura de " 02798 << "transferencia origem com a ID " 02799 << DataHeader.SourceTransferID << ". O conteudo da mensagem " 02800 << "possui " << DataSize << " bytes no total." << endl; 02801 #endif 02802 02803 RioStatus = m_TransferInfo->GetTransfer( DataHeader.DataTransferID, 02804 &IPTransfer, &PortTransfer, 02805 &FinalizeCallback, 02806 &FinalizeCallbackParam, 02807 &ProcessCallback, 02808 &ProcessCallbackParam, 02809 &DataTransfer, &DataTransferSize, 02810 &TransferType ); 02811 if( FAILED( RioStatus ) ) 02812 { 02813 INTERFACELOG << "CNetInterface::ProcessData erro 0x" << hex << RioStatus 02814 << dec << " (" << GetErrorDescription( RioStatus ) << ") " 02815 << "ao executar a funcao GetTransfer. O erro foi gerado " 02816 << "para o par IP " << inet_ntoa( ip ) << ", a porta " 02817 << ntohs( Port ) << ", com o Source ID " 02818 << DataHeader.SourceTransferID << " e o Destination ID " 02819 << DataHeader.DataTransferID << ". O pacote recebido tinha " 02820 << "um tamanho de " << DataSize << " bytes, sendo " 02821 << ", com esperado, " << DATAHEADERSIZE << " bytes usado " 02822 << "pelo cabecalho. Ignorando a mensagem!" << endl; 02823 02824 #ifdef RIO_DEBUG1 02825 INTERFACELOG << "[CNetInterface - ProcessData] Finish2" << endl; 02826 #endif 02827 02828 return; 02829 } 02830 02831 // Inicializa IPTransfer com a copia de IPTransfer; 02832 ipt.s_addr = IPTransfer; 02833 02834 // Verificamos se o par IP, Porta passado a funcao e o mesmo associado a 02835 // transferencia cujo parametro foi passado como parametro. 02836 if( ( IPTransfer != 0 ) && ( PortTransfer != 0 ) && 02837 ( ( IP != IPTransfer ) || ( Port != PortTransfer ) ) ) 02838 { 02839 INTERFACELOG << "CNetInterface::ProcessData aviso: o IP " 02840 << inet_ntoa( ipt ) << " e a porta " 02841 << ntohs( PortTransfer ) << " associados a transferencia " 02842 << "com o ID " << DataHeader.DataTransferID << " nao sao " 02843 << "iguais ao IP " << inet_ntoa( ip ) << " e a porta " 02844 << ntohs( Port ) << " passados como parametros da funcao! " 02845 << "Ignorando a mensagem!" << endl; 02846 02847 #ifdef RIO_DEBUG1 02848 INTERFACELOG << "[CNetInterface - ProcessData] Finish3" << endl; 02849 #endif 02850 02851 return; 02852 } 02853 02854 // Verifica se o tipo de transferencia e o adequado. 02855 if( TransferType != RECEIVINGDATA ) 02856 { 02857 // Transferencia do tipo incorreto. Neste caso, nao podemos chamar a 02858 // callback e nem remover o buffer. 02859 INTERFACELOG << "CNetInterface::ProcessData a transferencia " 02860 << "associada ao IP " << inet_ntoa( ipt ) << " e a porta " 02861 << ntohs( PortTransfer ) << " nao e do tipo de " 02862 << "recebimento de dados. Nenhuma callback sera chamada! " 02863 << "Ignorando a mensagem!" << endl; 02864 02865 #ifdef RIO_DEBUG1 02866 INTERFACELOG << "[CNetInterface - ProcessData] Finish4" << endl; 02867 #endif 02868 02869 return; 02870 } 02871 02872 // O par IP, Porta da transferencia bate e o tipo de transferencia e de 02873 // recebimento de dados. Neste caso, primeiramente deveremos extrair dos 02874 // dados o cabecalho com o tipo de mensagem para definirmos o que sera feito 02875 // com os dados. A callback chamada sera a ProcessCallbackParam se os dados 02876 // estiverem associados a um comando (CMDDATA) ou a callback de finalizacao 02877 // FinalizeCallback para todos os outros tipos. 02878 02879 // Agora verificamos o tipo de dados, pois o que deveremos fazer dependera 02880 // do tipo de dados que foi recebido. 02881 switch( DataHeader.DataType ) 02882 { 02883 // Foi recebida uma mensagem de erro interna. Neste caso, o ponteiro 02884 // Data devera apontar para um int, e DataSize deve ser igual ao 02885 // tamanho de um int. Neste caso deveremos chamar a callback de 02886 // finalizacao FinalizeCallback e depois remover a estrutura de 02887 // transferencia. 02888 case RSTDATA: 02889 // Verificamos se o tamanho do pacote e o adequado. 02890 if( DataSize != sizeof ( int ) ) 02891 { 02892 INTERFACELOG << "CNetInterface::ProcessData a mensagem do tipo " 02893 << "RSTDATA recebida do par IP " 02894 << inet_ntoa( ip ) << " e a porta " 02895 << ntohs( Port ) << " estava com o tamanho " 02896 << "incorreto: foram recebidos " << DataSize 02897 << " bytes quando o correto seria " 02898 << sizeof( int ) << " bytes! Ignorando a mensagem!" 02899 << endl; 02900 02901 #ifdef RIO_DEBUG1 02902 INTERFACELOG << "[CNetInterface - ProcessData] Finish5" << endl; 02903 #endif 02904 02905 return; 02906 } 02907 02908 // Copia o valor do erro para Result. 02909 memcpy( &Result, Data, sizeof( int ) ); 02910 02911 // Chamamos a callback com o erro. 02912 FinalizeCallback( FinalizeCallbackParam, Result ); 02913 02914 // Devemos remover a estrutura de transferencia. 02915 RemoveTrasnfer = true; 02916 02917 break; 02918 02919 // Foi recebida uma mensagem com um comando. Neste caso, deveremos 02920 // simplesmente chamar a callback de processamento ProcessCallback e 02921 // nao remover a estrutura de transferencia (ela devera ser removida, 02922 // neste caso, quando uma mensagem RESULTDATA for recebida). 02923 case CMDDATA: 02924 // Verificamos se a estrutura de transferencia esta associada a um 02925 // recebimento de um comando (esta estrutura e a unica para a qual 02926 // ProcessCallback e diferente de NULL. 02927 if( ProcessCallback == NULL ) 02928 { 02929 INTERFACELOG << "CNetInterface::ProcessData a mensagem do tipo " 02930 << "CMDDATA recebida do par IP " 02931 << inet_ntoa( ip ) << " e a porta " 02932 << ntohs( Port ) << " foi enviada para uma " 02933 << "estrutura nao associada a um recebimento de " 02934 << "um comando! Ignorando a mensagem!" << endl; 02935 02936 #ifdef RIO_DEBUG1 02937 INTERFACELOG << "[CNetInterface - ProcessData] Finish6" << endl; 02938 #endif 02939 02940 return; 02941 } 02942 02943 // Aqui simplesmente passamos o comando recebido a callback de 02944 // processamento. 02945 ProcessCallback( ProcessCallbackParam, Data, DataSize ); 02946 02947 // Nao devemos remover a estrutura de transferencia. 02948 RemoveTrasnfer = false; 02949 02950 break; 02951 02952 // Foi recebida uma mensagem de resultado. Neste caso, o ponteiro 02953 // Data devera apontar para um int, e DataSize deve ser igual ao 02954 // tamanho de um int. Neste caso deveremos chamar a callback de 02955 // finalizacao FinalizeCallback e depois remover a estrutura de 02956 // transferencia. Esta mensagem e usada para terminar uma transferencia 02957 // iniciada por uma mensagem CMDDATA. 02958 case RESULTDATA: 02959 // Verificamos se o tamanho do pacote e o adequado. 02960 if( DataSize != sizeof ( int ) ) 02961 { 02962 INTERFACELOG << "CNetInterface::ProcessData a mensagem do tipo " 02963 << "RESULTDATA recebida do par IP " 02964 << inet_ntoa( ip ) << " e a porta " 02965 << ntohs( Port ) << " estava com o tamanho " 02966 << "incorreto: foram recebidos " << DataSize 02967 << " bytes quando o correto seria " 02968 << sizeof( int ) << " bytes! Ignorando a mensagem!" 02969 << endl; 02970 02971 #ifdef RIO_DEBUG1 02972 INTERFACELOG << "[CNetInterface - ProcessData] Finish7" << endl; 02973 #endif 02974 02975 return; 02976 } 02977 02978 // Copia o valor do erro para Result. 02979 memcpy( &Result, Data, sizeof( int ) ); 02980 02981 // Chamamos a callback com o erro. 02982 FinalizeCallback( FinalizeCallbackParam, Result ); 02983 02984 // Devemos remover a estrutura de transferencia. 02985 RemoveTrasnfer = true; 02986 02987 break; 02988 02989 // Verificamos se a estrutura de transferencia esta associada ao 02990 // recebimento de um bloco. 02991 case BLOCKDATA: 02992 // Verificamos se a estrutura esta associada a um envio de dados 02993 // Neste caso DataTransfer deveria nao ser NULL (para as mensagens 02994 // CMDDATA e RESULTDATA podemos supor que DataTransfer e NULL, 02995 // porque quando ProcessCallback nao e NULL DataTransfer e NULL e 02996 // vice-versa). 02997 if( DataTransfer == NULL ) 02998 { 02999 INTERFACELOG << "CNetInterface::ProcessData a mensagem do tipo " 03000 << "BLOCKDATA recebida do par IP " 03001 << inet_ntoa( ip ) << " e a porta " 03002 << ntohs( Port ) << " para uma estrutura nao " 03003 << "associada ao recebimento de um bloco! " 03004 << "Ignorando a mensagem!" << endl; 03005 03006 #ifdef RIO_DEBUG1 03007 INTERFACELOG << "[CNetInterface - ProcessData] Finish8" << endl; 03008 #endif 03009 03010 return; 03011 } 03012 03013 // Verificamos agora se recebemos todos os bytes do bloco. 03014 if( DataSize != DataTransferSize ) 03015 { 03016 INTERFACELOG << "CNetInterface::ProcessData a mensagem do tipo " 03017 << "BLOCKDATA recebida do par IP " 03018 << inet_ntoa( ip ) << " e a porta " 03019 << ntohs( Port ) << " tem " << DataSize 03020 << " bytes, mas deveria ter " << DataTransferSize 03021 << " bytes! Ignorando a mensagem!" << endl; 03022 03023 #ifdef RIO_DEBUG1 03024 INTERFACELOG << "[CNetInterface - ProcessData] Finish9" 03025 << endl; 03026 #endif 03027 03028 return; 03029 } 03030 03031 // Copia os dados para o buffer passado quando SendData foi chamado. 03032 memcpy( DataTransfer, Data, DataSize ); 03033 03034 // Chama a callback informando que o bloco foi recebido com 03035 // sucesso. 03036 FinalizeCallback( FinalizeCallbackParam, S_OK ); 03037 03038 // Devemos remover a estrutura de transferencia. 03039 RemoveTrasnfer = true; 03040 03041 break; 03042 03043 // Neste caso recebemos um tipo invalido de mensagem que sera entao 03044 // ignorado. Um erro, porem, sera enviado ao outro lado. 03045 default: 03046 INTERFACELOG << "CNetInterface::ProcessData a mensagem de tipo " 03047 << DataHeader.DataType << " invalido recebida do par " 03048 << "IP " << inet_ntoa( ip ) << " e a porta " 03049 << ntohs( Port ) << ". Ignorando a mensagem!" << endl; 03050 03051 #ifdef RIO_DEBUG1 03052 INTERFACELOG << "[CNetInterface - ProcessData] Finish10" << endl; 03053 #endif 03054 03055 return; 03056 03057 break; 03058 } 03059 03060 // Verifica se devemos remover a estrutura de transferencia e, se 03061 // necessario, tentamos remove-la. 03062 if( RemoveTrasnfer ) 03063 { 03064 RioStatus = m_TransferInfo->RemoveTransfer( DataHeader.DataTransferID ); 03065 if( FAILED( RioStatus ) ) 03066 { 03067 INTERFACELOG << "CNetInterface::ProcessData erro 0x" << hex 03068 << RioStatus << dec << " (" 03069 << GetErrorDescription( RioStatus ) << ") ao executar " 03070 << "a funcao RemoveTransfer. O erro foi gerado para " 03071 << "o par IP " << inet_ntoa( ip ) << " e a porta " 03072 << ntohs( Port ) << "." << endl; 03073 } 03074 } 03075 03076 #ifdef RIO_DEBUG1 03077 INTERFACELOG << "[CNetInterface - ProcessData] Finish11" << endl; 03078 #endif 03079 03080 return; 03081 }
| void CNetInterface::ProcessError | ( | int | IP, | |
| int | Port, | |||
| RioResult | RioError, | |||
| const char * | Msg, | |||
| EErrorType | ErrorType, | |||
| void * | Param | |||
| ) |
Esta funcao e chamada quando algum erro ocorrer com a transferencia de dados.
| IP | endereco IP da maquina associada ao socket com o erro. | |
| Port | porta associada ao socket com erro | |
| RioError | erro que ocorreu na transferencia dos dados. | |
| Msg | Mensagem a ser impressa junto com o erro (usada para sabermos onde o erro foi gerado) | |
| ErrorType | tipo do erro que foi gerado (se foi gerado por um recebimento de dados, por um envio de dados, ou por um outro motivo). | |
| Param | parametro generico opcional passado a funcao. No nosso caso, quando nao NULL, contem o identificador da transferencia associada ao erro (isso somente e usado pelo envio dos dados, no recebimento, e passado sempre NULLTRANSFERID). |
Definition at line 3238 of file NetInterface.cpp.
03241 { 03242 // Armazena o identificador para a estrutura criada para enviar os dados 03243 // ao outro lado (passado como parametro a funcao, se nao for NULL). 03244 TTransferID TransferID; 03245 // Armazena o resultado da execucao das funcoes do RIO. 03246 RioResult RioStatus; 03247 // Armazena o IP guardado na estrutura da transferencia com o ID TransferID. 03248 int IPTransfer; 03249 // Armazena a porta guardada na estrutura da transferencia com o ID 03250 // TransferID. 03251 int PortTransfer; 03252 // Armazena a callback de finalizacao associada a transferencia. 03253 callback_t FinalizeCallback; 03254 // Armazena o parametro que deve ser passado quando a callback 03255 // FinalizeCallback for chamada. 03256 void *FinalizeCallbackParam; 03257 // Armazena a callback de processamento de dados recebidos (somente usada 03258 // quando mensagens com comandos, do tipo CMDDATA, sao enviadas para o 03259 // outro lado). 03260 cmdcallback_t ProcessCallback; 03261 // Armazena o parametro que deve ser passado quando a callback 03262 // ProcessCallbackParam for chamada. 03263 void *ProcessCallbackParam; 03264 // Armazena o ponteiro para os dados que foram enviados (e aqui que vamos 03265 // remover este buffer, apos chamarmos a callback FinalizeCallback). 03266 char *Data; 03267 // Armazena o tamanho em bytes dos dados apontados por Data. 03268 unsigned int DataSize; 03269 // Armazena o tipo da transferencia (se e para envio de dados, o correto 03270 // para esta chamada ou recebimento de dados, que seria incorreto para 03271 // esta chamada). 03272 ETransferType TransferType; 03273 // Armazena o identificador, no outro lado, do destino dos dados em yuma 03274 // transferencia de envio de dados. 03275 TTransferID DestTransferID; 03276 // Armazena uma copia do IP para ser usadao pela funcao inet_ntoa do 03277 // parametro IP e uma copia, tambem para ser usada pela funcao inet_ntoa, 03278 // do parametro IPTransfer. 03279 in_addr ip, ipt; 03280 03281 #ifdef RIO_DEBUG1 03282 INTERFACELOG << "[CNetInterface - ProcessError] Start" << endl; 03283 #endif 03284 03285 // Inicializa o campo TransferID de acordo com Param (atualmente, este valor 03286 // e um identificador valido quando erros ocorrem no envio de dados, mas e 03287 // NULLTRANSFERID quando recebemos dados, pois a ID da transferencia neste 03288 // caso esta dentro dos dados recebidos). 03289 TransferID = ( TTransferID ) ( TLTransferID ) Param; 03290 03291 // Imprime a informacao do erro (isso deve estar dentro de RIO_DEBUG2?) 03292 ip.s_addr = IP; 03293 03294 INTERFACELOG << "[ProcessError] " << Msg << ": erro 0x" << hex << RioError 03295 << dec << " (" << GetErrorDescription( RioError ) << ") " 03296 << "recebido do objeto de uma das classes de envio de dados. " 03297 << "O erro foi gerado para o par IP " << inet_ntoa( ip ) 03298 << " e a porta " << ntohs( Port ) << "." << endl; 03299 03300 // Faz as finalizacoes dependendo do erro chamado. 03301 switch( ErrorType ) 03302 { 03303 // Ocorreu um erro ao recebermos dados por uma conexao TCP. Neste caso, 03304 // Chamaremos a funcao da classe m_TransferInfo para varrer a cache e 03305 // remover todas as transferencias de leitura pendentes para o par IP, 03306 // porta dado (note que este par IP, porta deveria ser diferente de 0). 03307 case RECEIVEERROR: 03308 #ifdef RIO_DEBUG2 03309 INTERFACELOG << "CNetInterface::ProcessError Recebido o erro tipo " 03310 << "RECEIVEERROR para o par IP " << inet_ntoa( ip ) 03311 << " e a porta " << ntohs( Port ) << ". Fechando " 03312 << "todas as conexoes de leitura!" << endl; 03313 #endif 03314 03315 // Executa a funcao FinalizeAllTransfers para finalizarmos todas as 03316 // trasnferencias de leitura de dados pendentes. 03317 RioStatus = m_TransferInfo->FinalizeAllTransfers( IP, Port, 03318 RECEIVINGDATA, 03319 RioError ); 03320 if( FAILED( RioStatus ) ) 03321 { 03322 #ifdef RIO_DEBUG2 03323 INTERFACELOG << "CNetInterface::ProcessError erro 0x" << hex 03324 << RioStatus << dec << " (" 03325 << GetErrorDescription( RioStatus ) << ") ao " 03326 << "executar a funcao FinalizeAllTransfers para o " 03327 << "par IP " << inet_ntoa( ip ) << " e a porta " 03328 << ntohs( Port ) << "." << endl; 03329 03330 #endif 03331 03332 #ifdef RIO_DEBUG1 03333 INTERFACELOG << "[CNetInterface - ProcessError] Finish1" 03334 << endl; 03335 #endif 03336 03337 return; 03338 } 03339 break; 03340 03341 // Neste caso, ocorreu um erro ao enviarmos os dados. Se TransferID, 03342 // dado por param, for diferente de NULLTRANSFERID, entao tentamos 03343 // chamar a callback associada a transfer com a ID TransferID para 03344 // informar que ocorreu um erro ao enviarmos os dados. 03345 case SENDERROR: 03346 // Chama a callback e remove a transferencia, se TransferID for 03347 // diferente de NULLTRANSFERID. 03348 if( TransferID != NULLTRANSFERID ) 03349 { 03350 RioStatus = m_TransferInfo->GetTransfer( TransferID, 03351 &IPTransfer, 03352 &PortTransfer, 03353 &FinalizeCallback, 03354 &FinalizeCallbackParam, 03355 &ProcessCallback, 03356 &ProcessCallbackParam, 03357 &Data, &DataSize, 03358 &TransferType, 03359 &DestTransferID ); 03360 if( FAILED( RioStatus ) ) 03361 { 03362 INTERFACELOG << "CNetInterface::ProcessError erro 0x" << hex 03363 << RioStatus << dec << " (" 03364 << GetErrorDescription( RioStatus ) << ") ao " 03365 << "executar a funcao GetTransfer. O erro foi " 03366 << "gerado para o par IP " << inet_ntoa( ip ) 03367 << " e a porta " << ntohs( Port ) << ", e a " 03368 << " transferencia com a ID " << TransferID 03369 << "." << endl; 03370 03371 #ifdef RIO_DEBUG1 03372 INTERFACELOG << "[CNetInterface - ProcessError] Finish2" 03373 << endl; 03374 #endif 03375 03376 return; 03377 } 03378 03379 // Inicializa IPTransfer com a copia de IPTransfer; 03380 ipt.s_addr = IPTransfer; 03381 03382 // Verificamos se o par IP, Porta passado a funcao e o mesmo 03383 // associado a transferencia cujo parametro foi passado como 03384 // parametro. 03385 if( ( IP != IPTransfer ) || ( Port != PortTransfer ) ) 03386 { 03387 INTERFACELOG << "CNetInterface::ProcessError aviso: o IP " 03388 << inet_ntoa( ipt ) << " e a porta " 03389 << ntohs( PortTransfer ) << " associados a " 03390 << "transferencia com o ID " << TransferID 03391 << " nao sao iguais ao IP " << inet_ntoa( ip ) 03392 << " e a porta " << ntohs( Port ) 03393 << " passados como parametros da funcao." 03394 << endl; 03395 03396 #ifdef RIO_DEBUG1 03397 INTERFACELOG << "[CNetInterface - ProcessError] Finish3" 03398 << endl; 03399 #endif 03400 03401 return; 03402 } 03403 03404 // Verificamos se o tipo da transferencia e de envio de dados. 03405 if( TransferType != SENDINGDATA ) 03406 { 03407 INTERFACELOG << "CNetInterface::ProcessError O tipo da " 03408 << "transferencia associada ao par IP " 03409 << inet_ntoa( ip ) << " e a porta " 03410 << ntohs( Port ) << ", com o ID " << TransferID 03411 << " nao e uma transferencia de envio de " 03412 << "dados!" << endl; 03413 03414 #ifdef RIO_DEBUG1 03415 INTERFACELOG << "[CNetInterface - ProcessError] Finish4" 03416 << endl; 03417 #endif 03418 03419 return; 03420 } 03421 03422 // O par IP, Porta da transferencia bate e o tipo de 03423 // transferencia e de envio. Entao, chamamos a callback e 03424 // removemos o dado e a transferencia. 03425 03426 // Se ocorreu um erro no envio dos dados, entao deveremos 03427 // enviar um erro ao outro lado da conexao, para que a espera 03428 // pelo dado possa ser abortada, gerando um erro. 03429 SendRst( IP, Port, DestTransferID, RioError ); 03430 03431 // Chama a callback de finalizacao associada a transferencia de 03432 // escrita, se ela nao for nula, ou seja, se um ponteiro para 03433 // uma callback foi passado quando enviamos os dados. 03434 if( FinalizeCallback != NULL ) 03435 FinalizeCallback( FinalizeCallbackParam, RioError ); 03436 03437 // Deleta o buffer com os dados que ja foram enviados com 03438 // sucesso. 03439 delete[] Data; 03440 03441 // Remove a estrutura de transferencia da lista com todas as 03442 // transferencias. 03443 RioStatus = m_TransferInfo->RemoveTransfer( TransferID ); 03444 if( FAILED( RioStatus ) ) 03445 { 03446 #ifdef RIO_DEBUG2 03447 INTERFACELOG << "CNetInterface::ProcessError erro 0x" << hex 03448 << RioStatus << dec << " (" 03449 << GetErrorDescription( RioStatus ) << ") ao " 03450 << "executar a funcao RemoveTransfer. O erro " 03451 << "foi gerado para o par IP " 03452 << inet_ntoa( ip ) << " e a porta " 03453 << ntohs( Port ) << "." << endl; 03454 #endif 03455 03456 #ifdef RIO_DEBUG1 03457 INTERFACELOG << "[CNetInterface - ProcessError] Finish5" 03458 << endl; 03459 #endif 03460 03461 return; 03462 03463 } 03464 } 03465 03466 // Outros tipos de erros. Neste caso, nao precisamos fazer nenhuma 03467 // acao. 03468 case OTHERERROR: 03469 #ifdef RIO_DEBUG2 03470 INTERFACELOG << "CNetInterface::ProcessError Recebido o erro " 03471 << "tipo OTHERERROR para o par IP " 03472 << inet_ntoa( ip ) << " e a porta " 03473 << ntohs( Port ) << ". Nenhuma acao precisa ser " 03474 << "tomada!" << endl; 03475 #endif 03476 break; 03477 03478 // Foi passado um tipo de dado incorreto 03479 default: 03480 #ifdef RIO_DEBUG2 03481 INTERFACELOG << "CNetInterface::ProcessError Foi passado um " 03482 << "tipo de erro " << ErrorType << " invalido ao " 03483 << "chamar a funcao para o par IP " 03484 << inet_ntoa( ip ) << " e a porta " 03485 << ntohs( Port ) << ". Chamada ignorada!" << endl; 03486 #endif 03487 break; 03488 } 03489 03490 #ifdef RIO_DEBUG1 03491 INTERFACELOG << "[CNetInterface - ProcessError] Finish6" << endl; 03492 #endif 03493 }
| void CNetInterface::ProcessTransferIDs | ( | void * | CmdParam, | |
| char * | Command, | |||
| int | CommandSize | |||
| ) | [static, private] |
Funcao de callback usada pela funcao ExpectTellId para processar os identificadores recebidos dos servidores de armazenamento e enviar, usando estes identificadores, os blocos para os servidores de armazenamento.
| CmdParam | parametro passado quando a funcao ExpectCmd foi chamada em ExpectTellId (um ponteiro para uma estrutura do tipo TTellIdData). | |
| Command | comando (enviado pela funcao TellId) recebido de um servidor de armazenamento. | |
| CommandSize | tamanho em bytes do comando. |
Definition at line 2029 of file NetInterface.cpp.
02031 { 02032 // Vetor para criar o comando a ser enviado pela rede. 02033 u32 *TellIdCmd; 02034 // Ponteiro para a estrutura com as informacoes para processarmos os 02035 // comandos enviados pelos servidores de armazenamento necessarios para 02036 // obtermos os identificadores de transferencia para o envio dos blocos. 02037 TTellIdData *TellIdData; 02038 02039 // Obtem o ponteiro para a estrutura NewData. 02040 TellIdData = ( TTellIdData * ) CmdParam; 02041 02042 #ifdef RIO_DEBUG1 02043 STATICINTERFACELOG << "[CNetInterface - ProcessTransferID] Start" << endl; 02044 #endif 02045 02046 // Obtem os campos enviados no comando, verificando se algum erro ocorreu 02047 // ao receber um comando. 02048 // 02049 // Obs: O que fazer no caso de um comando errado? Abortar tudo e reportar 02050 // um erro? 02051 // 02052 if( CommandSize != CMD_TELLID_BYTESIZE ) 02053 { 02054 // Ocorreu um erro ao enviar o comando, pois o tamanho do comando nao 02055 // esta correto. O que fazer neste caso, ja que nao temos uma ID para 02056 // enviar o bloco ao storage com o erro? Chamar a callback nao e 02057 // correto, e tambem nao posso enviar uma mensagem ao servidor de 02058 // armazenamento pois nao temos o IP, porta dele. Vou simplesmente 02059 // ignorar a ID, mas talvez precisemos decidir o que sera feito neste 02060 // caso (e no seguinte, quando o comando tem o tamanho correto mas nao 02061 // tem o tipo correto). 02062 02063 #ifdef RIO_DEBUG2 02064 STATICINTERFACELOG << "CNetInterface::ProcessTransferIDs recebido um " 02065 << "comando com tamanho invalido. Tamanho = " 02066 << CommandSize << "bytes (esperado " 02067 << CMD_TELLID_BYTESIZE << " bytes), comando = " 02068 << hex; 02069 for( int i = 0; i < CommandSize; i++ ) 02070 { 02071 STATICINTERFACELOG << "0x" << ( unsigned short ) Command[ i ]; 02072 if( i != ( CommandSize - 1 ) ) 02073 STATICINTERFACELOG << ","; 02074 else 02075 STATICINTERFACELOG << "." << dec << endl; 02076 } 02077 #endif 02078 02079 #ifdef RIO_DEBUG1 02080 STATICINTERFACELOG << "[CNetInterface - ProcessTransferID] Finish1" 02081 << endl; 02082 #endif 02083 } 02084 else 02085 { 02086 // Coloca os dados em um vetor com 4 entradas do tipo u32, e converte 02087 // os valores convertidos na funcao TellId para a ordem da rede 02088 // novamente para a ordem da maquina. 02089 TellIdCmd = ( u32 * ) Command; 02090 // Converte o identificador do comando. 02091 TellIdCmd[ 0 ] = ntohl( TellIdCmd[ 0 ] ); 02092 // Converte a porta (de um inteiro de 32 bits para um inteiro de 16 02093 // bits). 02094 TellIdCmd[ 2 ] = htons( ( short ) ( ntohl( TellIdCmd[ 2 ] ) ) ); 02095 // Converte a ID de transferencia recebida da ordem da rede para a ordem 02096 // da maquina (pois a funcao SendData espera a ID no formato da 02097 // maquina). 02098 TellIdCmd[ 3 ] = ntohl( TellIdCmd[ 3 ] ); 02099 02100 // Verifica se o comando e um comando enviado pela execucao da funcao 02101 // TellId. 02102 if( TellIdCmd[ 0 ] == CMD_TELLID ) 02103 { 02104 #ifdef RIO_DEBUG2 02105 in_addr ip; 02106 ip.s_addr = TellIdCmd[ 1 ]; 02107 STATICINTERFACELOG << "CNetInterface::ProcessTransferIDs tentando " 02108 << "enviar um bloco ao endereco IP " 02109 << inet_ntoa( ip ) << " e a porta " 02110 << ntohs( TellIdCmd[ 2 ] ) << ", usando a " 02111 << "transferencia com o ID " << TellIdCmd[ 3 ] 02112 << ", a partir da transferencia local com a ID " 02113 << TellIdData->SentDataTransfer << "." << endl; 02114 #endif 02115 02116 // Envia o bloco para o par IP, porta indicado por TellIdCmd[ 1 ] 02117 // (IP), TellIdCmd[ 1 ] (porta), usando a ID de transferencia dada 02118 // em TellIdCmd[ 3 ] (ID da transferencia). 02119 TellIdData->NetInterface->SendBlock( TellIdCmd[ 1 ], TellIdCmd[ 2 ], 02120 ( TTransferID ) TellIdCmd[ 3 ], TellIdData->Buffer, 02121 TellIdData->BufferSize, NULL, NULL ); 02122 02123 #ifdef RIO_DEBUG2 02124 STATICINTERFACELOG << "CNetInterface::ProcessTransferIDs um bloco " 02125 << " foi enviado ao endereco IP " 02126 << inet_ntoa( ip ) << " e a porta " 02127 << ntohs( TellIdCmd[ 2 ] ) << ", e foi " 02128 << "associado a transferencia com o ID " 02129 << TellIdCmd[ 3 ] << ", a partir da " 02130 << "transferencia local com a ID " 02131 << TellIdData->SentDataTransfer << "." << endl; 02132 #endif 02133 02134 #ifdef RIO_DEBUG1 02135 STATICINTERFACELOG << "[CNetInterface - ProcessTransferID] Finish2" 02136 << endl; 02137 #endif 02138 02139 } 02140 else 02141 { 02142 // Ocorreu um erro ao enviar o comando, pois o tipo do comando nao 02143 // esta correto. O que fazer neste caso, ja que nao temos uma ID 02144 // para enviar o bloco ao storage com o erro? Chamar a callback nao 02145 // e correto, e tambem nao posso enviar uma mensagem ao servidor de 02146 // armazenamento pois nao temos o IP, porta dele. Vou simplesmente 02147 // ignorar a ID, mas talvez precisemos decidir o que sera feito 02148 // neste caso (e no anterior, quando o comando tem o tamanho correto 02149 // mas nao tem o tipo correto). 02150 02151 #ifdef RIO_DEBUG2 02152 STATICINTERFACELOG << "CNetInterface::ProcessTransferIDs recebido " 02153 << "um comando com o tipo invalido, apesar de o " 02154 << "tamanho estar correto. Tamanho = " 02155 << CommandSize << "bytes, comando = " << hex; 02156 for( int i = 0; i < CommandSize; i++ ) 02157 { 02158 STATICINTERFACELOG << "0x" << ( unsigned short ) Command[ i ]; 02159 if( i != ( CommandSize - 1 ) ) 02160 STATICINTERFACELOG << ","; 02161 else 02162 STATICINTERFACELOG << "." << dec << endl; 02163 } 02164 #endif 02165 02166 #ifdef RIO_DEBUG1 02167 STATICINTERFACELOG << "[CNetInterface - ProcessTransferID] Finish3" 02168 << endl; 02169 #endif 02170 } 02171 } 02172 02173 #ifdef RIO_DEBUG1 02174 STATICINTERFACELOG << "[CNetInterface - ProcessTransferID] Finish4" << endl; 02175 #endif 02176 }
| void CNetInterface::SendBlock | ( | int | ipadr, | |
| int | port, | |||
| TTransferID | TransferID, | |||
| char * | bufadr, | |||
| int | buflen, | |||
| callback_t | callback, | |||
| void * | callbackparm, | |||
| bool | UseTCP = true, |
|||
| unsigned int | VideoRate = 0 | |||
| ) |
Funcao para enviar um bloco de um dos arquivos armazenados em um dos storages do RIO, ou para enviar um bloco de um arquivo resultante de uma busca nos logs, para o par ipadr, port do destino.
| ipadr | endereco IP para o qual o bloco deve ser enviado. | |
| port | porta para o qual o bloco deve ser enviado. | |
| TransferID | identificador da estrutura de transferencia no endereco destino associada ao recebimento do bloco a ser enviado. | |
| bufadr | endereco com os dados do bloco. | |
| buflen | tamanho do bloco em bytes. | |
| callback | callback a ser chamada quando o bloco for enviado com sucesso ao destino. | |
| callbackparm | parametro a ser passado pela callback. | |
| UseTCP | valor booleano que, se false, indica que o bloco deve ser enviado em tempo real (via UDP sem retransmissao) e, se for true, indica que o bloco deve ser enviado em tempo nao real (usando a conexao TCP). Este paramtro e opcional e tem o valor default de true (usar a conexao TCP). | |
| VideoRate | taxa de transmissao do video (somente nas transferencias em tempo real). A taxa define define, caso estejamos estejamos enviando trafego em tempo real (os videos) a taxa de transmissao do video em Kbps. Como ele somente e usado pelo servidor de armazenamento, ele possui um valor default de 0, para que nao seja necessario alterarmos o codigo do cliente e do servidor de despacho. |
Obs: O que vamos fazer neste caso da transferencia em tempo real? O metodo que pensamos antes de criar uma classe abstrata pode nao ser adequado, pois nao sei se sera possivel simular a transferencia em tempo real e o multicast usando o TCP e, se isso for verdade, precisaremos criar objetos das duas classes (CNetTcp e CNetUdp) e avaliarmos o que vamos fazer em casos de conflido do uso dos objetos das duas classes (por exemplo, isso ocorrera com as funcoes que obtem os pares IP,porta descritas anteriormente). Obs2: Por enquanto, somente as copias em tempo nao real serao feitas pela funcao. As outras copias chamarao imediatamente a callback com o erro ERROR_NETINTERFACE + ERROR_INVALID_TRAFFIC (o erro que identifica a classe mais o erro de trafego invalido).
Definition at line 1674 of file NetInterface.cpp.
01678 { 01679 // Armazena o resultado ao executarmos as funcoes do RIO. 01680 RioResult RioStatus; 01681 01682 #ifdef RIO_DEBUG2 01683 // Usado para armazenar o IP para impressao. 01684 in_addr ip; 01685 01686 ip.s_addr = ipadr; 01687 #endif 01688 01689 #ifdef RIO_DEBUG1 01690 INTERFACELOG << "[CNetInterface - SendBlock] Start" << endl; 01691 #endif 01692 01693 // Primeiramente verificamos se a copia e em tempo nao real (eu estou 01694 // supondo que o multicast e em tempo real). O parametro VideoRate por 01695 // enquanto nao sera usado. 01696 if( UseTcp ) 01697 { 01698 #ifdef RIO_DEBUG2 01699 INTERFACELOG << "CNetInterface::SendBlock usando o TCP ao enviar o " 01700 << "bloco ao endereco IP " << inet_ntoa( ip ) << "e a " 01701 << "porta " << ntohs( port ) << " usando a transferencia " 01702 << "com a ID " << TransferID << "." << endl; 01703 #endif 01704 } 01705 else 01706 { 01707 #ifdef RIO_DEBUG2 01708 INTERFACELOG << "CNetInterface::SendBlock usando o UDP ao enviar o " 01709 << "bloco ao endereco IP " << inet_ntoa( ip ) << "e a " 01710 << "porta " << ntohs( port ) << " usando a transferencia " 01711 << "com a ID " << TransferID << "." << endl; 01712 #endif 01713 01714 // Se o trafego for em tempo nao real, por enquanto isso sera um erro, 01715 // porque a classe UDP ainda nao foi implementada. Quando a classe UDP 01716 // for implementada, as linhas ate o comentario // UseTcp = false; 01717 // deverao ser removidas, e deveremos remover este comentario. 01718 01719 #ifdef RIO_DEBUG2 01720 INTERFACELOG << "CNetInterface::SendBlock erro ao enviar o bloco ao " 01721 << "endereco IP " << inet_ntoa( ip ) << " e a porta " 01722 << ntohs( port ) << " porque a copia em tempo real via " 01723 << "UDP ainda nao foi implementada. Chamando a callback " 01724 << "com o erro 0x" << hex 01725 << ERROR_NETINTERFACE + ERROR_INVALID_TRAFFIC << dec 01726 << " (" << GetErrorDescription( ERROR_NETINTERFACE + 01727 ERROR_INVALID_TRAFFIC ) 01728 << ")." << endl; 01729 #endif 01730 01731 // Chama a callback, pois a implementacao para os trafegos alem do te,po 01732 // nao real ainda nao foram implementadas (e deveriam usar a NetMgr e a 01733 // RioNeti). 01734 callback( callbackparm, ERROR_NETINTERFACE + ERROR_INVALID_TRAFFIC ); 01735 01736 #ifdef RIO_DEBUG1 01737 INTERFACELOG << "[CNetInterface - SendBlock] Finish1" << endl; 01738 #endif 01739 01740 return; 01741 } 01742 01743 // Tenta criar uma nova mensagem do tipo comando e envia-la ao endereco de 01744 // destino. 01745 RioStatus = SendData( ipadr, port, callback, callbackparm, bufadr, buflen, 01746 BLOCKDATA, UseTcp, TransferID ); 01747 01748 #ifdef RIO_DEBUG2 01749 if( FAILED( RioStatus ) ) 01750 { 01751 INTERFACELOG << "CNetInterface::SendBlock erro 0x" << hex << RioStatus 01752 << dec << " (" << GetErrorDescription( RioStatus ) << ") " 01753 << "ao enviar o bloco ao endereco IP " << inet_ntoa( ip ) 01754 << " e a porta " << ntohs( port ) << "." << endl; 01755 } 01756 01757 INTERFACELOG << "CNetInterface::SendBlock enviado o bloco ao endereco " 01758 << "endereco IP " << inet_ntoa( ip ) << " e a porta " 01759 << ntohs( port ) << " para a transferencia com a ID " 01760 << TransferID << "." << endl; 01761 #endif 01762 01763 #ifdef RIO_DEBUG1 01764 INTERFACELOG << "[CNetInterface - SendBlock] Finish2" << endl; 01765 #endif 01766 }
| void CNetInterface::SendCmd | ( | int | ipadr, | |
| int | port, | |||
| TTransferID | TransferID, | |||
| char * | cmdp, | |||
| int | cmdl, | |||
| callback_t | callback, | |||
| void * | callbackparm | |||
| ) |
Funcao para enviar uma mensagem do tipo comando ao endereco ipadr, port destino, passando o comando dado em cmdp (com o tamanho de cmdl).
| ipadr | endereco IP para o qual o comando deve ser enviado. | |
| port | porta para o qual o comando deve ser enviado. | |
| TransferID | identificador da estrutura de transferencia no endereco destino associada ao recebimento do comando a ser enviado. | |
| cmdp | ponteiro para o comando a ser enviado. | |
| cmdl | tamanho do comandio a ser enviado. | |
| callback | callback a ser chamada quando o comando foi enviado com sucesso ao outro lado? Ele nao espera por um result? | |
| callbackparm | parametro a ser passado a callback quando ela for chamada. |
Definition at line 1579 of file NetInterface.cpp.
01582 { 01583 // Armazena o resultado ao executarmos as funcoes do RIO. 01584 RioResult RioStatus; 01585 01586 #ifdef RIO_DEBUG2 01587 // Usado para armazenar o IP para impressao. 01588 in_addr ip; 01589 01590 ip.s_addr = ipadr; 01591 #endif 01592 01593 #ifdef RIO_DEBUG1 01594 INTERFACELOG << "[CNetInterface - SendCmd] Start" << endl; 01595 #endif 01596 01597 // Tenta criar uma nova mensagem do tipo comando e envia-la ao endereco de 01598 // destino. 01599 RioStatus = SendData( ipadr, port, callback, callbackparm, cmdp, cmdl, 01600 CMDDATA, true, TransferID ); 01601 01602 #ifdef RIO_DEBUG2 01603 if( FAILED( RioStatus ) ) 01604 { 01605 INTERFACELOG << "CNetInterface::SendCmd erro 0x" << hex << RioStatus 01606 << dec << " (" << GetErrorDescription( RioStatus ) << ") " 01607 << "ao enviar o comando ao endereco IP " << inet_ntoa( ip ) 01608 << " e a porta " << ntohs( port ) << "." << endl; 01609 } 01610 #endif 01611 01612 #ifdef RIO_DEBUG2 01613 INTERFACELOG << "CNetInterface::SendCmd enviando um comando ao endereco " 01614 << "endereco IP " << inet_ntoa( ip ) << " e a porta " 01615 << ntohs( port ) << " para a transferencia com a ID " 01616 << TransferID << "." << endl; 01617 #endif 01618 01619 #ifdef RIO_DEBUG1 01620 INTERFACELOG << "[CNetInterface - SendCmd] Finish" << endl; 01621 #endif 01622 }
| RioResult CNetInterface::SendData | ( | int | IP, | |
| int | Port, | |||
| callback_t | FinalizeCallback, | |||
| void * | FinalizeCallbackParam, | |||
| char * | Data, | |||
| unsigned int | DataSize, | |||
| EDataType | DataType, | |||
| bool | UseTCP, | |||
| TTransferID | DestTransferID, | |||
| TTransferID * | TransferID = NULL | |||
| ) | [private] |
Funcao para criar uma nova estrutura de transferencia e enviar os dados passados como parametro, anexando no inicio dos dados o cabecalho que informa o tipo de dados (passado como parametro) e o identificador da transferencia do outro lado da conexao para a qual os dados serao enviados.
| IP | endereco destino dos dados. | |
| Port | porta no endereco destino para a qual os dados serao enviados. | |
| FinalizeCallback | callback chamada quando finalizamos a transferencia. | |
| CallbackParam | valor a ser passado quando chamarmos a callback FinalizeCallback. | |
| Data | ponteiro para os dados a serem enviados. | |
| DataSize | numero de bytes nos dados a serem enviados. | |
| DataType | tipo dos dados (ver o tipo EDataType). | |
| DestTransferID | identificador associado ao envio destes dados no outro lado da conexao (ou seja, o identificador no IP, porta destino associado aos dados que serao enviados). | |
| UseTCP | se true os dados devem ser enviados usando o objeto da classe CNetTCP e, se false, devem ser enviados usando o objeto da classe CNetUDP. | |
| TransferID | ponteiro para armazenar o identificador associado a estrutura criada para o envio dos dados. Se for NULL, o identificador nao sera armazenado. |
Definition at line 769 of file NetInterface.cpp.
00775 { 00776 // Armazena os codigos de erro do RIO retornado pelas funcoes. 00777 RioResult RioStatus, RioStatus2; 00778 // Armazena os dados a serem enviados pelo par IP, Port (o cabecalho mais 00779 // os dados do endereco apontado por Data) . 00780 char *RawData; 00781 // Armazena o tamanho dos dados a serem enviados. 00782 unsigned int RawDataSize; 00783 // Estrutura com o cabecalho dos dados a serem enviados. 00784 SDataHeader DataHeader; 00785 // Armazena temporariamente a ID retornada por NewTransfer 00786 TTransferID AuxTransferID; 00787 00788 #ifdef RIO_DEBUG2 00789 in_addr ip; 00790 00791 ip.s_addr = IP; 00792 #endif 00793 00794 #ifdef RIO_DEBUG1 00795 INTERFACELOG << "[CNetInterface - SendData] Start" << endl; 00796 #endif 00797 00798 // Inicializa o identificador de transferencia (se passado). 00799 if( TransferID != NULL ) 00800 *TransferID = NULLTRANSFERID; 00801 00802 // Primeiramente tentamos alocar um novo buffer para armazenar o cabecalho 00803 // mais os dados. 00804 RawDataSize = DataSize + sizeof( DataHeader ); 00805 try 00806 { 00807 RawData = new char[ RawDataSize ]; 00808 } 00809 catch( bad_alloc& ba ) 00810 { 00811 #ifdef RIO_DEBUG2 00812 INTERFACELOG << "CNetInterface::SendData Erro de alocacao de memoria (" 00813 << "bad_alloc, error = " << ba.what() << ") ao criar o " 00814 << "buffer com o cabecalho mais os dados a serem " 00815 << "enviados. Nao foi possivel enviar os dados ao IP " 00816 << inet_ntoa( ip ) << " e a porta " << ntohs( Port ) 00817 << endl; 00818 #endif 00819 00820 #ifdef RIO_DEBUG1 00821 INTERFACELOG << "[CNetInterface - SendData] Finish1" << endl; 00822 #endif 00823 00824 return ERROR_NETINTERFACE + ERROR_MEMORY; 00825 } 00826 00827 // Tenta agora criar uma nova estrutura no objeto da classe de gerenciamento 00828 // de estruturas. 00829 RioStatus = m_TransferInfo->NewTransfer( IP, Port, FinalizeCallback, 00830 FinalizeCallbackParam, NULL, NULL, 00831 RawData, RawDataSize, SENDINGDATA, 00832 DestTransferID, &AuxTransferID ); 00833 00834 if( FAILED( RioStatus ) ) 00835 { 00836 #ifdef RIO_DEBUG2 00837 INTERFACELOG << "CNetInterface::SendData Erro 0x" << hex << RioStatus 00838 << dec << " (" << GetErrorDescription( RioStatus ) 00839 << ") ao executar a funcao NewTransfer do objeto " 00840 << "m_TransferInfo ao criar uma estrutura para ser " 00841 << "associada ao envio dos dados. Nao foi possivel enviar " 00842 << "os dados ao IP " << inet_ntoa( ip ) << " e a porta " 00843 << ntohs( Port ) << endl; 00844 #endif 00845 00846 #ifdef RIO_DEBUG1 00847 INTERFACELOG << "[CNetInterface - SendData] Finish2" << endl; 00848 #endif 00849 00850 return RioStatus; 00851 } 00852 00853 // Inicializa o cabecalho. 00854 DataHeader.DataType = htons( (uint16_t) DataType ); 00855 DataHeader.SourceTransferID = htonl( (uint32_t) ( AuxTransferID ) ); 00856 DataHeader.DataTransferID = htonl( (uint32_t) DestTransferID ); 00857 00858 // Copia os dados em RawData. 00859 memcpy( RawData, &DataHeader, sizeof( DataHeader ) ); 00860 memcpy( &RawData[ sizeof( DataHeader ) ], Data, DataSize ); 00861 00862 // Envia os dados para o par IP, Port. Se UseTCP for true, a transferencia 00863 // usara o TCP e, se for false, usara o UDP (por enquanto, usar esta opcao 00864 // deveria gerar um erro. 00865 if( UseTCP ) 00866 RioStatus = m_NetTcp->SendData( IP, Port, RawData, RawDataSize, 00867 ( void * ) ( TLTransferID ) AuxTransferID ); 00868 else // Descomentar a chamada e remover a linha de atribuicao RioStatus para 00869 // um valor invalido quando o UDP for implementado. 00870 //RioStatus = m_NetUdp->SendData( IP, Port, RawData, RawDataSize, 00871 // ( void * ) AuxTransferID ); 00872 00873 if( FAILED( RioStatus ) ) 00874 { 00875 #ifdef RIO_DEBUG2 00876 INTERFACELOG << "CNetInterface::SendData Erro 0x" << hex << RioStatus 00877 << dec << " (" << GetErrorDescription( RioStatus ) 00878 << ") ao executar a funcao SendData do objeto m_Net ao " 00879 << "enviar os dados ao destino. Nao foi possivel enviar " 00880 << "os dados ao IP " << inet_ntoa( ip ) << " e a porta " 00881 << ntohs( Port ) << endl; 00882 #endif 00883 00884 // Devemos chamar a callback? 00885 if( FinalizeCallback != NULL ) 00886 FinalizeCallback( FinalizeCallbackParam, ERROR_NETINTERFACE + 00887 ERROR_SOCKET_SEND ); 00888 00889 // Remove a estrutura da transferencia criada do hash. 00890 RioStatus2 = m_TransferInfo->RemoveTransfer( AuxTransferID ); 00891 #ifdef RIO_DEBUG2 00892 if( FAILED( RioStatus2 ) ) 00893 { 00894 INTERFACELOG << "CNetInterface::SendData Erro 0x" << hex 00895 << RioStatus2 << dec << " (" 00896 << GetErrorDescription( RioStatus2 ) << ") ao " 00897 << "executar a funcao RemoveTransfer do objeto " 00898 << "m_TransferInfo ao remover a estrutura criada mas " 00899 << "que nao sera usada!" << endl; 00900 } 00901 #endif 00902 00903 #ifdef RIO_DEBUG1 00904 INTERFACELOG << "[CNetInterface - SendData] Finish3" << endl; 00905 #endif 00906 00907 return RioStatus; 00908 } 00909 00910 #ifdef RIO_DEBUG2 00911 INTERFACELOG << "CNetInterface::SendData enviando os dados do endereco 0x" 00912 << hex << ( unsigned long ) Data << dec << " com o tamanho de " 00913 << DataSize << " bytes ao endereco endereco IP " 00914 << inet_ntoa( ip ) << " e a porta " << ntohs( Port ) 00915 << " com a ID " << AuxTransferID << ". Cabecalho enviado com " 00916 << "os dados: DataType = 0x" << hex << DataHeader.DataType 00917 << ", DataHeader.SourceTransferID = 0x" 00918 << DataHeader.SourceTransferID 00919 << ", DataHeader.DataTransferID = 0x" 00920 << DataHeader.DataTransferID << ". O endereco do vetor com o " 00921 << " cabecalho mais os dados e igual a 0x" 00922 << ( unsigned long ) RawData << dec << ", e serao enviados " 00923 << "um total de " << RawDataSize << " bytes." << endl; 00924 #endif 00925 00926 // Copia o identificador de transferencia. 00927 if( TransferID != NULL ) 00928 *TransferID = AuxTransferID; 00929 00930 #ifdef RIO_DEBUG1 00931 INTERFACELOG << "[CNetInterface - SendData] Finish4" << endl; 00932 #endif 00933 00934 return S_OK; 00935 }
| void CNetInterface::SendDataCompleted | ( | int | IP, | |
| int | Port, | |||
| void * | Param | |||
| ) |
Esta Funcao sera chamada pelo objeto de uma das classes de rede (NetTCP ou NetUDP) quando os dados tiverem sido enviados para um endereco (com ou sem sucesso).
| IP | endereco ip da maquina que enviou os dados. | |
| Port | porta a partir da qual o pacote foi enviado a partir da maquina que enviou estes dados | |
| Param | parametro passado quando os dados foram enviados. No nosso caso, ele e o identificador da transferencia usada para enviar os dados. |
Definition at line 3086 of file NetInterface.cpp.
03087 { 03088 // Armazena o identificador para a estrutura criada para enviar os dados 03089 // ao outro lado (passado como parametro a funcao). 03090 TTransferID TransferID; 03091 // Armazena o resultado da execucao das funcoes do RIO. 03092 RioResult RioStatus; 03093 // Armazena o IP guardado na estrutura da transferencia com o ID TransferID. 03094 int IPTransfer; 03095 // Armazena a porta guardada na estrutura da transferencia com o ID 03096 // TransferID. 03097 int PortTransfer; 03098 // Armazena a callback de finalizacao associada a transferencia. 03099 callback_t FinalizeCallback; 03100 // Armazena o parametro que deve ser passado quando a callback 03101 // FinalizeCallback for chamada. 03102 void *FinalizeCallbackParam; 03103 // Armazena a callback de processamento de dados recebidos (somente usada 03104 // quando mensagens com comandos, do tipo CMDDATA, sao enviadas para o 03105 // outro lado). 03106 cmdcallback_t ProcessCallback; 03107 // Armazena o parametro que deve ser passado quando a callback 03108 // ProcessCallbackParam for chamada. 03109 void *ProcessCallbackParam; 03110 // Armazena o ponteiro para os dados que foram enviados (e aqui que vamos 03111 // remover este buffer, apos chamarmos a callback FinalizeCallback). 03112 char *Data; 03113 // Armazena o tamanho em bytes dos dados apontados por Data. 03114 unsigned int DataSize; 03115 // Armazena o tipo da transferencia (se e para envio de dados, o correto 03116 // para esta chamada ou recebimento de dados, que seria incorreto para 03117 // esta chamada). 03118 ETransferType TransferType; 03119 // Armazena uma copia do IP para ser usadao pela funcao inet_ntoa do 03120 // parametro IP e uma copia, tambem para ser usada pela funcao inet_ntoa, 03121 // do parametro IPTransfer. 03122 in_addr ip, ipt; 03123 03124 #ifdef RIO_DEBUG1 03125 INTERFACELOG << "[CNetInterface - SendDataCompleted] Start" << endl; 03126 #endif 03127 03128 // Obtem o ID associado ao envio dos dados. 03129 TransferID = ( TTransferID ) ( TLTransferID ) Param; 03130 03131 // Inicializa ip com a copia do IP. 03132 ip.s_addr = IP; 03133 03134 #ifdef RIO_DEBUG2 03135 INTERFACELOG << "CNetInterface::SendDataCompleted funcao chamada para " 03136 << "informar que o envio de dados ao IP " << inet_ntoa( ip ) 03137 << " e a porta " << ntohs( Port ) << " foi finalizada com " 03138 << " sucesso. O envio estava associado a transferencia com " 03139 << " a ID " << TransferID << "." << endl; 03140 #endif 03141 03142 RioStatus = m_TransferInfo->GetTransfer( TransferID, &IPTransfer, 03143 &PortTransfer, &FinalizeCallback, 03144 &FinalizeCallbackParam, 03145 &ProcessCallback, 03146 &ProcessCallbackParam, &Data, 03147 &DataSize, &TransferType ); 03148 if( FAILED( RioStatus ) ) 03149 { 03150 INTERFACELOG << "CNetInterface::SendDataCompleted erro 0x" << hex 03151 << RioStatus << dec << " (" 03152 << GetErrorDescription( RioStatus ) << ") ao executar a " 03153 << "funcao GetTransfer. O erro foi gerado para o par IP " 03154 << inet_ntoa( ip ) << " e a porta " << ntohs( Port ) << "." 03155 << endl; 03156 03157 #ifdef RIO_DEBUG1 03158 INTERFACELOG << "[CNetInterface - SendDataCompleted] Finish1" << endl; 03159 #endif 03160 03161 return; 03162 } 03163 03164 // Inicializa IPTransfer com a copia de IPTransfer; 03165 ipt.s_addr = IPTransfer; 03166 03167 // Verificamos se o par IP, Porta passado a funcao e o mesmo associado a 03168 // transferencia cujo parametro foi passado como parametro. Note que nao 03169 // precisamos verificar, como na funcao acima, se IPTransfer e PortTransfer 03170 // sao ambos 0 porque todas as funcoes de envio de dados precisam passar o 03171 // par IP, porta destino dos dados. 03172 if( ( IP != IPTransfer ) || ( Port != PortTransfer ) ) 03173 { 03174 INTERFACELOG << "CNetInterface::SendDataCompleted aviso: o IP " 03175 << inet_ntoa( ipt ) << " e a porta " 03176 << ntohs( PortTransfer ) << " associados a transferencia " 03177 << "com o ID " << TransferID << " nao sao iguais ao IP " 03178 << inet_ntoa( ip ) << " e a porta " << ntohs( Port ) 03179 << " passados como parametros da funcao." << endl; 03180 03181 #ifdef RIO_DEBUG1 03182 INTERFACELOG << "[CNetInterface - SendDataCompleted] Finish2" << endl; 03183 #endif 03184 03185 return; 03186 } 03187 03188 if( TransferType != SENDINGDATA ) // Verifica se o tipo de 03189 // transferencia e o adequado. 03190 { 03191 // Transferencia do tipo incorreto. Neste caso, nao podemos chamar a 03192 // callback e nem remover o buffer. 03193 INTERFACELOG << "CNetInterface::SendDataCompleted a transferencia " 03194 << "associada ao IP " << inet_ntoa( ipt ) << " e a porta " 03195 << ntohs( PortTransfer ) << " nao e do tipo de envio de " 03196 << "dados. A callback nao sera chamada e o buffer Data " 03197 << "nao sera removido!" << endl; 03198 03199 #ifdef RIO_DEBUG1 03200 INTERFACELOG << "[CNetInterface - SendDataCompleted] Finish3" << endl; 03201 #endif 03202 03203 return; 03204 } 03205 03206 // O par IP, Porta da transferencia bate e o tipo de transferencia e de 03207 // envio. Entao, chamamos a callback e removemos o dado e a transferencia. 03208 03209 // Chama a callback de finalizacao associada a transferencia, se ela nao 03210 // for nula, ou seja, se um ponteiro para uma callback foi passado quando 03211 // enviamos os dados. 03212 if( FinalizeCallback != NULL ) 03213 FinalizeCallback( FinalizeCallbackParam, S_OK ); 03214 03215 // Deleta o buffer com os dados que ja foram enviados com sucesso. 03216 delete[] Data; 03217 03218 // Remove a estrutura de transferencia da lista com todas as transferencias. 03219 RioStatus = m_TransferInfo->RemoveTransfer( TransferID ); 03220 if( FAILED( RioStatus ) ) 03221 { 03222 INTERFACELOG << "CNetInterface::SendDataCompleted erro 0x" << hex 03223 << RioStatus << dec << " (" 03224 << GetErrorDescription( RioStatus ) << ") ao executar a " 03225 << "funcao RemoveTransfer. O erro foi gerado para o par " 03226 << "IP " << inet_ntoa( ip ) << " e a porta " 03227 << ntohs( Port ) << "." << endl; 03228 } 03229 03230 #ifdef RIO_DEBUG1 03231 INTERFACELOG << "[CNetInterface - SendDataCompleted] Finish4" << endl; 03232 #endif 03233 03234 return; 03235 }
| void CNetInterface::SendResult | ( | int | ipadr, | |
| int | port, | |||
| TTransferID | TransferID, | |||
| int | result | |||
| ) |
Funcao para enviar uma mensagem do tipo resultado ao endereco ipadr, port destino, passando o resultado dado em result.
| ipadr | endereco IP para o qual o comando deve ser enviado. | |
| port | porta para o qual o comando deve ser enviado. | |
| TransferID | identificador da estrutura de transferencia no endereco destino associada ao recebimento do resultado a ser enviado. | |
| result | resultado a ser passado. |
Definition at line 1626 of file NetInterface.cpp.
01628 { 01629 // Armazena o resultado ao executarmos as funcoes do RIO. 01630 RioResult RioStatus; 01631 01632 #ifdef RIO_DEBUG2 01633 // Usado para armazenar o IP para impressao. 01634 in_addr ip; 01635 01636 ip.s_addr = ipadr; 01637 #endif 01638 01639 #ifdef RIO_DEBUG1 01640 INTERFACELOG << "[CNetInterface - SendResult] Start" << endl; 01641 #endif 01642 01643 // Tenta criar uma nova mensagem do tipo comando e envia-la ao endereco de 01644 // destino. 01645 RioStatus = SendData( ipadr, port, NULL, NULL, ( char * ) &result, 01646 sizeof( int ), RESULTDATA, true, TransferID ); 01647 01648 #ifdef RIO_DEBUG2 01649 if( FAILED( RioStatus ) ) 01650 { 01651 INTERFACELOG << "CNetInterface::SendResult erro 0x" << hex << RioStatus 01652 << dec << " (" << GetErrorDescription( RioStatus ) << ") " 01653 << "ao enviar o resultado " << result << " ao endereco IP " 01654 << inet_ntoa( ip ) << " e a porta " << ntohs( port ) << "." 01655 << endl; 01656 } 01657 #endif 01658 01659 #ifdef RIO_DEBUG2 01660 INTERFACELOG << "CNetInterface::SendResult enviando o resultado " << result 01661 << " ao endereco IP " << inet_ntoa( ip ) << " e a porta " 01662 << ntohs( port ) << " para a transferencia com a ID " 01663 << TransferID << "." << endl; 01664 #endif 01665 01666 #ifdef RIO_DEBUG1 01667 INTERFACELOG << "[CNetInterface - SendResult] Finish" << endl; 01668 #endif 01669 }
| void CNetInterface::SendRst | ( | int | ipadr, | |
| int | port, | |||
| TTransferID | TransferID, | |||
| int | result | |||
| ) |
Esta funcao e usada para enviar uma mensagem com um codigo de erro para cancelar um pedido pendende (note que este erro, ao contrario da mensagem enviada por SendResult, indica que um erro ocorreu durante o processamento das IDs de transferencia).
Obs: Por enquanto, isso ocorrera quando, ao cliente solicitar uma busca nos logs do servidor, pedir ou um bloco que um arquivo com os resultados de uma busca cuja identificacao nao existe, ou se pedir um bloco invalido deste arquivo.
| ipadr | endereco IP para onde deveremos enviar o codigo de erro. | |
| port | porta para onde deveremos enviar o codigo de erro. | |
| TransferID | identificador da estrutura de transferencia no endereco destino associada ao recebimento do resultado a ser enviado. | |
| result | codigo de erro a ser enviado. |
Definition at line 2659 of file NetInterface.cpp.
02661 { 02662 // Armazena o resultado ao executarmos as funcoes do RIO. 02663 RioResult RioStatus; 02664 02665 #ifdef RIO_DEBUG2 02666 // Usado para armazenar o IP para impressao. 02667 in_addr ip; 02668 02669 ip.s_addr = ipadr; 02670 #endif 02671 02672 #ifdef RIO_DEBUG1 02673 INTERFACELOG << "[CNetInterface - SendRst] Start" << endl; 02674 #endif 02675 02676 // Tenta criar uma nova mensagem do tipo comando e envia-la ao endereco de 02677 // destino. 02678 RioStatus = SendData( ipadr, port, NULL, NULL, ( char * ) &result, 02679 sizeof( int ), RSTDATA, true, TransferID ); 02680 02681 #ifdef RIO_DEBUG2 02682 if( FAILED( RioStatus ) ) 02683 { 02684 INTERFACELOG << "CNetInterface::SendRst erro 0x" << hex << RioStatus 02685 << dec << " (" << GetErrorDescription( RioStatus ) << ") " 02686 << "ao enviar o erro " << result << " ao endereco IP " 02687 << inet_ntoa( ip ) << " e a porta " << ntohs( port ) << "." 02688 << endl; 02689 } 02690 02691 INTERFACELOG << "CNetInterface::SendRst enviando o resultado " << result 02692 << " ao endereco IP " << inet_ntoa( ip ) << " e a porta " 02693 << ntohs( port ) << " para a transferencia com a ID " 02694 << TransferID << "." << endl; 02695 #endif 02696 02697 02698 #ifdef RIO_DEBUG1 02699 INTERFACELOG << "[CNetInterface - SendRst] Finish" << endl; 02700 #endif 02701 }
| void CNetInterface::setLogRotation | ( | CLogRotation * | LogRotation | ) |
Funcao para definir o objeto (do tipo CLogRotation) a ser usado para armazenar as estatisticas de envio de pacotes.
| LogRotation | ponteiro para um objeto do tipo CLogRotation. |
Definition at line 2552 of file NetInterface.cpp.
02553 { 02554 #ifdef RIO_DEBUG1 02555 INTERFACELOG << "[CNetInterface - setLogRotation] Start" << endl; 02556 #endif 02557 02558 if( !m_Started ) 02559 { 02560 #ifdef RIO_DEBUG2 02561 INTERFACELOG << "CNetInterface::setLogRotation o objeto nao foi " 02562 << "inicializado." << endl; 02563 #endif 02564 02565 #ifdef RIO_DEBUG1 02566 INTERFACELOG << "[CNetInterface - setLogRotation] Finish1" << endl; 02567 #endif 02568 02569 return; 02570 } 02571 02572 // Seta a classe de log para o objeto da classe CNetTcp. 02573 m_NetTcp->setLogRotation( LogRotation ); 02574 // Seta a classe de log para o objeto da classe CNetUdp. 02575 // Obs: Esta linha esta comentada porque, como a classe CNetUdp nao esta 02576 // implementada, nenhum objeto foi criado para ela. Esta linha devera ser 02577 // descomentada quando a classe CNetUdp for criada porque, em caso 02578 // contrario, as estatisticas de envio geradas por este objeto poderao nao 02579 // ser contabilizadas. 02580 //m_NetUdp->setLogRotation( LogRotation ); 02581 02582 #ifdef RIO_DEBUG1 02583 INTERFACELOG << "[CNetInterface - setLogRotation] Finish2" << endl; 02584 #endif 02585 }
| RioResult CNetInterface::Start | ( | int | ServerPort, | |
| time_t | ConnectionTimeOut = 0, |
|||
| unsigned int | ReceiveTimeOut = 0, |
|||
| unsigned int | SendTimeOut = 0, |
|||
| CLogRotation * | LogRotation = NULL | |||
| ) |
Funcao usada para inicializar a classe usada pelo servidor ou o storage.
| ServerPort | porta TCP a qual devemos no conectar (este parametro somente e usado pelos servidores). | |
| ConnectionTimeOut | timeout (em segundos) para uma conexao entre o cliente e um dos servidores (usado somente pelas conexoes TCP). | |
| ReceiveTimeOut | timeout (em milisegundos) para os comandos de recebimento de dados (recv). | |
| SendTimeOut | timeout (em milisegunfod) para os comandos de envio de dados (send). | |
| LogRotation | ponteiro para o objeto que gerencia o armazenamento dos logs de envio de dados pelo servidor (de armazenamento). | |
| isStorage | usado para indicar se o objeto esta associado a um servidor de despacho (false) ou a um servidor de armazenamento (true). Esta parametro somente e usado com o parametro LogPath para podermos criar um nome diferenciado para o servidor de despacho e para o servidor de armazenamento. | |
| LogPath | caminho do arquivo usado para armazenar os logs dos envio de dados. Se usarmos o parametro default NULL, as impressoes serao colocadas na RioErr. Em caso contrario, o nome do do arquivo sera gerado segundo o seguinte criterio: RIOServerEmul_<maquina>.<dominio>.log se o servidor de despacho executou a funcao. RIOStorageEmul_<maquina>.<dominio>.log se o servidor de armazenamento executou a funcao. |
Obs: Este parametro, assim como na classe NetMgr e RioNeti, somente estara disponivel se a constante RIO_DEBUG_FILE for usada.
Definition at line 1132 of file NetInterface.cpp.
01137 { 01138 // Armazena o codigo de erro do RIO retornado pelas funcoes. 01139 RioResult RioStatus; 01140 // Estrutura para armazenar as informacoes do objeto da classe CNetTcp 01141 SNetTcpConfig NetTcpConfig; 01142 // Estrutura para armazenar as informacoes do objeto da classe CNetUdp 01143 SNetUdpConfig NetUdpConfig; 01144 01145 // Usado para compor o nome do arquivo se LogPath for NULL (somente quando 01146 // RIO_DEBUG_FILE for usado). 01147 #ifdef RIO_DEBUG_FILE 01148 string file; 01149 // Armazena o nome do arquivo do log. 01150 const char *LogFileName; 01151 #endif 01152 01153 #ifdef RIO_DEBUG1 01154 RioErr << "[CNetInterface - Start] - Start" << endl; 01155 #endif 01156 01157 // Verifica se o objeto ja foi inicializado. 01158 if( m_Started ) 01159 { 01160 #ifdef RIO_DEBUG2 01161 RioErr << "CNetInterface::Start o objeto ja foi inicializado." 01162 << endl; 01163 #endif 01164 01165 #ifdef RIO_DEBUG1 01166 RioErr << "[CNetInterface - Start] Finish1" << endl; 01167 #endif 01168 01169 return ERROR_NETINTERFACE + ERROR_STARTED; 01170 } 01171 01172 // Inicializa o objeto da classe para geracao de logs 01173 #ifdef RIO_DEBUG_FILE 01174 if( LogPath == NULL ) 01175 { 01176 char tmpName[256]; 01177 char tmpDomain[256]; 01178 gethostname( tmpName, 255 ); 01179 getdomainname( tmpDomain, 255 ); 01180 string file; 01181 01182 if( isStorage ) 01183 file = "RIOStorageEmul_"; 01184 else 01185 file = "RIOServerEmul_"; 01186 01187 file += tmpName; 01188 if( strstr( tmpName, tmpDomain ) == NULL ) 01189 { 01190 file += "."; 01191 file += tmpDomain; 01192 } 01193 file += ".log"; 01194 01195 LogFileName = file.c_str(); 01196 } 01197 else 01198 LogFileName = LogPath; 01199 #endif 01200 01201 // Inicializa todos os campos da estrutura. 01202 memset( &NetTcpConfig, 0, sizeof( NetTcpConfig ) ); 01203 // Inicializa os campos da estrutura NetConfig usados pelo servidor para a 01204 // conexao TCP. 01205 NetTcpConfig.isServer = true; 01206 NetTcpConfig.ReceiveTimeOut = ReceiveTimeOut; 01207 NetTcpConfig.SendTimeOut = SendTimeOut; 01208 NetTcpConfig.ConnectionTimeOut = ConnectionTimeOut; 01209 NetTcpConfig.ServerPort = ServerPort; 01210 NetTcpConfig.LogRotation = LogRotation; 01211 #ifdef RIO_DEBUG_FILE 01212 // Inicializa as informacoes de depuracao. 01213 NetTcpConfig.LogFileName = LogFileName; 01214 #endif 01215 // Usa a funcao FindIP para obter um IP para a conexao do servidor ou 01216 // storage. 01217 RioStatus = FindIP( &NetTcpConfig.HostIP ); 01218 if ( FAILED( RioStatus ) ) 01219 { 01220 #ifdef RIO_DEBUG2 01221 RioErr << "CNetInterface::Start erro ao executar FindIP." << endl; 01222 #endif 01223 01224 #ifdef RIO_DEBUG1 01225 RioErr << "[CNetInterface - Start] Finish2" << endl; 01226 #endif 01227 01228 return RioStatus; 01229 } 01230 01231 // Tenta criar e inicializar um novo objeto da classe CTransferInfo. 01232 RioStatus = StartTransferInfo(); 01233 if( FAILED( RioStatus ) ) 01234 { 01235 #ifdef RIO_DEBUG2 01236 RioErr << "CNetInterface::Start erro 0x" << hex << RioStatus << dec 01237 << " (" << GetErrorDescription( RioStatus ) 01238 << ") ao executar a funcao StartTransferInfo" << endl; 01239 #endif 01240 01241 #ifdef RIO_DEBUG1 01242 RioErr << "[CNetInterface - Start] Finish3" << endl; 01243 #endif 01244 01245 return RioStatus; 01246 } 01247 01248 // Tenta inicializar o objeto da classe CNetTcp para o envio de dados em 01249 // tempo nao real. 01250 RioStatus = StartNetTcp( &NetTcpConfig ); 01251 if( FAILED( RioStatus ) ) 01252 { 01253 #ifdef RIO_DEBUG2 01254 RioErr << "CNetInterface::Start erro 0x" << hex << RioStatus << dec 01255 << " (" << GetErrorDescription( RioStatus ) 01256 << ") ao executar a funcao StartNet" << endl; 01257 #endif 01258 01259 #ifdef RIO_DEBUG1 01260 RioErr << "[CNetInterface - Start] Finish4" << endl; 01261 #endif 01262 01263 return RioStatus; 01264 } 01265 01266 // Inicializa os campos da estrutura NetConfig usados pelo cliente para a 01267 // conexao UDP. 01268 NetUdpConfig.isServer = true; 01269 NetUdpConfig.LogRotation = LogRotation; 01270 NetUdpConfig.HostIP = NetTcpConfig.HostIP; 01271 #ifdef RIO_DEBUG_FILE 01272 NetUdpConfig.LogFileName = LogFileName; 01273 #endif 01274 01275 // Tenta inicializar o objeto da classe CNetUdp para o envio de dados em 01276 // tempo real. 01277 RioStatus = StartNetUdp( &NetUdpConfig ); 01278 if( FAILED( RioStatus ) ) 01279 { 01280 #ifdef RIO_DEBUG2 01281 RioErr << "CNetInterface::Start erro 0x" << hex << RioStatus << dec 01282 << " (" << GetErrorDescription( RioStatus ) 01283 << ") ao executar a funcao StartNetUdp" << endl; 01284 #endif 01285 01286 #ifdef RIO_DEBUG1 01287 RioErr << "[CNetInterface - Start] Finish5" << endl; 01288 #endif 01289 01290 return RioStatus; 01291 } 01292 01293 // Informa que a classe foi corretamente inicializada. 01294 m_Started = true; 01295 01296 #ifdef RIO_DEBUG2 01297 RioErr << "CNetInterface::Start objeto criado e inicializado com sucesso!" 01298 << endl; 01299 #endif 01300 01301 #ifdef RIO_DEBUG1 01302 RioErr << "[CNetInterface - Start] Finish6" << endl; 01303 #endif 01304 01305 return S_OK; 01306 }
| RioResult CNetInterface::Start | ( | struct sockaddr_in * | ServerAddress, | |
| unsigned int | ServerAddressSize, | |||
| time_t | ConnectionTimeOut = 0, |
|||
| unsigned int | ReceiveTimeOut = 0, |
|||
| unsigned int | SendTimeOut = 0 | |||
| ) |
Funcao usada para inicializar a classe usada pelo cliente.
| ServerAddress | vetor de estruturas (do tipo sockaddr_in) com os enderecos (IP, porta) dos servidores com os quais o cliente deve criar uma conexao (este parametro e ignorado para as conexoes UDP, ou seja, se UseTcp for igual a false). | |
| ServerAddressSize | numero de enderecos no vetor ServerAddress. | |
| ConnectionTimeOut | timeout (em segundos) para uma conexao entre o cliente e um dos servidores (usado somente pelas conexoes TCP). | |
| ReceiveTimeOut | timeout (em milisegundos) para os comandos de recebimento de dados (recv). | |
| SendTimeOut | timeout (em milisegunfod) para os comandos de envio de dados (send). | |
| LogPath | caminho do arquivo usado para armazenar os logs dos envio de dados. Se usarmos o parametro default NULL, as impressoes serao colocadas na RioErr. Em caso contrario, o nome do do arquivo sera RIOClientEmul_<maquina>.<dominio>.log. Este parametro, assim como na classe NetMgr e RioNeti, somente estara disponivel se a constante RIO_DEBUG_FILE for usada. |
Definition at line 945 of file NetInterface.cpp.
00951 { 00952 // Armazena o codigo de erro do RIO retornado pelas funcoes. 00953 RioResult RioStatus; 00954 // Estrutura para armazenar as informacoes do objeto da classe CNetTcp 00955 SNetTcpConfig NetTcpConfig; 00956 // Estrutura para armazenar as informacoes do objeto da classe CNetUdp 00957 SNetUdpConfig NetUdpConfig; 00958 00959 // Usado para compor o nome do arquivo se LogPath for NULL (somente quando 00960 // RIO_DEBUG_FILE for usado). 00961 #ifdef RIO_DEBUG_FILE 00962 string file; 00963 // Armazena o nome do arquivo do log. 00964 const char *LogFileName; 00965 #endif 00966 00967 00968 #ifdef RIO_DEBUG1 00969 RioErr << "[CNetInterface - Start] Start" << endl; 00970 #endif 00971 00972 // Verifica se o objeto ja foi inicializado. 00973 if( m_Started ) 00974 { 00975 #ifdef RIO_DEBUG2 00976 RioErr << "CNetInterface::Start o objeto ja foi inicializado." 00977 << endl; 00978 #endif 00979 00980 #ifdef RIO_DEBUG1 00981 RioErr << "[CNetInterface - Start] Finish1" << endl; 00982 #endif 00983 00984 return ERROR_NETINTERFACE + ERROR_STARTED; 00985 } 00986 00987 // Inicializa o objeto da classe para geracao de logs 00988 #ifdef RIO_DEBUG_FILE 00989 if( LogPath == NULL ) 00990 { 00991 char tmpName[256]; 00992 char tmpDomain[256]; 00993 gethostname( tmpName, 255 ); 00994 getdomainname( tmpDomain, 255 ); 00995 char tmpPid[ 20 ]; // Tamanho de um inteiro de 64 bits (caso o rio 00996 // rio seja compilado em uma maquina cujo int 00997 // e de 64 bits). 00998 pid_t myPid; 00999 myPid = getpid(); 01000 sprintf( tmpPid, "%d", ( int ) myPid ); 01001 file = "RIOClientEmul_"; 01002 file += tmpPid; 01003 file += "_"; 01004 file += tmpName; 01005 01006 if( strstr( tmpName, tmpDomain ) == NULL ) 01007 { 01008 file += "."; 01009 file += tmpDomain; 01010 } 01011 file += ".log"; 01012 01013 LogFileName = file.c_str(); 01014 } 01015 else 01016 LogFileName = LogPath; 01017 #endif 01018 01019 // Inicializa todos os campos da estrutura. 01020 memset( &NetTcpConfig, 0, sizeof( NetTcpConfig ) ); 01021 // Inicializa os campos da estrutura NetConfig usados pelo cliente para a 01022 // conexao TCP. 01023 NetTcpConfig.isServer = false; 01024 NetTcpConfig.ReceiveTimeOut = ReceiveTimeOut; 01025 NetTcpConfig.SendTimeOut = SendTimeOut; 01026 NetTcpConfig.ConnectionTimeOut = ConnectionTimeOut; 01027 NetTcpConfig.ServerAddress = ServerAddress; 01028 NetTcpConfig.ServerAddressSize = ServerAddressSize; 01029 #ifdef RIO_DEBUG_FILE 01030 NetTcpConfig.LogFileName = LogFileName; 01031 #endif 01032 01033 // Usa a funcao FindIP para obter um IP para a conexao do cliente. 01034 RioStatus = FindIP( &NetTcpConfig.HostIP ); 01035 if ( FAILED( RioStatus ) ) 01036 { 01037 #ifdef RIO_DEBUG2 01038 RioErr << "CNetInterface::Start erro ao executar FindIP." << endl; 01039 #endif 01040 01041 #ifdef RIO_DEBUG1 01042 RioErr << "[CNetInterface - Start] Finish2" << endl; 01043 #endif 01044 01045 return RioStatus; 01046 } 01047 01048 // Tenta criar e inicializar um novo objeto da classe CTransferInfo. 01049 RioStatus = StartTransferInfo(); 01050 if( FAILED( RioStatus ) ) 01051 { 01052 #ifdef RIO_DEBUG2 01053 RioErr << "CNetInterface::Start erro 0x" << hex << RioStatus << dec 01054 << " (" << GetErrorDescription( RioStatus ) 01055 << ") ao executar a funcao StartTransferInfo" << endl; 01056 #endif 01057 01058 #ifdef RIO_DEBUG1 01059 RioErr << "[CNetInterface - Start] Finish3" << endl; 01060 #endif 01061 01062 return RioStatus; 01063 } 01064 01065 // Tenta inicializar o objeto da classe CNetTcp para o envio de dados em 01066 // tempo nao real. 01067 RioStatus = StartNetTcp( &NetTcpConfig ); 01068 if( FAILED( RioStatus ) ) 01069 { 01070 #ifdef RIO_DEBUG2 01071 RioErr << "CNetInterface::Start erro 0x" << hex << RioStatus << dec 01072 << " (" << GetErrorDescription( RioStatus ) 01073 << ") ao executar a funcao StartNetTcp" << endl; 01074 #endif 01075 01076 #ifdef RIO_DEBUG1 01077 RioErr << "[CNetInterface - Start] Finish4" << endl; 01078 #endif 01079 01080 return RioStatus; 01081 } 01082 01083 // Inicializa os campos da estrutura NetConfig usados pelo cliente para a 01084 // conexao UDP. 01085 NetUdpConfig.isServer = false; 01086 NetUdpConfig.HostIP = NetTcpConfig.HostIP; 01087 #ifdef RIO_DEBUG_FILE 01088 NetUdpConfig.LogFileName = LogFileName; 01089 #endif 01090 01091 // Tenta inicializar o objeto da classe CNetUdp para o envio de dados em 01092 // tempo real. 01093 RioStatus = StartNetUdp( &NetUdpConfig ); 01094 if( FAILED( RioStatus ) ) 01095 { 01096 #ifdef RIO_DEBUG2 01097 RioErr << "CNetInterface::Start erro 0x" << hex << RioStatus << dec 01098 << " (" << GetErrorDescription( RioStatus ) 01099 << ") ao executar a funcao StartNetUdp" << endl; 01100 #endif 01101 01102 #ifdef RIO_DEBUG1 01103 RioErr << "[CNetInterface - Start] Finish5" << endl; 01104 #endif 01105 01106 return RioStatus; 01107 } 01108 01109 // Informa que a classe foi corretamente inicializada. 01110 m_Started = true; 01111 01112 #ifdef RIO_DEBUG2 01113 RioErr << "CNetInterface::Start objeto criado e inicializado com sucesso!" 01114 << endl; 01115 #endif 01116 01117 #ifdef RIO_DEBUG1 01118 RioErr << "[CNetInterface - Start] Finish6" << endl; 01119 #endif 01120 01121 return S_OK; 01122 }
| RioResult CNetInterface::StartNetTcp | ( | SNetTcpConfig * | NetConfig | ) | [private] |
Funcao usada para criar e inicializar o objeto derivado da classe classes CNetTcp.
| NetConfig | estrutura com as configuracoes do objeto a ser criado da classe CNetTcp. |
Definition at line 644 of file NetInterface.cpp.
00645 { 00646 // Armazena o codigo de erro do RIO retornado pelas funcoes. 00647 RioResult RioStatus; 00648 00649 #ifdef RIO_DEBUG1 00650 INTERFACELOG << "[CNetInterface::StartNetTcp] Start" << endl; 00651 #endif 00652 00653 // Devemos criar um objeto para transferencias via TCP. 00654 m_NetTcp = new CNetTcp( this ); 00655 if( m_NetTcp == NULL ) 00656 { 00657 #ifdef RIO_DEBUG2 00658 INTERFACELOG << "CNetInterface::StartNetTcp erro de alocacao de " 00659 << "memoria ao criar o objeto da classe CNetTcp." << endl; 00660 #endif 00661 00662 #ifdef RIO_DEBUG1 00663 INTERFACELOG << "[CNetInterface - StartNetTcp] Finish1" << endl; 00664 #endif 00665 00666 return ERROR_NETINTERFACE + ERROR_MEMORY; 00667 } 00668 00669 // Tenta inicializar a classe. 00670 RioStatus = m_NetTcp->Start( NetConfig ); 00671 if( FAILED( RioStatus ) ) 00672 { 00673 #ifdef RIO_DEBUG2 00674 INTERFACELOG << "CNetInterface::StartNetTcp erro 0x" << hex << RioStatus 00675 << dec << " (" << GetErrorDescription( RioStatus ) << ") " 00676 << "ao executar a funcao Start do objeto da classe " 00677 << "CNetTcp." << endl; 00678 #endif 00679 00680 delete m_NetTcp; 00681 m_NetTcp = NULL; 00682 00683 #ifdef RIO_DEBUG1 00684 INTERFACELOG << "[CNetInterface - StartNetTcp ] Finish2" << endl; 00685 #endif 00686 00687 return RioStatus; 00688 } 00689 00690 #ifdef RIO_DEBUG2 00691 INTERFACELOG << "CNetInterface::StartNetTcp objeto criado e inicializado!" 00692 << endl; 00693 #endif 00694 00695 #ifdef RIO_DEBUG1 00696 INTERFACELOG << "[CNetInterface - StartNetTcp] Finish3" << endl; 00697 #endif 00698 00699 return S_OK; 00700 }
| RioResult CNetInterface::StartNetUdp | ( | SNetUdpConfig * | NetConfig | ) | [private] |
Funcao usada para criar e inicializar o objeto derivado da classe classes CNetUdp.
| NetConfig | estrutura com as configuracoes do objeto a ser criado da classe CNetUdp. |
Definition at line 704 of file NetInterface.cpp.
00705 { 00706 #ifdef RIO_DEBUG1 00707 INTERFACELOG << "[CNetInterface::StartNetUdp] Start" << endl; 00708 #endif 00709 00710 // Depois que a classe UDP for implementada, deveremos fazer as 00711 // inicializacoes (provavelmente sera igual a da classe TCP acima). 00712 m_NetUdp = NULL; 00713 00714 #ifdef RIO_DEBUG2 00715 INTERFACELOG << "CNetInterface::StartNetUdp objeto criado e inicializado!" 00716 << endl; 00717 #endif 00718 00719 #ifdef RIO_DEBUG1 00720 INTERFACELOG << "[CNetInterface::StartNetUdp] Finish" << endl; 00721 #endif 00722 00723 return S_OK; 00724 }
| RioResult CNetInterface::StartTransferInfo | ( | ) | [private] |
Funcao usada para criar um novo objeto da classe CTransferInfo.
Definition at line 727 of file NetInterface.cpp.
00728 { 00729 #ifdef RIO_DEBUG1 00730 INTERFACELOG << "[CNetInterface - StartTransferInfo] Start" << endl; 00731 #endif 00732 00733 try 00734 { 00735 m_TransferInfo = new CTransferInfo( this ); 00736 } 00737 catch( bad_alloc &ba ) 00738 { 00739 #ifdef RIO_DEBUG2 00740 INTERFACELOG << "CNetInterface::StartTransferInfo Erro de alocacao de " 00741 << "memoria (bad_alloc, error = " << ba.what() << ") ao " 00742 << "criar o objeto do tipo CTransferInfo para gerenciar " 00743 << "as transferencias." << endl; 00744 #endif 00745 00746 #ifdef RIO_DEBUG1 00747 INTERFACELOG << "[CNetInterface - SendData] Finish1" << endl; 00748 #endif 00749 00750 return ERROR_NETINTERFACE + ERROR_MEMORY; 00751 } 00752 00753 #ifdef RIO_DEBUG2 00754 INTERFACELOG << "CNetInterface::StartTransferInfo objeto criado e " 00755 << "inicializado!" << endl; 00756 #endif 00757 00758 #ifdef RIO_DEBUG1 00759 INTERFACELOG << "[CNetInterface - StartTransferInfo] Finish2" << endl; 00760 #endif 00761 00762 return S_OK; 00763 }
| RioResult CNetInterface::Stop | ( | void | ) |
Funcao para parar o funcionamento do objeto da classe, parando todas as threads que tenham sido criadas por um objeto de uma das classes derivadas da CNet e tambem todas as estruturas alocadas.
Definition at line 1311 of file NetInterface.cpp.
01312 { 01313 // Armazena o codigo de erro do RIO retornado pelas funcoes. 01314 RioResult RioStatus; 01315 01316 #ifdef RIO_DEBUG1 01317 INTERFACELOG << "[CNetInterface - Stop] Start" << endl; 01318 #endif 01319 01320 if( !m_Started ) 01321 { 01322 #ifdef RIO_DEBUG2 01323 INTERFACELOG << "CNetInterface::Stop o objeto nao foi inicializado." 01324 << endl; 01325 #endif 01326 01327 #ifdef RIO_DEBUG1 01328 INTERFACELOG << "[CNetInterface - Stop] Finish1" << endl; 01329 #endif 01330 01331 return ERROR_NETTCP + ERROR_NOT_STARTED; 01332 } 01333 01334 // Para o objeto da classe de transferencia de dados TCP. 01335 RioStatus = m_NetTcp->Stop(); 01336 if( FAILED( RioStatus ) ) 01337 { 01338 #ifdef RIO_DEBUG2 01339 INTERFACELOG << "CNetInterface::Stop erro 0x" << hex << RioStatus << dec 01340 << " (" << GetErrorDescription( RioStatus ) 01341 << ") ao executar a funcao Stop do objeto da classe " 01342 << "CNetTcp" << endl; 01343 #endif 01344 01345 #ifdef RIO_DEBUG1 01346 INTERFACELOG << "[CNetInterface - Stop] Finish2" << endl; 01347 #endif 01348 01349 return RioStatus; 01350 } 01351 01352 // Obs: Quando a classe UDP for implementada, deveremos tambem executar aqui 01353 // a funcao Stop desta classe. O codigo esta comentado e e dado a seguir. 01354 // Note que o ultimo comentario devera passar a ser 01355 // "[CNetInterface - Stop] Finish4". 01356 // Para o objeto da classe de transferencia de dados UDP. 01357 //RioStatus = m_NetUdp->Stop(); 01358 //if( FAILED( RioStatus ) ) 01359 //{ 01360 // #ifdef RIO_DEBUG2 01361 // INTERFACELOG << "CNetInterface::Stop erro 0x" << hex << RioStatus << dec 01362 // << " (" << GetErrorDescription( RioStatus ) 01363 // << ") ao executar a funcao Stop do objeto da classe " 01364 // << "CNetUdp" << endl; 01365 // #endif 01366 // 01367 // #ifdef RIO_DEBUG1 01368 // INTERFACELOG << "[CNetInterface - Stop] Finish3" << endl; 01369 // #endif 01370 // 01371 // return RioStatus; 01372 //} 01373 01374 // Destroi o objeto responsavel pelo gerenciamento das transmissoes 01375 if( m_TransferInfo != NULL ) 01376 delete m_TransferInfo; 01377 01378 // Destroi o objeto responsavel pelas transmissoes de dados via TCP. 01379 if( m_NetTcp != NULL ) 01380 delete m_NetTcp; 01381 01382 // Destroi o objeto responsavel pelas transmissoes de dados via UDP. 01383 // 01384 // Obs: Esta linha nao esta comentada porque verificamos se m_NetUdp e 01385 // NULL. 01386 if( m_NetUdp != NULL ) 01387 delete m_NetUdp; 01388 01389 // Indica que a classe nao esta mais inicializada! 01390 m_Started = false; 01391 01392 // Obtem o acesso exclusivo ao mapa com as transferencias pendendes. 01393 //pthread_mutex_lock( &m_MapMutex ); 01394 01395 // Libera o acesso exclusivo ao mapa com as transferencias pendendes. 01396 //pthread_mutex_unlock( &m_MapMutex ); 01397 01398 #ifdef RIO_DEBUG2 01399 RioErr << "CNetInterface::Stop objeto finalizado com sucesso!" << endl; 01400 #endif 01401 01402 #ifdef RIO_DEBUG1 01403 INTERFACELOG << "[CNetInterface - Stop] Finish3" << endl; 01404 #endif 01405 01406 return S_OK; 01407 }
| void CNetInterface::TellId | ( | int | ipadr, | |
| int | port, | |||
| TTransferID | TransferID, | |||
| int | tellip, | |||
| int | tellport, | |||
| TTransferID | tellTTransferID, | |||
| callback_t | callback, | |||
| void * | callbackparm | |||
| ) |
Envia ao outro lado da conexao, usando um comando, as informacoes necessarias para que este lado envie um bloco.
| ipadr | endereco IP para onde a ID deve ser enviada. | |
| port | porta neste endereco para onde a ID deve ser enviada. | |
| TransferID | identificador da estrutura de transferencia no endereco destino associada ao recebimento do comando com a ID que devera ser processado. | |
| tellip | endereco IP (local?) informando, ao outro lado, para onde o bloco deve ser enviado quando o comando com a ID for recebido. | |
| tellport | porta (local?) informando, ao outro lado, para onde o bloco deve ser enviado quando o comando com a ID for recebido. | |
| tellTransferID | identificador da estrutura de transferencia (local) assiada ao bloco a ser recebido pelo outro lado depois de a ID ser processada. | |
| callback | callback a ser chamada quando o processamento do comando que envia as informacoes terminar. | |
| callbackparm | parametro a ser passado quando a callback for chamada. |
Definition at line 1880 of file NetInterface.cpp.
01884 { 01885 // Vetor para criar o comando a ser enviado pela rede. 01886 u32 TellIdCmd[ CMD_TELLID_SIZE ]; 01887 01888 #ifdef RIO_DEBUG2 01889 // Usado para armazenar o IP para impressao. 01890 in_addr ip, ipt; 01891 01892 ip.s_addr = ipadr; 01893 ipt.s_addr = tellip; 01894 #endif 01895 01896 #ifdef RIO_DEBUG1 01897 INTERFACELOG << "[CNetInterface - TellId] Start" << endl; 01898 #endif 01899 01900 // Inicializa os campos do comando. 01901 // 01902 // Obs: precisamos avaliar se o comando tera a mesma estrutura, ou seja, 01903 // se sera ou nao necessario a deteccao de duplicatas do comando que 01904 // eventualmente possam ter sido enviadas. 01905 // 01906 TellIdCmd[ 0 ] = htonl( CMD_TELLID ); 01907 TellIdCmd[ 1 ] = tellip; 01908 TellIdCmd[ 2 ] = htonl( ntohs( ( short ) tellport ) ); 01909 TellIdCmd[ 3 ] = htonl( tellTTransferID ); 01910 01911 // Envia o comando usando a funcao SendCmd. 01912 SendCmd( ipadr, port, TransferID, ( char * ) TellIdCmd, CMD_TELLID_BYTESIZE, 01913 callback, callbackparm ); 01914 01915 #ifdef RIO_DEBUG2 01916 INTERFACELOG << "CNetInterface::TellId Informando a ID " << tellTTransferID 01917 << " associada ao endereco IP " << inet_ntoa( ipt ) << " e a " 01918 << "porta " << ntohs( tellport ) << " ao endereco IP " 01919 << inet_ntoa( ip ) << " e a porta " << ntohs( port ) 01920 << " usando a ID " << TransferID << "." << endl; 01921 #endif 01922 01923 #ifdef RIO_DEBUG1 01924 INTERFACELOG << "[CNetInterface - TellId] Finish" << endl; 01925 #endif 01926 }
| bool CNetInterface::thereAreFragments | ( | RioBlock | block | ) |
Funcao para verificar se fragmentos foram recebidos para o bloco passado como parametro.
Obs: Como ainda nao implementamos a classe CNetUdp, que sera a responsavel pela copia em tempo real, esta funcao ira retornar false se for chamada, e imprimira um erro se RIO_DEBUG2 estiver sendo usado.
| block | bloco para o qual desejamos ver se existem fragmentos. |
Definition at line 2506 of file NetInterface.cpp.
02507 { 02508 #ifdef RIO_DEBUG1 02509 INTERFACELOG << "[CNetInterface - thereAreFragments] Start" << endl; 02510 #endif 02511 02512 #ifdef RIO_DEBUG2 02513 INTERFACELOG << "[CNetInterface::thereAreFragments] Esta funcao nao esta " 02514 << "implementada! Retornado o valor false!" << endl; 02515 #endif 02516 02517 #ifdef RIO_DEBUG1 02518 INTERFACELOG << "[CNetInterface - thereAreFragments] Finish" << endl; 02519 #endif 02520 02521 return false; 02522 }
friend class CTransferInfo [friend] |
Definition at line 1037 of file NetInterface.h.
debugCerr CNetInterface::m_log [static] |
Definition at line 494 of file NetInterface.h.
pthread_mutex_t CNetInterface::m_MapMutex [private] |
Definition at line 372 of file NetInterface.h.
CNetTcp* CNetInterface::m_NetTcp [private] |
Definition at line 364 of file NetInterface.h.
CNetUdp* CNetInterface::m_NetUdp [private] |
Definition at line 367 of file NetInterface.h.
bool CNetInterface::m_Started [private] |
Definition at line 361 of file NetInterface.h.
CTransferInfo* CNetInterface::m_TransferInfo [private] |
Definition at line 370 of file NetInterface.h.
1.6.3