NetInterface.h

Go to the documentation of this file.

/*
 * Copyright (C) 2010, Edmundo Albuquerque de Souza e Silva.
 *
 * This file may be distributed under the terms of the Q Public License
 * as defined by Trolltech AS of Norway and appearing in the file
 * LICENSE.QPL included in the packaging of this file.
 *
 * THIS FILE IS PROVIDED AS IS WITH NO WARRANTY OF ANY KIND, INCLUDING
 * THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
 * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Thanks: Jose Renato Santos
 *
 */

///////////////////////////////////////////////////////////////////
// NetInterface.h: headers for NetInterface.cpp 
///////////////////////////////////////////////////////////////////

#ifndef __NETINTERFACE_H_
#define __NETINTERFACE_H_

// Unidades usadas do C++
#include <fstream>
#include <string>
#include <ext/hash_map>

// Unidades usadas do C.
#include <pthread.h>
#include <arpa/inet.h>

// Unidades uadas do RIO.
#include "RioError.h"
#include "RioInterfaceTypes.h"
#include "NetTcp.h"
#include "NetUdp.h"
#include "td4types.h"

// Namespace para usar a STL.
using namespace std;
// Namespace para usar a extensao da STL (o hash_map). Devemos realmente usar
// esta extensao?
using namespace __gnu_cxx;

class CLogRotation;
class CNet;

// Constante para o valor invalido de um identificador de uma transferencia 
// (somente para evitar sabermos como a constante e definida na classe).
#define NULLTRANSFERID CTransferInfo::NullTransferID

// Constante para sabermos o tamanho do cabecalho (novamente para evitar 
// colocarmos esta informacao no codigo).
#define DATAHEADERSIZE sizeof( SDataHeader )

// Define um tipo para o ID da estrutura STransferInfo.
// Obs: este valor e um int para ser compativel com o valor reqid usado na 
// NetMgr. No futuro, se necessario, podemos usar um valor maior, como um
// unsigned long long int. 
typedef int TTransferID;
// Constante usada para a implementação de 64 bis (para converter o int para o
// long e evitar assim um erro).
typedef long TLTransferID;

// Indica se a transferencia e nao definida (UNDEFINEDTYPE), se estamos enviando 
// (SENDINGDATA) ou recebendo (RECEIVINGDATA) dados.
// A transferencia nao definida e usada quando nao achamos uma identificacao de
// transferencia, e e usada pela funcao FinalizeAllTransfers da classe 
// CTransferInfo, quando desejamos indicar que queremos fechar todas as 
// transferencias para um dado par IP, porta. 
enum ETransferType 
{
    UNDEFINEDTYPE,
    SENDINGDATA,
    RECEIVINGDATA
};

// Constante com um tempo de timeout default para os comandos send e recv (e o
// mesmo dado no arquivo RioTcp.h para a conexao principal, mas aqui ele e dado
// em milisegundos). 
const int NETTCPTIMEOUTSECONDS = 5000;

// Estrutura com as informacoes sobre cada conexao.
typedef struct
{
    int IP; // Endereco IP associado a transferencia.
    int Port; // Porta associado a transferencia.
    TTransferID TransferID; // Identificacao da transferencia associada a 
                            // estrutura (sera que e necessaria?).
    callback_t FinalizeCallback; // Callback a ser chamada quando a estrutura
                                 // for removida.
    void *FinalizeCallbackParam; // Parametro passado ao chamar a callback 
                                 // FinalizeCallback.
    cmdcallback_t ProcessCallback; // Callback a ser vhamda quando precisamos
                                   // processar um conjunto de dados antes de
                                   // recebermos os dados definitivos por
                                    // esta transferencia.  
    void *ProcessCallbackParam; // Parametro passado ao chamar a callback 
                                // ProcessCallback.
    char *Data; // Dados associados a transferencia.
    unsigned int DataSize; // Quantidade (em bytes) de dados associados a
                           // transferencia.
    TTransferID DestTransferID; // Identificador da transferencia do outro lado
                                // (usado somente quando enviamos dados).
    ETransferType TransferType; // Define se estamos enviando ou recebendo
                                // dados.                        
} STransferInfo;

// Nova estrutura com uma funcao para comparar dois identificadores da hash
// que armazena os identificadores.
struct EqTrasnferID
{
  bool operator()( const TTransferID ID1, const TTransferID ID2 ) const
  {
    return ( ID1 == ID2 );
  }
};

// Novo tipo de hash para o identificador de uma transferencia
typedef hash< TTransferID > TTransferHash;

// Novo tipo para armazenar os ponteiros para as estruturas STransferInfo, com 
// uma busca eficiente
typedef hash_map< TTransferID, STransferInfo, TTransferHash, EqTrasnferID > 
        TTransferInfoHash;

// Possiveis tipos de dados enviados entre o cliente e o servidor.
enum EDataType 
{
    RSTDATA, // Uma mensagem de erro foi enviada.
    CMDDATA, // Um comando foi enviado.
    RESULTDATA, // Um resultado (em geral, de um comando) foi enviado.
    BLOCKDATA // Um bloco foi enviado..
};

// Define os possiveis tipos de comandos (os comandos para o tipo CMDDATA).
#define CMD_TELLID 1 // Atualmente este e o unico tipo de comando

// Define as constantes para cada comando.
// Tamanho do comando CMD_TELLID em unidades do tipo u32.
#define CMD_TELLID_SIZE 4
// Tamanho do comando CMD_TELLID em bytes.
#define CMD_TELLID_BYTESIZE 4 * sizeof( u32 )

// Estrutura com o cabecalho dos dados enviados.
typedef struct
{
    // Tipo dos dados a serem enviados;
    uint16_t DataType; 
    // Identificador da estrutura  STransferInfo associada aos dados que estao 
    // sendo enviados.
    uint32_t SourceTransferID;
    // Identificador, no outro lado da conexao, da estrutura STransferInfo que 
    // foi criada para o recebimento destes dados. 
    uint32_t DataTransferID; 
} SDataHeader;

// Classe para armazenar as transferencias em andamento.
class CTransferInfo
{
    private:
        // Ponteiro para o objeto da classe de gerenciamento associada a este
        // objeto de envio dos dados.
        CNetInterface *m_NetInterface;
        // Define o proximo numero usado para identificar a proxima estrutura a
        // ser criada pela funcao NewTransfer.
        TTransferID m_NextTransferID;
        // hash para buscar, pela identificacao da transferencia, uma das
        // transferencias (talvez possamos fazer igual a RioNeti e usar uma
        // hash).
        TTransferInfoHash m_TransferInfoHash;
        // mutex para garantir o acesso exclusivo as estruturas de um objeto
        // da classe.
        pthread_mutex_t m_Mutex;
        
        /**
         * Funcao para achar o ID TransferID na hash.
         * @param TransferID ID a ser buscada.
         * @return iterador para na hash para o ID se o ID for valido e existir
         * na hash, ou m_TransferInfoHash.end() em caso contrario. 
         */
        TTransferInfoHash::iterator FindTransferID( TTransferID TransferID );
        
    public:
        // Constante usada para sabermos se a ID de uma transferencia e ou nao 
        // valida.
        static const TTransferID NullTransferID = -1;

        /**
         * Construtor da classe, usado para criar um novo objeto desta classe.
         * @param ponteiro para o objeto da classe CNetInterface que gerencia 
         * as transferencias.
         */
        CTransferInfo( CNetInterface *NetInterface );

        /**
         * Destrutor da classe, usado para remover um objeto desta classe 
         * criado anteriormente.
         */
        ~CTransferInfo();
        
        /**
         * Funcao para criar uma nova estrutura para gerenciar uma transferencia
         * @param IP endereco IP associado a nova transferencia.
         * @param Port Porta associada a nova transferencia.
         * @param FinalizeCallback callback chamada quando finalizamos a 
         * transferencia.
         * @param FinalizeCallbackParam valor a ser passado quando chamarmos a 
         * callback FinalizeCallback.
         * @param ProcessCallback callback chamada para processar um dado 
         * recebido. Neste caso, a transrencia nao sera finalizada, e um novo
         * dado devera ser recebido para finaliza-la (esta callback somente e
         * chamada para os dados do tipo CMDDATA).
         * @param ProcessCallbackParam valor a ser passado quando chamarmos a 
         * callback ProcessCallback.
         * @param Data dados associados a estrutura de transferencia a ser
         * criada.
         * @param DataSize numero de bytes nos dados associados a transferencia.
         * @param TransferType tipo da transferencia: se estamos enviando dados
         * (SENDINGDATA) ou se estamos recebendo dados (RECEIVINGDATA).
         * @param DestTransferID Identificador da transferencia de destino. Ele
         * e usado somente quando enviamos dados, e diz qual e a identificacao 
         * da transferencia, no outro lado, que recebera os dados. Atualmente,
         * e somente usado quando finalizamos as conexoes ou quando ocorre um
         * erro ao escrevermos os dados. 
         * @param TransferID ponteiro para um valor que recebera a ID associada
         * a transferencia (usado para buscar pela estrutura associada a esta
         * transferencia). Se for NULL, o 
         * identificador nao sera armazenado.
         * @return S_OK se a estrutura para a transferencia foi criada com 
         * sucesso ou o codigo de erro se algum erro ocorrer.
         */
        RioResult NewTransfer( int IP, int Port, callback_t FinalizeCallback,
                               void *FinalizeCallbackParam, 
                               cmdcallback_t ProcessCallback, 
                               void *ProcessCallbackParam, char *Data,
                               unsigned int DataSize, 
                               ETransferType TransferType, 
                               TTransferID DestTransferID,
                               TTransferID *TransferID = NULL );

        /**
         * Funcao para remover uma estrutura de transferencia.
         * @param TransferID ID da transferencia a ser removida.
         * @return S_OK se a estrutura da transferencia foi removida com 
         * sucesso, ou o codigo do erro caso algum erro tenha ocorrido.
         */
        RioResult RemoveTransfer( TTransferID TransferID ); 
        
        /**
         * Funcao para buscar por uma estrutura de transferencia cuja ID e  
         * passada como parametro, e retornar as informacoes sobre esta
         * transferencia 
         * @param TransferID identificador para a transferencia que desejamos
         * obter os dados passados a funcao NewTransfer quando a estrutura para
         * a transferencia foi criada. 
         * @param IP ponteiro para o endereco para armazenar o endereco IP 
         * associado a nova transferencia.
         * @param Port ponteiro para o endereco para armazenar a porta associada 
         * a nova transferencia.
         * @param FinalizeCallback ponteiro para o endereco da callback chamada 
         * quando finalizamos a transferencia.
         * @param FinalizeCallbackParam ponteiro para o valor a ser passado 
         * quando chamarmos a callback FinalizeCallback.
         * @param ProcessCallback ponteiro para o endereco da callback chamada 
         * para processar um dado.
         * @param ProcessCallbackParam ponteiro para o valor a ser passado 
         * quando chamarmos a callback FinalizeCallback.
         * @param Data ponteiro para armazenar o ponteiro para os dados 
         * associados a estrutura de transferencia a ser criada.
         * @param DataSize ponteiro para armazenar o numero de bytes nos dados 
         * associados a transferencia.
         * @param TransferType ponteiro para armazenar o tipo da transferencia: 
         * se estamos enviando dados (SENDINGDATA) ou se estamos recebendo dados
         * (RECEIVINGDATA).
         * @param DestTransferID ponteiro para armazenar a identificacao da
         * transferencia associada a um envio de dados. Se for NULL (o default,
         * se nao for passado), a ID nao sera retornada (fizemos isso porque,
         * atualmente, somente a funcao ProcessError da classe CNetInterface
         * esta usando este ID, quando ocorre um erro no envio dos dados, para
         * avisar o erro ao outro lado da conexao).
         * @return S_OK se a estrutura para a transferencia foi criada com 
         * sucesso ou o codigo de erro se algum erro ocorrer.
         */     
        RioResult GetTransfer( TTransferID TransferID, int *IP, int *Port, 
                               callback_t *FinalizeCallback, 
                               void **FinalizeCallbackParam, 
                               cmdcallback_t *ProcessCallback, 
                               void **ProcessCallbackParam, char **Data,
                               unsigned int *DataSize, 
                               ETransferType *TransferType,
                               TTransferID *DestTransferID = NULL );
                                
        /**
         * Funcao para chamar todas as callbacks de finalizacao da transferencia
         * para as transferencias associadas ao par IP, porta passado como 
         * parametro, e depois remover todas as estruturas de transferencia 
         * associadas ao mesmo par IP, porta. As callbacks serao finalizadas com 
         * o erro passado como parametro.
         * 
         * Obs: Se o ponteiro para os dados passados ao criarmos a estrutura
         * para a transferencia nao for NULL, entao os dados tambem serao
         * removidos.
         * Obs2: se IP e Port foram ambos 0, todas as transferencias serao
         * finalizadas (esta chamada e usada pelo destrutor da classe para
         * garantir que todas as transferencias foram finalizadas).
         * 
         * @param IP endereco IP para o qual desejamos finalizar todas as 
         * transferencias que estao pendentes.
         * @param Port porta para a qual desejamos finalizar todas as 
         * transferencias pendentes.
         * @param TransferType tipo de transferencia que desejamos fechar. Se
         * for igual a UNDEFINEDTYPE, todas as transferencias (de leitura e 
         * de escrita) serao fechadas. Caso contrario, somente as transferencias
         * do tipo dado serao fechadas. 
         * @param RioError erro a ser passado quando as callbaks forem chamadas.
         * @return S_OK se as estruturas de transferencia associadas ao par IP,
         * porta foram removidas com sucesso ou o codigo de erro em caso 
         * contrario (note que as callbacks nao gerarao erros porque sao funcoes
         * cujo retorno e do tipo void).
         */    
        RioResult FinalizeAllTransfers( int IP, int Port, 
                                        ETransferType TransferType, 
                                        RioResult RioError );                    
};

// Estrutura com as informacoes necessarias ao processamento da funcao 
// ExpectTellId da classe CNetInterface (usada quando enviamos blocos aos
// servidores de armazenamento).
typedef struct
{
    // Endereco dos dados (um bloco) a ser enviados aos servidores de 
    // armazenamento dos quais receberemos uma ID de transferencia.
    char *Buffer;
    // Tamanho dos dados (um bloco) a serem enviados (em bytes).
    unsigned int BufferSize; 
    // Armazena a callback a ser chamada apos todas as IDs de transferencias dos
    // servidores de armazenamento serem recebidas e todos os blocos serem
    // enviados (note que e enviado um bloco por replicacao).
    callback_t callback;
    // Parametro a ser chamado quando a callback e chamada.
    void *callbackparm;
    // Identificador da transferencia responsavel por receber as IDs dos 
    // servidores de armazenamento e enviar os blocos (criada pela funcao
    // ExpectTellID). 
    TTransferID SentDataTransfer;
    // Ponteiro para o objeto da classe CNetInterface no qual as IDs serao
    // processadas.
    CNetInterface *NetInterface;
} TTellIdData;

// Classe para gerenciar o envio de dados.
class CNetInterface
{
    private:
        // Variavel booleana para indicar se a classe nao foi inicializada.
        bool m_Started;
        // Ponteiro para o objeto da classe de Rede responsavel por enviar dados
        // pelas conexoes TCP.
        CNetTcp *m_NetTcp;
        // Ponteiro para o objeto da classe de Rede responsavel por enviar dados
        // pelas conexoes TCP.
        CNetUdp *m_NetUdp;
        // Ponteiro para o objeto da classe que gerencia as transferencias em
        // andamento.
        CTransferInfo *m_TransferInfo;
        // Mutex para garantir o acesso exclusivo ao mapa m_TransferInfoMap.
        pthread_mutex_t m_MapMutex;
        
        /** 
         * Funcao usada para criar e inicializar o objeto derivado da classe 
         * classes CNetTcp.
         * @param NetConfig estrutura com as configuracoes do objeto a ser
         * criado da classe CNetTcp.
         * @return S_OK se a criacao e inicializao do objeto foi feita com 
         * sucesso ou false se algum erro ocorreu.
         */
        RioResult StartNetTcp( SNetTcpConfig *NetConfig );

        /** 
         * Funcao usada para criar e inicializar o objeto derivado da classe 
         * classes CNetUdp.
         * @param NetConfig estrutura com as configuracoes do objeto a ser
         * criado da classe CNetUdp.
         * @return S_OK se a criacao e inicializao do objeto foi feita com 
         * sucesso ou false se algum erro ocorreu.
         */
        RioResult StartNetUdp( SNetUdpConfig *NetConfig );
        
        /** 
         * Funcao usada para criar um novo objeto da classe CTransferInfo.
         * @return S_OK se a criacao e inicializao do objeto foi feita com 
         * sucesso ou false se algum erro ocorreu.
         */
        RioResult StartTransferInfo();
        
        /**
         * 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.
         * @param IP endereco destino dos dados.
         * @param Port porta no endereco destino para a qual os dados serao
         * enviados.
         * @param FinalizeCallback callback chamada quando finalizamos a 
         * transferencia.
         * @param CallbackParam valor a ser passado quando chamarmos a callback
         * FinalizeCallback.
         * @param Data ponteiro para os dados a serem enviados.
         * @param DataSize numero de bytes nos dados a serem enviados.
         * @param DataType tipo dos dados (ver o tipo EDataType).
         * @param 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).
         * @param 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. 
         * @param TransferID ponteiro para armazenar o identificador associado
         * a estrutura criada para o envio dos dados. Se for NULL, o 
         * identificador nao sera armazenado.
         * @return S_OK se os dados foram criados e colocados com sucesso para
         * serem enviados na fila do socket do par IP, porta passado como
         * parametro, ou o codigo de erro de algo der errado.
         */
         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 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.
          * @param CmdParam parametro passado quando a funcao ExpectCmd foi
          * chamada em ExpectTellId (um ponteiro para uma estrutura do tipo
          * TTellIdData).
          * @param Command comando (enviado pela funcao TellId) recebido de um
          * servidor de armazenamento.
          * @param CommandSize tamanho em bytes do comando.
          */   
         static void ProcessTransferIDs( void *CmdParam, char *Command,
                                         int CommandSize );
                                                
         /**
          * 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 Param parametro passado quando a funcao ExpectTellId foi
          * chamada (mais uma vez um ponteiro para uma estrutura do tipo
          * TTellIdData).
          * @param 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).
          */
          static void FinalizeSendBlocks( void *Param, int Result ); 
         /** 
          * 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.
          * @param IP ponteiro para o endereco no qual o IP sera armazenado.
          * @return S_OK se nenhum erro ocorreu ao descobrir a interface, ou o
          * codigo de erro indicando o erro que ocorreu.
          */
         RioResult FindIP( int *IP );

    public:
        // O seguinte membro estático também deve ser declarados no arquivo
        // NetInterface.cpp, fora da classe CNetInterface.
        #ifdef RIO_DEBUG_FILE
        static ofstream m_log;
        #else
        static debugCerr m_log;
        #endif

        /**
          * Construtor da classe CNetInterface, usado para criar um novo objeto
          * da classe.
          */
        CNetInterface();

        /**
         * Destrutor da classe CNetInterface, usado para deletar um objeto da
         * classe.
         */
        ~CNetInterface();

        /**
         * Funcao usada para inicializar a classe usada pelo cliente.
         * @param 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).
         * @param ServerAddressSize numero de enderecos no vetor ServerAddress.
         * @param ConnectionTimeOut timeout (em segundos) para uma conexao entre
         * o cliente e um dos servidores (usado somente pelas conexoes TCP).
         * @param ReceiveTimeOut timeout (em milisegundos) para os comandos de 
         * recebimento de dados (recv).
         * @param SendTimeOut timeout (em milisegunfod) para os comandos de 
         * envio de dados (send).
         * @param 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.
         * @return S_OK se nenhum erro ocorreu ao inicializar a classe, ou o
         * erro em caso contrario.
         */
        #ifdef RIO_DEBUG_FILE
        RioResult Start( struct sockaddr_in *ServerAddress, 
                         unsigned int ServerAddressSize,  
                         time_t ConnectionTimeOut = 0,
                         unsigned int ReceiveTimeOut = 0, 
                         unsigned int SendTimeOut = 0, 
                         const char *LogPath = NULL );
        #else
        RioResult Start( struct sockaddr_in *ServerAddress, 
                         unsigned int ServerAddressSize,  
                         time_t ConnectionTimeOut = 0,
                         unsigned int ReceiveTimeOut = 0, 
                         unsigned int SendTimeOut = 0 );
        #endif

        /**
         * Funcao usada para inicializar a classe usada pelo servidor ou
         * o storage.
         * @param ServerPort porta TCP a qual devemos no conectar (este 
         * parametro somente e usado pelos servidores).
         * @param ConnectionTimeOut timeout (em segundos) para uma conexao entre
         * o cliente e um dos servidores (usado somente pelas conexoes TCP).
         * @param ReceiveTimeOut timeout (em milisegundos) para os comandos de 
         * recebimento de dados (recv).
         * @param SendTimeOut timeout (em milisegunfod) para os comandos de 
         * envio de dados (send).
         * @param LogRotation ponteiro para o objeto que gerencia o 
         * armazenamento dos logs de envio de dados pelo servidor (de 
         * armazenamento).
         * @param 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.
         * @param 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.
         * @return S_OK se nenhum erro ocorreu ao inicializar a classe, ou o
         * erro em caso contrario.
         * Obs2: Devido a ser usado para criar um nome para o log, o parametro
         * isStorage tambem somente e usado quando a constante RIO_DEBUG_FILE 
         * for usada.
         */
        #ifdef RIO_DEBUG_FILE
        RioResult Start( int ServerPort, time_t ConnectionTimeOut = 0, 
                         unsigned int ReceiveTimeOut = 0, 
                         unsigned int SendTimeOut = 0,
                         CLogRotation *LogRotation = NULL, 
                         bool isStorage = false, const char *LogPath = NULL );
        #else
        RioResult Start( int ServerPort, time_t ConnectionTimeOut = 0, 
                         unsigned int ReceiveTimeOut = 0, 
                         unsigned int SendTimeOut = 0,
                         CLogRotation *LogRotation = NULL );
        #endif

        /**
         * 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.
         * @return S_OK se nenhum erro ocorreu ao parar a classe, ou o codigo do
         * erro em caso contrario.
         */ 
        RioResult Stop();

        /**
         * 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).
         * @param ipaddr ponteiro para armazenar o endereco IP.
         * @param port ponteiro para armazenar a porta.
         * @param 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).
         */
        void getmyaddrport( int *ipaddr, int *port, int server = 0 );
        
        /** 
         * 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.
         * @param ipaddr ponteiro para armazenar os enderecos IPs.
         * @param port ponteiro para armazenar as portas.
         */
        void getalladdrport( int **ipaddr, int **port );
        
        /**
         * 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.
         * @return endereco IP associado ao objeto da classe.
         */
        int getipaddr();


        /**
         * Funcao para enviar uma mensagem do tipo comando ao endereco ipadr,
         * port destino, passando o comando dado em cmdp (com o tamanho de 
         * cmdl).
         * @param ipadr endereco IP para o qual o comando deve ser enviado.
         * @param port porta para o qual o comando deve ser enviado.
         * @param TransferID identificador da estrutura de transferencia no 
         * endereco destino associada ao recebimento do comando a ser enviado.
         * @param cmdp ponteiro para o comando a ser enviado.
         * @param cmdl tamanho do comandio a ser enviado.
         * @param callback callback a ser chamada quando o comando foi enviado
         * com sucesso ao outro lado? Ele nao espera por um result?
         * @param callbackparm parametro a ser passado a callback quando ela for
         * chamada.
         */
        void SendCmd( int ipadr, int port, TTransferID TransferID, char *cmdp, 
                      int cmdl, callback_t callback, void *callbackparm );
                         
        /**
         * Funcao para enviar uma mensagem do tipo resultado ao endereco ipadr,
         * port destino, passando o resultado dado em result.
         * @param ipadr endereco IP para o qual o comando deve ser enviado.
         * @param port porta para o qual o comando deve ser enviado.
         * @param TransferID identificador da estrutura de transferencia no 
         * endereco destino associada ao recebimento do resultado a ser enviado.
         * @param result resultado a ser passado.
         */
        void SendResult( int ipadr, int port, TTransferID TransferID, 
                         int result );
                         
        /**
         * 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.
         * @param ipadr endereco IP para o qual o bloco deve ser enviado.
         * @param port porta para o qual o bloco deve ser enviado.
         * @param TransferID identificador da estrutura de transferencia no
         * endereco destino associada ao recebimento do bloco a ser enviado.
         * @param bufadr endereco com os dados do bloco.
         * @param buflen tamanho do bloco em bytes.
         * @param callback callback a ser chamada quando o bloco for enviado com
         * sucesso ao destino.
         * @param callbackparm parametro a ser passado pela callback.
         * @param 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).
         * @param 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).
         */                 
        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 criar uma nova estrutura de transferencia para esperar
         * por um bloco a ser enviado pelo outro lado da conexao.
         * @param buf ponteiro para o lugar onde o bloco, quando recebido, sera
         * armazenado.
         * @param len tamanho em blocos do bloco que estamos esperando.
         * @param callback callback a ser chamada quando o bloco for recebido.
         * @param callbackparm parametro a ser passado a callback
         * @param 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).
         * @param 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).
         * @param 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).
         * @return identificador da estrutura de trasnferencia criada que sera 
         * associada ao bloco a ser recebido.
         */                   
        TTransferID ExpectBlock( char *buf, int len, callback_t callback, 
                                 void *callbackparm, int sendack = 1,
                                 int IP = 0, int Port = 0 );
                                 
        /**
         * Cancela a espera por dados em uma estrutura de transferencia criada
         * anteriormente (sem chamar a callback).   
         * @param TransferID identificador da transferencia a ser cancelada.
         * @param 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.
         * @return 0 se algum erro ocorreu (possivelmente uma ID invalida) ou 1
         * em caso de sucesso. Como o retorno e ignorado em todos os lugares
         * que 
         */                      
        int CancelExpect( TTransferID TransferID, int result );
        
        /**
         * Envia ao outro lado da conexao, usando um comando, as informacoes
         * necessarias para que este lado envie um bloco.
         * @param ipadr endereco IP para onde a ID deve ser enviada.
         * @param port porta neste endereco para onde a ID deve ser enviada.
         * @param TransferID identificador da estrutura de transferencia no
         * endereco destino associada ao recebimento do comando com a ID que
         * devera ser processado.
         * @param tellip endereco IP (local?) informando, ao outro lado, para
         * onde o bloco deve ser enviado quando o comando com a ID for recebido.
         * @param tellport porta (local?) informando, ao outro lado, para
         * onde o bloco deve ser enviado quando o comando com a ID for recebido.
         * @param tellTransferID identificador da estrutura de transferencia 
         * (local) assiada ao bloco a ser recebido pelo outro lado depois de a
         * ID ser processada.
         * @param callback callback a ser chamada quando o processamento do 
         * comando que envia as informacoes terminar.
         * @param callbackparm parametro a ser passado quando a callback for
         * chamada.
         */
        void TellId( int ipadr, int port, TTransferID TransferID,
                     int tellip, int tellport, TTransferID tellTTransferID,
                     callback_t callback, void *callbackparm );
        
        /** 
         * Funcao para esperar por um bloco vindo do outro lado da conexao.
         * @param ipadr endereco IP para onde a ID deve ser enviada.
         * @param port porta neste endereco para onde a ID deve ser enviada.
         * @param TransferID identificador da estrutura de transferencia no
         * endereco destino associada ao recebimento do comando com a ID que
         * devera ser processado.
         * @param bufadr ponteiro para o endereco que armazenara o bloco 
         * recebido do outro lado.
         * @param buflen tamanho esperado para o bloco.
         * @param callback callback a ser chamada quando o bloco for recebido.
         * @param callbackparm parametro a ser passado quando a callback for 
         * chamada.
         */                
        void GetBlock( int ipadr, int port, TTransferID TransferID, 
                       char *bufadr, int buflen, callback_t callback, 
                       void *callbackparm );
                           
        /**
         * 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.
         * @param buf ponteiro com os dados do bloco a ser enviado.
         * @param len tamanho em bytes do bloco.
         * @param callback callback a ser chamada quando todos os blocos forem
         * enviados com sucesso.
         * @param callbackparm parametro a ser passado quando a callback for
         * chamada
         * @param 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).
         * @param 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).
         * @return identificador da estrutura criada que sera associada ao 
         * bloco a ser recebido.
         */                   
        TTransferID ExpectTellId( char *buf, int len, callback_t callback, 
                                  void *callbackparm, int IP = 0, 
                                  int Port = 0 );

        /**
         * Funcao usada para imprimir um buffer (em geral, dados recebidos pela
         * conexao).
         * @param label string a ser impressa antes do conteudo do pacote.
         * @param data dados do pacote a serem impressos
         * @param datal tamanho em bytes dos dados.
         */
        static void dumppkt( const char *label, char *data, int datal );

        /**
         * 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.
         * 
         * @param block_id identificador do bloco (provavelmente o identificador
         * da estrutura de transferencia associada ao recebimento deste bloco).
         * @param traffic tipo de trafego (UNICASTTRAFFIC ou MULTICASTTRAFFIC).
         * @return numero de bytes recebidos do bloco.
         */
        int FreeBlock( unsigned int block_id, RioStreamType traffic );

        /**
         * 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.
         * 
         * @param useCache valor booleando indicando se estamos usando ou nao
         * uma cache de blocos.
         * @param nBuffers buffer com as informacoes dos blocos para os quais
         * nao desejamos mais esperar.
         * @return soma dos tamanhos dos bytes recebidos em cada bloco.
         */
        int FreePendentBlocks( bool useCache, int nBuffers );

        /**
         * 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.
         * 
         * @param block bloco para o qual desejamos ver se existem fragmentos.
         * @return true se frgamentos ja foram recebidos para o bloco ou false
         * se nenhum fragmento foi recebido para o bloco.
         */
        bool thereAreFragments( RioBlock block );

        /**
         * 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.
         */
        void Getmyaddr( int *my_address, int *my_port );

        /**
         * Funcao para definir o objeto (do tipo CLogRotation) a ser usado para
         * armazenar as estatisticas de envio de pacotes.
         * @param LogRotation ponteiro para um objeto do tipo CLogRotation.
         */
        void setLogRotation( CLogRotation *LogRotation );

        /** 
         * 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.
         * 
         * @param callback callback a ser chamada quando o objeto NetBuf criado
         * for removido.
         * @param callbackparm parametro a ser passado a callback.
         * @param cmdcallback callback a ser chamada quando recebermos a 
         * resposta com o tamanho do arquivo de busca e o identificador deste 
         * arquivo.
         * @param 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).
         * @param 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).
         * @return Identificador da estrutura de transferencia usado para 
         * receber o comando (no caso, o comando enviado pela funcao TellId e o
         * usado para receber as informacoes do arquivo com o resultado de uma
         * busca nos logs).
         */
        TTransferID ExpectCmd( callback_t callback, void *callbackparm,
                               cmdcallback_t cmdcallback, int IP = 0,
                               int Port = 0 );
                               
        /**
         * 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. 
         * 
         * @param ipadr endereco IP para onde deveremos enviar o codigo de 
         * erro.
         * @param port porta para onde deveremos enviar o codigo de erro.
         * @param TransferID identificador da estrutura de transferencia no 
         * endereco destino associada ao recebimento do resultado a ser enviado.
         * @param result codigo de erro a ser enviado.
         */                        
        void SendRst( int ipadr, int port, TTransferID TransferID, 
                      int result );
        
        /**
         * Esta funcao e chamada pelo objeto de uma das classes de rede (NetTCP 
         * ou NetUDP) ao receber dados pela rede.
         * @param IP endereco IP da maquina que enviou os dados.
         * @param Port porta a partir da qual o pacote foi enviado a partir da
         * maquina que enviou estes dados
         * @param Data Dados enviados.
         * @param 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.
         */
        void ProcessData( int IP, int Port, char *Data, unsigned int DataSize );

        /**
         * 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).
         * @param IP endereco ip da maquina que enviou os dados.
         * @param Port porta a partir da qual o pacote foi enviado a partir da
         * maquina que enviou estes dados
         * @param Param parametro passado quando os dados foram enviados. No
         * nosso caso, ele e o identificador da transferencia usada para enviar 
         * os dados.
         */
        void SendDataCompleted( int IP, int Port, void *Param );
        
        /**
         * Esta funcao e chamada quando algum erro ocorrer com a transferencia
         * de dados. 
         * @param IP endereco IP da maquina associada ao socket com o erro.
         * @param Port porta associada ao socket com erro
         * @param RioError erro que ocorreu na transferencia dos dados.
         * @param Msg Mensagem a ser impressa junto com o erro (usada para 
         * sabermos onde o erro foi gerado)
         * @param 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 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).
         */                        
        void ProcessError( int IP, int Port, RioResult RioError, 
                           const char *Msg, EErrorType ErrorType, void *Param );
        
        /**
         * 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.
         * 
         * @param IP endereco IP da maquina associada ao socket com o erro.
         * @param Port porta associada ao socket com erro
         * @param timeout se for true a conexao foi fechada por timeout e, se
         * for false, a conexao foi fechada pelo outro lado da conexao.
         */
        void ConnectionClosed( int IP, int Port, EClosedType ClosedType ); 
        
        /**
         * Funcao para verificar se um dado par IP, Porta esta ou nao associado
         * a uma conexao do objeto desta classe.
         * @param IP IP a ser verificado.
         * @param Port Porta a ser verificada.
         * @param 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).
         * @return true se o par IP, Porta esta associado a uma conexao 
         * associada a um dos objetos (das classes CNetTcp e CNetUdp) do objeto
         * da classe CNetInterface, ou false se o par IP, Porta nao estiver em 
         * uma destas conexoes ou se algum erro ocorreu (note que, assim como
         * as outras funcoes relacionadas a um par IP, porta, nao podemos
         * repassar o erro para cima nas classes para manter a conpatibilidade.
         * Em caso de erro na checagem, a implementacao antiga entao sera a 
         * usada).
         */
        bool FindIPAndPort( int IP, int Port, bool UseTCP = true );

        friend class CTransferInfo;
};
#endif  // __NETINTERFACE_H_

---